13-gbd6f'/>
aboutsummaryrefslogblamecommitdiff
path: root/src/ui/mainvisual.cpp
blob: fdf7076e7404cc330009a1b35fad756e046c4953 (plain) (tree)
1
2
                                                                            
                                                                            



















                                                                             

                       
                        
                      
                 
                   





                       
                                       
 
                                  
 


                                                           

 
                                        
                                                       
 
                              
                              
                                                                         




                                                                 
                      



                         
                                                                 








                                                                      

                                   
                   

 
                                               
 










                                        

 
                        
 

                                   

                       
                    
             

 
                                                                 
 

                                        
 



                                    
     














                                                                                         
     



                          
                         
                     

                             
     
                                   
     



                                   
                      
 
                      
     
                              


                              
                    
     
             

 
                                           
 

                                       

 
                                         
 
                    

 
                                         
 

                         
 
 
                                                 
 


                                       
     
                        
                   
                                                
                                             
                                             







                                                         
         
                                  
                  

         

 
                                 
 
                                                
                                         



                                    
                            
                                             
     
                                               

                                                       





                                                   
     

 
                                 
 


                                                    







                                                        
 
                                                                 




                                                                              
 




                                                                                 
 
                                                                              
 




                                                                              
 





                                                                              

                                                                                        



                                           
        
                         
 
                              
                                            
                                
                                         

                     
 

 
                             
 



                                                                          
                                       

                                                                   
                                                          
                                                     
     
                                

                                
 









                                                                     
                                
                                     
     

                                                          
     
                                
                                     
     

                                                         
                                      



                                                             
                                   




                                                     
     
                                
                                    

     

                                                                     
                                               






                                                                 
                                

                                        
 

                                                               
                                            





                                                              
     
                                
                                     
     

                                                                   
                                            
             

 
 
                               
 
                                                                 

                                                                              
                                                    

                                                     
                              

                              
                                                                   

                                                               
                                                

                                                 
                              

                                                                        
                                                         

                                                          
                              

                                                                        
                                                         

                                                          
                              

                                                                         
                                                         

                                                          
                              

                                                                        
                                                            

                                                             
                              
 
                                    
                                                                        
 
                     

 

                           
                    
                                            
 
            
                              
                                                           
 

                                                          
 
                                                                 



                                                                                      
                                                                             
 

                                                                            

 

                     
 

                      
                               





                                 
                                         
 
                                
               
                           

                    
                             






                                                                           

                              



                                                  
 
             
     
                           
                                     

        
                     
                                                                 
                                      
 
                                 
     
                    
                                                                        
             
                                


                                
                                                                          
             
                                

                                
                
                          
                   
         
                                               
                               
                               
                              










                                                                  

         
                
 
 
                                 
 
                            
                
                                    
         
                                                           






                                                                                      


                                                                


                                                 




                                                                         











                                                                                      



                                                                                                 


                                                 






                                                                       

         
 

              
            
                              
                              



                   
                               
                                 
 
 

               
 


                                     
                     
 
                                      
                
 
                                


                                                            
 



                                           
     
                

 
                             
 
                              
     

                                            

                          
                                                           
                                                                      
     
                               
                                 
 
/***************************************************************************
 *   Copyright (C) 2007-2010 by Ilya Kotov                                 *
 *   forkotov02@hotmail.ru                                                 *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#include <QTimer>
#include <QSettings>
#include <QPainter>
#include <QMenu>
#include <QActionGroup>
#include <qmmp/buffer.h>
#include <qmmp/qmmp.h>
#include <math.h>
#include <stdlib.h>
#include "skin.h"
#include "fft.h"
#include "inlines.h"
#include "mainvisual.h"


MainVisual *MainVisual::m_instance = 0;

MainVisual *MainVisual::instance()
{
    if (!m_instance)
        qFatal ("MainVisual: this object is not created!");
    return m_instance;
}

MainVisual::MainVisual (QWidget *parent)
        : Visual (parent), m_vis (0), m_playing (false)
{
    m_skin = Skin::instance();
    m_ratio = m_skin->ratio();
    connect(m_skin, SIGNAL(skinChanged()), this, SLOT(updateSettings()));
    m_timer = new QTimer (this);
    connect(m_timer, SIGNAL (timeout()), this, SLOT (timeout()));
    m_nodes.clear();
    createMenu();
    readSettings();
    m_instance = this;
}

MainVisual::~MainVisual()
{
    QSettings settings(Qmmp::configFile(), QSettings::IniFormat);
    if (m_vis)
    {
        settings.setValue("Visualization/type",m_vis->name());
        delete m_vis;
        m_vis = 0;
    }
    else
        settings.setValue("Visualization/type", "None");
    settings.setValue("Visualization/rate", 1000/m_timer->interval());
    while (!m_nodes.isEmpty())
        delete m_nodes.takeFirst();
    m_instance = 0;
}

void MainVisual::setVisual (VisualBase *newvis)
{
    m_timer->stop();
    if (m_vis)
        delete m_vis;
    m_vis = newvis;
    if (m_vis)
        m_timer->start();
    else
    {
        m_pixmap.fill (Qt::transparent);
        update();
    }
}

void MainVisual::clear()
{
    while (!m_nodes.isEmpty())
        delete m_nodes.takeFirst();
    if (m_vis)
        m_vis->clear();
    m_pixmap = m_bg;
    update();
}

void MainVisual::add (unsigned char *data, qint64 size, int chan)
{
    if (!m_timer->isActive () || !m_vis)
        return;

    short *l = 0, *r = 0;
    qint64 samples = size/chan >> 1;
    int frames = samples/512;
    for (int i = 0; i < frames; ++i)
    {
        l = new short[512];
        r = 0;
        if (chan == 2)
        {
            r = new short[512];
            stereo16_from_stereopcm16 (l, r, (short *) (data + i*4*512), 512);
        }
        else if (chan == 1)
            mono16_from_monopcm16 (l, (short *) (data + i*2*512), 512);
        else
        {
            r = new short[512];
            stereo16_from_multichannel(l, r, (short *) (data + i*2*chan*512), 512, chan);
        }
        m_nodes.append (new VisualNode (l, r, 512));
    }
}

void MainVisual::timeout()
{
    VisualNode *node = 0;
    mutex()->lock ();

    while(m_nodes.size() > 5)
    {
        delete m_nodes.takeFirst();
    }

    if(!m_nodes.isEmpty())
        node = m_nodes.takeFirst();

    mutex()->unlock();

    if (m_vis && node)
    {
        m_vis->process (node);
        m_pixmap = m_bg;
        QPainter p(&m_pixmap);
        m_vis->draw (&p);
        delete node;
    }
    update();
}

void MainVisual::paintEvent (QPaintEvent *)
{
    QPainter painter (this);
    painter.drawPixmap (0,0, m_pixmap);
}

void MainVisual::hideEvent (QHideEvent *)
{
    m_timer->stop();
}

void MainVisual::showEvent (QShowEvent *)
{
    if (m_vis)
        m_timer->start();
}

void MainVisual::mousePressEvent (QMouseEvent *e)
{
    if (e->button() == Qt::RightButton)
        m_menu->exec(e->globalPos());
    else
    {
        m_pixmap = m_bg;
        if (!m_vis)
            setVisual(new mainvisual::Analyzer);
        else if (m_vis->name() == "Analyzer")
            setVisual(new mainvisual::Scope);
        else if (m_vis->name() == "Scope")
            setVisual(0);

        QString str = "Off";
        if (m_vis)
            str = m_vis->name();
        foreach(QAction *act, m_visModeGroup->actions ())
        if (str == act->data().toString())
        {
            act->setChecked(true);
            break;
        }
    }
}

void MainVisual::drawBackGround()
{
    m_bg = QPixmap (76 * m_ratio, 16 * m_ratio);
    if (m_transparentAction->isChecked())
    {
        m_bg.fill (Qt::transparent);
        return;
    }
    QPainter painter(&m_bg);
    for (int x = 0; x < 76 * m_ratio; x += 2)
    {
        painter.setPen(m_skin->getVisColor(0));
        painter.drawLine(x + 1, 0, x + 1, 16 *m_ratio);
        for (int y = 0; y < 16 *m_ratio; y += 2)
        {
            painter.setPen(m_skin->getVisColor(0));
            painter.drawPoint(x,y);
            painter.setPen(m_skin->getVisColor(1));
            painter.drawPoint(x,y + 1);
        }
    }
}

void MainVisual::updateSettings()
{
    m_ratio = m_skin->ratio();
    resize(76 * m_ratio, 16 * m_ratio);
    m_pixmap = QPixmap (76 * m_ratio, 16 * m_ratio);
    drawBackGround();
    m_pixmap = m_bg;
    update();
    QAction *act = m_fpsGroup->checkedAction ();
    if (act)
        m_timer->setInterval (1000/act->data().toInt());
    else
        m_timer->setInterval (40);

    QSettings settings(Qmmp::configFile(), QSettings::IniFormat);
    act = m_peaksFalloffGroup->checkedAction ();
    if (act)
        settings.setValue("Visualization/peaks_falloff", act->data().toInt());
    else
        settings.setValue("Visualization/peaks_falloff", 3);

    act = m_analyzerFalloffGroup->checkedAction ();
    if (act)
        settings.setValue("Visualization/analyzer_falloff", act->data().toInt());
    else
        settings.setValue("Visualization/analyzer_falloff", 3);

    settings.setValue("Visualization/show_peaks", m_peaksAction->isChecked());

    act = m_analyzerModeGroup->checkedAction();
    if (act)
        settings.setValue("Visualization/analyzer_mode", act->data().toInt());
    else
        settings.setValue("Visualization/analyzer_mode", 0);

    act = m_analyzerTypeGroup->checkedAction();
    if (act)
        settings.setValue("Visualization/analyzer_type", act->data().toInt());
    else
        settings.setValue("Visualization/analyzer_type", 1);

    settings.setValue("Visualization/transparent_bg", m_transparentAction->isChecked());

    act = m_visModeGroup->checkedAction ();
    QString visName;
    if (act)
        visName = act->data().toString();
    else
        visName == "Off";

    if (visName == "Analyzer")
        setVisual(new mainvisual::Analyzer);
    else if (visName == "Scope")
        setVisual(new mainvisual::Scope);
    else
        setVisual(0);

}

void MainVisual::createMenu()
{
    m_menu = new QMenu (this);
    connect(m_menu, SIGNAL(triggered (QAction *)),SLOT(updateSettings()));
    QMenu *visMode = m_menu->addMenu(tr("Visualization Mode"));
    m_visModeGroup = new QActionGroup(this);
    m_visModeGroup->setExclusive(true);
    m_visModeGroup->addAction(tr("Analyzer"))->setData("Analyzer");
    m_visModeGroup->addAction(tr("Scope"))->setData("Scope");
    m_visModeGroup->addAction(tr("Off"))->setData("None");
    foreach(QAction *act, m_visModeGroup->actions ())
    {
        act->setCheckable(true);
        visMode->addAction(act);
    }

    QMenu *analyzerMode = m_menu->addMenu(tr("Analyzer Mode"));
    m_analyzerModeGroup = new QActionGroup(this);
    m_analyzerTypeGroup = new QActionGroup(this);
    m_analyzerModeGroup->addAction(tr("Normal"))->setData(0);
    m_analyzerModeGroup->addAction(tr("Fire"))->setData(1);
    m_analyzerModeGroup->addAction(tr("Vertical Lines"))->setData(2);
    m_analyzerTypeGroup->addAction(tr("Lines"))->setData(0);
    m_analyzerTypeGroup->addAction(tr("Bars"))->setData(1);
    foreach(QAction *act, m_analyzerModeGroup->actions ())
    {
        act->setCheckable(true);
        analyzerMode->addAction(act);
    }
    analyzerMode->addSeparator ();
    foreach(QAction *act, m_analyzerTypeGroup->actions ())
    {
        act->setCheckable(true);
        analyzerMode->addAction(act);
    }
    analyzerMode->addSeparator ();
    m_peaksAction = analyzerMode->addAction(tr("Peaks"));
    m_peaksAction->setCheckable(true);


    QMenu *refreshRate = m_menu->addMenu(tr("Refresh Rate"));
    m_fpsGroup = new QActionGroup(this);
    m_fpsGroup->setExclusive(true);
    m_fpsGroup->addAction(tr("50 fps"))->setData(50);
    m_fpsGroup->addAction(tr("25 fps"))->setData(25);
    m_fpsGroup->addAction(tr("10 fps"))->setData(10);
    m_fpsGroup->addAction(tr("5 fps"))->setData(5);
    foreach(QAction *act, m_fpsGroup->actions ())
    {
        act->setCheckable(true);
        refreshRate->addAction(act);
    }

    QMenu *analyzerFalloff = m_menu->addMenu(tr("Analyzer Falloff"));
    m_analyzerFalloffGroup = new QActionGroup(this);
    m_analyzerFalloffGroup->setExclusive(true);
    m_analyzerFalloffGroup->addAction(tr("Slowest"))->setData(1);
    m_analyzerFalloffGroup->addAction(tr("Slow"))->setData(2);
    m_analyzerFalloffGroup->addAction(tr("Medium"))->setData(3);
    m_analyzerFalloffGroup->addAction(tr("Fast"))->setData(4);
    m_analyzerFalloffGroup->addAction(tr("Fastest"))->setData(5);
    foreach(QAction *act, m_analyzerFalloffGroup->actions ())
    {
        act->setCheckable(true);
        analyzerFalloff->addAction(act);
    }

    QMenu *peaksFalloff = m_menu->addMenu(tr("Peaks Falloff"));
    m_peaksFalloffGroup = new QActionGroup(this);
    m_peaksFalloffGroup->setExclusive(true);
    m_peaksFalloffGroup->addAction(tr("Slowest"))->setData(1);
    m_peaksFalloffGroup->addAction(tr("Slow"))->setData(2);
    m_peaksFalloffGroup->addAction(tr("Medium"))->setData(3);
    m_peaksFalloffGroup->addAction(tr("Fast"))->setData(4);
    m_peaksFalloffGroup->addAction(tr("Fastest"))->setData(5);
    foreach(QAction *act, m_peaksFalloffGroup->actions ())
    {
        act->setCheckable(true);
        peaksFalloff->addAction(act);
    }
    QMenu *background = m_menu->addMenu(tr("Background"));
    m_transparentAction = background->addAction(tr("Transparent"));
    m_transparentAction->setCheckable(true);
    update();
}


void MainVisual::readSettings()
{
    QSettings settings(Qmmp::configFile(), QSettings::IniFormat);

    QString name = settings.value("Visualization/type","Analyzer").toString();
    m_visModeGroup->actions ()[0]->setChecked(true);
    foreach(QAction *act, m_visModeGroup->actions ())
    if (name == act->data().toString())
        act->setChecked(true);

    m_peaksAction->setChecked(