case EVAS_COLORSPACE_RGBA_S3TC_DXT3:
case EVAS_COLORSPACE_RGBA_S3TC_DXT4:
case EVAS_COLORSPACE_RGBA_S3TC_DXT5:
+ case EVAS_COLORSPACE_ETC1_ALPHA:
block_size = 16;
// fallthrough
case EVAS_COLORSPACE_ETC1:
SHADER_YUY2_NOMUL,
SHADER_NV12,
SHADER_NV12_NOMUL,
+
+ SHADER_RGB_A_PAIR,
+ SHADER_RGB_A_PAIR_NOMUL,
/*
SHADER_FILTER_INVERT,
SHADER_FILTER_INVERT_NOMUL,
#define MAX_ATLAS_H 512
#define DEF_ATLAS_H 512
+#define ATLAS_FORMATS_COUNT 11
+
Eina_List *cspaces; // depend on the values of etc1, etc2 and st3c
struct {
struct {
Eina_List *whole;
- Eina_List *atlas[10];
+ Eina_List *atlas[ATLAS_FORMATS_COUNT];
} tex;
Eina_Hash *native_pm_hash;
{
Evas_Engine_GL_Context *gc;
Evas_GL_Image *im;
- Evas_GL_Texture_Pool *pt, *ptu, *ptv, *ptuv, *ptt;
+ Evas_GL_Texture_Pool *pt, *ptu, *ptv, *ptt;
+ union {
+ Evas_GL_Texture_Pool *ptuv;
+ Evas_GL_Texture_Pool *pta;
+ };
RGBA_Font_Glyph *fglyph;
int x, y, w, h;
int tx, ty;
int x, int y, int w, int h,
int r, int g, int b, int a,
Eina_Bool smooth);
+void evas_gl_common_context_rgb_a_pair_push(Evas_Engine_GL_Context *gc,
+ Evas_GL_Texture *tex,
+ double sx, double sy, double sw, double sh,
+ int x, int y, int w, int h,
+ int r, int g, int b, int a,
+ Eina_Bool smooth);
void evas_gl_common_context_image_map_push(Evas_Engine_GL_Context *gc,
Evas_GL_Texture *tex,
int npoints,
void evas_gl_common_texture_nv12_update(Evas_GL_Texture *tex, DATA8 **row, unsigned int w, unsigned int h);
Evas_GL_Texture *evas_gl_common_texture_nv12tiled_new(Evas_Engine_GL_Context *gc, DATA8 **rows, unsigned int w, unsigned int h);
void evas_gl_common_texture_nv12tiled_update(Evas_GL_Texture *tex, DATA8 **row, unsigned int w, unsigned int h);
+Evas_GL_Texture *evas_gl_common_texture_rgb_a_pair_new(Evas_Engine_GL_Context *gc, RGBA_Image *im);
+void evas_gl_common_texture_rgb_a_pair_update(Evas_GL_Texture *tex, RGBA_Image *im);
void evas_gl_common_image_alloc_ensure(Evas_GL_Image *im);
void evas_gl_common_image_all_unload(Evas_Engine_GL_Context *gc);
#else
# define GLERR(fn, fl, ln, op)
#endif
+#define GLERRLOG() GLERR(__FUNCTION__, __FILE__, __LINE__, "")
Eina_Bool evas_gl_common_module_open(void);
void evas_gl_common_module_close(void);
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
}
+static inline void
+_comp_tex_sub_2d(Evas_Engine_GL_Context *gc, int x, int y, int w, int h, int fmt, int imgsize, const void *pix)
+{
+ if ((w > gc->shared->info.max_texture_size) ||
+ (h > gc->shared->info.max_texture_size)) return;
+ glCompressedTexSubImage2D(GL_TEXTURE_2D, 0, x, y, w, h, fmt, imgsize, pix);
+ GLERR(__FUNCTION__, __FILE__, __LINE__, "glCompressedTexSubImage2D");
+}
+
#include "evas_gl_3d_common.h"
#endif
SHADER_TEXTURE_ADD(shared, NV12_NOMUL, tex);
SHADER_TEXTURE_ADD(shared, NV12_NOMUL, texuv);
+ SHADER_TEXTURE_ADD(shared, RGB_A_PAIR, tex);
+ SHADER_TEXTURE_ADD(shared, RGB_A_PAIR, texm);
+ SHADER_TEXTURE_ADD(shared, RGB_A_PAIR_NOMUL, tex);
+ SHADER_TEXTURE_ADD(shared, RGB_A_PAIR_NOMUL, texm);
+
if (gc->state.current.cur_prog == PRG_INVALID)
glUseProgram(shared->shader[0].prog);
else glUseProgram(gc->state.current.cur_prog);
}
void
+evas_gl_common_context_rgb_a_pair_push(Evas_Engine_GL_Context *gc,
+ Evas_GL_Texture *tex,
+ double sx, double sy,
+ double sw, double sh,
+ int x, int y, int w, int h,
+ int r, int g, int b, int a,
+ Eina_Bool smooth)
+
+{
+ /* This RGB+Alpha mode is used for ETC1+Alpha textures, where the shader
+ * will multiply RGB by alpha. Two textures are created: tex->{pt,pta}.
+ * Since the exact encoding doesn't matter here (decoding is transparent
+ * from the shader point of view), this method could be used for other
+ * colorspaces as well (eg. RGB565+Alpha4, ...).
+ */
+
+ int pnum, nv, nc, nu, nm, i;
+ GLfloat tx1, tx2, ty1, ty2, t2x1, t2x2, t2y1, t2y2;
+ GLuint prog;
+ int pn;
+
+ prog = gc->shared->shader[evas_gl_common_shader_choice
+ (0, NULL, r, g, b, a, SHADER_RGB_A_PAIR_NOMUL, SHADER_RGB_A_PAIR)].prog;
+
+ pn = _evas_gl_common_context_push(RTYPE_IMAGE,
+ gc, tex, NULL,
+ prog,
+ x, y, w, h,
+ EINA_TRUE,
+ smooth,
+ EINA_FALSE, 0, 0, 0, 0);
+
+ gc->pipe[pn].region.type = RTYPE_IMAGE;
+ gc->pipe[pn].shader.cur_tex = tex->pt->texture;
+ gc->pipe[pn].shader.cur_texm = tex->pta->texture;
+ gc->pipe[pn].shader.cur_prog = prog;
+ gc->pipe[pn].shader.smooth = smooth;
+ gc->pipe[pn].shader.blend = EINA_TRUE;
+ gc->pipe[pn].shader.render_op = gc->dc->render_op;
+ gc->pipe[pn].shader.clip = 0;
+ gc->pipe[pn].shader.cx = 0;
+ gc->pipe[pn].shader.cy = 0;
+ gc->pipe[pn].shader.cw = 0;
+ gc->pipe[pn].shader.ch = 0;
+ gc->pipe[pn].array.line = 0;
+ gc->pipe[pn].array.use_vertex = EINA_TRUE;
+ // if nomul... dont need this
+ gc->pipe[pn].array.use_color = EINA_TRUE;
+ gc->pipe[pn].array.use_texuv = EINA_TRUE;
+ gc->pipe[pn].array.use_texuv2 = 0;
+ gc->pipe[pn].array.use_texuv3 = 0;
+ gc->pipe[pn].array.use_texm = EINA_TRUE;
+ gc->pipe[pn].array.use_texsam = 0;
+
+ pipe_region_expand(gc, pn, x, y, w, h);
+
+ pnum = gc->pipe[pn].array.num;
+ nv = pnum * 3; nc = pnum * 4; nu = pnum * 2; nm = pnum * 2;
+ gc->pipe[pn].array.num += 6;
+ array_alloc(gc, pn);
+
+ tx1 = (sx) / (double)tex->pt->w;
+ ty1 = (sy) / (double)tex->pt->h;
+ tx2 = (sx + sw) / (double)tex->pt->w;
+ ty2 = (sy + sh) / (double)tex->pt->h;
+
+ t2x1 = sx / (double)tex->pta->w;
+ t2y1 = sy / (double)tex->pta->h;
+ t2x2 = (sx + sw) / (double)tex->pta->w;
+ t2y2 = (sy + sh) / (double)tex->pta->h;
+
+ PUSH_VERTEX(pn, x , y , 0);
+ PUSH_VERTEX(pn, x + w, y , 0);
+ PUSH_VERTEX(pn, x , y + h, 0);
+
+ PUSH_TEXUV(pn, tx1, ty1);
+ PUSH_TEXUV(pn, tx2, ty1);
+ PUSH_TEXUV(pn, tx1, ty2);
+
+ PUSH_TEXM(pn, t2x1, t2y1);
+ PUSH_TEXM(pn, t2x2, t2y1);
+ PUSH_TEXM(pn, t2x1, t2y2);
+
+ PUSH_VERTEX(pn, x + w, y , 0);
+ PUSH_VERTEX(pn, x + w, y + h, 0);
+ PUSH_VERTEX(pn, x , y + h, 0);
+
+ PUSH_TEXUV(pn, tx2, ty1);
+ PUSH_TEXUV(pn, tx2, ty2);
+ PUSH_TEXUV(pn, tx1, ty2);
+
+ PUSH_TEXM(pn, t2x2, t2y1);
+ PUSH_TEXM(pn, t2x2, t2y2);
+ PUSH_TEXM(pn, t2x1, t2y2);
+
+ for (i = 0; i < 6; i++)
+ {
+ PUSH_COLOR(pn, r, g, b, a);
+ }
+}
+
+void
evas_gl_common_context_image_map_push(Evas_Engine_GL_Context *gc,
Evas_GL_Texture *tex,
int npoints,
CS_APPEND(EVAS_COLORSPACE_RGBA8_ETC2_EAC);
CS_APPEND(EVAS_COLORSPACE_RGB8_ETC2);
CS_APPEND(EVAS_COLORSPACE_ETC1);
+ CS_APPEND(EVAS_COLORSPACE_ETC1_ALPHA);
}
else if (gc->shared->info.etc1)
- CS_APPEND(EVAS_COLORSPACE_ETC1);
+ {
+ CS_APPEND(EVAS_COLORSPACE_ETC1);
+ CS_APPEND(EVAS_COLORSPACE_ETC1_ALPHA);
+ }
if (gc->shared->info.s3tc)
{
CS_APPEND(EVAS_COLORSPACE_RGB_S3TC_DXT1);
case EVAS_COLORSPACE_AGRY88:
break;
case EVAS_COLORSPACE_ETC1:
+ case EVAS_COLORSPACE_ETC1_ALPHA:
if (gc->shared->info.etc1 && !gc->shared->info.etc2) break;
ERR("We don't know what to do with ETC1 on this hardware. You need to add a software converter here.");
break;
case EVAS_COLORSPACE_AGRY88:
break;
case EVAS_COLORSPACE_ETC1:
+ case EVAS_COLORSPACE_ETC1_ALPHA:
if (gc->shared->info.etc1 && !gc->shared->info.etc2) break;
ERR("We don't know what to do with ETC1 on this hardware. You need to add a software converter here.");
break;
case EVAS_COLORSPACE_AGRY88:
break;
case EVAS_COLORSPACE_ETC1:
+ case EVAS_COLORSPACE_ETC1_ALPHA:
if (gc->shared->info.etc1 && !gc->shared->info.etc2) break;
ERR("We don't know what to do with ETC1 on this hardware. You need to add a software converter here.");
break;
if (!im->gc->shared->info.sec_image_map) return;
if (!im->gc->shared->info.bgra) return;
// does not handle yuv yet.
- if (im->cs.space != EVAS_COLORSPACE_ARGB8888 &&
- im->cs.space != EVAS_COLORSPACE_GRY8 &&
- im->cs.space != EVAS_COLORSPACE_AGRY88 &&
- im->cs.space != EVAS_COLORSPACE_ETC1 &&
- im->cs.space != EVAS_COLORSPACE_RGB8_ETC2 &&
- im->cs.space != EVAS_COLORSPACE_RGBA8_ETC2_EAC) return;
+ // TODO: Check this list of cspaces
+ switch (im->cs.space)
+ {
+ case EVAS_COLORSPACE_YCBCR422P601_PL:
+ case EVAS_COLORSPACE_YCBCR422P709_PL:
+ case EVAS_COLORSPACE_RGB565_A5P:
+ case EVAS_COLORSPACE_YCBCR422601_PL:
+ case EVAS_COLORSPACE_YCBCR420NV12601_PL:
+ case EVAS_COLORSPACE_YCBCR420TM12601_PL:
+ case EVAS_COLORSPACE_ETC1_ALPHA:
+ return;
+ default: break;
+ }
if (im->content_hint == EVAS_IMAGE_CONTENT_HINT_DYNAMIC)
{
if (im->cs.data)
im->dirty = 0;
if (!im->tex) return;
break;
+ case EVAS_COLORSPACE_ETC1_ALPHA:
+ if ((im->tex) && (im->dirty))
+ {
+ evas_cache_image_load_data(&im->im->cache_entry);
+ evas_gl_common_texture_rgb_a_pair_update(im->tex, im->im);
+ evas_cache_image_unload_data(&im->im->cache_entry);
+ }
+ else if ((!im->tex))
+ {
+ evas_cache_image_load_data(&im->im->cache_entry);
+ im->tex = evas_gl_common_texture_rgb_a_pair_new(gc, im->im);
+ evas_cache_image_unload_data(&im->im->cache_entry);
+ }
+ im->dirty = 0;
+ if (!im->tex) return;
+ break;
case EVAS_COLORSPACE_YCBCR422P601_PL:
case EVAS_COLORSPACE_YCBCR422P709_PL:
if ((im->tex) && (im->dirty))
im->cs.space);
}
-void
-evas_gl_common_image_push(Evas_Engine_GL_Context *gc, Evas_GL_Image *im,
- int dx, int dy, int dw, int dh,
- int sx, int sy, int sw, int sh,
- int cx, int cy, int cw, int ch,
- int r, int g, int b, int a, int smooth,
- int yuv, int yuy2, int nv12)
+static void
+_evas_gl_common_image_push(Evas_Engine_GL_Context *gc, Evas_GL_Image *im,
+ int dx, int dy, int dw, int dh,
+ int sx, int sy, int sw, int sh,
+ int cx, int cy, int cw, int ch,
+ int r, int g, int b, int a, Eina_Bool smooth,
+ Eina_Bool yuv, Eina_Bool yuy2, Eina_Bool nv12,
+ Eina_Bool rgb_a_pair)
{
double ssx, ssy, ssw, ssh;
int nx, ny, nw, nh;
dx, dy, dw, dh,
r, g, b, a,
smooth);
+ else if (rgb_a_pair)
+ evas_gl_common_context_rgb_a_pair_push(gc,
+ im->tex,
+ sx, sy, sw, sh,
+ dx, dy, dw, dh,
+ r, g, b, a,
+ smooth);
else
evas_gl_common_context_image_push(gc,
im->tex,
nx, ny, nw, nh,
r, g, b, a,
smooth);
+ else if (rgb_a_pair)
+ evas_gl_common_context_rgb_a_pair_push(gc,
+ im->tex,
+ ssx, ssy, ssw, ssh,
+ nx, ny, nw, nh,
+ r, g, b, a,
+ smooth);
else
evas_gl_common_context_image_push(gc,
im->tex,
Cutout_Rect *rct;
int c, cx, cy, cw, ch;
int i;
- int yuv = 0;
- int yuy2 = 0;
- int nv12 = 0;
+ Eina_Bool yuv = EINA_FALSE;
+ Eina_Bool yuy2 = EINA_FALSE;
+ Eina_Bool nv12 = EINA_FALSE;
+ Eina_Bool rgb_a_pair = EINA_FALSE;
if (sw < 1) sw = 1;
if (sh < 1) sh = 1;
return;
}
- if ((im->cs.space == EVAS_COLORSPACE_YCBCR422P601_PL) ||
- (im->cs.space == EVAS_COLORSPACE_YCBCR422P709_PL))
- yuv = 1;
- if (im->cs.space == EVAS_COLORSPACE_YCBCR422601_PL)
- yuy2 = 1;
- if ((im->cs.space == EVAS_COLORSPACE_YCBCR420NV12601_PL) ||
- (im->cs.space == EVAS_COLORSPACE_YCBCR420TM12601_PL))
- nv12 = 1;
+ switch (im->cs.space)
+ {
+ case EVAS_COLORSPACE_YCBCR422P601_PL:
+ case EVAS_COLORSPACE_YCBCR422P709_PL:
+ yuv = EINA_TRUE;
+ break;
+ case EVAS_COLORSPACE_YCBCR422601_PL:
+ yuy2 = EINA_TRUE;
+ break;
+ case EVAS_COLORSPACE_YCBCR420NV12601_PL:
+ case EVAS_COLORSPACE_YCBCR420TM12601_PL:
+ nv12 = EINA_TRUE;
+ break;
+ case EVAS_COLORSPACE_ETC1_ALPHA:
+ rgb_a_pair = EINA_TRUE;
+ break;
+ default: break;
+ }
if ((sw == dw) && (sh == dh)) smooth = 0;
{
if (gc->dc->clip.use)
{
- evas_gl_common_image_push(gc, im,
- dx, dy, dw, dh,
- sx, sy, sw, sh,
- gc->dc->clip.x, gc->dc->clip.y,
- gc->dc->clip.w, gc->dc->clip.h,
- r, g, b, a, smooth,
- yuv, yuy2, nv12);
+ _evas_gl_common_image_push(gc, im,
+ dx, dy, dw, dh,
+ sx, sy, sw, sh,
+ gc->dc->clip.x, gc->dc->clip.y,
+ gc->dc->clip.w, gc->dc->clip.h,
+ r, g, b, a, smooth,
+ yuv, yuy2, nv12, rgb_a_pair);
}
else
{
- evas_gl_common_image_push(gc, im,
- dx, dy, dw, dh,
- sx, sy, sw, sh,
- dx, dy, dw, dh,
- r, g, b, a, smooth,
- yuv, yuy2, nv12);
+ _evas_gl_common_image_push(gc, im,
+ dx, dy, dw, dh,
+ sx, sy, sw, sh,
+ dx, dy, dw, dh,
+ r, g, b, a, smooth,
+ yuv, yuy2, nv12, rgb_a_pair);
}
return;
}
{
rct = rects->rects + i;
- evas_gl_common_image_push(gc, im,
- dx, dy, dw, dh,
- sx, sy, sw, sh,
- rct->x, rct->y, rct->w, rct->h,
- r, g, b, a, smooth,
- yuv, yuy2, nv12);
+ _evas_gl_common_image_push(gc, im,
+ dx, dy, dw, dh,
+ sx, sy, sw, sh,
+ rct->x, rct->y, rct->w, rct->h,
+ r, g, b, a, smooth,
+ yuv, yuy2, nv12, rgb_a_pair);
}
/* restore clip info */
gc->dc->clip.use = c; gc->dc->clip.x = cx; gc->dc->clip.y = cy; gc->dc->clip.w = cw; gc->dc->clip.h = ch;
NULL, 0
};
+/////////////////////////////////////////////
+const char rgb_a_pair_frag_glsl[] =
+#include "shader/rgb_a_pair_frag.h"
+ ;
+Evas_GL_Program_Source shader_rgb_a_pair_frag_src =
+{
+ rgb_a_pair_frag_glsl,
+ NULL, 0
+};
+
+const char rgb_a_pair_vert_glsl[] =
+#include "shader/rgb_a_pair_vert.h"
+ ;
+Evas_GL_Program_Source shader_rgb_a_pair_vert_src =
+{
+ rgb_a_pair_vert_glsl,
+ NULL, 0
+};
+
+const char rgb_a_pair_nomul_frag_glsl[] =
+#include "shader/rgb_a_pair_nomul_frag.h"
+ ;
+Evas_GL_Program_Source shader_rgb_a_pair_nomul_frag_src =
+{
+ rgb_a_pair_nomul_frag_glsl,
+ NULL, 0
+};
+
+const char rgb_a_pair_nomul_vert_glsl[] =
+#include "shader/rgb_a_pair_nomul_vert.h"
+ ;
+Evas_GL_Program_Source shader_rgb_a_pair_nomul_vert_src =
+{
+ rgb_a_pair_nomul_vert_glsl,
+ NULL, 0
+};
+
/////////////////////////////////////////////
static void
SHADER_SOURCE_LINE(YUY2_NOMUL, yuy2_nomul),
SHADER_SOURCE_LINE(NV12, nv12),
SHADER_SOURCE_LINE(NV12_NOMUL, nv12_nomul),
+
+ SHADER_SOURCE_LINE(RGB_A_PAIR, rgb_a_pair),
+ SHADER_SOURCE_LINE(RGB_A_PAIR_NOMUL, rgb_a_pair_nomul),
};
static int
{ EINA_FALSE, EINA_TRUE, EVAS_COLORSPACE_GRY8, &lum_fmt, &lum_ifmt },
{ EINA_TRUE, EINA_FALSE, EVAS_COLORSPACE_AGRY88, &lum_alpha_fmt, &lum_alpha_ifmt },
{ EINA_TRUE, EINA_TRUE, EVAS_COLORSPACE_AGRY88, &lum_alpha_fmt, &lum_alpha_ifmt },
+ // ETC1/2 support
{ EINA_FALSE, EINA_FALSE, EVAS_COLORSPACE_ETC1, &etc1_fmt, &etc1_fmt },
{ EINA_FALSE, EINA_TRUE, EVAS_COLORSPACE_ETC1, &etc1_fmt, &etc1_fmt },
{ EINA_FALSE, EINA_FALSE, EVAS_COLORSPACE_RGB8_ETC2, &etc2_rgb_fmt, &etc2_rgb_fmt },
// images marked as no alpha but format supports it (RGBA8_ETC2_EAC):
{ EINA_FALSE, EINA_FALSE, EVAS_COLORSPACE_RGBA8_ETC2_EAC, &etc2_rgba_fmt, &etc2_rgba_fmt },
{ EINA_FALSE, EINA_TRUE, EVAS_COLORSPACE_RGBA8_ETC2_EAC, &etc2_rgba_fmt, &etc2_rgba_fmt },
+ { EINA_TRUE, EINA_FALSE, EVAS_COLORSPACE_ETC1_ALPHA, &etc1_fmt, &etc1_fmt },
+ { EINA_TRUE, EINA_TRUE, EVAS_COLORSPACE_ETC1_ALPHA, &etc1_fmt, &etc1_fmt },
// S3TC support
{ EINA_FALSE, EINA_FALSE, EVAS_COLORSPACE_RGB_S3TC_DXT1, &s3tc_rgb_dxt1_fmt, &s3tc_rgb_dxt1_fmt },
{ EINA_FALSE, EINA_TRUE, EVAS_COLORSPACE_RGB_S3TC_DXT1, &s3tc_rgb_dxt1_fmt, &s3tc_rgb_dxt1_fmt },
case EVAS_COLORSPACE_ETC1:
case EVAS_COLORSPACE_RGB8_ETC2:
case EVAS_COLORSPACE_RGBA8_ETC2_EAC:
+ case EVAS_COLORSPACE_ETC1_ALPHA:
case EVAS_COLORSPACE_RGB_S3TC_DXT1:
case EVAS_COLORSPACE_RGBA_S3TC_DXT1:
case EVAS_COLORSPACE_RGBA_S3TC_DXT2:
case EVAS_COLORSPACE_RGB_S3TC_DXT1:
case EVAS_COLORSPACE_RGBA_S3TC_DXT1:
case EVAS_COLORSPACE_ETC1:
+ case EVAS_COLORSPACE_ETC1_ALPHA:
case EVAS_COLORSPACE_RGB8_ETC2:
{
/*
GLERR(__FUNCTION__, __FILE__, __LINE__, "");
if ((tex->gc->shared->info.etc1_subimage ||
- (im->cache_entry.space != EVAS_COLORSPACE_ETC1))
+ ((im->cache_entry.space != EVAS_COLORSPACE_ETC1) &&
+ (im->cache_entry.space != EVAS_COLORSPACE_ETC1_ALPHA)))
&& (tex->pt->w != width || tex->pt->h != height))
{
int err;
// FIXME: Changing settings on the fly.
// The first texture will be black.
// How to fallback? We need a whole texture now.
- if (im->cache_entry.space == EVAS_COLORSPACE_ETC1)
+ if ((im->cache_entry.space == EVAS_COLORSPACE_ETC1) ||
+ (im->cache_entry.space == EVAS_COLORSPACE_ETC1_ALPHA))
tex->gc->shared->info.etc1_subimage = EINA_FALSE;
}
}
}
Evas_GL_Texture *
+evas_gl_common_texture_rgb_a_pair_new(Evas_Engine_GL_Context *gc,
+ RGBA_Image *im)
+{
+ Evas_GL_Texture *tex;
+ int lformat, w, h;
+
+ // FIXME/TODO: We don't support texture atlasses here (a bit tricky)
+
+ // Some debugging. We could return.
+ if (im->cache_entry.space != EVAS_COLORSPACE_ETC1_ALPHA)
+ WRN("Using RGB+A texture pair with format %d", im->cache_entry.space);
+
+ w = im->cache_entry.w;
+ h = im->cache_entry.h;
+
+ lformat = _evas_gl_texture_search_format(EINA_FALSE, gc->shared->info.bgra,
+ im->cache_entry.space);
+ if (lformat < 0) return NULL;
+
+ tex = evas_gl_common_texture_alloc(gc, w, h, EINA_TRUE);
+ if (!tex) return NULL;
+
+ // Allocate RGB texture normally - as a 'whole'
+ tex->pt = _pool_tex_new(gc, w, h,
+ *matching_format[lformat].intformat,
+ *matching_format[lformat].format);
+ if (!tex->pt)
+ {
+ evas_gl_common_texture_light_free(tex);
+ return NULL;
+ }
+ pt_link(gc, tex->pt);
+ tex->pt->slot = -1;
+
+ // And now Alpha texture -- FIXME could intformat be different? (eg. ALPHA4)
+ tex->pta = _pool_tex_new(gc, w, h,
+ *matching_format[lformat].intformat,
+ *matching_format[lformat].format);
+ if (!tex->pta)
+ {
+ pt_unref(tex->pt);
+ evas_gl_common_texture_light_free(tex);
+ return NULL;
+ }
+ pt_link(gc, tex->pta);
+ tex->pta->slot = -1;
+
+ evas_gl_common_texture_rgb_a_pair_update(tex, im);
+ return tex;
+}
+
+void
+evas_gl_common_texture_rgb_a_pair_update(Evas_GL_Texture *tex,
+ RGBA_Image *im)
+{
+ DATA8 *data1, *data2;
+ Eina_Bool comp, upload;
+ int w, h, sz, rowlen, ystep = 1;
+
+ if (!tex->pt) return;
+
+ // Handle compressed formats with 4x4 blocks format
+ if (((int) im->cache_entry.space >= (int) EVAS_COLORSPACE_ETC1) &&
+ ((int) im->cache_entry.space <= (int) EVAS_COLORSPACE_RGBA_S3TC_DXT5))
+ ystep = 4;
+
+ w = im->cache_entry.w + im->cache_entry.borders.l + im->cache_entry.borders.r;
+ h = im->cache_entry.h + im->cache_entry.borders.t + im->cache_entry.borders.b;
+ rowlen = _evas_gl_texture_size_get(w, ystep, tex->pt->intformat, NULL);
+ sz = _evas_gl_texture_size_get(w, h, tex->pt->intformat, &comp);
+ data1 = im->image.data8;
+ data2 = data1 + sz;
+ upload = !!data1;
+
+ if (tex->gc->shared->info.unpack_row_length)
+ {
+ glPixelStorei(GL_UNPACK_ROW_LENGTH, w); GLERRLOG();
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1); GLERRLOG();
+ glBindTexture(GL_TEXTURE_2D, tex->pt->texture); GLERRLOG();
+ if (!_tex_2d(tex->gc, tex->pt->intformat, w, h, tex->pt->format, tex->pt->dataformat))
+ goto on_error;
+ if (upload)
+ {
+ if (comp)
+ _comp_tex_sub_2d(tex->gc, 0, 0, w, h, tex->pt->format, sz, data1);
+ else
+ _tex_sub_2d(tex->gc, 0, 0, w, h, tex->pt->format, tex->pt->dataformat, data1);
+ }
+ glBindTexture(GL_TEXTURE_2D, tex->pta->texture); GLERRLOG();
+ if (!_tex_2d(tex->gc, tex->pta->intformat, w, h, tex->pta->format, tex->pta->dataformat))
+ goto on_error;
+ if (upload)
+ {
+ if (comp)
+ _comp_tex_sub_2d(tex->gc, 0, 0, w, h, tex->pt->format, sz, data2);
+ else
+ _tex_sub_2d(tex->gc, 0, 0, w, h, tex->pt->format, tex->pt->dataformat, data2);
+ }
+ }
+ else
+ {
+ int y;
+
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1); GLERRLOG();
+ glBindTexture(GL_TEXTURE_2D, tex->pt->texture); GLERRLOG();
+ if (!_tex_2d(tex->gc, tex->pt->intformat, w, h, tex->pt->format,
+ tex->pt->dataformat))
+ goto on_error;
+ if (upload)
+ {
+ if (w == tex->w)
+ {
+ if (comp)
+ _comp_tex_sub_2d(tex->gc, 0, 0, w, h, tex->pt->format, sz, data1);
+ else
+ _tex_sub_2d(tex->gc, 0, 0, w, h, tex->pt->format, tex->pt->dataformat, data1);
+ }
+ else
+ {
+ for (y = 0; y < h; y += ystep)
+ {
+ if (comp)
+ _comp_tex_sub_2d(tex->gc, 0, 0, w, h, tex->pt->format, sz, data1);
+ else
+ _tex_sub_2d(tex->gc, 0, y, w, ystep, tex->pt->format,
+ tex->pt->dataformat, data1 + rowlen * y / ystep);
+ }
+ }
+ }
+
+ glBindTexture(GL_TEXTURE_2D, tex->pta->texture); GLERRLOG();
+ if (!_tex_2d(tex->gc, tex->pta->intformat, w, h, tex->pta->format,
+ tex->pta->dataformat))
+ goto on_error;
+ if (upload)
+ {
+ if (w == tex->w)
+ {
+ if (comp)
+ _comp_tex_sub_2d(tex->gc, 0, 0, w, h, tex->pt->format, sz, data2);
+ else
+ _tex_sub_2d(tex->gc, 0, 0, w, h, tex->pt->format, tex->pt->dataformat, data2);
+ }
+ else
+ {
+ for (y = 0; y < h; y += ystep)
+ {
+ if (comp)
+ _comp_tex_sub_2d(tex->gc, 0, 0, w, h, tex->pt->format, sz, data2);
+ else
+ _tex_sub_2d(tex->gc, 0, y, w, ystep, tex->pt->format,
+ tex->pt->dataformat, data2 + rowlen * y / ystep);
+ }
+ }
+ }
+ }
+on_error:
+ if (tex->pt->texture != tex->gc->pipe[0].shader.cur_tex)
+ {
+ glBindTexture(GL_TEXTURE_2D, tex->gc->pipe[0].shader.cur_tex);
+ GLERRLOG();
+ }
+}
+
+Evas_GL_Texture *
evas_gl_common_texture_yuv_new(Evas_Engine_GL_Context *gc, DATA8 **rows, unsigned int w, unsigned int h)
{
Evas_GL_Texture *tex;
case EVAS_COLORSPACE_ETC1:
case EVAS_COLORSPACE_RGB8_ETC2:
case EVAS_COLORSPACE_RGBA8_ETC2_EAC:
+ case EVAS_COLORSPACE_ETC1_ALPHA:
ERR("This image is encoded in ETC1 or ETC2, not returning any data");
error = EVAS_LOAD_ERROR_UNKNOWN_FORMAT;
*image_data = NULL;
projects / platform / upstream / efl.git / commitdiff