AbstractTask drawing amplitude graph of a given Signal in a bitmap. More...

#include <signal_plot.h>

Inheritance diagram for Beatmup::Audio::SignalPlot:

Public Member Functions
	SignalPlot ()

void	setSignal (Signal *)
	Sets the input signal to plot. More...

void	setBitmap (AbstractBitmap *)
	Sets the output bitmap. More...

void	setPlotArea (IntRectangle)
	Specifies a rectangular area in pixels in the output bitmap where the plot will be drawn. More...

void	setWindow (IntRectangle window, float scale)
	Specifies a time range (X coordinate) and a magnitude range (Y coordinate scaled by `scale`) that will be plotted. More...

void	setPalette (color4i bgColor, color4i color1, color4i color2)
	Specifies plot colors. More...

void	setChannels (int channels)
	Specifies which channels to plot. More...

AbstractBitmap *	getBitmap () const

Signal *	getSignal () const

Public Member Functions inherited from Beatmup::AbstractTask
virtual bool	processOnGPU (GraphicPipeline &gpu, TaskThread &thread)
	Executes the task on GPU. More...

Public Member Functions inherited from Beatmup::Object
virtual	~Object ()

Protected Member Functions
virtual bool	process (TaskThread &thread)
	Executes the task on CPU within a given thread. More...

virtual void	beforeProcessing (ThreadIndex, ProcessingTarget target, GraphicPipeline *)
	Instruction called before the task is executed. More...

virtual void	afterProcessing (ThreadIndex, GraphicPipeline *, bool)
	Instruction called after the task is executed. More...

virtual TaskDeviceRequirement	getUsedDevices () const
	Communicates devices (CPU and/or GPU) the task is run on. More...

virtual ThreadIndex	getMaxThreads () const
	Gives the upper limint on the number of threads the task may be performed by. More...

Private Member Functions
void	getPlot (TaskThread &thread, std::vector< int > &data, int &left, int &right)

Private Member Functions inherited from Beatmup::BitmapContentLock
	BitmapContentLock ()

	~BitmapContentLock ()

void	readLock (GraphicPipeline gpu, AbstractBitmap bitmap, ProcessingTarget target)
	Locks content of a bitmap for reading using a specific processing target device. More...

void	writeLock (GraphicPipeline gpu, AbstractBitmap bitmap, ProcessingTarget target)
	Locks content of a bitmap for writing using a specific processing target device. More...

void	unlock (AbstractBitmap *bitmap)
	Drops a lock to the bitmap. More...

void	unlockAll ()
	Unlocks all the locked bitmaps unconditionally. More...

template<const ProcessingTarget target>
void	lock (GraphicPipeline gpu, AbstractBitmap input, AbstractBitmap *output)

void	lock (GraphicPipeline gpu, ProcessingTarget target, AbstractBitmap input, AbstractBitmap *output)

template<const ProcessingTarget target>
void	lock (GraphicPipeline gpu, std::initializer_list< AbstractBitmap > read, std::initializer_list< AbstractBitmap * > write)

template<typename ... Args>
void	unlock (AbstractBitmap *first, Args ... others)

Private Attributes
Signal *	signal

AbstractBitmap *	bitmap

IntRectangle	outputRect

IntRectangle	signalWindow

float	scale

int	channels

std::vector< int >	values

struct {
color4i bgColor

color4i color1

color4i color2

}	palette

Additional Inherited Members
Public Types inherited from Beatmup::AbstractTask
enum class	TaskDeviceRequirement { CPU_ONLY , GPU_OR_CPU , GPU_ONLY }
	Specifies which device (CPU and/or GPU) is used to run the task. More...

Static Public Member Functions inherited from Beatmup::AbstractTask
static ThreadIndex	validThreadCount (int number)
	Valid thread count from a given integer value. More...

Detailed Description

AbstractTask drawing amplitude graph of a given Signal in a bitmap.

Definition at line 31 of file signal_plot.h.

Constructor & Destructor Documentation

◆ SignalPlot()

SignalPlot::SignalPlot ( )

Definition at line 191 of file signal_plot.cpp.

                       :
     signal(NULL), bitmap(NULL), outputRect(0,0,100,100), signalWindow(0,-32768,100,32767), scale(1.0f), channels(-1)
     //fixme: set reasonable values
 {
     palette.bgColor = Color::WHITE;
     palette.color1 = Color::DARK_SEA_GREEN1;
     palette.color2 = Color::DARK_SEA_GREEN2;
 }

Member Function Documentation

◆ getPlot()

void SignalPlot::getPlot	(	TaskThread &	thread,
		std::vector< int > &	data,
		int &	left,
		int &	right
	)

private

Definition at line 130 of file signal_plot.cpp.

                                                                                         {
     const dtime
         startTime = signalWindow.a.x + thread.currentThread() * signalWindow.width() / thread.numThreads(),
         stopTime  = signalWindow.a.x + (thread.currentThread() + 1) * signalWindow.width() / thread.numThreads(),
         length = stopTime - startTime;
     left = thread.currentThread() * outputRect.width() / thread.numThreads();
     right = (thread.currentThread() + 1) * outputRect.width() / thread.numThreads();
  
     const int width = right - left;
  
     const float
         mag = (float)signalWindow.height(),
         heightMag = (outputRect.height() - 1) / mag;
  
     // measure!
     const int count = width * signal->getChannelCount();
     typedef sample16 sample;
     sample *min = new sample[count], *max = new sample[count];
     Signal::Meter ptr(*signal, startTime);
     ptr.measure<sample>(length, width, min, max);
  
     // compute bin heights in function of the channel mode
     // single channel
     if (0 <= channels && channels < signal->getChannelCount()) {
         data.reserve(2 * width);
         sample* pMin = min + channels, *pMax = max + channels;
         for (int x = 0; x < width; x++) {
             data.push_back( outputRect.b.y - (int)std::min(std::max(.0f, pMin->x * scale - signalWindow.a.y), mag) * heightMag );
             data.push_back( outputRect.b.y - (int)std::min(std::max(.0f, pMax->x * scale - signalWindow.a.y), mag) * heightMag );
             pMin += channels;
             pMax += channels;
         }
     }
     // combined channels: minmin --- minmax *** maxmin --- maxmax
     else {
         data.reserve(4 * width);
         sample* pMin = min, *pMax = max;
         for (int x = 0; x < width; x++) {
             sample ymm = *pMin++, ymM = ymm, yMm = *pMax++, yMM = yMm;
             for (int ch = 1; ch < signal->getChannelCount(); ch++) {
                 ymm = std::min(ymm, *pMin);
                 ymM = std::max(ymM, *pMin++);
                 yMm = std::min(yMm, *pMax);
                 yMM = std::max(yMM, *pMax++);
             }
             if (yMm < ymM) {
                 sample _ = ymM;
                 ymM = yMm;
                 yMm = _;
             }
             data.push_back(outputRect.b.y - (int)std::min(std::max(.0f, yMM.x * scale - signalWindow.a.y), mag) * heightMag);
             data.push_back(outputRect.b.y - (int)std::min(std::max(.0f, yMm.x * scale - signalWindow.a.y), mag) * heightMag);
             data.push_back(outputRect.b.y - (int)std::min(std::max(.0f, ymM.x * scale - signalWindow.a.y), mag) * heightMag);
             data.push_back(outputRect.b.y - (int)std::min(std::max(.0f, ymm.x * scale - signalWindow.a.y), mag) * heightMag);
         }
     }
     delete[] min;
     delete[] max;
 }

◆ process()

bool SignalPlot::process ( TaskThread & thread )

protectedvirtual

Executes the task on CPU within a given thread.

Generally called by multiple threads.

Parameters

thread associated task execution context

Returns: true if the execution is finished correctly, false otherwise

Implements Beatmup::AbstractTask.

Definition at line 201 of file signal_plot.cpp.

                                            {
     std::vector<int> yyy;
     int x0, x1;
     getPlot(thread, yyy, x0, x1);
     thread.synchronize();
     auto y = yyy.begin();
     // single channel
     if (0 <= channels && channels < signal->getChannelCount())
         for (int x = x0; x < x1 && !thread.isTaskAborted(); x++) {
             int y0 = *y++, y1 = *y++;
             BitmapProcessing::write<Kernels::DrawBars3>(*bitmap, x, outputRect.a.y, y0, y1, outputRect.b.y, palette.bgColor, palette.color1);
         }
     // all channels
     else
         for (int x = x0; x < x1 && !thread.isTaskAborted(); x++) {
             int y0 = *y++, y1 = *y++, y2 = *y++, y3 = *y++;
             BitmapProcessing::write<Kernels::DrawBars5>(
                 *bitmap, x, outputRect.a.y, y0, y1, y2, y3, outputRect.b.y,
                 palette.bgColor, palette.color1, palette.color2
             );
         }
     return true;
 }

◆ beforeProcessing()

void SignalPlot::beforeProcessing	(	ThreadIndex	threadCount,
		ProcessingTarget	target,
		GraphicPipeline *	gpu
	)

protectedvirtual

Instruction called before the task is executed.

Parameters

threadCount	Number of threads used to perform the task
target	Device used to perform the task
gpu	A graphic pipeline instance; may be null.

Reimplemented from Beatmup::AbstractTask.

Definition at line 226 of file signal_plot.cpp.

                                                                                                         {
     NullTaskInput::check(signal, "input signal");
     NullTaskInput::check(bitmap, "output bitmap");
     writeLock(gpu, bitmap,  ProcessingTarget::CPU);
     outputRect.normalize();
     signalWindow.normalize();
 }

◆ afterProcessing()

void SignalPlot::afterProcessing	(	ThreadIndex	threadCount,
		GraphicPipeline *	gpu,
		bool	aborted
	)

protectedvirtual

Instruction called after the task is executed.

Parameters

threadCount	Number of threads used to perform the task
gpu	GPU to be used to execute the task; may be null.
aborted	`true` if the task was aborted

Reimplemented from Beatmup::AbstractTask.

Definition at line 235 of file signal_plot.cpp.

                                                                     {
     unlock(bitmap);
 }

◆ getUsedDevices()

AbstractTask::TaskDeviceRequirement SignalPlot::getUsedDevices ( ) const

protectedvirtual

Communicates devices (CPU and/or GPU) the task is run on.

Reimplemented from Beatmup::AbstractTask.

Definition at line 240 of file signal_plot.cpp.

                                                                    {
     return TaskDeviceRequirement::CPU_ONLY;
 }

◆ getMaxThreads()

ThreadIndex SignalPlot::getMaxThreads ( ) const

protectedvirtual

Gives the upper limint on the number of threads the task may be performed by.

The actual number of threads running a specific task may be less or equal to the returned value, depending on the number of workers in ThreadPool running the task.

Reimplemented from Beatmup::AbstractTask.

Definition at line 245 of file signal_plot.cpp.

                                             {
     BEATMUP_ASSERT_DEBUG(bitmap != nullptr);
     return validThreadCount(bitmap->getWidth());
 }

◆ setSignal()

void SignalPlot::setSignal ( Signal * signal )

Sets the input signal to plot.

Definition at line 251 of file signal_plot.cpp.

                                          {
     this->signal = signal;
 }

◆ setBitmap()

void SignalPlot::setBitmap ( AbstractBitmap * bitmap )

Sets the output bitmap.

Definition at line 256 of file signal_plot.cpp.

                                                  {
     this->bitmap = bitmap;
 }

◆ setPlotArea()

void SignalPlot::setPlotArea ( IntRectangle rectangle )

Specifies a rectangular area in pixels in the output bitmap where the plot will be drawn.

Definition at line 261 of file signal_plot.cpp.

                                                    {
     this->outputRect = rectangle;
 }

◆ setWindow()

void SignalPlot::setWindow	(	IntRectangle	window,
		float	scale
	)

Specifies a time range (X coordinate) and a magnitude range (Y coordinate scaled by scale) that will be plotted.

Parameters

window	a rectangle in time-value plane containing the two ranges
scale	magnitude scaling factor

Definition at line 266 of file signal_plot.cpp.

                                                            {
     this->signalWindow = window;
     this->scale = scale;
 }

◆ setPalette()

void SignalPlot::setPalette	(	color4i	bgColor,
		color4i	color1,
		color4i	color2
	)

Specifies plot colors.

Parameters

bgColor	background color
color1	main plotting color
color2	second plotting color used when plotting all the channels together (see setChannels())

Definition at line 272 of file signal_plot.cpp.

                                                                            {
     palette.bgColor = bgColor;
     palette.color1 = color1;
     palette.color2 = color2;
 }

◆ setChannels()

void SignalPlot::setChannels ( int channels )

Specifies which channels to plot.

Parameters

channels a channel number (counted from 0) to plot a single channel; any number out of correct range to plot all channels

Definition at line 279 of file signal_plot.cpp.

                                          {
     this->channels = channels;
 }

◆ getBitmap()

AbstractBitmap* Beatmup::Audio::SignalPlot::getBitmap ( ) const

inline

Definition at line 98 of file signal_plot.h.

98 { return bitmap; }

◆ getSignal()

Signal* Beatmup::Audio::SignalPlot::getSignal ( ) const

inline

Definition at line 99 of file signal_plot.h.

99 { return signal; }

Member Data Documentation

◆ signal

Signal* Beatmup::Audio::SignalPlot::signal

private

Definition at line 33 of file signal_plot.h.

◆ bitmap

AbstractBitmap* Beatmup::Audio::SignalPlot::bitmap

private

Definition at line 34 of file signal_plot.h.

◆ outputRect

IntRectangle Beatmup::Audio::SignalPlot::outputRect

private

Definition at line 35 of file signal_plot.h.

◆ signalWindow

IntRectangle Beatmup::Audio::SignalPlot::signalWindow

private

Definition at line 36 of file signal_plot.h.

◆ scale

float Beatmup::Audio::SignalPlot::scale

private

Definition at line 37 of file signal_plot.h.

◆ channels

int Beatmup::Audio::SignalPlot::channels

private

Definition at line 38 of file signal_plot.h.

◆ values

std::vector<int> Beatmup::Audio::SignalPlot::values

private

Definition at line 40 of file signal_plot.h.

◆ bgColor

color4i Beatmup::Audio::SignalPlot::bgColor

Definition at line 43 of file signal_plot.h.

◆ color1

color4i Beatmup::Audio::SignalPlot::color1

Definition at line 43 of file signal_plot.h.

◆ color2

color4i Beatmup::Audio::SignalPlot::color2

Definition at line 43 of file signal_plot.h.

◆

struct { ... } Beatmup::Audio::SignalPlot::palette

The documentation for this class was generated from the following files:

core/audio/signal_plot.h
core/audio/signal_plot.cpp

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SignalPlot()

Member Function Documentation

◆ getPlot()

◆ process()

◆ beforeProcessing()

◆ afterProcessing()

◆ getUsedDevices()

◆ getMaxThreads()

◆ setSignal()

◆ setBitmap()

◆ setPlotArea()

◆ setWindow()

◆ setPalette()

◆ setChannels()

◆ getBitmap()

◆ getSignal()

Member Data Documentation

◆ signal

◆ bitmap

◆ outputRect

◆ signalWindow

◆ scale

◆ channels

◆ values

◆ bgColor

◆ color1

◆ color2

◆