Beatmup::FormatConverter Class Reference

Converts bitmap content from one pixel format to another one. More...

#include <converter.h>

Inheritance diagram for Beatmup::FormatConverter:

Public Member Functions
	FormatConverter ()
void	setBitmaps (AbstractBitmap *input, AbstractBitmap *output)
ThreadIndex	getMaxThreads () const
	Gives the upper limint on the number of threads the task may be performed by. More...
TaskDeviceRequirement	getUsedDevices () const
	Communicates devices (CPU and/or GPU) the task is run on. More...
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 ()

Static Public Member Functions
static void	convert (AbstractBitmap &input, AbstractBitmap &output)
Static Public Member Functions inherited from Beatmup::AbstractTask
static ThreadIndex	validThreadCount (int number)
	Valid thread count from a given integer value. More...

Protected Member Functions
virtual bool	process (TaskThread &thread)
	Executes the task on CPU within a given thread. More...
virtual void	beforeProcessing (ThreadIndex threadCount, ProcessingTarget target, GraphicPipeline *gpu)
	Instruction called before the task is executed. More...
virtual void	afterProcessing (ThreadIndex threadCount, GraphicPipeline *gpu, bool aborted)
	Instruction called after the task is executed. More...

Private Member Functions
void	doConvert (int outX, int outY, msize nPix)
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
const int	MIN_PIXEL_COUNT_PER_THREAD = 1000
	minimum number of pixels per worker More...
AbstractBitmap *	input
AbstractBitmap *	output
	input and output bitmaps More...

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...

Detailed Description

Converts bitmap content from one pixel format to another one.

Definition at line 28 of file converter.h.

Constructor & Destructor Documentation

FormatConverter()

FormatConverter::FormatConverter

(

)

Definition at line 38 of file converter.cpp.

                                 :
    input(nullptr), output(nullptr)
{}

Member Function Documentation

doConvert()

void FormatConverter::doConvert ( int  outX, int  outY, msize  nPix  )

private

Definition at line 110 of file converter.cpp.

                                                              {
#define CALL_CONVERT_AND_RETURN(IN_T, OUT_T) \
    convertBlock < IN_T, OUT_T >(*input, *output, outX, outY, nPix); return;
 
    // for all (left) possible pairs of pixel formats, do the conversion
    switch (input->getPixelFormat()) {
    case SingleByte:
        switch (output->getPixelFormat()) {
            case TripleByte:    CALL_CONVERT_AND_RETURN(SingleByteBitmapReader, TripleByteBitmapWriter)
            case QuadByte:      CALL_CONVERT_AND_RETURN(SingleByteBitmapReader, QuadByteBitmapWriter)
            case SingleFloat:   CALL_CONVERT_AND_RETURN(SingleByteBitmapReader, SingleFloatBitmapWriter)
            case TripleFloat:   CALL_CONVERT_AND_RETURN(SingleByteBitmapReader, TripleFloatBitmapWriter)
            case QuadFloat:     CALL_CONVERT_AND_RETURN(SingleByteBitmapReader, QuadFloatBitmapWriter)
            default: throw ImplementationUnsupported("Cannot convert given formats");
        }
 
    case TripleByte:
        switch (output->getPixelFormat()) {
            case SingleByte:    CALL_CONVERT_AND_RETURN(TripleByteBitmapReader, SingleByteBitmapWriter)
            case QuadByte:      CALL_CONVERT_AND_RETURN(TripleByteBitmapReader, QuadByteBitmapWriter)
            case SingleFloat:   CALL_CONVERT_AND_RETURN(TripleByteBitmapReader, SingleFloatBitmapWriter)
            case TripleFloat:   CALL_CONVERT_AND_RETURN(TripleByteBitmapReader, TripleFloatBitmapWriter)
            case QuadFloat:     CALL_CONVERT_AND_RETURN(TripleByteBitmapReader, QuadFloatBitmapWriter)
            default: throw ImplementationUnsupported("Cannot convert given formats");
        }
 
    case QuadByte:
        switch (output->getPixelFormat()) {
            case SingleByte:    CALL_CONVERT_AND_RETURN(QuadByteBitmapReader, SingleByteBitmapWriter)
            case TripleByte:    CALL_CONVERT_AND_RETURN(QuadByteBitmapReader, TripleByteBitmapWriter)
            case SingleFloat:   CALL_CONVERT_AND_RETURN(QuadByteBitmapReader, SingleFloatBitmapWriter)
            case TripleFloat:   CALL_CONVERT_AND_RETURN(QuadByteBitmapReader, TripleFloatBitmapWriter)
            case QuadFloat:     CALL_CONVERT_AND_RETURN(QuadByteBitmapReader, QuadFloatBitmapWriter)
            default: throw ImplementationUnsupported("Cannot convert given formats");
        }
 
    case SingleFloat:
        switch (output->getPixelFormat()) {
            case SingleByte:    CALL_CONVERT_AND_RETURN(SingleFloatBitmapReader, SingleByteBitmapWriter)
            case TripleByte:    CALL_CONVERT_AND_RETURN(SingleFloatBitmapReader, TripleByteBitmapWriter)
            case QuadByte:      CALL_CONVERT_AND_RETURN(SingleFloatBitmapReader, QuadByteBitmapWriter)
            case TripleFloat:   CALL_CONVERT_AND_RETURN(SingleFloatBitmapReader, TripleFloatBitmapWriter)
            case QuadFloat:     CALL_CONVERT_AND_RETURN(SingleFloatBitmapReader, QuadFloatBitmapWriter)
            default: throw ImplementationUnsupported("Cannot convert given formats");
        }
 
    case TripleFloat:
        switch (output->getPixelFormat()) {
            case SingleByte:    CALL_CONVERT_AND_RETURN(TripleFloatBitmapReader, SingleByteBitmapWriter)
            case TripleByte:    CALL_CONVERT_AND_RETURN(TripleFloatBitmapReader, TripleByteBitmapWriter)
            case QuadByte:      CALL_CONVERT_AND_RETURN(TripleFloatBitmapReader, QuadByteBitmapWriter)
            case SingleFloat:   CALL_CONVERT_AND_RETURN(TripleFloatBitmapReader, SingleFloatBitmapWriter)
            case QuadFloat:     CALL_CONVERT_AND_RETURN(TripleFloatBitmapReader, QuadFloatBitmapWriter)
            default: throw ImplementationUnsupported("Cannot convert given formats");
        }
 
    case QuadFloat:
        switch (output->getPixelFormat()) {
            case SingleByte:    CALL_CONVERT_AND_RETURN(QuadFloatBitmapReader, SingleByteBitmapWriter)
            case TripleByte:    CALL_CONVERT_AND_RETURN(QuadFloatBitmapReader, TripleByteBitmapWriter)
            case QuadByte:      CALL_CONVERT_AND_RETURN(QuadFloatBitmapReader, QuadByteBitmapWriter)
            case SingleFloat:   CALL_CONVERT_AND_RETURN(QuadFloatBitmapReader, SingleFloatBitmapWriter)
            case TripleFloat:   CALL_CONVERT_AND_RETURN(QuadFloatBitmapReader, TripleFloatBitmapWriter)
            default: throw ImplementationUnsupported("Cannot convert given formats");
        }
 
    case BinaryMask:
        switch (output->getPixelFormat()) {
            case SingleByte:    CALL_CONVERT_AND_RETURN(BinaryMaskReader, SingleByteBitmapWriter)
            case TripleByte:    CALL_CONVERT_AND_RETURN(BinaryMaskReader, TripleByteBitmapWriter)
            case QuadByte:      CALL_CONVERT_AND_RETURN(BinaryMaskReader, QuadByteBitmapWriter)
            case SingleFloat:   CALL_CONVERT_AND_RETURN(BinaryMaskReader, SingleFloatBitmapWriter)
            case TripleFloat:   CALL_CONVERT_AND_RETURN(BinaryMaskReader, TripleFloatBitmapWriter)
            default: throw ImplementationUnsupported("Cannot convert given formats");
        }
 
    case QuaternaryMask:
        switch (output->getPixelFormat()) {
            case SingleByte:    CALL_CONVERT_AND_RETURN(QuaternaryMaskReader, SingleByteBitmapWriter)
            case TripleByte:    CALL_CONVERT_AND_RETURN(QuaternaryMaskReader, TripleByteBitmapWriter)
            case QuadByte:      CALL_CONVERT_AND_RETURN(QuaternaryMaskReader, QuadByteBitmapWriter)
            case SingleFloat:   CALL_CONVERT_AND_RETURN(QuaternaryMaskReader, SingleFloatBitmapWriter)
            case TripleFloat:   CALL_CONVERT_AND_RETURN(QuaternaryMaskReader, TripleFloatBitmapWriter)
            default: throw ImplementationUnsupported("Cannot convert given formats");
        }
 
    case HexMask:
        switch (output->getPixelFormat()) {
            case SingleByte:    CALL_CONVERT_AND_RETURN(HexMaskReader, SingleByteBitmapWriter)
            case TripleByte:    CALL_CONVERT_AND_RETURN(HexMaskReader, TripleByteBitmapWriter)
            case QuadByte:      CALL_CONVERT_AND_RETURN(HexMaskReader, QuadByteBitmapWriter)
            case SingleFloat:   CALL_CONVERT_AND_RETURN(HexMaskReader, SingleFloatBitmapWriter)
            case TripleFloat:   CALL_CONVERT_AND_RETURN(HexMaskReader, TripleFloatBitmapWriter)
            default: throw ImplementationUnsupported("Cannot convert given formats");
        }
    }
}

process()

bool FormatConverter::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 74 of file converter.cpp.

                                                {
    // if the bitmaps are equal, say done
    if (input == output)
        return true;
 
    // if pixel formats are identical, just copy
    if (input->getPixelFormat() == output->getPixelFormat()) {
        if (thread.currentThread() == 0)
            memcpy(
                output->getData(0,0),
                input->getData(0,0),
                input->getMemorySize()
            );
        return true;
    }
 
    // compute splitting accordingly to the current thread index
    int w = output->getWidth();
    msize
        npix = w * output->getHeight(),
        start = npix * thread.currentThread() / thread.numThreads(),
        stop = npix * (1 + thread.currentThread()) / thread.numThreads();
 
    // computing initial position
    int outx = (int)(start % w), outy = (int)(start / w);
 
    const int LOOK_AROUND_INTERVAL = 123456;
    while (start < stop && !thread.isTaskAborted()) {
        doConvert(outx, outy, stop-start);
        start += LOOK_AROUND_INTERVAL;
    }
 
    return true;
}

beforeProcessing()

void FormatConverter::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 60 of file converter.cpp.

                                                                                                             {
    NullTaskInput::check(input, "input bitmap");
    NullTaskInput::check(output, "output bitmap");
    RuntimeError::check(input->getSize() == output->getSize(),
        "Input and output bitmap must be of the same size.");
    lock<ProcessingTarget::CPU>(gpu, input, output);
}

afterProcessing()

void FormatConverter::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 69 of file converter.cpp.

                                                                                                 {
    unlock(input, output);
}

setBitmaps()

void FormatConverter::setBitmaps	(	AbstractBitmap *	input,
		AbstractBitmap *	output
	)

Definition at line 43 of file converter.cpp.

                                                                              {
    this->input = input;
    this->output = output;
}

getMaxThreads()

ThreadIndex FormatConverter::getMaxThreads ( ) const

virtual

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 49 of file converter.cpp.

                                                 {
    return AbstractTask::validThreadCount((int)(output->getSize().numPixels() / MIN_PIXEL_COUNT_PER_THREAD));
}

getUsedDevices()

AbstractTask::TaskDeviceRequirement FormatConverter::getUsedDevices ( ) const

virtual

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

Reimplemented from Beatmup::AbstractTask.

Definition at line 54 of file converter.cpp.

                                                                        {
    // it does not make sense to convert bitmaps on GPU
    return TaskDeviceRequirement::CPU_ONLY;
}

convert()

void FormatConverter::convert ( AbstractBitmap &  input, AbstractBitmap &  output  )

static

Definition at line 209 of file converter.cpp.

                                                                           {
    FormatConverter me;
    me.setBitmaps(&input, &output);
 
    if (input.getContext().isManagingThread()) {
        RuntimeError::check(input.getSize() == output.getSize(),
            "Input and output bitmap must be of the same size.");
 
        // the bitmaps are assumed locked in this case
        me.doConvert(0, 0, input.getSize().numPixels());
 
    }
    else
        input.getContext().performTask(me);
}

Member Data Documentation

MIN_PIXEL_COUNT_PER_THREAD

const int Beatmup::FormatConverter::MIN_PIXEL_COUNT_PER_THREAD = 1000

private

minimum number of pixels per worker

Definition at line 30 of file converter.h.

input

AbstractBitmap* Beatmup::FormatConverter::input

private

Definition at line 31 of file converter.h.

output

AbstractBitmap * Beatmup::FormatConverter::output

private

input and output bitmaps

Definition at line 31 of file converter.h.

---

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

• core/bitmap/converter.h
• core/bitmap/converter.cpp