~ubuntu-branches/ubuntu/utopic/blender/utopic-proposed

 *

 */

 

#include "IMB_colormanagement.h"

#include "IMB_colormanagement_intern.h"

 

static char global_role_default_float[MAX_COLORSPACE_NAME];

static char global_role_default_sequencer[MAX_COLORSPACE_NAME];

 

 

static int global_tot_colorspace = 0;

static int global_tot_display = 0;

static int global_tot_view = 0;

 

/* lock used by pre-cached processors getters, so processor wouldn't

 * be created several times

typedef struct ColormanageProcessor {

        OCIO_ConstProcessorRcPtr *processor;

        CurveMapping *curve_mapping;

} ColormanageProcessor;

 

static struct global_glsl_state {

        OCIO_ConstProcessorRcPtr *processor;

 

        /* Settings of processor for comparison. */

        char view[MAX_COLORSPACE_NAME];

        char display[MAX_COLORSPACE_NAME];

        char input[MAX_COLORSPACE_NAME];

 */

typedef struct ColormanageCacheViewSettings {

        int flag;

        int view;

        float exposure;

        float gamma;

        CurveMapping *curve_mapping;

} ColormanageCacheViewSettings;

 

 

typedef struct ColormnaageCacheData {

        int flag;        /* view flags of cached buffer */

        float exposure;  /* exposure value cached buffer is calculated with */

        float gamma;     /* gamma value cached buffer is calculated with */

        CurveMapping *curve_mapping;  /* curve mapping used for cached buffer */

        int curve_mapping_timestamp;  /* time stamp of curve mapping used for cached buffer */

} ColormnaageCacheData;

        ibuf->colormanage_cache->data = data;

}

 

                                               const ColorManagedViewSettings *view_settings)

{

        int view = IMB_colormanagement_view_get_named_index(view_settings->view_transform);

 

        cache_view_settings->view = view;

        cache_view_settings->exposure = view_settings->exposure;

        cache_view_settings->gamma = view_settings->gamma;

        cache_view_settings->flag = view_settings->flag;

        cache_view_settings->curve_mapping = view_settings->curve_mapping;

}

                 */

                cache_data = colormanage_cachedata_get(cache_ibuf);

 

                    cache_data->gamma != view_settings->gamma ||

                    cache_data->flag != view_settings->flag ||

                    cache_data->curve_mapping != curve_mapping ||

                    cache_data->curve_mapping_timestamp != curve_mapping_timestamp)

 

        /* store data which is needed to check whether cached buffer could be used for color managed display settings */

        cache_data = MEM_callocN(sizeof(ColormnaageCacheData), "color manage cache imbuf data");

        cache_data->exposure = view_settings->exposure;

        cache_data->gamma = view_settings->gamma;

        cache_data->flag = view_settings->flag;

        cache_data->curve_mapping = curve_mapping;

        cache_data->curve_mapping_timestamp = curve_mapping_timestamp;

 

static void colormanage_load_config(OCIO_ConstConfigRcPtr *config)

{

        const char *name;

 

        /* get roles */

        for (index = 0 ; index < tot_colorspace; index++) {

                OCIO_ConstColorSpaceRcPtr *ocio_colorspace;

                const char *description;

 

                name = OCIO_configGetColorSpaceNameByIndex(config, index);

 

        }

 

        global_tot_display = tot_display;

}

 

static void colormanage_free_config(void)

        /* free views */

        BLI_freelistN(&global_views);

 

        OCIO_exit();

}

 

        return NULL;

}

 

                                                                 const char *display,

                                                                 float exposure, float gamma,

                                                                 const char *from_colorspace)

        OCIO_ConstConfigRcPtr *config = OCIO_getCurrentConfig();

        OCIO_DisplayTransformRcPtr *dt;

        OCIO_ConstProcessorRcPtr *processor;

 

        dt = OCIO_createDisplayTransform();

 

        OCIO_displayTransformSetView(dt, view_transform);

        OCIO_displayTransformSetDisplay(dt, display);

 

        /* fstop exposure control */

        if (exposure != 0.0f) {

                OCIO_MatrixTransformRcPtr *mt;

        else

                view_settings->view_transform[0] = '\0';

 

        view_settings->flag = 0;

        view_settings->gamma = 1.0f;

        view_settings->exposure = 0.0f;

                        imb_freerectImBuf(ibuf);

 

                IMB_colormanagement_transform(ibuf->rect_float, ibuf->x, ibuf->y, ibuf->channels,

        }

}

 

{

        ColorManagedDisplay *display;

        ColorManagedView *default_view = NULL;

 

        if (view_settings->view_transform[0] == '\0') {

                display = colormanage_display_get_named(display_settings->display_device);

                }

        }

 

        /* OCIO_TODO: move to do_versions() */

        if (view_settings->exposure == 0.0f && view_settings->gamma == 0.0f) {

                view_settings->exposure = 0.0f;

                default:

                        printf("Unknown role was passed to %s\n", __func__);

                        BLI_assert(0);

        }

 

        return NULL;

                ibuf->colormanage_flag &= ~IMB_COLORMANAGE_IS_DATA;

}

 

/*********************** Threaded display buffer transform routines *************************/

 

typedef struct DisplayBufferThread {

 

        int channels;

        float dither;

 

        const char *byte_colorspace;

        const char *float_colorspace;

 

        int channels = ibuf->channels;

        float dither = ibuf->dither;

 

        int offset = channels * start_line * ibuf->x;

        int display_buffer_byte_offset = DISPLAY_BUFFER_CHANNELS * start_line * ibuf->x;