wavewidget.cc

/*
 * SubTimer source file
 *  Copyright (C) 2005 Peter Salvi
 *   Last modification: <2005.03.23., 16:21:02>
 *
 *  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 <qapplication.h>
#include <qbrush.h>
#include <qevent.h>
#include <qmessagebox.h>
#include <qmutex.h>
#include <qpainter.h>
#include <qpen.h>
#include <qpixmap.h>
#include <qsize.h>
#include <qsizepolicy.h>
#include <qstring.h>
#include <qtimer.h>
#include <qwidget.h>

#include "common.hh"
#include "oggwave.hh"
#include "playthread.hh"
#include "wavefile.hh"
#include "wavewidget.hh"

WaveWidget::WaveWidget(QWidget *parent, const char *name) 
  : QWidget (parent, name)
{
  wave_file = NULL;
  playdata = NULL;
  playing = false;

  pthread = new PlayThread;
  paint_lock = new QMutex;

  paint_timer = new QTimer(this);
  connect(paint_timer, SIGNAL(timeout()), this, SLOT(repaint()));
  
  xzoom = (int)(4 * 640.0 / MAX_PIXPERSEC); yzoom = 4;
  setBackgroundMode(Qt::NoBackground);
}

WaveWidget::~WaveWidget()
{
  if(wave_file != NULL) {
    if(wave_file->isOpen())
      wave_file->close();
    delete wave_file;
  }
  if(playdata != NULL)
    delete[] playdata;
  delete pthread;
  delete paint_lock;
  delete paint_timer;
}

bool WaveWidget::loadFile(QString const fname)
{
  WaveFile *tmpwave;
  if(fname.right(4).upper() == ".OGG")
    tmpwave = new OggWave();
  else
    return false;               // no other file formats implemented yet

  if(!tmpwave->open(fname, xzoom)) {
    delete tmpwave;
    return false;
  }

  if(wave_file != NULL) {
    if(wave_file->isOpen())
      wave_file->close();
    delete wave_file;
  }
  wave_file = tmpwave;

  start_time = QTime(0, 0);
  end_time = QTime(0, 0, 2);
  left = QTime(0, 0);
  right = left.addSecs(xzoom);
  emit lengthChanged(MSECS(wave_file->length()) -
                    xzoom * 1000);

  return true;
}

bool WaveWidget::isVisible(QTime const t) const
{
  return (t > left) & (t < right);
}

void WaveWidget::setStartTime(QTime t)
{
  start_time = t;
  repaint();
}

void WaveWidget::setEndTime(QTime t)
{
  end_time = t;
  repaint();
}

QTime WaveWidget::startTime() const 
{ 
  return start_time; 
}

QTime WaveWidget::endTime() const 
{ 
  return end_time; 
}

void WaveWidget::setXZoom(int zoom) 
{ 
  xzoom = (int)(std::pow(2.0, zoom - 1) * (640.0 / MAX_PIXPERSEC)); 
  right = left.addSecs(xzoom);
  if(SECS(wave_file->length()) < xzoom)
    emit lengthChanged(0);
  else
    emit lengthChanged(MSECS(wave_file->length()) - xzoom * 1000);
  wave_file->changeRes(xzoom);
  repaint(); 
}

void WaveWidget::setYZoom(int zoom) 
{ 
  yzoom = zoom; 
  repaint(); 
}

void WaveWidget::scrollTo(int start)
{
  if(wave_file != NULL)
    if(wave_file->isOpen()) {
      if(SECS(wave_file->length()) < xzoom) {
        left = QTime(0, 0);
        right = left.addSecs(xzoom);
      } else if(SECS(wave_file->length()) - start < xzoom) {
        right = wave_file->length();
        left = QTIME_MS(MSECS(right) - xzoom * 1000);
      } else {
        right = QTIME_S(start).addSecs(xzoom);
        left = QTIME_S(start);
      }
      emit positionChanged(start);
      repaint();
    }
}

void WaveWidget::customEvent(QCustomEvent *e)
{
  if(e->type() == (QEvent::Type)PlayThread::Finished) {
    playing = false;
    paint_timer->stop();
    repaint();
  }
}

void WaveWidget::mousePressEvent(QMouseEvent *e)
{
  QTime tmp = left.addMSecs((int)((double)(1000.0 * xzoom) * 
                                  ((double)e->x() / (double)width())));
  QTime const max = wave_file->length();
  if(tmp < max)
    if(e->button() == Qt::LeftButton) {
      if(tmp > end_time) {
        end_time = tmp.addSecs(2);
        if(end_time > max)
          end_time = max;
        emit endTimeChanged(&end_time);
      }
      start_time = tmp;
      emit startTimeChanged(&start_time);
    }
    else if(e->button() == Qt::RightButton) {
      if(tmp >= start_time) {
        end_time = tmp;
        emit endTimeChanged(&end_time);
      }
    }
  repaint();
}

void WaveWidget::paintEvent(QPaintEvent *) 
{
  QPixmap pm(width(), height());  
  QPainter p(&pm);
  QPen pen;

  pm.fill(QColor(10, 10, 10));

  if(wave_file != NULL)
    if(wave_file->isOpen()) {
      int tmp;
      int const t_width = 640, t_height = height();
      char *buf = new char[t_width * 2];

      wave_file->getDispBuffer(left, buf);

      p.setViewport(0, 0, t_width, t_height);
      p.setWindow(0, 0, t_width, t_height);
      pen.setWidth(1);
      pen.setColor(QColor(60, 60, 60));
      p.setPen(pen);
      p.drawLine(0, t_height / 2, t_width, t_height / 2);
      pen.setColor(QColor(120, 120, 120));
      p.setPen(pen);
      for(int i = 0; i < t_width; ++i) {
        int offs = (int)buf[i * 2] * yzoom / 10;
        if(offs > t_height / 2) offs = t_height / 2;
        if(offs < -t_height / 2) offs = -t_height / 2;
        p.drawLine(i, t_height / 2, i, t_height / 2 + offs);
        offs = (int)buf[i * 2 + 1] * yzoom / 10;
        if(offs > t_height / 2) offs = t_height / 2;
        if(offs < -t_height / 2) offs = -t_height / 2;
        p.drawLine(i, t_height / 2, i, t_height / 2 + offs);    
      }
      pen.setColor(QColor(30, 180, 30));
      p.setPen(pen);
      tmp = timeToPos(start_time);
      p.drawLine(tmp, 0, tmp, t_height-1);
      pen.setColor(QColor(180, 30, 30));
      p.setPen(pen);
      tmp = timeToPos(end_time);
      p.drawLine(tmp, 0, tmp, t_height-1);

#ifdef WHITE_LINE
      if(playing) {
        pen.setColor(QColor(200, 200, 200));
        p.setPen(pen);
        paint_lock->lock();
        int const offset = (int)((double)(MSECS(play_end) - 
                                    MSECS(play_start)) * play_position);
        paint_lock->unlock();
        tmp = timeToPos(QTIME_MS(MSECS(play_start) + offset));
        p.drawLine(tmp, 0, tmp, t_height-1);
      }
#endif // WHITE_LINE

      delete[] buf;
    }
  bitBlt(this, 0, 0, &pm);
}

void WaveWidget::playSelected()
{
  if(playing)
    return;
  
  WaveFormat f;
  wave_file->waveFormat(f);

  char const *pcm_name = strdup("plughw:0,0");
  if(snd_pcm_open(&playback_handle, pcm_name, 
                  SND_PCM_STREAM_PLAYBACK, 0) < 0) {
    QMessageBox::critical(this, tr("Cannot open PCM device"),
                          tr("Cannot open the PCM device!"), 
                          QMessageBox::Cancel, QMessageBox::NoButton);
    return;
  }
  
  snd_pcm_hw_params_t *hw_params;
  if(snd_pcm_hw_params_malloc(&hw_params) < 0) {
    QMessageBox::critical(this, tr("Cannot configure PCM device"),
                          tr("Cannot configure the PCM device!"), 
                          QMessageBox::Cancel, QMessageBox::NoButton);
    return;
  }
  if(snd_pcm_hw_params_any(playback_handle, hw_params) < 0) {
    QMessageBox::critical(this, tr("Cannot configure PCM device"),
                          tr("Cannot configure the PCM device!"), 
                          QMessageBox::Cancel, QMessageBox::NoButton);
    return;
  }

  if(snd_pcm_hw_params_set_access(playback_handle, hw_params, f.access) < 0) {
    QMessageBox::critical(this, tr("Cannot set access mode"),
                          tr("Cannot set access mode!"), 
                          QMessageBox::Cancel, QMessageBox::NoButton);
    return;
  }
  if(snd_pcm_hw_params_set_format(playback_handle, hw_params, f.format) < 0) {
    QMessageBox::critical(this, tr("Cannot set PCM format"),
                          tr("Cannot set PCM format!"), 
                          QMessageBox::Cancel, QMessageBox::NoButton);
    return;
  }
  if(snd_pcm_hw_params_set_rate_near(playback_handle, 
                                     hw_params, &f.rate, 0) < 0) {
    QMessageBox::critical(this, tr("Cannot set PCM rate"),
                          tr("Cannot set PCM rate!"), 
                          QMessageBox::Cancel, QMessageBox::NoButton);
    return;
  }
  if(snd_pcm_hw_params_set_channels(playback_handle, 
                                    hw_params, f.channels) < 0) {
    QMessageBox::critical(this, tr("Cannot set the number of channels"),
                          tr("Cannot set the number of channels!"), 
                          QMessageBox::Cancel, QMessageBox::NoButton);
    return;
  }

  if(snd_pcm_hw_params(playback_handle, hw_params) < 0) {
    QMessageBox::critical(this, tr("Cannot configure PCM device"),
                          tr("Cannot configure the PCM device!"), 
                          QMessageBox::Cancel, QMessageBox::NoButton);
    return;
  }
  snd_pcm_hw_params_free(hw_params);
        
  if(snd_pcm_prepare(playback_handle) < 0) {
    QMessageBox::critical(this, tr("Cannot prepare PCM device"),
                          tr("Cannot prepare the PCM device!"), 
                          QMessageBox::Cancel, QMessageBox::NoButton);
    return;
  }

  playing = true;
  if(playdata != NULL)
    delete[] playdata;
  play_position = 0.0;

  playsize = wave_file->getPlayBufferSize(start_time, end_time);
  playdata = new char[playsize];
  wave_file->getPlayBuffer(start_time, playdata, playsize);

  pthread->initThread(this, playback_handle, paint_lock, &play_position);
  pthread->loadData(playdata, playsize, f);
  pthread->start();

#ifdef WHITE_LINE
  play_start = start_time;
  play_end = end_time;
  paint_timer->start(PAINT_FREQ);
#endif // WHITE_LINE
}

void WaveWidget::stopPlayback()
{
  if(!playing)
    return;

  QApplication::postEvent(pthread, new QCustomEvent(PlayThread::Stop));
}

int WaveWidget::timeToPos(QTime t)
{
  return (int)(((double)left.msecsTo(t) / (double)(1000.0 * xzoom)) * 
               (double)width());
}

---