/*

 *      GPAC - Multimedia Framework C SDK

 *

 *      Authors: Jean Le Feuvre

 *      Copyright (c) Telecom ParisTech 2000-2025

 *          All rights reserved

 *

 *  This file is part of GPAC / software 2D rasterizer module

 *

 *  GPAC is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU Lesser General Public License as published by

 *  the Free Software Foundation; either version 2, or (at your option)

 *  any later version.

 *

 *  GPAC is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU Lesser General Public License for more details.

 *

 *  You should have received a copy of the GNU Lesser General Public

 *  License along with this library; see the file COPYING.  If not, write to

 *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.

 *

 *

 */

#include "rast_soft.h"

#ifndef GPAC_DISABLE_EVG

static void get_surface_world_matrix(GF_EVGSurface *surf, GF_Matrix2D *mat)

{

  gf_mx2d_init(*mat);

  if (surf->center_coords) {

    gf_mx2d_add_scale(mat, FIX_ONE, -FIX_ONE);

    gf_mx2d_add_translation(mat, INT2FIX(surf->width / 2), INT2FIX(surf->height / 2));

  }

}

static GF_Err evg_raster_ctx_init(EVGRasterCtx *raster_ctx, GF_EVGSurface *surf)

{

  raster_ctx->max_gray_spans = raster_ctx->alloc_gray_spans = FT_MAX_GRAY_SPANS;

  raster_ctx->gray_spans = gf_malloc(sizeof(EVG_Span)* raster_ctx->max_gray_spans);

  if (!raster_ctx->gray_spans) return GF_OUT_OF_MEM;

  raster_ctx->surf = surf;

  return GF_OK;

}

static void evg_raster_ctx_uninit(EVGRasterCtx *raster_ctx)

{

  if (raster_ctx->gray_spans) gf_free(raster_ctx->gray_spans);

  if (raster_ctx->stencil_pix_run) gf_free(raster_ctx->stencil_pix_run);

  if (raster_ctx->stencil_pix_run2) gf_free(raster_ctx->stencil_pix_run2);

  if (raster_ctx->stencil_pix_run3) gf_free(raster_ctx->stencil_pix_run3);

  if (raster_ctx->uv_alpha) gf_free(raster_ctx->uv_alpha);

}

GF_EXPORT

GF_EVGSurface *gf_evg_surface_new(Bool center_coords)

{

  GF_Err e;

  GF_EVGSurface *surf;

  GF_SAFEALLOC(surf, GF_EVGSurface);

  if (!surf) return NULL;

  surf->center_coords = center_coords;

  surf->qlevel = GF_RASTER_HIGH_QUALITY;

  surf->yuv_prof = 1;

  e = evg_raster_ctx_init(&surf->raster_ctx, surf);

  if (e) {

    gf_free(surf);

    return NULL;

  }

  return surf;

}

EVG_Surface3DExt *evg_init_3d_surface(GF_EVGSurface *surf);

GF_EXPORT

GF_Err gf_evg_surface_enable_3d(GF_EVGSurface *surf)

{

  if (!surf) return GF_BAD_PARAM;

  if (surf->ext3d) return GF_OK;

  surf->ext3d = evg_init_3d_surface(surf);

  if (!surf->ext3d) return GF_OUT_OF_MEM;

  return GF_OK;

}

GF_EXPORT

GF_Err gf_evg_enable_threading(GF_EVGSurface *surf, s32 nb_threads)

{

#ifndef GPAC_DISABLE_THREADS

  u32 i, run_size;

  char szName[100];

  if (!surf) return GF_BAD_PARAM;

  if (surf->nb_threads) return GF_OK;

  if (gf_opts_get_bool("core", "no-mx")) return GF_OK;

  if (nb_threads<0) {

    GF_SystemRTInfo rti;

    gf_sys_get_rti(0, &rti, 0);

    if (rti.nb_cores<2) return GF_IO_ERR;

    nb_threads = rti.nb_cores-1;

  }

  surf->nb_threads = (u32) nb_threads;

  if (!surf->nb_threads) return GF_OK;

  surf->th_raster_ctx = gf_malloc(sizeof(EVGRasterCtx) * surf->nb_threads);

  sprintf(szName, "EVGMX%p", surf);

  surf->raster_mutex = gf_mx_new(szName);

  if (!surf->th_raster_ctx || !surf->raster_mutex) {

    surf->nb_threads = 0;

    return GF_OUT_OF_MEM;

  }

  run_size = surf->width ? (sizeof(u32) * (surf->width+2)) : 0;

  if (surf->width && surf->not_8bits) run_size *= 2;

  memset(surf->th_raster_ctx, 0, sizeof(EVGRasterCtx) * surf->nb_threads);

  for (i=0; i<surf->nb_threads; i++) {

    EVGRasterCtx *rctx = &surf->th_raster_ctx[i];

    sprintf(szName, "gf_evg_%d", i+1);

    rctx->th = gf_th_new(szName);

    if (!rctx->th) {

      surf->nb_threads = i;

      break;

    }

    rctx->surf = surf;

    rctx->max_gray_spans = rctx->alloc_gray_spans = FT_MAX_GRAY_SPANS;

    rctx->gray_spans = gf_malloc(sizeof(EVG_Span) * rctx->max_gray_spans);

    if (run_size) {

      rctx->stencil_pix_run = gf_realloc(rctx->stencil_pix_run, run_size);

    }

    if (!rctx->gray_spans || !rctx->stencil_pix_run) {

      surf->nb_threads = i;

      break;

    }

    rctx->th_state = 1;

  }

  surf->raster_sem = gf_sema_new(surf->nb_threads, 0);

  if (!surf->raster_sem)

    surf->nb_threads = 0;

  //launch all threads

  for (i=0; i<surf->nb_threads; i++) {

    EVGRasterCtx *rctx = &surf->th_raster_ctx[i];

    gf_th_run(rctx->th, th_sweep_lines, rctx);

  }

#endif //GPAC_DISABLE_THREADS

  return GF_OK;

}

GF_EXPORT

void gf_evg_surface_set_center_coords(GF_EVGSurface *surf, Bool center_coords)

{

  if (surf) surf->center_coords = center_coords;

}

GF_EXPORT

void gf_evg_surface_delete(GF_EVGSurface *surf)

{

  u32 i;

  if (!surf)

    return;

  for (i=0; i<surf->max_lines; i++) {

    gf_free(surf->scanlines[i].cells);

    if (surf->scanlines[i].pixels)

      gf_free(surf->scanlines[i].pixels);

  }

  gf_free(surf->scanlines);

  if (surf->internal_mask) gf_free(surf->internal_mask);

  evg_raster_ctx_uninit(&surf->raster_ctx);

  if (surf->ext3d) {

    gf_free(surf->ext3d);

  }

#ifndef GPAC_DISABLE_THREADS

  if (surf->nb_threads) {

    for (i=0; i<surf->nb_threads; i++) {

      EVGRasterCtx *rctx = &surf->th_raster_ctx[i];

      rctx->th_state = 0;

    }

    gf_sema_notify(surf->raster_sem, surf->nb_threads);

    for (i=0; i<surf->nb_threads; i++) {

      EVGRasterCtx *rctx = &surf->th_raster_ctx[i];

      //wait for destruction

      while (!rctx->th_state) {

        gf_sleep(0);

      }

      gf_th_del(surf->th_raster_ctx[i].th);

      evg_raster_ctx_uninit(&surf->th_raster_ctx[i]);

    }

    gf_free(surf->th_raster_ctx);

    gf_mx_del(surf->raster_mutex);

    gf_sema_del(surf->raster_sem);

  }

#endif

  gf_free(surf);

}

GF_EXPORT

GF_Err gf_evg_surface_set_matrix(GF_EVGSurface *surf, GF_Matrix2D *mat)

{

  GF_Matrix2D tmp;

  if (!surf) return GF_BAD_PARAM;

  get_surface_world_matrix(surf, &surf->mat);

  surf->is_3d_matrix = GF_FALSE;

  if (!mat) {

    gf_mx2d_init(surf->shader_mx);

    return GF_OK;

  }

  gf_mx2d_init(tmp);

  gf_mx2d_add_matrix(&tmp, mat);

  gf_mx2d_add_matrix(&tmp, &surf->mat);

  gf_mx2d_copy(surf->mat, tmp);

  gf_mx2d_copy(surf->shader_mx, *mat);

  return GF_OK;

}

GF_EXPORT

GF_Err gf_evg_surface_set_matrix_3d(GF_EVGSurface *surf, GF_Matrix *mat)

{

  if (!surf) return GF_BAD_PARAM;

  get_surface_world_matrix(surf, &surf->mat);

  surf->is_3d_matrix = GF_FALSE;

  if (!mat) return GF_OK;

  gf_mx_copy(surf->mx3d, *mat);

  surf->is_3d_matrix = GF_TRUE;

  return GF_OK;

}

static void evg_surface_set_components_idx(GF_EVGSurface *surf)

{

  surf->idx_y1=surf->idx_u=surf->idx_v=0;

  surf->idx_a=surf->idx_r=surf->idx_g=surf->idx_b=0;

  switch (surf->pixelFormat) {

  case GF_PIXEL_YUYV:

    surf->idx_y1=0;

    surf->idx_u=1;

    surf->idx_v=3;

    break;

  case GF_PIXEL_YVYU:

    surf->idx_y1=0;

    surf->idx_u=3;

    surf->idx_v=1;

    break;

  case GF_PIXEL_UYVY:

    surf->idx_y1=1;

    surf->idx_u=0;

    surf->idx_v=2;

    break;

  case GF_PIXEL_VYUY:

    surf->idx_y1=1;

    surf->idx_u=2;

    surf->idx_v=0;

    break;

  case GF_PIXEL_ALPHAGREY:

    surf->idx_a = 0;

    surf->idx_g = 1;

    break;

  case GF_PIXEL_GREYALPHA:

    surf->idx_a = 1;

    surf->idx_g = 0;

    break;

  case GF_PIXEL_ARGB:

    surf->idx_a=0;

    surf->idx_r=1;

    surf->idx_g=2;

    surf->idx_b=3;

    break;

  case GF_PIXEL_RGBA:

  case GF_PIXEL_YUVA444_PACK:

    surf->idx_a=3;

    surf->idx_r=0;

    surf->idx_g=1;

    surf->idx_b=2;

    break;

  case GF_PIXEL_UYVA444_PACK:

    surf->idx_a=3;

    surf->idx_r=1;

    surf->idx_g=0;

    surf->idx_b=2;

    break;

  case GF_PIXEL_YUV444_PACK:

    surf->idx_r=0;

    surf->idx_g=1;

    surf->idx_b=2;

    break;

  case GF_PIXEL_VYU444_PACK:

    surf->idx_r=1;

    surf->idx_g=2;

    surf->idx_b=0;

    break;

  case GF_PIXEL_BGRA:

    surf->idx_a=3;

    surf->idx_r=2;

    surf->idx_g=1;

    surf->idx_b=0;

    break;

  case GF_PIXEL_ABGR:

    surf->idx_a=0;

    surf->idx_r=3;

    surf->idx_g=2;

    surf->idx_b=1;

    break;

  case GF_PIXEL_RGBX:

    surf->idx_r=0;

    surf->idx_g=1;

    surf->idx_b=2;

    surf->idx_a=3;

    break;

  case GF_PIXEL_BGRX:

    surf->idx_r=2;

    surf->idx_g=1;

    surf->idx_b=0;

    surf->idx_a=3;

    break;

  case GF_PIXEL_XRGB:

    surf->idx_a=0;

    surf->idx_r=1;

    surf->idx_g=2;

    surf->idx_b=3;

    break;

  case GF_PIXEL_XBGR:

    surf->idx_a=0;

    surf->idx_r=3;

    surf->idx_g=2;

    surf->idx_b=1;

    break;

  case GF_PIXEL_RGB:

    surf->idx_r=0;

    surf->idx_g=1;

    surf->idx_b=2;

    break;

  case GF_PIXEL_BGR:

    surf->idx_r=2;

    surf->idx_g=1;

    surf->idx_b=0;

    break;

  }

}

static GF_Err gf_evg_surface_attach_to_buffer_internal(GF_EVGSurface *surf, u8 *pixels, u32 width, u32 height, s32 pitch_x, s32 pitch_y, GF_PixelFormat pixelFormat, Bool probe_only)

{

  u32 BPP;

  Bool size_changed=GF_FALSE;

  if (!probe_only) {

    if (!surf || !pixels) return GF_BAD_PARAM;

    surf->is_transparent = GF_FALSE;

    surf->not_8bits = GF_FALSE;

  }

  switch (pixelFormat) {

  case GF_PIXEL_GREYSCALE:

    BPP = 1;

    break;

  case GF_PIXEL_ALPHAGREY:

  case GF_PIXEL_GREYALPHA:

    BPP = 2;

    if (!probe_only)

      surf->is_transparent = GF_TRUE;

    break;

  case GF_PIXEL_RGB_332:

    BPP = 1;

    break;

  case GF_PIXEL_RGB_444:

  case GF_PIXEL_RGB_555:

  case GF_PIXEL_RGB_565:

    BPP = 2;

    break;

  case GF_PIXEL_ARGB:

  case GF_PIXEL_BGRA:

  case GF_PIXEL_RGBA:

  case GF_PIXEL_ABGR:

    if (!probe_only)

      surf->is_transparent = GF_TRUE;

  case GF_PIXEL_RGBX:

  case GF_PIXEL_BGRX:

  case GF_PIXEL_XRGB:

  case GF_PIXEL_XBGR:

    BPP = 4;

    break;

  case GF_PIXEL_BGR:

  case GF_PIXEL_RGB:

    BPP = 3;

    break;

  case GF_PIXEL_YUV:

  case GF_PIXEL_YVU:

  case GF_PIXEL_NV12:

  case GF_PIXEL_NV21:

  case GF_PIXEL_YUV422:

  case GF_PIXEL_YUV444:

  case GF_PIXEL_YUYV:

  case GF_PIXEL_YVYU:

  case GF_PIXEL_UYVY:

  case GF_PIXEL_VYUY:

    BPP = 1;

    break;

  case GF_PIXEL_YUV_10:

  case GF_PIXEL_NV12_10:

  case GF_PIXEL_NV21_10:

  case GF_PIXEL_YUV422_10:

  case GF_PIXEL_YUV444_10:

    BPP = 2;

    if (!probe_only)

      surf->not_8bits = GF_TRUE;

    break;

  case GF_PIXEL_YUVA444_PACK:

  case GF_PIXEL_UYVA444_PACK:

    if (!probe_only)

      surf->is_transparent = GF_TRUE;

    BPP = 4;

    break;

  case GF_PIXEL_YUV444_PACK:

  case GF_PIXEL_VYU444_PACK:

    BPP = 3;

    break;

  default:

    return GF_NOT_SUPPORTED;

  }

  if (probe_only) return GF_OK;

  if (!pitch_x) pitch_x = BPP;

  if (!pitch_y) {

    gf_pixel_get_size_info(pixelFormat, width, height, NULL, &pitch_y, NULL, NULL, NULL);

  }

  surf->pitch_x = pitch_x;

  surf->pitch_y = pitch_y;

  if (!surf->raster_ctx.stencil_pix_run || (surf->width != width)) {

    u32 run_size = sizeof(u32) * (width+2);

    if (surf->not_8bits) run_size *= 2;

    surf->raster_ctx.stencil_pix_run = gf_realloc(surf->raster_ctx.stencil_pix_run, run_size);

    if (!surf->raster_ctx.stencil_pix_run) return GF_OUT_OF_MEM;

    if (surf->raster_ctx.stencil_pix_run2) {

      surf->raster_ctx.stencil_pix_run2 = gf_realloc(surf->raster_ctx.stencil_pix_run2, run_size);

      if (!surf->raster_ctx.stencil_pix_run2) return GF_OUT_OF_MEM;

    }

    if (surf->raster_ctx.stencil_pix_run3) {

      surf->raster_ctx.stencil_pix_run3 = gf_realloc(surf->raster_ctx.stencil_pix_run3, run_size);

      if (!surf->raster_ctx.stencil_pix_run3) return GF_OUT_OF_MEM;

    }

#ifndef GPAC_DISABLE_THREADS

    u32 i;

    for (i=0; i<surf->nb_threads; i++) {

      EVGRasterCtx *rctx = &surf->th_raster_ctx[i];

      rctx->stencil_pix_run = gf_realloc(rctx->stencil_pix_run, run_size);

      if (!rctx->stencil_pix_run) return GF_OUT_OF_MEM;

      if (rctx->stencil_pix_run2) {

        rctx->stencil_pix_run2 = gf_realloc(rctx->stencil_pix_run2, run_size);

        if (!rctx->stencil_pix_run2) return GF_OUT_OF_MEM;

      }

      if (rctx->stencil_pix_run3) {

        rctx->stencil_pix_run3 = gf_realloc(rctx->stencil_pix_run3, run_size);

        if (!rctx->stencil_pix_run3) return GF_OUT_OF_MEM;

      }

    }

#endif

  }

  if (surf->width != width) {

    surf->width = width;

    size_changed = GF_TRUE;

  }

  if (surf->height != height) {

    surf->height = height;

    size_changed = GF_TRUE;

  }

  surf->pixels = (char*)pixels;

  surf->pixelFormat = pixelFormat;

  surf->BPP = BPP;

  evg_surface_set_components_idx(surf);

  gf_evg_surface_set_matrix(surf, NULL);

  if (size_changed && surf->internal_mask) {

    gf_free(surf->internal_mask);

    surf->internal_mask = NULL;

  }

  if (surf->ext3d && size_changed) {

    surf->ext3d->depth_buffer = NULL;

    if (!surf->vp_w || !surf->vp_h) {

      surf->vp_x = 0;

      surf->vp_y = 0;

      surf->vp_w = surf->width;

      surf->vp_h = surf->height;

    }

  }

  return GF_OK;

}

GF_EXPORT

GF_Err gf_evg_surface_attach_to_buffer(GF_EVGSurface *surf, u8 *pixels, u32 width, u32 height, s32 pitch_x, s32 pitch_y, GF_PixelFormat pixelFormat)

{

  return gf_evg_surface_attach_to_buffer_internal(surf, pixels, width, height, pitch_x, pitch_y, pixelFormat, GF_FALSE);

}

GF_EXPORT

GF_Err gf_evg_surface_attach_to_texture(GF_EVGSurface *surf, GF_EVGStencil * sten)

{

  EVG_Texture *tx = (EVG_Texture *) sten;

  if (!surf || (tx->type != GF_STENCIL_TEXTURE)) return GF_BAD_PARAM;

  return gf_evg_surface_attach_to_buffer_internal(surf, tx->pixels, tx->width, tx->height, 0, tx->stride, tx->pixel_format, GF_FALSE);

}

GF_EXPORT

Bool gf_evg_surface_format_ok(GF_PixelFormat pixelFormat)

{

  GF_Err e = gf_evg_surface_attach_to_buffer_internal(NULL, NULL, 0, 0, 0, 0, pixelFormat, GF_TRUE);

  if (e==GF_OK) return GF_TRUE;

  return GF_FALSE;

}

GF_EXPORT

GF_Err gf_evg_surface_clear(GF_EVGSurface *surf, GF_IRect *rc, u32 color)

{

  GF_IRect clear;

  if (!surf) return GF_BAD_PARAM;

  if (rc) {

    s32 _x, _y;

    if (surf->center_coords) {

      _x = rc->x + surf->width / 2;

      _y = surf->height / 2 - rc->y;

    } else {

      _x = rc->x;

      _y = rc->y - rc->height;

    }

    /*clip is outside our bounds, ignore*/

    if ((_x>=(s32) surf->width) || (_x + rc->width < 0))

      return GF_OK;

    if ((_y>= (s32) surf->height) || (_y + rc->height < 0))

      return GF_OK;

    clear.width = (u32) rc->width;

    if (_x>=0) {

      clear.x = (u32) _x;

    } else {

      if ( (s32) clear.width + _x < 0) return GF_BAD_PARAM;

      clear.width += _x;

      clear.x = 0;

    }

    if (clear.x + clear.width > (s32) surf->width)

      clear.width = surf->width - clear.x;

    if (!clear.width)

      return GF_OK;

    clear.height = (u32) rc->height;

    if (_y>=0) {

      clear.y = _y;

    } else {

      if ( (s32) clear.height + _y < 0) return GF_BAD_PARAM;

      clear.height += _y;

      clear.y = 0;

    }

    if (clear.y + clear.height > (s32) surf->height)

      clear.height = surf->height - clear.y;

    if (!clear.height)

      return GF_OK;

  } else {

    clear.x = clear.y = 0;

    clear.width = surf->width;

    clear.height = surf->height;

  }

  switch (surf->pixelFormat) {

  /*RGB formats*/

  case GF_PIXEL_GREYSCALE:

    return evg_surface_clear_grey(surf, clear, color);

  case GF_PIXEL_ALPHAGREY:

  case GF_PIXEL_GREYALPHA:

    return evg_surface_clear_alphagrey(surf, clear, color);

  case GF_PIXEL_ARGB:

  case GF_PIXEL_BGRA:

  case GF_PIXEL_RGBA:

  case GF_PIXEL_ABGR:

    return evg_surface_clear_argb(surf, clear, color);

  case GF_PIXEL_RGBX:

  case GF_PIXEL_BGRX:

  case GF_PIXEL_XRGB:

  case GF_PIXEL_XBGR:

    return evg_surface_clear_rgbx(surf, clear, color);

  case GF_PIXEL_RGB:

  case GF_PIXEL_BGR:

    return evg_surface_clear_rgb(surf, clear, color);

  case GF_PIXEL_RGB_444:

    return evg_surface_clear_444(surf, clear, color);

  case GF_PIXEL_RGB_555:

    return evg_surface_clear_555(surf, clear, color);

  case GF_PIXEL_RGB_565:

    return evg_surface_clear_565(surf, clear, color);

  case GF_PIXEL_RGB_332:

    return evg_surface_clear_332(surf, clear, color);

  /*YUV formats*/

  case GF_PIXEL_YUV:

  case GF_PIXEL_YVU:

    return evg_surface_clear_yuv420p(surf, clear, color);

  case GF_PIXEL_YUV422:

    return evg_surface_clear_yuv422p(surf, clear, color);

  case GF_PIXEL_NV12:

    return evg_surface_clear_nv12(surf, clear, color, GF_FALSE);

  case GF_PIXEL_NV21:

    return evg_surface_clear_nv12(surf, clear, color, GF_TRUE);

  case GF_PIXEL_YUV444:

    return evg_surface_clear_yuv444p(surf, clear, color);

  case GF_PIXEL_YUYV:

  case GF_PIXEL_YVYU:

  case GF_PIXEL_UYVY:

  case GF_PIXEL_VYUY:

    return evg_surface_clear_yuyv(surf, clear, color);

  case GF_PIXEL_YUV_10:

    return evg_surface_clear_yuv420p_10(surf, clear, color);

  case GF_PIXEL_NV12_10:

    return evg_surface_clear_nv12_10(surf, clear, color, GF_FALSE);

  case GF_PIXEL_NV21_10:

    return evg_surface_clear_nv12_10(surf, clear, color, GF_TRUE);

  case GF_PIXEL_YUV422_10:

    return evg_surface_clear_yuv422p_10(surf, clear, color);

  case GF_PIXEL_YUV444_10:

    return evg_surface_clear_yuv444p_10(surf, clear, color);

  case GF_PIXEL_YUVA444_PACK:

  case GF_PIXEL_UYVA444_PACK:

    return evg_surface_clear_argb(surf, clear, gf_evg_argb_to_ayuv(surf, color) );

  case GF_PIXEL_YUV444_PACK:

  case GF_PIXEL_VYU444_PACK:

    return evg_surface_clear_rgb(surf, clear, gf_evg_argb_to_ayuv(surf, color) );

  default:

    return GF_BAD_PARAM;

  }

}

GF_EXPORT

GF_Err gf_evg_surface_set_raster_level(GF_EVGSurface *surf, GF_RasterQuality RasterSetting)

{

  if (!surf) return GF_BAD_PARAM;

  surf->qlevel = RasterSetting;

  return GF_OK;

}

GF_EXPORT

GF_RasterQuality gf_evg_surface_get_raster_level(GF_EVGSurface *surf)

{

  if (!surf) return GF_RASTER_HIGH_QUALITY;

  return surf->qlevel;

}

GF_EXPORT

GF_Err gf_evg_surface_force_aa(GF_EVGSurface *surf)

{

  if (!surf) return GF_BAD_PARAM;

  surf->aa_level = 0xFF;

  return GF_OK;

}

GF_EXPORT

GF_Err gf_evg_surface_set_clipper(GF_EVGSurface *surf , GF_IRect *rc)

{

  if (!surf) return GF_BAD_PARAM;

  if (rc) {

    surf->clipper = *rc;

    surf->useClipper = 1;

    /*clipper was given in BIFS like coords, we work with bottom-min for rect, (0,0) top-left of surface*/

    if (surf->center_coords) {

      surf->clipper.x += surf->width / 2;

      surf->clipper.y = surf->height / 2 - rc->y;

    } else {

      surf->clipper.y -= rc->height;

    }

    if (surf->clipper.x <=0) {

      if (surf->clipper.x + (s32) surf->clipper.width < 0) return GF_BAD_PARAM;

      surf->clipper.width += surf->clipper.x;

      surf->clipper.x = 0;

    }

    if (surf->clipper.y <=0) {

      if (surf->clipper.y + (s32) surf->clipper.height < 0) return GF_BAD_PARAM;

      surf->clipper.height += surf->clipper.y;

      surf->clipper.y = 0;

    }

    if (surf->clipper.x + surf->clipper.width > (s32) surf->width) {

      surf->clipper.width = surf->width - surf->clipper.x;

    }

    if (surf->clipper.y + surf->clipper.height > (s32) surf->height) {

      surf->clipper.height = surf->height - surf->clipper.y;

    }

  } else {

    surf->useClipper = 0;

  }

  return GF_OK;

}

GF_EXPORT

Bool gf_evg_surface_use_clipper(GF_EVGSurface *surf)

{

  if (!surf) return 0;

  return surf->useClipper ? GF_TRUE : GF_FALSE;

}

static Bool setup_grey_callback(GF_EVGSurface *surf, Bool for_3d, Bool multi_sten)

{

  u32 a, uv_alpha_size=0;

  Bool use_const = GF_TRUE;

  //default fill_run callback

  surf->fill_run = evg_fill_run;

  //mask mode draw,

  if (surf->mask_mode == GF_EVGMASK_DRAW) {

    if (surf->sten && (surf->sten->type == GF_STENCIL_SOLID)) {

      EVG_Brush *sc = (EVG_Brush *)surf->sten;

      u32 col = sc->color;

      if (sc->alpha < 0xFF) {

        u32 ca = ((u32) (GF_COL_A(col) + 1) * sc->alpha) >> 8;

        col = ( ((ca<<24) & 0xFF000000) ) | (col & 0x00FFFFFF);

      }

      surf->fill_col = col;

      surf->fill_col_wide = evg_col_to_wide(surf->fill_col);

      if (GF_COL_A(col)<0xFF)

        surf->fill_spans = (EVG_SpanFunc) evg_grey_fill_const_a;

      else

        surf->fill_spans = (EVG_SpanFunc) evg_grey_fill_const;

    } else {

      surf->fill_spans = (EVG_SpanFunc) evg_grey_fill_var;

    }

    if (surf->ext3d) {

      surf->fill_single = evg_grey_fill_single;

      surf->fill_single_a = evg_grey_fill_single_a;

    }

    return GF_TRUE;

  }

  //in 3D mode, we only write one pixel at a time except in YUV modes

  if (for_3d) {

    a = 1;

    use_const = GF_TRUE;

  }

  else if (!multi_sten && surf->sten && (surf->sten->type == GF_STENCIL_SOLID)) {

    EVG_Brush *sc = (EVG_Brush *)surf->sten;

    u32 col = sc->color;

    if (sc->alpha < 0xFF) {

      u32 ca = ((u32) (GF_COL_A(col) + 1) * sc->alpha) >> 8;

      col = ( ((ca<<24) & 0xFF000000) ) | (col & 0x00FFFFFF);

    }

    surf->fill_col = col;

    a = GF_COL_A(surf->fill_col);

  } else {

    a = 0;

    use_const = GF_FALSE;

  }

  //mask is used, force fill with variable alpha (xxx_fill_var) and use masking callback for fill_run

  if ((surf->mask_mode == GF_EVGMASK_USE) || (surf->mask_mode == GF_EVGMASK_RECORD) ){

    a = 0;

    use_const = GF_FALSE;

    if (surf->mask_mode == GF_EVGMASK_USE)

      surf->fill_run = evg_fill_run_mask;

  } else if (surf->mask_mode == GF_EVGMASK_USE_INV) {

    a = 0;

    use_const = GF_FALSE;

    surf->fill_run = evg_fill_run_mask_inv;

  }

  if (use_const && !a && !surf->is_transparent) return GF_FALSE;

  surf->is_422 = GF_FALSE;

  surf->yuv_type = 0;

  surf->swap_uv = GF_FALSE;

  surf->yuv_flush_uv = NULL;

  surf->direct_yuv_3d = GF_FALSE;

  if (surf->comp_mode) a=100;

  else if (surf->get_alpha) a=100;

  surf->fill_single = NULL;

  surf->fill_single_a = NULL;

  switch (surf->pixelFormat) {

  case GF_PIXEL_GREYSCALE:

    if (use_const) {

      if (a!=0xFF) {

        surf->fill_spans = (EVG_SpanFunc) evg_grey_fill_const_a;

      } else {

        surf->fill_spans = (EVG_SpanFunc) evg_grey_fill_const;

      }

    } else {

      surf->fill_spans = (EVG_SpanFunc) evg_grey_fill_var;

    }

    if (surf->ext3d) {

      surf->fill_single = evg_grey_fill_single;

      surf->fill_single_a = evg_grey_fill_single_a;

    }

    break;

  case GF_PIXEL_ALPHAGREY:

  case GF_PIXEL_GREYALPHA:

    if (use_const) {

      if (a!=0xFF) {

        surf->fill_spans = (EVG_SpanFunc) evg_alphagrey_fill_const_a;

      } else {

        surf->fill_spans = (EVG_SpanFunc) evg_alphagrey_fill_const;

      }

    } else {

      surf->fill_spans = (EVG_SpanFunc) evg_alphagrey_fill_var;

    }

    if (surf->ext3d) {

      surf->fill_single = evg_alphagrey_fill_single;

      surf->fill_single_a = evg_alphagrey_fill_single_a;

    }

    break;

  case GF_PIXEL_YUVA444_PACK:

  case GF_PIXEL_UYVA444_PACK:

    surf->yuv_type = EVG_YUV;

  case GF_PIXEL_ARGB:

  case GF_PIXEL_RGBA:

  case GF_PIXEL_BGRA:

  case GF_PIXEL_ABGR: