dxt_decoder.h File Reference

#include "dxt_common.h"

Include dependency graph for dxt_decoder.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
int	dxt_decoder_buffer_allocate (struct dxt_decoder *decoder, unsigned char **image, int *image_size)
int	dxt_decoder_buffer_free (unsigned char *image)
struct dxt_decoder *	dxt_decoder_create (enum dxt_type type, int width, int height, enum dxt_format out_format, int legacy)
int	dxt_decoder_decompress (struct dxt_decoder *encoder, unsigned char *image_compressed, DXT_IMAGE_TYPE *image)
int	dxt_decoder_destroy (struct dxt_decoder *decoder)

Function Documentation

dxt_decoder_buffer_allocate()

int dxt_decoder_buffer_allocate	(	struct dxt_decoder *	decoder,
		unsigned char **	image,
		int *	image_size )

Allocate buffer for decompressed image by decoder

Parameters

decoder	Decoder structure
image	Pointer to variable where buffer pointer will be placed
image_size	Pointer to variable where image data size will be set

Returns

0 if succeeds, otherwise nonzero

Documented at declaration

Definition at line 340 of file dxt_decoder.c.

{
    *image_size = decoder->width * decoder->height * 4 * sizeof(DXT_IMAGE_TYPE);
    *image = (DXT_IMAGE_TYPE*)malloc(*image_size);
    if ( *image == NULL )
        return -1;
    return 0;
}

References DXT_IMAGE_TYPE, dxt_decoder::height, and dxt_decoder::width.

Referenced by perform_decode().

dxt_decoder_buffer_free()

int dxt_decoder_buffer_free

(

unsigned char *

image

)

Free buffer for decompressed image

Parameters

image

Pointer to buffer where decompressed image data are stored

Returns

0 if succeeds, otherwise nonzero

Documented at declaration

Definition at line 527 of file dxt_decoder.c.

{
    free(image);
    return 0;
}

Referenced by perform_decode().

dxt_decoder_create()

struct dxt_decoder * dxt_decoder_create	(	enum dxt_type	type,
		int	width,
		int	height,
		enum dxt_format	out_format,
		int	legacy )

Create DXT decoder

Parameters

width
height

Returns

decoder structure or zero if fails

Documented at declaration

Todo

Free other stuff as well

Definition at line 106 of file dxt_decoder.c.

{
    struct dxt_decoder* decoder = (struct dxt_decoder*)malloc(sizeof(struct dxt_decoder));
 
#ifndef HAVE_MACOSX
    glewExperimental = GL_TRUE;
    GLenum err = glewInit();
    assert(err == GLEW_OK);
#endif
    
    assert(out_format == DXT_FORMAT_RGBA || out_format == DXT_FORMAT_YUV422);
    assert(out_format == DXT_FORMAT_RGBA ||
        (out_format == DXT_FORMAT_YUV422 && width % 2 == 0)); /* width % 2 for YUV422 */
 
    if ( decoder == NULL )
        return NULL;
    decoder->type = type;
    decoder->width = width;
    decoder->height = height;
    decoder->out_format = out_format;
    decoder->legacy = legacy;
    //glutReshapeWindow(1, 1);
    
    if(legacy) {
            glEnable(GL_TEXTURE_2D);
    }
    
    // Create empty texture
    glGenTextures(1, &decoder->compressed_tex);
    glBindTexture(GL_TEXTURE_2D, decoder->compressed_tex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    
    GLenum internalformat;
    size_t size;
 
    if ( decoder->type == DXT_TYPE_DXT5_YCOCG ) {
            internalformat = GL_COMPRESSED_RGBA_S3TC_DXT5_EXT;
            size = ((decoder->width + 3) / 4 * 4) * ((decoder->height + 3) / 4 * 4);
    } else {
            internalformat = GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
            size = ((decoder->width + 3) / 4 * 4) * ((decoder->height + 3) / 4 * 4) / 2;
    }
 
    GLvoid *tmp_data = malloc(size); // data pointer to glCompressedTexImage2D shouldn't be 0
    glCompressedTexImage2DARB(GL_TEXTURE_2D, 0, internalformat, decoder->width, decoder->height, 0,
                    size, tmp_data);
    free(tmp_data);
 
    // Create fbo    
    glGenFramebuffers(1, &decoder->fbo_rgba);
    glBindFramebuffer(GL_FRAMEBUFFER, decoder->fbo_rgba);
    
    glGenTextures(1, &decoder->uncompressed_rgba_tex); 
    glBindTexture(GL_TEXTURE_2D, decoder->uncompressed_rgba_tex); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
    glTexImage2D(GL_TEXTURE_2D, 0 , DXT_IMAGE_GL_FORMAT, decoder->width, decoder->height, 0, GL_RGBA, DXT_IMAGE_GL_TYPE, 0); 
    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, decoder->uncompressed_rgba_tex, 0);
    glBindFramebuffer(GL_FRAMEBUFFER, 0);
    
    // Create program [display] and its shader
    decoder->program_display = glCreateProgram();  
    // Create shader from file
    decoder->shader_fragment_display = 0;
    switch(decoder->type) 
    {
        case DXT_TYPE_DXT5_YCOCG:
                if(legacy)
                    decoder->shader_fragment_display = dxt_shader_create_from_source(fp_display_dxt5ycocg_legacy, GL_FRAGMENT_SHADER);
                else
                    decoder->shader_fragment_display = dxt_shader_create_from_source(fp_display_dxt5ycocg, GL_FRAGMENT_SHADER);
                break;
        case DXT_TYPE_DXT1:
                if(legacy)
                    decoder->shader_fragment_display = dxt_shader_create_from_source(fp_display_legacy, GL_FRAGMENT_SHADER);
                else
                    decoder->shader_fragment_display = dxt_shader_create_from_source(fp_display, GL_FRAGMENT_SHADER);
                break;
        case DXT_TYPE_DXT1_YUV:
                if(legacy)
                    decoder->shader_fragment_display = dxt_shader_create_from_source(fp_display_dxt1_yuv_legacy, GL_FRAGMENT_SHADER);
                else
                    decoder->shader_fragment_display = dxt_shader_create_from_source(fp_display_dxt1_yuv, GL_FRAGMENT_SHADER);
                break;
    }
    if(legacy) {
        decoder->shader_vertex_display = dxt_shader_create_from_source(vp_compress_legacy, GL_VERTEX_SHADER);
    } else {
        decoder->shader_vertex_display = dxt_shader_create_from_source(vp_compress, GL_VERTEX_SHADER);
    }
    if ( decoder->shader_fragment_display == 0 || decoder->shader_vertex_display == 0 ) {
        free(decoder);
        return NULL;
    }
    // Attach shader to program and link the program
    glAttachShader(decoder->program_display, decoder->shader_fragment_display);
    glAttachShader(decoder->program_display, decoder->shader_vertex_display);
    glLinkProgram(decoder->program_display);
    
    if(out_format == DXT_FORMAT_YUV422) {
            glGenTextures(1, &decoder->uncompressed_yuv422_tex);
            glBindTexture(GL_TEXTURE_2D, decoder->uncompressed_yuv422_tex); 
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); 
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); 
            glTexImage2D(GL_TEXTURE_2D, 0 , GL_RGBA, decoder->width / 2, decoder->height, 0, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0); 
            
            glGenFramebuffers(1, &decoder->fbo_yuv422);
            
            if(legacy) {
                decoder->shader_fragment_rgba_to_yuv422 = dxt_shader_create_from_source(fp_display_rgba_to_yuv422_legacy, GL_FRAGMENT_SHADER);
                decoder->shader_vertex_rgba_to_yuv422 = dxt_shader_create_from_source(vp_compress_legacy, GL_VERTEX_SHADER);
            } else {
                decoder->shader_fragment_rgba_to_yuv422 = dxt_shader_create_from_source(fp_display_rgba_to_yuv422, GL_FRAGMENT_SHADER);
                decoder->shader_vertex_rgba_to_yuv422 = dxt_shader_create_from_source(vp_compress, GL_VERTEX_SHADER);
            }
            
            decoder->program_rgba_to_yuv422 = glCreateProgram();
            glAttachShader(decoder->program_rgba_to_yuv422, decoder->shader_fragment_rgba_to_yuv422);
            glAttachShader(decoder->program_rgba_to_yuv422, decoder->shader_vertex_rgba_to_yuv422);
            glLinkProgram(decoder->program_rgba_to_yuv422);
            
            glUseProgram(decoder->program_rgba_to_yuv422);
            glUniform1i(glGetUniformLocation(decoder->program_rgba_to_yuv422, "image"), 0);
            glUniform1f(glGetUniformLocation(decoder->program_rgba_to_yuv422, "imageWidth"),
                        (GLfloat) decoder->width);
 
            if(!decoder->legacy) {
#if ! defined __APPLE__ || defined __MAC_10_11
                GLint g_vertexLocation;
                GLuint g_vertices;
 
                // ToDo:
                glGenVertexArrays(1, &decoder->g_vao_422);
 
                // ToDo:
                glBindVertexArray(decoder->g_vao_422);
 
                // http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
                g_vertexLocation = glGetAttribLocation(decoder->program_rgba_to_yuv422, "position");
 
                // http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
                glGenBuffers(1, &g_vertices);
 
                // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
                glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
 
                // http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
                //glBufferData(GL_ARRAY_BUFFER, 3 * 4 * sizeof(GLfloat), (GLfloat*) points, GL_STATIC_DRAW);
                glBufferData(GL_ARRAY_BUFFER, 8 * 4 * sizeof(GLfloat), (GLfloat*) points, GL_STATIC_DRAW);
 
                // http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
                glUseProgram(decoder->program_rgba_to_yuv422);
 
                // http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
                glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
 
                // http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
                glEnableVertexAttribArray(g_vertexLocation);
 
                glBindFragDataLocation(decoder->program_rgba_to_yuv422, 0, "colorOut");
#endif
            }
                        
            glUseProgram(0);
    }
    if(!decoder->legacy) {
#if ! defined __APPLE__ || defined __MAC_10_11
        GLint g_vertexLocation;
        GLuint g_vertices;
 
        // ToDo:
        glGenVertexArrays(1, &decoder->g_vao);
 
        // ToDo:
        glBindVertexArray(decoder->g_vao);
 
        // http://www.opengl.org/sdk/docs/man/xhtml/glGetAttribLocation.xml
        g_vertexLocation = glGetAttribLocation(decoder->program_display, "position");
 
        // http://www.opengl.org/sdk/docs/man/xhtml/glGenBuffers.xml
        glGenBuffers(1, &g_vertices);
 
        // http://www.opengl.org/sdk/docs/man/xhtml/glBindBuffer.xml
        glBindBuffer(GL_ARRAY_BUFFER, g_vertices);
 
        // http://www.opengl.org/sdk/docs/man/xhtml/glBufferData.xml
        //glBufferData(GL_ARRAY_BUFFER, 3 * 4 * sizeof(GLfloat), (GLfloat*) points, GL_STATIC_DRAW);
        glBufferData(GL_ARRAY_BUFFER, 8 * 4 * sizeof(GLfloat), (GLfloat*) points, GL_STATIC_DRAW);
 
        // http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
        glUseProgram(decoder->program_display);
 
        // http://www.opengl.org/sdk/docs/man/xhtml/glVertexAttribPointer.xml
        glVertexAttribPointer(g_vertexLocation, 4, GL_FLOAT, GL_FALSE, 0, 0);
 
        // http://www.opengl.org/sdk/docs/man/xhtml/glEnableVertexAttribArray.xml
        glEnableVertexAttribArray(g_vertexLocation);
 
        glBindFragDataLocation(decoder->program_display, 0, "colorOut");
 
        glUseProgram(0);
#endif
 
 
#ifdef USE_PBO_DXT_DECODER
            glGenBuffersARB(1, &decoder->pbo_in); //Allocate PBO
            glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, decoder->pbo_in);
            glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB,
                            ((width + 3) / 4 * 4) * ((height + 3) / 4 * 4)  / (decoder->type == DXT_TYPE_DXT5_YCOCG ? 1 : 2),
                            0,
                            GL_STREAM_DRAW_ARB);
            glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
 
            glGenBuffersARB(1, &decoder->pbo_out); //Allocate PBO
            glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, decoder->pbo_out);
            glBufferDataARB(GL_PIXEL_PACK_BUFFER_ARB, ((width + 3) / 4 * 4) * ((height + 3) / 4 * 4)  * (out_format == DXT_FORMAT_YUV422 ? 2 : 4), 0, GL_STREAM_READ_ARB);
            glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
#endif
 
    }
    
    return decoder;
}

References dxt_decoder::compressed_tex, DXT_FORMAT_RGBA, DXT_FORMAT_YUV422, DXT_IMAGE_GL_FORMAT, DXT_IMAGE_GL_TYPE, dxt_shader_create_from_source(), DXT_TYPE_DXT1, DXT_TYPE_DXT1_YUV, DXT_TYPE_DXT5_YCOCG, dxt_decoder::fbo_rgba, dxt_decoder::fbo_yuv422, fp_display_dxt1_yuv, fp_display_dxt5ycocg, fp_display_rgba_to_yuv422_legacy, dxt_decoder::g_vao, dxt_decoder::g_vao_422, dxt_decoder::height, dxt_decoder::legacy, dxt_decoder::out_format, points, dxt_decoder::program_display, dxt_decoder::program_rgba_to_yuv422, dxt_decoder::shader_fragment_display, dxt_decoder::shader_fragment_rgba_to_yuv422, dxt_decoder::shader_vertex_display, dxt_decoder::shader_vertex_rgba_to_yuv422, dxt_decoder::type, type, dxt_decoder::uncompressed_rgba_tex, dxt_decoder::uncompressed_yuv422_tex, and dxt_decoder::width.

Referenced by configure_with(), and perform_decode().

Here is the call graph for this function:

dxt_decoder_decompress()

int dxt_decoder_decompress	(	struct dxt_decoder *	decoder,
		unsigned char *	image_compressed,
		DXT_IMAGE_TYPE *	image )

Decompress image by DXT decoder

Parameters

Decoder	structure
image_compressed	Compressed image data
image_compressed_size	Compressed image data size
image	Pointer to buffer where image data will be placed

Returns

0 if succeeds, otherwise nonzero

Documented at declaration

Definition at line 351 of file dxt_decoder.c.

{    
#ifdef USE_PBO_DXT_DECODER
        GLubyte *ptr;
#endif
 
#ifdef RTDXT_DEBUG
    TIMER_INIT();
    
    TIMER_START();
#endif
    glBindTexture(GL_TEXTURE_2D, decoder->compressed_tex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
        int data_size = ((decoder->width + 3) / 4 * 4) * ((decoder->height + 3) / 4 * 4) /
                               (decoder->type == DXT_TYPE_DXT5_YCOCG ? 1 : 2);
#ifdef USE_PBO_DXT_DECODER
    glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, decoder->pbo_in); // current pbo
    glCompressedTexSubImage2DARB (GL_TEXTURE_2D, 0, 0, 0,
                    (decoder->width + 3) / 4 * 4,
                    (decoder->height + 3) / 4 * 4,
                    decoder->type == DXT_TYPE_DXT5_YCOCG ? GL_COMPRESSED_RGBA_S3TC_DXT5_EXT : GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
                    data_size,
                    0);
    glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, data_size, 0, GL_STREAM_DRAW_ARB);
    ptr = (GLubyte*)glMapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, GL_WRITE_ONLY_ARB);
    if(ptr)
    {
            // update data directly on the mapped buffer
            memcpy(ptr, image_compressed, data_size); 
            glUnmapBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB); // release pointer to mapping buffer
    }
#else
    glCompressedTexSubImage2DARB (GL_TEXTURE_2D, 0, 0, 0,
                    (decoder->width + 3) / 4 * 4,
                    (decoder->height + 3) / 4 * 4,
                    decoder->type == DXT_TYPE_DXT5_YCOCG ? GL_COMPRESSED_RGBA_S3TC_DXT5_EXT : GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
                    data_size,
                    image_compressed);
#endif
 
 
#ifdef RTDXT_DEBUG
    glFinish();
    TIMER_STOP_PRINT("Texture Load:      ");
    
    TIMER_START();
#endif
    
    // Render to framebuffer
    glBindFramebuffer(GL_FRAMEBUFFER, decoder->fbo_rgba);
    
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glViewport(0, 0, decoder->width, decoder->height);
 
    glUseProgram(decoder->program_display);
    
    glBindTexture(GL_TEXTURE_2D, decoder->compressed_tex);
    
    if(decoder->legacy) {
        glBegin(GL_QUADS);
        glTexCoord2f(0.0, 0.0); glVertex2f(-1.0, -1.0);
        glTexCoord2f(1.0, 0.0); glVertex2f(1.0, -1.0);
        glTexCoord2f(1.0, 1.0); glVertex2f(1.0, 1.0);
        glTexCoord2f(0.0, 1.0); glVertex2f(-1.0, 1.0);
        glEnd();
    } else {
#if ! defined __APPLE__ || defined __MAC_10_11
        glBindVertexArray(decoder->g_vao);
        glDrawArrays(GL_TRIANGLES, 0, 6);
        glBindVertexArray(0);
#endif
    }
    
    glUseProgram(0);
#ifdef RTDXT_DEBUG
    glFinish();
    TIMER_STOP_PRINT("Texture Decompress:");
    
    TIMER_START();
#endif
    if(decoder->out_format != DXT_FORMAT_YUV422) { /* so RGBA */
            // Disable framebuffer
 
#ifdef USE_PBO_DXT_DECODER
            // glReadPixels() should return immediately.
            glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, decoder->pbo_out);
            glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
            glReadPixels(0, 0, decoder->width, decoder->height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
 
            // map the PBO to process its data by CPU
            glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, decoder->pbo_out);
            ptr = (GLubyte*)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,
                            GL_READ_ONLY_ARB);
            if(ptr)
            {
                    memcpy(image, ptr, decoder->width * decoder->height * 4);
                    glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
            }
 
            // back to conventional pixel operation
            glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
#else
            glReadPixels(0, 0, decoder->width, decoder->height, GL_RGBA, DXT_IMAGE_GL_TYPE, image);
#endif
 
            glBindFramebuffer(GL_FRAMEBUFFER, 0);
    } else {
 
            glBindFramebuffer(GL_FRAMEBUFFER, decoder->fbo_yuv422);
            glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, decoder->uncompressed_yuv422_tex, 0);
            
            glBindTexture(GL_TEXTURE_2D, decoder->uncompressed_rgba_tex); /* to texturing unit 0 */
 
            glPushAttrib(GL_VIEWPORT_BIT);
            glViewport( 0, 0, decoder->width / 2, decoder->height);
 
            glUseProgram(decoder->program_rgba_to_yuv422);
            
            if(decoder->legacy) {
                glBegin(GL_QUADS);
                glTexCoord2f(0.0, 0.0); glVertex2f(-1.0, -1.0);
                glTexCoord2f(1.0, 0.0); glVertex2f(1.0, -1.0);
                glTexCoord2f(1.0, 1.0); glVertex2f(1.0, 1.0);
                glTexCoord2f(0.0, 1.0); glVertex2f(-1.0, 1.0);
                glEnd();
            } else {
#if ! defined __APPLE__ || defined __MAC_10_11
                glBindVertexArray(decoder->g_vao_422);
                glDrawArrays(GL_TRIANGLES, 0, 6);
                glBindVertexArray(0);
#endif
            }
            
            glPopAttrib();
 
#ifdef USE_PBO_DXT_DECODER
            // glReadPixels() should return immediately.
            glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, decoder->pbo_out);
            glReadBuffer(GL_COLOR_ATTACHMENT0_EXT);
            glReadPixels(0, 0, decoder->width / 2, decoder->height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, 0);
 
            // map the PBO to process its data by CPU
            glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, decoder->pbo_out);
            ptr = (GLubyte*)glMapBufferARB(GL_PIXEL_PACK_BUFFER_ARB,
                            GL_READ_ONLY_ARB);
            if(ptr)
            {
                    memcpy(image, ptr, decoder->width  * decoder->height * (decoder->out_format == DXT_FORMAT_YUV422 ? 2 : 4));
                    glUnmapBufferARB(GL_PIXEL_PACK_BUFFER_ARB);
            }
 
            // back to conventional pixel operation
            glBindBufferARB(GL_PIXEL_PACK_BUFFER_ARB, 0);
#else
            glReadPixels(0, 0, decoder->width / 2, decoder->height, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8_REV, image);
#endif
 
            //glReadPixels(0, 0, decoder->width / 2, decoder->height, GL_RGBA, DXT_IMAGE_GL_TYPE, image);
            glBindFramebuffer(GL_FRAMEBUFFER, 0);
            glUseProgram(0);
    }
    
#ifdef RTDXT_DEBUG    
    glFinish();
    TIMER_STOP_PRINT("Texture Save:      ");
#endif
    
    return 0;
}

References dxt_decoder::compressed_tex, DXT_FORMAT_YUV422, DXT_IMAGE_GL_TYPE, DXT_TYPE_DXT5_YCOCG, dxt_decoder::fbo_rgba, dxt_decoder::fbo_yuv422, dxt_decoder::g_vao, dxt_decoder::g_vao_422, dxt_decoder::height, dxt_decoder::legacy, dxt_decoder::out_format, dxt_decoder::program_display, dxt_decoder::program_rgba_to_yuv422, TIMER_INIT, TIMER_START, TIMER_STOP_PRINT, dxt_decoder::type, dxt_decoder::uncompressed_rgba_tex, dxt_decoder::uncompressed_yuv422_tex, and dxt_decoder::width.

Referenced by dxt_glsl_decompress(), and perform_decode().

dxt_decoder_destroy()

int dxt_decoder_destroy

(

struct dxt_decoder *

decoder

)

Destroy DXT decoder

Parameters

decoder

Decoder structure

Returns

0 if succeeds, otherwise nonzero

Documented at declaration

Definition at line 535 of file dxt_decoder.c.

{
    glDeleteShader(decoder->shader_fragment_display);
    glDeleteProgram(decoder->program_display);
    glDeleteTextures(1, &decoder->compressed_tex);
    glDeleteTextures(1, &decoder->uncompressed_rgba_tex);
    glDeleteFramebuffers(1,  &decoder->fbo_rgba);
    
    if(decoder->out_format == DXT_FORMAT_YUV422) {
        glDeleteTextures(1, &decoder->uncompressed_yuv422_tex);
        glDeleteFramebuffers(1,  &decoder->fbo_yuv422);
    }
    free(decoder);
    return 0;
}

References dxt_decoder::compressed_tex, DXT_FORMAT_YUV422, dxt_decoder::fbo_rgba, dxt_decoder::fbo_yuv422, dxt_decoder::out_format, dxt_decoder::program_display, dxt_decoder::shader_fragment_display, dxt_decoder::uncompressed_rgba_tex, and dxt_decoder::uncompressed_yuv422_tex.

Referenced by dxt_glsl_decompress_done(), dxt_glsl_decompress_reconfigure(), and perform_decode().