The package rpms/strawberry.git has added or updated architecture specific content in its
spec file (ExclusiveArch/ExcludeArch or %ifarch/%ifnarch) in commit(s):
https://src.fedoraproject.org/cgit/rpms/strawberry.git/commit/?id=72de649....
Change:
+%ifnarch s390 s390x
Thanks.
Full change:
============
commit 72de649ff205cb7b752a0e838ba19d341168a3a5
Author: Robert-Andr Mauchin <zebob.m(a)gmail.com>
Date: Fri Oct 26 15:28:07 2018 +0200
Initial import (#1642118)
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..d39bd8c
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+/strawberry-0.3.3.tar.gz
diff --git a/0001-Analyzer-code-cleanup-and-try-to-fix-crash-on-Fedora.patch
b/0001-Analyzer-code-cleanup-and-try-to-fix-crash-on-Fedora.patch
new file mode 100644
index 0000000..a78c588
--- /dev/null
+++ b/0001-Analyzer-code-cleanup-and-try-to-fix-crash-on-Fedora.patch
@@ -0,0 +1,653 @@
+From 6d888eb51aeeef2716b393110aaa6728b52b7b6a Mon Sep 17 00:00:00 2001
+From: Jonas Kvinge <jonas(a)jkvinge.net>
+Date: Sun, 30 Sep 2018 15:32:21 +0200
+Subject: [PATCH] Analyzer code cleanup and try to fix crash on Fedora
+
+---
+ src/analyzer/analyzerbase.cpp | 86 ++++++++--------
+ src/analyzer/analyzerbase.h | 25 +++--
+ src/analyzer/blockanalyzer.cpp | 181 +++++++++++++++++----------------
+ src/analyzer/blockanalyzer.h | 26 ++---
+ 4 files changed, 160 insertions(+), 158 deletions(-)
+
+diff --git a/src/analyzer/analyzerbase.cpp b/src/analyzer/analyzerbase.cpp
+index bc70dd8..5536e96 100644
+--- a/src/analyzer/analyzerbase.cpp
++++ b/src/analyzer/analyzerbase.cpp
+@@ -27,14 +27,13 @@
+
+ #include "analyzerbase.h"
+
++#include "core/logging.h"
+ #include "engine/enginebase.h"
+
+ // INSTRUCTIONS Base2D
+-// 1. do anything that depends on height() in init(), Base2D will call it before
+-// you are shown
++// 1. do anything that depends on height() in init(), Base2D will call it before you are
shown
+ // 2. otherwise you can use the constructor to initialise things
+-// 3. reimplement analyze(), and paint to canvas(), Base2D will update the
+-// widget when you return control to it
++// 3. reimplement analyze(), and paint to canvas(), Base2D will update the widget when
you return control to it
+ // 4. if you want to manipulate the scope, reimplement transform()
+ // 5. for convenience <vector> <qpixmap.h> <qwdiget.h> are
pre-included
+ // TODO make an INSTRUCTIONS file
+@@ -50,37 +49,32 @@ template class Analyzer::Base<QWidget>;
+
+ Analyzer::Base::Base(QWidget *parent, uint scopeSize)
+ : QWidget(parent),
+- m_timeout(40) // msec
+- ,
+- m_fht(new FHT(scopeSize)),
+- m_engine(nullptr),
+- m_lastScope(512),
++ timeout_(40),
++ fht_(new FHT(scopeSize)),
++ engine_(nullptr),
++ lastscope_(512),
+ current_chunk_(0),
+ new_frame_(false),
+ is_playing_(false) {}
+
+-void Analyzer::Base::hideEvent(QHideEvent*) { m_timer.stop(); }
++void Analyzer::Base::hideEvent(QHideEvent*) { timer_.stop(); }
+
+-void Analyzer::Base::showEvent(QShowEvent*) { m_timer.start(timeout(), this); }
++void Analyzer::Base::showEvent(QShowEvent*) { timer_.start(timeout(), this); }
+
+-void Analyzer::Base::transform(Scope& scope) // virtual
+-{
++void Analyzer::Base::transform(Scope& scope) {
+
+- // this is a standard transformation that should give
+- // an FFT scope that has bands for pretty analyzers
++ // This is a standard transformation that should give an FFT scope that has bands for
pretty analyzers
+
+- // NOTE resizing here is redundant as FHT routines only calculate FHT::size()
+- // values
+- // scope.resize( m_fht->size() );
++ // NOTE: Resizing here is redundant as FHT routines only calculate FHT::size() values
scope.resize( fht_->size() );
+
+ float *front = static_cast<float*>(&scope.front());
+
+- float *f = new float[m_fht->size()];
+- m_fht->copy(&f[0], front);
+- m_fht->logSpectrum(front, &f[0]);
+- m_fht->scale(front, 1.0 / 20);
++ float *f = new float[fht_->size()];
++ fht_->copy(&f[0], front);
++ fht_->logSpectrum(front, &f[0]);
++ fht_->scale(front, 1.0 / 20);
+
+- scope.resize(m_fht->size() / 2); // second half of values are rubbish
++ scope.resize(fht_->size() / 2); // second half of values are rubbish
+ delete[] f;
+
+ }
+@@ -90,28 +84,28 @@ void Analyzer::Base::paintEvent(QPaintEvent *e) {
+ QPainter p(this);
+ p.fillRect(e->rect(), palette().color(QPalette::Window));
+
+- switch (m_engine->state()) {
++ switch (engine_->state()) {
+ case Engine::Playing: {
+- const Engine::Scope& thescope = m_engine->scope(m_timeout);
++ const Engine::Scope& thescope = engine_->scope(timeout_);
+ int i = 0;
+
+ // convert to mono here - our built in analyzers need mono, but the engines
provide interleaved pcm
+- for (uint x = 0; (int)x < m_fht->size(); ++x) {
+- m_lastScope[x] = double(thescope[i] + thescope[i + 1]) / (2 * (1 << 15));
++ for (uint x = 0; (int)x < fht_->size(); ++x) {
++ lastscope_[x] = double(thescope[i] + thescope[i + 1]) / (2 * (1 << 15));
+ i += 2;
+ }
+
+ is_playing_ = true;
+- transform(m_lastScope);
+- analyze(p, m_lastScope, new_frame_);
++ transform(lastscope_);
++ analyze(p, lastscope_, new_frame_);
+
+- // scope.resize( m_fht->size() );
++ lastscope_.resize(fht_->size());
+
+ break;
+ }
+ case Engine::Paused:
+ is_playing_ = false;
+- analyze(p, m_lastScope, new_frame_);
++ analyze(p, lastscope_, new_frame_);
+ break;
+
+ default:
+@@ -124,16 +118,18 @@ void Analyzer::Base::paintEvent(QPaintEvent *e) {
+ }
+
+ int Analyzer::Base::resizeExponent(int exp) {
++
+ if (exp < 3)
+ exp = 3;
+ else if (exp > 9)
+ exp = 9;
+
+- if (exp != m_fht->sizeExp()) {
+- delete m_fht;
+- m_fht = new FHT(exp);
++ if (exp != fht_->sizeExp()) {
++ delete fht_;
++ fht_ = new FHT(exp);
+ }
+ return exp;
++
+ }
+
+ int Analyzer::Base::resizeForBands(int bands) {
+@@ -153,12 +149,11 @@ int Analyzer::Base::resizeForBands(int bands) {
+ exp = 9;
+
+ resizeExponent(exp);
+- return m_fht->size() / 2;
++ return fht_->size() / 2;
+
+ }
+
+-void Analyzer::Base::demo(QPainter& p) // virtual
+-{
++void Analyzer::Base::demo(QPainter& p) {
+
+ static int t = 201; // FIXME make static to namespace perhaps
+
+@@ -171,7 +166,8 @@ void Analyzer::Base::demo(QPainter& p) // virtual
+ s[i] = dt * (sin(M_PI + (i * M_PI) / s.size()) + 1.0);
+
+ analyze(p, s, new_frame_);
+- } else
++ }
++ else
+ analyze(p, Scope(32, 0), new_frame_);
+
+ ++t;
+@@ -179,7 +175,7 @@ void Analyzer::Base::demo(QPainter& p) // virtual
+ }
+
+ void Analyzer::Base::polishEvent() {
+- init(); // virtual
++ init();
+ }
+
+ void Analyzer::interpolate(const Scope& inVec, Scope& outVec) {
+@@ -189,13 +185,13 @@ void Analyzer::interpolate(const Scope& inVec, Scope&
outVec) {
+
+ for (uint i = 0; i < outVec.size(); ++i, pos += step) {
+ const double error = pos - std::floor(pos);
+- const unsigned long offset = (unsigned long)pos;
++ const uint64_t offset = (uint64_t)pos;
+
+- unsigned long indexLeft = offset + 0;
++ uint64_t indexLeft = offset + 0;
+
+ if (indexLeft >= inVec.size()) indexLeft = inVec.size() - 1;
+
+- unsigned long indexRight = offset + 1;
++ uint64_t indexRight = offset + 1;
+
+ if (indexRight >= inVec.size()) indexRight = inVec.size() - 1;
+
+@@ -205,6 +201,7 @@ void Analyzer::interpolate(const Scope& inVec, Scope& outVec)
{
+ }
+
+ void Analyzer::initSin(Scope& v, const uint size) {
++
+ double step = (M_PI * 2) / size;
+ double radian = 0;
+
+@@ -212,12 +209,15 @@ void Analyzer::initSin(Scope& v, const uint size) {
+ v.push_back(sin(radian));
+ radian += step;
+ }
++
+ }
+
+ void Analyzer::Base::timerEvent(QTimerEvent *e) {
++
+ QWidget::timerEvent(e);
+- if (e->timerId() != m_timer.timerId()) return;
++ if (e->timerId() != timer_.timerId()) return;
+
+ new_frame_ = true;
+ update();
++
+ }
+diff --git a/src/analyzer/analyzerbase.h b/src/analyzer/analyzerbase.h
+index 2f4fe19..2ec8354 100644
+--- a/src/analyzer/analyzerbase.h
++++ b/src/analyzer/analyzerbase.h
+@@ -37,17 +37,17 @@ class Base : public QWidget {
+ Q_OBJECT
+
+ public:
+- ~Base() { delete m_fht; }
++ ~Base() { delete fht_; }
+
+- uint timeout() const { return m_timeout; }
++ uint timeout() const { return timeout_; }
+
+- void set_engine(EngineBase *engine) { m_engine = engine; }
++ void set_engine(EngineBase *engine) { engine_ = engine; }
+
+ void changeTimeout(uint newTimeout) {
+- m_timeout = newTimeout;
+- if (m_timer.isActive()) {
+- m_timer.stop();
+- m_timer.start(m_timeout, this);
++ timeout_ = newTimeout;
++ if (timer_.isActive()) {
++ timer_.stop();
++ timer_.start(timeout_, this);
+ }
+ }
+
+@@ -71,13 +71,12 @@ class Base : public QWidget {
+ virtual void demo(QPainter& p);
+
+ protected:
+- QBasicTimer m_timer;
+- uint m_timeout;
+- FHT* m_fht;
+- EngineBase* m_engine;
+- Scope m_lastScope;
++ QBasicTimer timer_;
++ uint timeout_;
++ FHT *fht_;
++ EngineBase *engine_;
++ Scope lastscope_;
+ int current_chunk_;
+-
+ bool new_frame_;
+ bool is_playing_;
+ };
+diff --git a/src/analyzer/blockanalyzer.cpp b/src/analyzer/blockanalyzer.cpp
+index 781e41a..32b308b 100644
+--- a/src/analyzer/blockanalyzer.cpp
++++ b/src/analyzer/blockanalyzer.cpp
+@@ -26,109 +26,105 @@ const uint BlockAnalyzer::MIN_COLUMNS = 32; // arbituary
+ const uint BlockAnalyzer::MAX_COLUMNS = 256; // must be 2**n
+ const uint BlockAnalyzer::FADE_SIZE = 90;
+
+-const char *BlockAnalyzer::kName =
+- QT_TRANSLATE_NOOP("AnalyzerContainer", "Block analyzer");
++const char *BlockAnalyzer::kName = QT_TRANSLATE_NOOP("AnalyzerContainer",
"Block analyzer");
+
+ BlockAnalyzer::BlockAnalyzer(QWidget *parent)
+ : Analyzer::Base(parent, 9),
+- m_columns(0) // uint
+- ,
+- m_rows(0) // uint
+- ,
+- m_y(0) // uint
+- ,
+- m_barPixmap(1, 1) // null qpixmaps cause crashes
+- ,
+- m_topBarPixmap(WIDTH, HEIGHT),
+- m_scope(MIN_COLUMNS) // Scope
+- ,
+- m_store(1 << 8, 0) // vector<uint>
+- ,
+- m_fade_bars(FADE_SIZE) // vector<QPixmap>
+- ,
+- m_fade_pos(1 << 8, 50) // vector<uint>
+- ,
+- m_fade_intensity(1 << 8, 32) // vector<uint>
+-{
++ columns_(0),
++ rows_(0),
++ y_(0),
++ barpixmap_(1, 1),
++ topbarpixmap_(WIDTH, HEIGHT),
++ scope_(MIN_COLUMNS),
++ store_(1 << 8, 0),
++ fade_bars_(FADE_SIZE),
++ fade_pos_(1 << 8, 50),
++ fade_intensity_(1 << 8, 32) {
++
+ setMinimumSize(MIN_COLUMNS * (WIDTH + 1) - 1, MIN_ROWS * (HEIGHT + 1) - 1); //-1 is
padding, no drawing takes place there
+ setMaximumWidth(MAX_COLUMNS * (WIDTH + 1) - 1);
+
+ // mxcl says null pixmaps cause crashes, so let's play it safe
+- for (uint i = 0; i < FADE_SIZE; ++i) m_fade_bars[i] = QPixmap(1, 1);
++ for (uint i = 0; i < FADE_SIZE; ++i) fade_bars_[i] = QPixmap(1, 1);
++
+ }
+
+ BlockAnalyzer::~BlockAnalyzer() {}
+
+ void BlockAnalyzer::resizeEvent(QResizeEvent *e) {
++
+ QWidget::resizeEvent(e);
+
+- m_background = QPixmap(size());
++ background_ = QPixmap(size());
+ canvas_ = QPixmap(size());
+
+- const uint oldRows = m_rows;
++ const uint oldRows = rows_;
+
+ // all is explained in analyze()..
+ //+1 to counter -1 in maxSizes, trust me we need this!
+- m_columns = qMax(uint(double(width() + 1) / (WIDTH + 1)), MAX_COLUMNS);
+- m_rows = uint(double(height() + 1) / (HEIGHT + 1));
++ columns_ = qMax(uint(double(width() + 1) / (WIDTH + 1)), MAX_COLUMNS);
++ rows_ = uint(double(height() + 1) / (HEIGHT + 1));
+
+ // this is the y-offset for drawing from the top of the widget
+- m_y = (height() - (m_rows * (HEIGHT + 1)) + 2) / 2;
++ y_ = (height() - (rows_ * (HEIGHT + 1)) + 2) / 2;
+
+- m_scope.resize(m_columns);
++ scope_.resize(columns_);
+
+- if (m_rows != oldRows) {
+- m_barPixmap = QPixmap(WIDTH, m_rows * (HEIGHT + 1));
++ if (rows_ != oldRows) {
++ barpixmap_ = QPixmap(WIDTH, rows_ * (HEIGHT + 1));
+
+ for (uint i = 0; i < FADE_SIZE; ++i)
+- m_fade_bars[i] = QPixmap(WIDTH, m_rows * (HEIGHT + 1));
++ fade_bars_[i] = QPixmap(WIDTH, rows_ * (HEIGHT + 1));
+
+- m_yscale.resize(m_rows + 1);
++ yscale_.resize(rows_ + 1);
+
+- const uint PRE = 1,
+- PRO = 1; // PRE and PRO allow us to restrict the range somewhat
++ const uint PRE = 1, PRO = 1; // PRE and PRO allow us to restrict the range
somewhat
+
+- for (uint z = 0; z < m_rows; ++z)
+- m_yscale[z] = 1 - (log10(PRE + z) / log10(PRE + m_rows + PRO));
++ for (uint z = 0; z < rows_; ++z)
++ yscale_[z] = 1 - (log10(PRE + z) / log10(PRE + rows_ + PRO));
+
+- m_yscale[m_rows] = 0;
++ yscale_[rows_] = 0;
+
+ determineStep();
+ paletteChange(palette());
+ }
+
+ drawBackground();
++
+ }
+
+ void BlockAnalyzer::determineStep() {
++
+ // falltime is dependent on rowcount due to our digital resolution (ie we have
boxes/blocks of pixels)
+ // I calculated the value 30 based on some trial and error
+
+ // the fall time of 30 is too slow on framerates above 50fps
+- const double fallTime = timeout() < 20 ? 20 * m_rows : 30 * m_rows;
++ const double fallTime = timeout() < 20 ? 20 * rows_ : 30 * rows_;
++
++ step_ = double(rows_ * timeout()) / fallTime;
+
+- m_step = double(m_rows * timeout()) / fallTime;
+ }
+
+-void BlockAnalyzer::framerateChanged() { // virtual
++void BlockAnalyzer::framerateChanged() {
+ determineStep();
+ }
+
+-void BlockAnalyzer::transform(Analyzer::Scope& s) // pure virtual
+-{
++void BlockAnalyzer::transform(Analyzer::Scope &s) {
++
+ for (uint x = 0; x < s.size(); ++x) s[x] *= 2;
+
+ float* front = static_cast<float*>(&s.front());
+
+- m_fht->spectrum(front);
+- m_fht->scale(front, 1.0 / 20);
++ fht_->spectrum(front);
++ fht_->scale(front, 1.0 / 20);
++
++ // the second half is pretty dull, so only show it if the user has a large analyzer by
setting to scope_.size() if large we prevent interpolation of large analyzers, this is
good!
++ s.resize(scope_.size() <= MAX_COLUMNS / 2 ? MAX_COLUMNS / 2 : scope_.size());
+
+- // the second half is pretty dull, so only show it if the user has a large analyzer by
setting to m_scope.size() if large we prevent interpolation of large analyzers, this is
good!
+- s.resize(m_scope.size() <= MAX_COLUMNS / 2 ? MAX_COLUMNS / 2 : m_scope.size());
+ }
+
+-void BlockAnalyzer::analyze(QPainter& p, const Analyzer::Scope& s,
+- bool new_frame) {
++void BlockAnalyzer::analyze(QPainter &p, const Analyzer::Scope &s, bool
new_frame) {
++
+ // y = 2 3 2 1 0 2
+ // . . . . # .
+ // . . . # # .
+@@ -139,7 +135,7 @@ void BlockAnalyzer::analyze(QPainter& p, const
Analyzer::Scope& s,
+ // y represents the number of blanks
+ // y starts from the top and increases in units of blocks
+
+- // m_yscale looks similar to: { 0.7, 0.5, 0.25, 0.15, 0.1, 0 }
++ // yscale_ looks similar to: { 0.7, 0.5, 0.25, 0.15, 0.1, 0 }
+ // if it contains 6 elements there are 5 rows in the analyzer
+
+ if (!new_frame) {
+@@ -149,50 +145,51 @@ void BlockAnalyzer::analyze(QPainter& p, const
Analyzer::Scope& s,
+
+ QPainter canvas_painter(&canvas_);
+
+- Analyzer::interpolate(s, m_scope);
++ Analyzer::interpolate(s, scope_);
+
+ // Paint the background
+- canvas_painter.drawPixmap(0, 0, m_background);
++ canvas_painter.drawPixmap(0, 0, background_);
+
+- for (uint y, x = 0; x < m_scope.size(); ++x) {
++ for (uint y, x = 0; x < scope_.size(); ++x) {
+ // determine y
+- for (y = 0; m_scope[x] < m_yscale[y]; ++y)
+- ;
++ for (y = 0; scope_[x] < yscale_[y]; ++y) continue;
+
+ // this is opposite to what you'd think, higher than y means the bar is lower
than y (physically)
+- if ((float)y > m_store[x])
+- y = int(m_store[x] += m_step);
++ if ((float)y > store_[x])
++ y = int(store_[x] += step_);
+ else
+- m_store[x] = y;
++ store_[x] = y;
+
+- // if y is lower than m_fade_pos, then the bar has exceeded the height of the
fadeout
++ // if y is lower than fade_pos_, then the bar has exceeded the height of the
fadeout
+ // if the fadeout is quite faded now, then display the new one
+- if (y <= m_fade_pos[x] /*|| m_fade_intensity[x] < FADE_SIZE / 3*/) {
+- m_fade_pos[x] = y;
+- m_fade_intensity[x] = FADE_SIZE;
++ if (y <= fade_pos_[x] /*|| fade_intensity_[x] < FADE_SIZE / 3*/) {
++ fade_pos_[x] = y;
++ fade_intensity_[x] = FADE_SIZE;
+ }
+
+- if (m_fade_intensity[x] > 0) {
+- const uint offset = --m_fade_intensity[x];
+- const uint y = m_y + (m_fade_pos[x] * (HEIGHT + 1));
+- canvas_painter.drawPixmap(x * (WIDTH + 1), y, m_fade_bars[offset], 0, 0, WIDTH,
height() - y);
++ if (fade_intensity_[x] > 0) {
++ const uint offset = --fade_intensity_[x];
++ const uint y = y_ + (fade_pos_[x] * (HEIGHT + 1));
++ canvas_painter.drawPixmap(x * (WIDTH + 1), y, fade_bars_[offset], 0, 0, WIDTH,
height() - y);
+ }
+
+- if (m_fade_intensity[x] == 0) m_fade_pos[x] = m_rows;
++ if (fade_intensity_[x] == 0) fade_pos_[x] = rows_;
+
+- // REMEMBER: y is a number from 0 to m_rows, 0 means all blocks are glowing, m_rows
means none are
+- canvas_painter.drawPixmap(x * (WIDTH + 1), y * (HEIGHT + 1) + m_y, *bar(),
++ // REMEMBER: y is a number from 0 to rows_, 0 means all blocks are glowing, rows_
means none are
++ canvas_painter.drawPixmap(x * (WIDTH + 1), y * (HEIGHT + 1) + y_, *bar(),
+ 0, y * (HEIGHT + 1), bar()->width(),
+ bar()->height());
+ }
+
+- for (uint x = 0; x < m_store.size(); ++x)
+- canvas_painter.drawPixmap(x * (WIDTH + 1), int(m_store[x]) * (HEIGHT + 1) + m_y,
m_topBarPixmap);
++ for (uint x = 0; x < store_.size(); ++x)
++ canvas_painter.drawPixmap(x * (WIDTH + 1), int(store_[x]) * (HEIGHT + 1) + y_,
topbarpixmap_);
+
+ p.drawPixmap(0, 0, canvas_);
++
+ }
+
+-static inline void adjustToLimits(int& b, int& f, uint& amount) {
++static inline void adjustToLimits(int &b, int &f, uint &amount) {
++
+ // with a range of 0-255 and maximum adjustment of amount, maximise the difference
between f and b
+
+ if (b < f) {
+@@ -215,6 +212,7 @@ static inline void adjustToLimits(int& b, int& f, uint&
amount) {
+ f = 255;
+ }
+ }
++
+ }
+
+ /**
+@@ -225,17 +223,18 @@ static inline void adjustToLimits(int& b, int& f, uint&
amount) {
+ * It won't modify the hue of fg unless absolutely necessary
+ * @return the adjusted form of fg
+ */
+-QColor ensureContrast(const QColor& bg, const QColor& fg, uint _amount = 150) {
++QColor ensureContrast(const QColor &bg, const QColor &fg, uint _amount = 150) {
++
+ class OutputOnExit {
+ public:
+- OutputOnExit(const QColor& color) : c(color) {}
++ OutputOnExit(const QColor &color) : c(color) {}
+ ~OutputOnExit() {
+ int h, s, v;
+ c.getHsv(&h, &s, &v);
+ }
+
+ private:
+- const QColor& c;
++ const QColor &c;
+ };
+
+ // hack so I don't have to cast everywhere
+@@ -352,24 +351,25 @@ QColor ensureContrast(const QColor& bg, const QColor& fg,
uint _amount = 150) {
+
+ #undef amount
+ // #undef STAMP
++
+ }
+
+-void BlockAnalyzer::paletteChange(const QPalette&) // virtual
+-{
++void BlockAnalyzer::paletteChange(const QPalette&) {
++
+ const QColor bg = palette().color(QPalette::Background);
+ const QColor fg = ensureContrast(bg, palette().color(QPalette::Highlight));
+
+- m_topBarPixmap.fill(fg);
++ topbarpixmap_.fill(fg);
+
+- const double dr = 15 * double(bg.red() - fg.red()) / (m_rows * 16);
+- const double dg = 15 * double(bg.green() - fg.green()) / (m_rows * 16);
+- const double db = 15 * double(bg.blue() - fg.blue()) / (m_rows * 16);
++ const double dr = 15 * double(bg.red() - fg.red()) / (rows_ * 16);
++ const double dg = 15 * double(bg.green() - fg.green()) / (rows_ * 16);
++ const double db = 15 * double(bg.blue() - fg.blue()) / (rows_ * 16);
+ const int r = fg.red(), g = fg.green(), b = fg.blue();
+
+ bar()->fill(bg);
+
+ QPainter p(bar());
+- for (int y = 0; (uint)y < m_rows; ++y)
++ for (int y = 0; (uint)y < rows_; ++y)
+ // graduate the fg color
+ p.fillRect(0, y * (HEIGHT + 1), WIDTH, HEIGHT, QColor(r + int(dr * y), g + int(dg *
y), b + int(db * y)));
+
+@@ -389,9 +389,9 @@ void BlockAnalyzer::paletteChange(const QPalette&) // virtual
+
+ // Precalculate all fade-bar pixmaps
+ for (uint y = 0; y < FADE_SIZE; ++y) {
+- m_fade_bars[y].fill(palette().color(QPalette::Background));
+- QPainter f(&m_fade_bars[y]);
+- for (int z = 0; (uint)z < m_rows; ++z) {
++ fade_bars_[y].fill(palette().color(QPalette::Background));
++ QPainter f(&fade_bars_[y]);
++ for (int z = 0; (uint)z < rows_; ++z) {
+ const double Y = 1.0 - (log10(FADE_SIZE - y) / log10(FADE_SIZE));
+ f.fillRect(0, z * (HEIGHT + 1), WIDTH, HEIGHT, QColor(r + int(dr * Y), g +
int(dg * Y), b + int(db * Y)));
+ }
+@@ -399,16 +399,19 @@ void BlockAnalyzer::paletteChange(const QPalette&) // virtual
+ }
+
+ drawBackground();
++
+ }
+
+ void BlockAnalyzer::drawBackground() {
++
+ const QColor bg = palette().color(QPalette::Background);
+ const QColor bgdark = bg.dark(112);
+
+- m_background.fill(bg);
++ background_.fill(bg);
++
++ QPainter p(&background_);
++ for (int x = 0; (uint)x < columns_; ++x)
++ for (int y = 0; (uint)y < rows_; ++y)
++ p.fillRect(x * (WIDTH + 1), y * (HEIGHT + 1) + y_, WIDTH, HEIGHT, bgdark);
+
+- QPainter p(&m_background);
+- for (int x = 0; (uint)x < m_columns; ++x)
+- for (int y = 0; (uint)y < m_rows; ++y)
+- p.fillRect(x * (WIDTH + 1), y * (HEIGHT + 1) + m_y, WIDTH, HEIGHT, bgdark);
+ }
+diff --git a/src/analyzer/blockanalyzer.h b/src/analyzer/blockanalyzer.h
+index e77bf72..be4dfe3 100644
+--- a/src/analyzer/blockanalyzer.h
++++ b/src/analyzer/blockanalyzer.h
+@@ -51,24 +51,24 @@ class BlockAnalyzer : public Analyzer::Base {
+ void determineStep();
+
+ private:
+- QPixmap* bar() { return &m_barPixmap; }
++ QPixmap *bar() { return &barpixmap_; }
+
+- uint m_columns, m_rows; // number of rows and columns of blocks
+- uint m_y; // y-offset from top of widget
+- QPixmap m_barPixmap;
+- QPixmap m_topBarPixmap;
+- QPixmap m_background;
++ uint columns_, rows_; // number of rows and columns of blocks
++ uint y_; // y-offset from top of widget
++ QPixmap barpixmap_;
++ QPixmap topbarpixmap_;
++ QPixmap background_;
+ QPixmap canvas_;
+- Analyzer::Scope m_scope; // so we don't create a vector every frame
+- std::vector<float> m_store; // current bar heights
+- std::vector<float> m_yscale;
++ Analyzer::Scope scope_; // so we don't create a vector every frame
++ std::vector<float> store_; // current bar heights
++ std::vector<float> yscale_;
+
+ // FIXME why can't I namespace these? c++ issue?
+- std::vector<QPixmap> m_fade_bars;
+- std::vector<uint> m_fade_pos;
+- std::vector<int> m_fade_intensity;
++ std::vector<QPixmap> fade_bars_;
++ std::vector<uint> fade_pos_;
++ std::vector<int> fade_intensity_;
+
+- float m_step; // rows to fall per frame
++ float step_; // rows to fall per frame
+ };
+
+ #endif
diff --git a/sources b/sources
new file mode 100644
index 0000000..0948dc3
--- /dev/null
+++ b/sources
@@ -0,0 +1 @@
+SHA512 (strawberry-0.3.3.tar.gz) =
9ed8fb9e9ce8cf187c9c16fc912823cce9848be428615ae797b270ae6c503f7c3e0e0b2362d97842f2707cfcb5b413015a7c062bde871fbb98f28627b2bc3875
diff --git a/strawberry-qt5-libraries.patch b/strawberry-qt5-libraries.patch
new file mode 100644
index 0000000..cd8d991
--- /dev/null
+++ b/strawberry-qt5-libraries.patch
@@ -0,0 +1,42 @@
+diff -up strawberry-0.3.3/CMakeLists.txt.use_qt5 strawberry-0.3.3/CMakeLists.txt
+--- strawberry-0.3.3/CMakeLists.txt.use_qt5 2018-10-22 03:14:34.852939691 +0200
++++ strawberry-0.3.3/CMakeLists.txt 2018-10-22 03:16:11.515764262 +0200
+@@ -211,9 +211,9 @@ endif()
+ option(USE_SYSTEM_QTSINGLEAPPLICATION "Use system QtSingleApplication library"
OFF)
+ if(USE_SYSTEM_QTSINGLEAPPLICATION)
+ message(STATUS "Using system QtSingleApplication library")
+- find_path(QTSINGLEAPPLICATION_INCLUDE_DIRS qtsingleapplication.h PATH_SUFFIXES
QtSolutions)
+- find_library(QTSINGLEAPPLICATION_LIBRARIES QtSolutions_SingleApplication-2.6)
+- find_library(QTSINGLECOREAPPLICATION_LIBRARIES QtSolutions_SingleCoreApplication-2.6)
++ find_path(QTSINGLEAPPLICATION_INCLUDE_DIRS qtsingleapplication.h PATH_SUFFIXES
qt5/QtSolutions)
++ find_library(QTSINGLEAPPLICATION_LIBRARIES Qt5Solutions_SingleApplication-2.6)
++ find_library(QTSINGLECOREAPPLICATION_LIBRARIES
Qt5Solutions_SingleCoreApplication-2.6)
+ else(USE_SYSTEM_QTSINGLEAPPLICATION)
+ message(STATUS "Using builtin QtSingleApplication library")
+ add_subdirectory(3rdparty/qtsingleapplication)
+@@ -225,11 +225,11 @@ endif(USE_SYSTEM_QTSINGLEAPPLICATION)
+ option(USE_SYSTEM_QXT "Use system Qxt library" OFF)
+ if (USE_SYSTEM_QXT)
+ message(STATUS "Using system Qxt library")
+- find_path(QXTCORE_INCLUDE_DIRS qxtglobal.h PATH_SUFFIXES QxtCore)
+- find_path(QXTGUI_INCLUDE_DIRS qxtglobalshortcut.h PATH_SUFFIXES QxtGui)
++ find_path(QXTCORE_INCLUDE_DIRS qxtglobal.h PATH_SUFFIXES qt5/QxtCore)
++ find_path(QXTGUI_INCLUDE_DIRS qxtglobalshortcut.h PATH_SUFFIXES qt5/QxtWidgets)
+ set(QXT_INCLUDE_DIRS ${QXTCORE_INCLUDE_DIRS} ${QXTGUI_INCLUDE_DIRS})
+ # We only need its header. We don't need to link to QxtCore.
+- find_library(QXT_LIBRARIES QxtGui)
++ find_library(QXT_LIBRARIES QxtWidgets-qt5)
+ else (USE_SYSTEM_QXT)
+ message(STATUS "Using builtin Qxt library")
+ add_definitions(-DQXT_STATIC -DBUILD_QXT_GUI -DBUILD_QXT_CORE)
+diff -up strawberry-0.3.3/src/CMakeLists.txt.use_qt5 strawberry-0.3.3/src/CMakeLists.txt
+--- strawberry-0.3.3/src/CMakeLists.txt.use_qt5 2018-10-22 03:14:34.853939689 +0200
++++ strawberry-0.3.3/src/CMakeLists.txt 2018-10-22 03:16:36.357719178 +0200
+@@ -880,6 +880,7 @@ target_link_libraries(strawberry_lib
+ ${QT_LIBRARIES}
+ ${CHROMAPRINT_LIBRARIES}
+ ${QTSINGLEAPPLICATION_LIBRARIES}
++ ${QTSINGLECOREAPPLICATION_LIBRARIES}
+ ${CMAKE_THREAD_LIBS_INIT}
+ ${SQLITE_LIBRARIES}
+ ${QOCOA_LIBRARIES}
diff --git a/strawberry-udisks-headers.patch b/strawberry-udisks-headers.patch
new file mode 100644
index 0000000..e148d79
--- /dev/null
+++ b/strawberry-udisks-headers.patch
@@ -0,0 +1,12 @@
+diff -up Clementine-fb00835468295925a6945a286406a2eec6bdb67a/src/CMakeLists.txt.udisks
Clementine-fb00835468295925a6945a286406a2eec6bdb67a/src/CMakeLists.txt
+---
Clementine-fb00835468295925a6945a286406a2eec6bdb67a/src/CMakeLists.txt.udisks 2018-10-05
11:56:49.000000000 +0200
++++ Clementine-fb00835468295925a6945a286406a2eec6bdb67a/src/CMakeLists.txt 2018-10-21
00:36:08.950165997 +0200
+@@ -946,6 +946,8 @@ if(HAVE_DBUS)
+ list(APPEND HEADERS ${CMAKE_CURRENT_BINARY_DIR}/dbus/avahientrygroup.h)
+ list(APPEND SOURCES ${CMAKE_CURRENT_BINARY_DIR}/dbus/avahientrygroup.cpp)
+
++ set_source_files_properties( dbus/org.freedesktop.UDisks.xml
dbus/org.freedesktop.UDisks.Device.xml PROPERTIES NO_NAMESPACE TRUE)
++
+ # DeviceKit DBUS interfaces
+ if(HAVE_DEVICEKIT)
+ set_source_files_properties(dbus/org.freedesktop.UDisks.xml
diff --git a/strawberry.appdata.xml b/strawberry.appdata.xml
new file mode 100644
index 0000000..1f063cb
--- /dev/null
+++ b/strawberry.appdata.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<application>
+ <id type="desktop">strawberry.desktop</id>
+ <metadata_license>CC0-1.0</metadata_license>
+ <project_license>GPL-3.0+</project_license>
+ <name>Strawberry Music Player</name>
+ <summary>An audio player and music collection organizer</summary>
+ <description>
+ <p>
+ Strawberry is a audio player and music collection organizer.
+It is a fork of Clementine. The name is inspired by the band Strawbs.
+ </p>
+ <p>Features::</p>
+ <ul>
+ <li>Play and organize music</li>
+ <li>Supports WAV, FLAC, WavPack, DSF, DSDIFF, Ogg Vorbis, Speex, MPC,
TrueAudio, AIFF, MP4, MP3 and ASF</li>
+ <li>Audio CD playback</li>
+ <li>Native desktop notifications</li>
+ <li>Playlists in multiple formats</li>
+ <li>Advanced output and device options with support for bit perfect playback
on Linux</li>
+ <li>Edit tags on music files</li>
+ <li>Fetch tags from MusicBrainz</li>
+ <li>Album cover art from Last.fm, Musicbrainz and Discogs</li>
+ <li>Song lyrics from AudD and API Seeds</li>
+ <li>Support for multiple backends</li>
+ <li>Audio analyzer</li>
+ <li>Equalizer</li>
+ <li>Transfer music to iPod, iPhone, MTP or mass-storage USB
player</li>
+ <li>Integrated Tidal support</li>
+ </ul>
+ </description>
+ <screenshots>
+ <screenshot type="default" width="1920"
height="1049">https://www.strawbs.org/pictures/screenshot-00...
+ <screenshot width="1920"
height="1080">https://www.strawbs.org/pictures/screenshot-00...
+ </screenshots>
+ <url
type="homepage">http://www.strawbs.org/</url>
+ <updatecontact>eclipseo(a)fedoraproject.org</updatecontact>
+</application>
diff --git a/strawberry.spec b/strawberry.spec
new file mode 100644
index 0000000..d19ba35
--- /dev/null
+++ b/strawberry.spec
@@ -0,0 +1,162 @@
+Name: strawberry
+Version: 0.3.3
+Release: 1%{?dist}
+Summary: An audio player and music collection organizer
+
+# Main program: GPLv3
+# src/analyzer and src/engine/gstengine and src/engine/xineengine: GPLv2
+# 3rdparty/taglib, src/widgets/fancytabwidget and src/widgets/stylehelper: LGPLv2
+# 3rdparty/qocoa: MIT
+# 3rdparty/utf8-cpp: Boost
+# src/core/timeconstants.h and ext/libstrawberry-common/core/logging and
ext/libstrawberry-common/core/messagehandler: ASL 2.0
+# some icons in qocoa: CC-BY-SA
+License: GPLv2 and GPLv3+ amd LGPLv2 and ASL 2.0 and MIT and Boost and CC-BY-SA
+URL:
http://www.strawbs.org/
+Source0:
https://github.com/jonaski/strawberry/archive/%{version}/%{name}-%{versio...
+# upstreamed
+Source1: strawberry.appdata.xml
+
+Patch4: strawberry-udisks-headers.patch
+# Use qt5 libraries (upstreamed)
+Patch11: strawberry-qt5-libraries.patch
+#
https://github.com/jonaski/strawberry/commit/6d888eb51aeeef2716b393110aaa...
+Patch12:
https://github.com/jonaski/strawberry/commit/6d888eb51aeeef2716b393110aaa...
+
+
+BuildRequires: boost-devel
+BuildRequires: cmake
+BuildRequires: desktop-file-utils
+BuildRequires: gcc-c++
+BuildRequires: gettext
+BuildRequires: libappstream-glib
+BuildRequires: liblastfm-qt5-devel
+BuildRequires: pkgconfig(alsa)
+BuildRequires: pkgconfig(dbus-1)
+BuildRequires: pkgconfig(gio-2.0)
+BuildRequires: pkgconfig(gio-unix-2.0)
+BuildRequires: pkgconfig(glib-2.0)
+BuildRequires: pkgconfig(glu)
+BuildRequires: pkgconfig(gstreamer-1.0)
+BuildRequires: pkgconfig(gstreamer-app-1.0)
+BuildRequires: pkgconfig(gstreamer-audio-1.0)
+BuildRequires: pkgconfig(gstreamer-base-1.0)
+BuildRequires: pkgconfig(gstreamer-tag-1.0)
+BuildRequires: pkgconfig(gthread-2.0)
+BuildRequires: pkgconfig(libcdio)
+BuildRequires: pkgconfig(libchromaprint)
+BuildRequires: pkgconfig(libmtp)
+BuildRequires: pkgconfig(libnotify)
+BuildRequires: pkgconfig(libpulse)
+BuildRequires: pkgconfig(libudf)
+BuildRequires: pkgconfig(protobuf)
+BuildRequires: pkgconfig(qca2-qt5)
+BuildRequires: pkgconfig(Qt5Concurrent)
+BuildRequires: pkgconfig(Qt5Core)
+BuildRequires: pkgconfig(Qt5DBus)
+BuildRequires: pkgconfig(Qt5Gui)
+BuildRequires: pkgconfig(Qt5Network)
+BuildRequires: pkgconfig(Qt5OpenGL)
+BuildRequires: pkgconfig(Qt5Sql)
+BuildRequires: pkgconfig(Qt5Widgets)
+BuildRequires: pkgconfig(Qt5X11Extras)
+BuildRequires: pkgconfig(Qt5Xml)
+BuildRequires: pkgconfig(QxtCore-qt5)
+BuildRequires: pkgconfig(sqlite3) >= 3.7
+BuildRequires: pkgconfig(taglib) >= 1.11
+BuildRequires: qt5-linguist
+BuildRequires: qtsingleapplication-qt5-devel >= 2.6.1-2
+BuildRequires: qtsinglecoreapplication-qt5-devel
+BuildRequires: sha2-devel
+%ifnarch s390 s390x
+BuildRequires: pkgconfig(libgpod-1.0)
+%endif
+
+Requires: gstreamer1-plugins-good
+Requires: hicolor-icon-theme
+Requires: qca-qt5-ossl%{?_isa}
+Requires: qtiocompressor >= 2.3.1-17
+
+Provides: bundled(qocoa)
+Provides: bundled(taglib) = 1.12-1
+Provides: bundled(utf8-cpp)
+
+
+%description
+Strawberry is a audio player and music collection organizer.
+It is a fork of Clementine. The name is inspired by the band Strawbs.
+
+Features:
+ * Play and organize music
+ * Supports WAV, FLAC, WavPack, DSF, DSDIFF, Ogg Vorbis, Speex, MPC,
+ TrueAudio, AIFF, MP4, MP3 and ASF
+ * Audio CD playback
+ * Native desktop notifications
+ * Playlists in multiple formats
+ * Advanced output and device options with support for bit perfect playback
+ on Linux
+ * Edit tags on music files
+ * Fetch tags from MusicBrainz
+ * Album cover art from Last.fm, Musicbrainz and Discogs
+ * Song lyrics from AudD and API Seeds
+ * Support for multiple backends
+ * Audio analyzer
+ * Equalizer
+ * Transfer music to iPod, iPhone, MTP or mass-storage USB player
+ * Integrated Tidal support
+
+
+%prep
+%autosetup -p1
+
+# Remove most 3rdparty libraries
+# Unbundle taglib next release:
+#
https://github.com/taglib/taglib/issues/837#issuecomment-428389347
+mv 3rdparty/{qocoa,taglib,utf8-cpp}/ .
+rm -fr 3rdparty/*
+mv {qocoa,taglib,utf8-cpp}/ 3rdparty/
+
+mv 3rdparty/qocoa/LICENSE.txt 3rdparty/qocoa/LICENCE-qcocoa.txt
+mv 3rdparty/taglib/COPYING 3rdparty/taglib/COPYING-taglib
+
+
+
+%build
+mkdir %{_target_platform}
+pushd %{_target_platform}
+%{cmake} \
+ -DBUILD_WERROR:BOOL=OFF \
+ -DCMAKE_BUILD_TYPE:STRING=Release \
+ -DUSE_SYSTEM_QTSINGLEAPPLICATION=1 \
+ -DUSE_SYSTEM_QXT=1 \
+ ..
+popd
+
+%make_build -C %{_target_platform}
+
+
+%install
+make install DESTDIR=%{buildroot} -C %{_target_platform}
+install -Dpm 0644 %{S:1} %{buildroot}%{_metainfodir}/strawberry.appdata.xml
+
+
+%check
+desktop-file-validate %{buildroot}%{_datadir}/applications/strawberry.desktop
+appstream-util validate-relax --nonet %{buildroot}%{_metainfodir}/strawberry.appdata.xml
+
+
+%files
+%license COPYING 3rdparty/qocoa/LICENCE-qcocoa.txt 3rdparty/taglib/COPYING-taglib
+%doc Changelog
+%{_bindir}/strawberry
+%{_bindir}/strawberry-tagreader
+%{_metainfodir}/strawberry.appdata.xml
+%{_datadir}/applications/strawberry.desktop
+%{_datadir}/icons/hicolor/*/apps/strawberry.*
+%{_mandir}/man1/strawberry.1.*
+%{_mandir}/man1/strawberry-tagreader.1.*
+
+
+
+%changelog
+* Sat Oct 20 2018 Robert-Andr Mauchin <zebob.m(a)gmail.com> - 0.3.3-1
+- Initial package