gpujpeg_to_dxt.cpp File Reference

#include "cuda_dxt/cuda_dxt.h"
#include <pthread.h>
#include <stdlib.h>
#include "libgpujpeg/gpujpeg_decoder.h"
#include "libgpujpeg/gpujpeg_version.h"
#include "debug.h"
#include "lib_common.h"
#include "host.h"
#include "utils/synchronized_queue.h"
#include "video.h"
#include "video_decompress.h"

Include dependency graph for gpujpeg_to_dxt.cpp:

Go to the source code of this file.

Macros
#define	MOD_NAME   "[GPUJPEG to DXT] "

Functions
static void	flush (struct state_decompresss_gpujpeg_to_dxt *s)
static decompress_status	gpujpeg_to_dxt_decompress (void *state, unsigned char *dst, unsigned char *buffer, unsigned int src_len, int frame_seq, video_frame_callbacks *, codec_t *)
static void	gpujpeg_to_dxt_decompress_done (void *state)
static int	gpujpeg_to_dxt_decompress_get_priority (codec_t compression, struct pixfmt_desc internal, codec_t ugc)
static int	gpujpeg_to_dxt_decompress_get_property (void *state, int property, void *val, size_t *len)
static void *	gpujpeg_to_dxt_decompress_init (void)
static int	gpujpeg_to_dxt_decompress_reconfigure (void *state, struct video_desc desc, int rshift, int gshift, int bshift, int pitch, codec_t out_codec)
static int	reconfigure_thread (struct thread_data *s, struct video_desc desc, int ppb)
	REGISTER_MODULE (gpujpeg_to_dxt, &gpujpeg_to_dxt_info, LIBRARY_CLASS_VIDEO_DECOMPRESS, VIDEO_DECOMPRESS_ABI_VERSION)
static void *	worker_thread (void *arg)

Variables
static const struct video_decompress_info	gpujpeg_to_dxt_info

Detailed Description

Author

Martin Pulec pulec.nosp@m.@ces.nosp@m.net.c.nosp@m.z

Definition in file gpujpeg_to_dxt.cpp.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[GPUJPEG to DXT] "

Definition at line 59 of file gpujpeg_to_dxt.cpp.

Referenced by gpujpeg_to_dxt_decompress_init(), and worker_thread().

Function Documentation

flush()

static void flush ( struct state_decompresss_gpujpeg_to_dxt * s )

static

Definition at line 210 of file gpujpeg_to_dxt.cpp.

{
        if (s->occupied_count > 0) {
                for (unsigned int i = 0; i < cuda_devices_count; ++i) {
                        if (i == s->free)
                                continue;
                        struct msg_frame *completed =
                                dynamic_cast<msg_frame *>(s->thread_data[(s->free+1)%cuda_devices_count].m_out.pop());
                        delete completed;
                }
                s->occupied_count = 0;
        }
        s->free = 0;
}

References cuda_devices_count.

Referenced by gpujpeg_to_dxt_decompress_done(), and gpujpeg_to_dxt_decompress_reconfigure().

gpujpeg_to_dxt_decompress()

static decompress_status gpujpeg_to_dxt_decompress ( void * state, unsigned char * dst, unsigned char * buffer, unsigned int src_len, int frame_seq, video_frame_callbacks * , codec_t *  )

static

Definition at line 308 of file gpujpeg_to_dxt.cpp.

{
        struct state_decompresss_gpujpeg_to_dxt *s = (struct state_decompresss_gpujpeg_to_dxt *) state;
        UNUSED(frame_seq);
 
        msg_frame *message = new msg_frame(src_len);
        memcpy(message->data, buffer, src_len);
 
        if(s->occupied_count < cuda_devices_count - 1) {
                s->thread_data[s->free].m_in.push(message);
                s->free = s->free + 1; // should not exceed cuda_device_count
                s->occupied_count += 1;
        } else {
                s->thread_data[s->free].m_in.push(message);
 
                s->free = (s->free + 1) % cuda_devices_count;
 
                struct msg_frame *completed =
                        dynamic_cast<msg_frame *>(s->thread_data[s->free].m_out.pop());
                assert(completed != NULL);
                memcpy(dst, completed->data, s->desc.width * s->desc.height / s->ppb);
 
                delete completed;
        }
 
        return DECODER_GOT_FRAME;
}

References cuda_devices_count, DECODER_GOT_FRAME, video_desc::height, state, UNUSED, and video_desc::width.

gpujpeg_to_dxt_decompress_done()

static void gpujpeg_to_dxt_decompress_done ( void * state )

static

Definition at line 347 of file gpujpeg_to_dxt.cpp.

{
        struct state_decompresss_gpujpeg_to_dxt *s = (struct state_decompresss_gpujpeg_to_dxt *) state;
 
        if(!state) {
                return;
        }
 
        flush(s);
 
        for(unsigned int i = 0; i < cuda_devices_count; ++i) {
                msg_quit *quit_msg = new msg_quit;
                s->thread_data[i].m_in.push(quit_msg);
        }
 
        for(unsigned int i = 0; i < cuda_devices_count; ++i) {
                pthread_join(s->thread_id[i], NULL);
        }
 
        delete s;
}

References cuda_devices_count, flush(), and state.

Here is the call graph for this function:

gpujpeg_to_dxt_decompress_get_priority()

static int gpujpeg_to_dxt_decompress_get_priority ( codec_t compression, struct pixfmt_desc internal, codec_t ugc )

static

Definition at line 369 of file gpujpeg_to_dxt.cpp.

                                                                                                                 {
        return compression == JPEG && (ugc == DXT1 || ugc == DXT5) ? 900 : -1;
}

References DXT1, DXT5, and JPEG.

gpujpeg_to_dxt_decompress_get_property()

static int gpujpeg_to_dxt_decompress_get_property ( void * state, int property, void * val, size_t * len )

static

Definition at line 337 of file gpujpeg_to_dxt.cpp.

{
        UNUSED(state);
        UNUSED(property);
        UNUSED(val);
        UNUSED(len);
 
        return FALSE;
}

References FALSE, len, property, state, UNUSED, and val.

gpujpeg_to_dxt_decompress_init()

static void * gpujpeg_to_dxt_decompress_init ( void )

static

Definition at line 183 of file gpujpeg_to_dxt.cpp.

{
        struct state_decompresss_gpujpeg_to_dxt *s;
 
        s = new state_decompresss_gpujpeg_to_dxt;
 
        s->free = 0;
        s->occupied_count = 0;
 
        for(unsigned int i = 0; i < cuda_devices_count; ++i) {
                int ret = gpujpeg_init_device(cuda_devices[i], TRUE);
                if(ret != 0) {
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "initializing CUDA device %d failed.\n", cuda_devices[0]);
                        delete s;
                        return NULL;
                }
        }
 
        for(unsigned int i = 0; i < cuda_devices_count; ++i) {
                s->thread_data[i].cuda_dev_index = i;
                int ret = pthread_create(&s->thread_id[i], NULL, worker_thread,  &s->thread_data[i]);
                assert(ret == 0);
        }
 
        return s;
}

References cuda_devices, cuda_devices_count, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, TRUE, and worker_thread().

Here is the call graph for this function:

gpujpeg_to_dxt_decompress_reconfigure()

static int gpujpeg_to_dxt_decompress_reconfigure ( void * state, struct video_desc desc, int rshift, int gshift, int bshift, int pitch, codec_t out_codec )

static

Reconfigureation function

Returns

0 to indicate error otherwise maximal buffer size which ins needed for image of given codec, width, and height

Definition at line 231 of file gpujpeg_to_dxt.cpp.

{
        struct state_decompresss_gpujpeg_to_dxt *s = (struct state_decompresss_gpujpeg_to_dxt *) state;
 
        UNUSED(rshift);
        UNUSED(gshift);
        UNUSED(bshift);
        assert(out_codec == DXT1 || out_codec == DXT5);
        if(out_codec == DXT1) {
                s->ppb = 2;
        } else { // DXT5
                s->ppb = 1;
        }
        s->desc = desc;
        assert(pitch == (int) desc.width / s->ppb); // default for DXT1
 
        flush(s);
 
        for(unsigned int i = 0; i < cuda_devices_count; ++i) {
                msg_reconfigure *reconf = new msg_reconfigure;
                reconf->desc = desc;
                reconf->out_codec = out_codec;
                reconf->ppb = s->ppb;
 
                s->thread_data[i].m_in.push(reconf);
 
                msg_reconfigure_status *status =
                        dynamic_cast<msg_reconfigure_status *>(s->thread_data[i].m_out.pop());
                assert(status != NULL);
                if (!status->success) {
                        delete status;
                        return FALSE;
                }
                delete status;
        }
 
        return TRUE;
}

References cuda_devices_count, desc, DXT1, DXT5, FALSE, flush(), state, TRUE, UNUSED, and video_desc::width.

Here is the call graph for this function:

reconfigure_thread()

static int reconfigure_thread ( struct thread_data * s, struct video_desc desc, int ppb )

static

Returns

maximal buffer size needed to image with such a properties

Definition at line 274 of file gpujpeg_to_dxt.cpp.

{
        if(s->gpujpeg_decoder != NULL) {
                gpujpeg_decoder_destroy(s->gpujpeg_decoder);
                s->gpujpeg_decoder = NULL;
        } else {
                gpujpeg_init_device(cuda_devices[s->cuda_dev_index], 0);
        }
 
        if(s->dxt_out_buff != NULL) {
                cuda_wrapper_free(s->dxt_out_buff);
                s->dxt_out_buff = NULL;
        }
 
        if(cuda_wrapper_malloc_host((void **) &s->dxt_out_buff, desc.width * desc.height / ppb)
                        != CUDA_WRAPPER_SUCCESS) {
                fprintf(stderr, "Could not allocate CUDA output buffer.\n");
                return false;
        }
        //gpujpeg_init_device(cuda_device, GPUJPEG_OPENGL_INTEROPERABILITY);
 
#if LIBGPUJPEG_API_VERSION <= 2
        s->gpujpeg_decoder = gpujpeg_decoder_create();
#else
        s->gpujpeg_decoder = gpujpeg_decoder_create(NULL);
#endif
        if(!s->gpujpeg_decoder) {
                log_msg(LOG_LEVEL_ERROR, "Creating GPUJPEG decoder failed.\n");
                return false;
        }
 
        return true;
}

References cuda_devices, cuda_wrapper_free(), cuda_wrapper_malloc_host(), CUDA_WRAPPER_SUCCESS, desc, video_desc::height, LOG_LEVEL_ERROR, log_msg(), and video_desc::width.

Referenced by worker_thread().

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	gpujpeg_to_dxt	,
		&	gpujpeg_to_dxt_info,
		LIBRARY_CLASS_VIDEO_DECOMPRESS	,
		VIDEO_DECOMPRESS_ABI_VERSION	)

worker_thread()

static void * worker_thread ( void * arg )

static

Definition at line 122 of file gpujpeg_to_dxt.cpp.

{
        struct thread_data *s =
                (struct thread_data *) arg;
 
        while(1) {
                msg *message = s->m_in.pop();
 
                if (dynamic_cast<msg_quit *>(message)) {
                        delete message;
                        break;
                } else if (dynamic_cast<msg_reconfigure *>(message)) {
                        msg_reconfigure *reconf = dynamic_cast<msg_reconfigure *>(message);
                        bool ret = reconfigure_thread(s, reconf->desc, reconf->ppb);
                        s->desc = reconf->desc;
                        s->out_codec = reconf->out_codec;
                        s->ppb = reconf->ppb;
 
                        msg_reconfigure_status *status = new msg_reconfigure_status(ret);
                        s->m_out.push(status);
 
                        delete message;
                } else if (dynamic_cast<msg_frame *>(message)) {
                        msg_frame *frame_msg = dynamic_cast<msg_frame *>(message);
                        struct gpujpeg_decoder_output decoder_output;
 
                        gpujpeg_decoder_output_set_cuda_buffer(&decoder_output);
                        gpujpeg_decoder_decode(s->gpujpeg_decoder, (uint8_t *) frame_msg->data, frame_msg->data_len,
                                        &decoder_output);
 
                        if (s->out_codec == DXT1) {
                                cuda_rgb_to_dxt1(decoder_output.data, s->dxt_out_buff, s->desc.width,
                                                -s->desc.height, 0);
                        } else {
                                cuda_rgb_to_dxt6(decoder_output.data, s->dxt_out_buff, s->desc.width,
                                                -s->desc.height, 0);
                        }
 
                        msg_frame *output_frame = new msg_frame(s->desc.width * s->desc.height / s->ppb);
 
                        if (cuda_wrapper_memcpy((char*) output_frame->data, s->dxt_out_buff,
                                                output_frame->data_len,
                                                CUDA_WRAPPER_MEMCPY_DEVICE_TO_HOST) !=
                                        CUDA_WRAPPER_SUCCESS) {
                                log_msg(LOG_LEVEL_ERROR, MOD_NAME "unable to copy from device.");
                        }
                        s->m_out.push(output_frame);
 
                        delete frame_msg;
                }
        }
 
        if(s->gpujpeg_decoder) {
                gpujpeg_decoder_destroy(s->gpujpeg_decoder);
        }
 
        cuda_wrapper_free(s->dxt_out_buff);
 
        return NULL;
}

References cuda_rgb_to_dxt1(), cuda_rgb_to_dxt6(), cuda_wrapper_free(), cuda_wrapper_memcpy(), CUDA_WRAPPER_MEMCPY_DEVICE_TO_HOST, CUDA_WRAPPER_SUCCESS, DXT1, video_desc::height, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, reconfigure_thread(), and video_desc::width.

Referenced by display_xrgl_run(), and gpujpeg_to_dxt_decompress_init().

Here is the call graph for this function:

Variable Documentation

gpujpeg_to_dxt_info

const struct video_decompress_info gpujpeg_to_dxt_info

static

Initial value:

= {
        gpujpeg_to_dxt_decompress_init,
        gpujpeg_to_dxt_decompress_reconfigure,
        gpujpeg_to_dxt_decompress,
        gpujpeg_to_dxt_decompress_get_property,
        gpujpeg_to_dxt_decompress_done,
        gpujpeg_to_dxt_decompress_get_priority,
}

Definition at line 373 of file gpujpeg_to_dxt.cpp.

                                                                {
        gpujpeg_to_dxt_decompress_init,
        gpujpeg_to_dxt_decompress_reconfigure,
        gpujpeg_to_dxt_decompress,
        gpujpeg_to_dxt_decompress_get_property,
        gpujpeg_to_dxt_decompress_done,
        gpujpeg_to_dxt_decompress_get_priority,
};