Ticket #4479: lyrics_visualizer.patch

visualize.cpp

@@ -22 +22 @@
 // mythtv
 #include <mythtv/mythdbcon.h>
 #include <mythtv/mythcontext.h>
+#include <mythtv/libmythui/mythuihelper.h>
 
 // mythmusic
 #include "mainvisual.h"
@@ -455 +456 @@
     }
 }AlbumArtFactory;
 
+Lyrics::Lyrics(MainVisual *parent)
+{
+    m_pParent = parent;
+
+    findFrontCover();
+
+    Decoder *dec = m_pParent->decoder();
+    if (dec)
+        m_filename = dec->getFilename();
+
+    fps = 1;
+}
+
+void Lyrics::findFrontCover(void)
+{
+    // if a front cover image is available show that first
+    AlbumArtImages albumArt(m_pParent->metadata());
+    if (albumArt.getImage(IT_FRONTCOVER))
+        m_currImageType = IT_FRONTCOVER;
+    else
+    {
+        // not available so just show the first image available
+        if (albumArt.getImageCount() > 0)
+            m_currImageType = albumArt.getImageAt(0)->imageType;
+        else
+            m_currImageType = IT_UNKNOWN;
+    }
+}
+
+Lyrics::~Lyrics()
+{
+}
+
+void Lyrics::resize(const QSize &newsize)
+{
+    m_size = newsize;
+}
+
+bool Lyrics::process(VisualNode *node)
+{
+    node = node;
+    return true;
+}
+
+void Lyrics::handleKeyPress(const QString &action)
+{
+    if (action == "DOWN")
+    {
+        if (m_start + 1 + m_visible_lines < int(m_lyrics.size()))
+            m_start++;
+    }
+
+    if (action == "UP")
+    {
+        if (m_start != 0)
+            m_start--;
+    }
+
+    if (action == "PAGEDOWN")
+    {
+        if (m_start + m_page_amount + m_visible_lines < int(m_lyrics.size()))
+            m_start += m_page_amount;
+        else
+            m_start = int(m_lyrics.size()) - m_page_amount;
+    }
+
+    if (action == "PAGEUP")
+    {
+        if (m_start < m_page_amount)
+            m_start = 0;
+        else
+            m_start -= m_page_amount;
+    }
+
+    if (action == "SELECT")
+    {
+        AlbumArtImages albumArt(m_pParent->metadata());
+        int newType = m_currImageType;
+
+        if (albumArt.getImageCount() > 0)
+        {
+            newType++;
+
+            while (!albumArt.getImage((ImageType) newType))
+            {
+                newType++;
+                if (newType == IT_LAST)
+                    newType = IT_UNKNOWN;
+            }
+        }
+
+        if (newType != m_currImageType)
+        {
+            m_currImageType = (ImageType) newType;
+            // force an update
+            m_cursize = QSize(0, 0);
+        }
+    }
+}
+
+bool Lyrics::needsUpdate() 
+{
+    if (m_cursize != m_size)
+        return true;
+
+    if (m_filename != m_pParent->decoder()->getFilename()) 
+    {
+        m_filename = m_pParent->decoder()->getFilename();
+        findFrontCover();
+        return true;
+    }
+
+    return false;
+}
+
+void Lyrics::calculateScreenInfo(QPainter *p)
+{
+    m_start = 0;
+    m_indentx = 0;
+    m_indenty = 0;
+    m_max_line_width = 0;
+    m_visible_lines = 0;
+    m_page_amount = 0;
+    m_font_height = 0;
+    m_lyrics_too_wide = false;
+    m_image_too_small = false;
+
+    if (!m_lyrics.empty())
+    {
+        p->setFont(GetMythUI()->GetMediumFont());
+       
+        QFontMetrics fm(p->font());
+        m_font_height = fm.height();
+
+        for (QVector<QString>::iterator i = m_lyrics.begin();
+                                        i != m_lyrics.end(); i++)
+        {
+            int width = fm.width(*i);
+            if (width > m_max_line_width) m_max_line_width = width;
+        }
+
+        m_indentx = int(0.03 * m_size.width());
+        m_indenty = int(0.03 * m_size.height());
+
+        if ((m_max_line_width + 2 * m_indentx) > m_size.width())
+        {
+            // Lyrics don't fit.  Remove them.
+            m_lyrics.clear();
+            m_max_line_width = 0;
+            m_indentx = 0;
+            m_indenty = 0;
+            m_lyrics_too_wide = true;
+        }
+        else
+        {
+            m_visible_lines = (m_size.height() - 2 * m_indenty) / m_font_height;
+            m_page_amount = m_visible_lines / 2;
+            if (m_size.width() < m_max_line_width + 3 * m_indentx +
+                                     int(0.1 * m_size.width()))
+            {
+                // Don't draw really small images
+                m_image_too_small = true;
+            }
+        }
+    }
+}
+
+bool Lyrics::draw(QPainter *p, const QColor &back)
+{
+    if (!m_pParent->decoder())
+        return false;
+
+    // If the song has changed or the size, reload
+    if (needsUpdate())
+    {
+        m_lyrics = m_pParent->metadata()->getUnsynchronizedLyrics();
+        calculateScreenInfo(p);
+
+        // Now we know how much room we have for the image.
+        QImage art(m_pParent->metadata()->getAlbumArt(m_currImageType));
+        if (art.isNull())
+        {
+            m_cursize = m_size;
+            m_image = QImage();
+        }
+        else if (!m_image_too_small)
+        {
+            int height_adjustment = m_lyrics_too_wide ?  m_font_height : 0;
+            QSize a_size(m_size.width() - m_max_line_width - 3 * m_indentx,
+                         m_size.height() - height_adjustment);
+            m_image = art.scaled(a_size, Qt::KeepAspectRatio,
+                                         Qt::SmoothTransformation);
+        }
+    }
+
+    if (m_image.isNull() && !m_image_too_small && m_lyrics.empty())
+    {
+        drawWarning(p, back, m_size, QObject::tr("?"));
+        return true;
+    }
+
+    p->fillRect(0, 0, m_size.width(), m_size.height(), back);
+
+    // Paint the image
+    if (!m_image_too_small)
+    {
+        int xpos = (m_size.width() - m_max_line_width -
+                                   m_indentx - m_image.width()) /2;
+        int ypos = m_lyrics_too_wide ? 0 :
+                               (m_size.height() - m_image.height()) / 2;
+        p->drawImage(xpos, ypos, m_image);
+    }
+
+    // Paint the Lyrics
+    p->setFont(GetMythUI()->GetMediumFont());
+    if (m_lyrics_too_wide)
+    {
+        // Lyrics are too wide to fit on the display.  Just write "Lyrics"
+        // at the bottom on the display to indicate they are available.
+        QFontMetrics fm(p->font());
+        QString l = "Lyrics";
+        int width = fm.width(l);
+        int height = m_font_height;
+        int x = m_size.width() / 2 - width / 2;
+        int y = m_size.height() - height;
+        p->setPen(Qt::white);
+        p->drawText(x, y, width, height, Qt::AlignCenter, l);
+    }
+    else
+    {
+        int textWidth = m_max_line_width;
+        int textHeight = m_font_height * m_lyrics.size();
+        int x = m_size.width() - m_max_line_width - m_indentx;
+        int y = m_indenty;
+   
+        int line = m_start;
+        for (int offset = 0;
+             line <= m_start + m_visible_lines-1 && line < int(m_lyrics.size());
+             offset += m_font_height, line++)
+        {
+            QString l = m_lyrics[line] + "\n";
+            p->setPen(Qt::white);
+            p->drawText(x, y + offset, textWidth, textHeight, Qt::AlignLeft, l);
+        }
+    }
+
+    // Store our new size
+    m_cursize = m_size;
+
+    return true;
+}
+
+static class LyricsFactory : public VisFactory
+{
+  public:
+    const QString &name(void) const
+    {
+        static QString name("Lyrics");
+        return name;
+    }
+
+    uint plugins(QStringList *list) const
+    {
+        *list << name();
+        return 1;
+    }
+
+    VisualBase *create(MainVisual *parent, long int winid, const QString &pluginName) const
+    {
+        (void)winid;
+        (void)pluginName;
+        return new Lyrics(parent);
+    }
+}LyricsFactory;
+
 Blank::Blank()
     : VisualBase(true)
 {

metadata.cpp

@@ -871 +871 @@
 
 //--------------------------------------------------------------------------
 
+QVector<QString> Metadata::getUnsynchronizedLyrics()
+{
+    QVector<QString> ulyrics;
+
+    ulyrics = MetaIOID3::getUnsynchronizedLyrics(m_filename);
+
+    return ulyrics;
+}
+
 MetadataLoadingThread::MetadataLoadingThread(AllMusic *parent_ptr)
 {
     parent = parent_ptr;

metadata.h

@@ -194 +194 @@
     QImage getAlbumArt(void);
     // this looks only for the given image type
     QImage getAlbumArt(ImageType type);
+    QVector<QString> getUnsynchronizedLyrics();
 
   private:
     void setCompilationFormatting(bool cd = false);

metaioid3.cpp

@@ -344 +344 @@
 }
 
 /*!
+ *
+ */
+QVector<QString> MetaIOID3::getUnsynchronizedLyrics(QString filename)
+{
+  QVector<QString> ulyrics;
+
+  TagLib::MPEG::File *taglib = new TagLib::MPEG::File(filename.local8Bit());
+  if (taglib != NULL)
+  {
+      TagLib::ID3v2::Tag *tag = taglib->ID3v2Tag();
+
+      if (tag != NULL && !tag->frameListMap()["USLT"].isEmpty())
+      {
+          TagLib::ID3v2::FrameList ulyricframes = tag->frameListMap()["USLT"];
+
+          // No special support for multiple USLT frames.  Just concatenate
+          // them all into one vector.
+          for(TagLib::ID3v2::FrameList::Iterator it = ulyricframes.begin();
+                                               it != ulyricframes.end(); ++it)
+          {
+              QString lstr = TStringToQString((*it)->toString());
+              QStringList sl = QStringList::split("\n", lstr, TRUE);
+              for (QStringList::Iterator it = sl.begin(); it != sl.end(); ++it)
+                  ulyrics.push_back(*it);
+          }
+      }
+      delete taglib;
+  }
+  if (ulyrics.size() == 1)
+  {
+      // It is useful to use only one line of the lyrics when it has no lyrics
+      // (classical music for example) to quiet tools that look for missing
+      // lyrics.  Just clear that line so it isn't displayed.
+      ulyrics.clear();
+  }
+  return ulyrics;
+}
+
+/*!
  * \brief Find the a custom comment tag by description.
  *        This is a copy of the same function in the
  *        TagLib::ID3v2::UserTextIdentificationFrame Class with a static

visualize.h

@@ -101 +101 @@
     QImage m_image;
 };
 
+class Lyrics : public VisualBase
+{
+  public:
+    Lyrics(MainVisual *parent);
+    virtual ~Lyrics();
+
+    void resize(const QSize &size);
+    bool process(VisualNode *node = 0);
+    bool draw(QPainter *p, const QColor &back = Qt::black);
+    void handleKeyPress(const QString &action);
+
+  private:
+    bool needsUpdate(void);
+    void findFrontCover(void);
+    void calculateScreenInfo(QPainter *p);
+
+    QSize m_size, m_cursize;
+    QString m_filename;
+    ImageType m_currImageType;
+    MainVisual *m_pParent;
+    QImage m_image;
+    QVector<QString> m_lyrics;
+    int m_start;
+    int m_page_amount;
+    int m_indentx;
+    int m_indenty;
+    int m_visible_lines;
+    int m_max_line_width;
+    int m_font_height;
+    bool m_lyrics_too_wide;
+    bool m_image_too_small;
+};
+
 class Blank : public VisualBase
 {
     // This draws ... well ... nothing  

metaioid3.h

@@ -41 +41 @@
     bool write(Metadata* mdata);
     Metadata* read(QString filename);
     static QImage getAlbumArt(QString filename, ImageType type);
+    static QVector<QString> getUnsynchronizedLyrics(QString filename);
 
   private:
     TagLib::MPEG::File *OpenFile(const QString &filename);