level.cpp

一个KDE下的录音程序

/*
 * level.cpp. Part of krecord by Gerd Knorr.
 *
 * Displays the input level.
 *
 * Copyright (C) 1998 Florian Kolbe
 *
 * History:
 *
 * Jun 04 1998 Florian Kolbe
 *    Created
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <math.h>
#include <limits.h>

#include <sys/types.h>

#include <qwidget.h>
#include <qpixmap.h>
#include <qpainter.h>
#include <qcolor.h>
#include <qtimer.h>

#include "sound.h"
#include "level.moc"

#ifndef min
#define min(a,b) ((a) < (b) ? (a) : (b))
#endif

#ifndef max
#define max(a,b) ((a) > (b) ? (a) : (b))
#endif

/* ---------------------------------------------------------------------- */

LevelWindow::LevelWindow(QWidget *parent, char *name):QWidget(parent,name,0)
{
    /* which type of vu-meter ? */
    PowervsMax=1;
    LogvsLinear=1;
    
    /*
      did not get sound-params yet.
    */
    init  = FALSE;
    sdata = NULL;
    
    /*
      no peaks initially.
    */
    peak[0] = 0;
    peak[1] = 0;
    
    clipLeft=false;
    clipRight=false;
    
    /*
      will use output buffer, so no background necessary.
    */
    setBackgroundMode(NoBackground);
    orange = QColor("orangered");
    
    /*
      Initialize output buffer.
    */   
    buffer = new QPixmap(size());
    
    /*
      Initialize timers to reset peaks.
    */
    timer[0] = new QTimer();
    timer[1] = new QTimer();
    connect(timer[0], SIGNAL(timeout()), this, SLOT(resetPeakLeft()));
    connect(timer[1], SIGNAL(timeout()), this, SLOT(resetPeakRight()));
    
} /* LevelWindow */

LevelWindow::~LevelWindow(void)
{    
    delete buffer;
    delete timer[0];
    delete timer[1];
}

void LevelWindow::resizeEvent(QResizeEvent*)
{
    /*
      Fix size of output buffer.
    */
    delete buffer;
    buffer = new QPixmap(size());   
}

void LevelWindow::resetPeakLeft(void)
{
    peak[0] = 0;
    clipLeft = false;
    repaint();
}

void LevelWindow::resetPeakRight(void)
{
    peak[1] = 0;
    clipRight = false;
    repaint();
}

void LevelWindow::drawBar(QPainter& painter, int channel, float level,
			  int size, bool drawRed)
{
    int xLevel = (int)(((float)width())*level); /* x-pos of current level */
    int x80    = width()*80/100;    /* x-pos of 80% level     */
    int y,x;
    
    /*
      Left/mono top, right bottom.
    */
    if (channel == 0) {
	y = 0;
    } else {
	y = height()/2;
    }
    
    const QColor *colortodraw=&darkGreen;
    if (drawRed) {
	colortodraw=&red;
    }
    
    /*
      Green: 0%-[level|80%]
    */
    painter.fillRect(0, y+1, max(1, min(xLevel, x80)), size-2, *colortodraw);
    
    /*
      Yellow part.
    */
    if (!drawRed) {
	colortodraw=&darkYellow;
    }
    
    if (level > 0.8) {
	painter.fillRect(x80, y+1, max(1, xLevel-x80), size-2, *colortodraw);
    }
    
    /*
      Current peak is either reached again or pushed.
    */
    if (level >= peak[channel]) {
	peak[channel] = level;
	timer[channel]->start(1000, TRUE);
    }
    
    /*
      Draw peak if greater than current level.
    */
    if (peak[channel] >= level) {
	
	/*
          0- 80: green
	  80- 98: yellow
	  99-100: orange
	*/
	painter.setPen(green);
	if (peak[channel] > 0.80) {
	    painter.setPen(yellow);
	}
	if (peak[channel] >= 0.99) {
	    painter.setPen(orange);
	}
	x = (int)min(width()*peak[channel]-1,width()-1);
	painter.drawLine(x, y+1, x, y+size-2);
    }
} /* drawBar */

void LevelWindow::paintEvent(QPaintEvent*)
{
   int      maxLeft  = 0;
   int      maxRight = 0;
   int      i;
   QPainter painter;
   int      maxAmp;
   int64_t powerLeft=0;
   int64_t powerRight=0;
   float    floatPowerLeft=0;
   float    floatPowerRight=0;
   char     buf[32];

#ifndef NO_COMPENSATE_BIAS
   int64_t bLeft=0;
   int64_t bRight=0;
#endif


   if ((init == FALSE) || !sdata) return;
   
   /* if true then calculate Power else calculate Max */
   if (PowervsMax) {
     /*
       Calculate power of the signal depending on format.

       Since the signal may not have an average value of 0 precisely,
       we shouldn't simply calculate:

       sum_for_all_samples (pulse_value