/*

 *      GPAC - Multimedia Framework C SDK

 *

 *      Authors: Jean Le Feuvre

 *      Copyright (c) Telecom ParisTech 2019-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

//TODO: support for color spaces, support for more than 10 bits and BigEndian format ?

#if 1

#define mul255(_a, _b)  ( (((u32)(_a) + 1) * (u32)(_b) ) >> 8)

#else

static s32

mul255(s32 a, s32 b)

{

  return ((a + 1) * b) >> 8;

}

#endif

static s32

mul255_zero(s32 a, s32 b)

{

  if (!a) return 0;

  return ((a + 1) * b) >> 8;

}

//RGB <-> YUV full range conversion, using integer (1024 factor)

#define YUV_USE_INT

void gf_evg_rgb_to_yuv(GF_EVGSurface *surf, GF_Color col, u8*y, u8*cb, u8*cr)

{

  u32 r = GF_COL_R(col);

  u32 g = GF_COL_G(col);

  u32 b = GF_COL_B(col);

#ifndef YUV_USE_INT

  *y = (u8) (0.299*r + 0.587 * g + 0.114 * b);

  *cb = (u8) (-0.169*(s32)r - 0.331*(s32)g + 0.499*b + 128);

  *cr = (u8) (0.499 * r - 0.418*(s32)g - 0.0813*(s32)b + 128);

#else

  u32 _v = 306*r + 601 * g + 117 * b;

  *y = (u8) (_v >> 10);

  _v = (-173*(s32)r - 339*(s32)g + 511*b + 131072);

  *cb = (u8) (_v >> 10);

  _v = (511 * r - 428*(s32)g - 83*(s32)b + 131072);

  *cr = (u8) (_v >> 10);

#endif

}

GF_Color gf_evg_argb_to_ayuv(GF_EVGSurface *surf, GF_Color col)

{

  u8 a, y, cb, cr;

  a = GF_COL_A(col);

  u32 r = GF_COL_R(col);

  u32 g = GF_COL_G(col);

  u32 b = GF_COL_B(col);

#ifndef YUV_USE_INT

  y = (u8) (0.299*r + 0.587 * g + 0.114 * b);

  cb = (u8) (-0.169*(s32)r - 0.331*(s32)g + 0.499*b + 128);

  cr = (u8) (0.499 * r - 0.418*(s32)g - 0.0813*(s32)b + 128);

#else

  u32 _v = 306*r + 601 * g + 117 * b;

  y = (u8) (_v >> 10);

  _v = (-173*(s32)r - 339*(s32)g + 511*b + 131072);

  cb = (u8) (_v >> 10);

  _v = (511 * r - 428*(s32)g - 83*(s32)b + 131072);

  cr = (u8) (_v >> 10);

#endif

  return GF_COL_ARGB(a, y, cb, cr);

}

GF_Err gf_gf_evg_rgb_to_yuv_f(GF_EVGSurface *surf, Float r, Float g, Float b, Float *y, Float *cb, Float *cr)

{

  *y = (0.299f * r + 0.587f * g + 0.114f * b);

  *cb = (-0.169f * (s32)r - 0.331f * (s32)g + 0.499f * b + 128.0f);

  *cr = (0.499f * r - 0.418f * (s32)g - 0.0813f * (s32)b + 128.0f);

  return GF_OK;

}

GF_Err gf_evg_yuv_to_rgb_f(GF_EVGSurface *surf, Float y, Float cb, Float cr, Float *r, Float *g, Float *b)

{

  *r = (y + 1.402f * (cr - 128.0f));

  *g = (y - 0.344136f * (cb - 128.0f) - 0.714136f * (cr-128.0f) );

  *b = (y + 1.772f * (cb - 128.0f) );

  return GF_OK;

}

GF_Color gf_evg_ayuv_to_argb(GF_EVGSurface *surf, GF_Color col)

{

  u32 a;

  s32 y, cb, cr;

  s32 r, g, b;

  a = GF_COL_A(col);

  y = GF_COL_R(col);

  cb = GF_COL_G(col);

  cr = GF_COL_B(col);

#ifndef YUV_USE_INT

  r = (s32) (y + 1.402 * (cr - 128));

  g = (s32) (y - 0.344136 * (cb - 128) - 0.714136*(cr-128) );

  b = (s32) (y + 1.772 * (cb - 128) );

#define TRUNC_8BIT(_a) if (_a<0) {_a = 0;} else if (_a>255) {_a=255;}

  TRUNC_8BIT(r)

  TRUNC_8BIT(g)

  TRUNC_8BIT(b)

#else

  y *= 1024;

  r = (s32) (y + 1436 * (cr - 128));

  g = (s32) (y - 352 * (cb - 128) - 731*(cr-128) );

  b = (s32) (y + 1814 * (cb - 128) );

#define TRUNC_8BIT(_a) if (_a<0) {_a = 0;} else { u32 __a = (u32) _a; __a>>=10; if (__a>255) {__a=255;} _a = __a; }

  TRUNC_8BIT(r)

  TRUNC_8BIT(g)

  TRUNC_8BIT(b)

#endif

  return GF_COL_ARGB(a, r, g, b);

}

u64 gf_evg_argb_to_ayuv_wide(GF_EVGSurface *surf, u64 col)

{

  u16 a, y, cb, cr;

  u32 r, g, b;

  a = (col>>48)&0xFFFF;

  r = (col>>32)&0xFFFF;

  g = (col>>16)&0xFFFF;

  b = (col)&0xFFFF;

#ifndef YUV_USE_INT

  y = (u16) (0.299*r + 0.587 * g + 0.114 * b);

  cb = (u16) (-0.169*(s32)r - 0.331*(s32)g + 0.499*b + 32768);

  cr = (u16) (0.499 * r - 0.418*(s32)g - 0.0813*(s32)b + 32768);

#else

  u32 _v = 306*r + 601 * g + 117 * b;

  y = (u16) (_v >> 10);

  _v = (-173*(s32)r - 339*(s32)g + 511*b + 33554432);

  cb = (u16) (_v >> 10);

  _v = (511 * r - 428*(s32)g - 83*(s32)b + 33554432);

  cr = (u16) (_v >> 10);

#endif

  return GF_COLW_ARGB(a, y, cb, cr);

}

u64 gf_evg_ayuv_to_argb_wide(GF_EVGSurface *surf, u64 col)

{

  u32 a;

  s64 y, cb, cr;

  s32 r, g, b;

  a = (col>>48)&0xFFFF;

  y = (col>>32)&0xFFFF;

  cb = (col>>16)&0xFFFF;

  cr = (col)&0xFFFF;

#ifndef YUV_USE_INT

  r = (s32) (y + 1.402 * (cr - 32768));

  g = (s32) (y - 0.344136 * (cb - 32768) - 0.714136*(cr-32768) );

  b = (s32) (y + 1.772 * (cb - 32768) );

#define TRUNC_16BIT(_a) if (_a<0) {_a = 0;} else if (_a>32768) {_a=32768;}

  TRUNC_16BIT(r)

  TRUNC_16BIT(g)

  TRUNC_16BIT(b)

#else

  y *= 1024;

  r = (s32) (y + 1436 * (cr - 32768));

  g = (s32) (y - 352 * (cb - 32768) - 731*(cr-32768) );

  b = (s32) (y + 1814 * (cb - 32768) );

#define TRUNC_16BIT(_a) if (_a<0) {_a = 0;} else { u32 __a = (u32) _a; __a>>=10; if (__a>32768) {__a=32768;} _a = __a; }

  TRUNC_16BIT(r)

  TRUNC_16BIT(g)

  TRUNC_16BIT(b)

#endif

  return GF_COLW_ARGB(a, r, g, b);

}

#if 0 //unused

void evg_make_ayuv_color_mx(GF_ColorMatrix *cmat, GF_ColorMatrix *yuv_cmat)

{

  GF_ColorMatrix cmx_y2r, cmx_r2y;

  gf_cmx_init(&cmx_r2y);

  gf_cmx_init(&cmx_y2r);

  cmx_r2y.identity = cmx_y2r.identity = GF_FALSE;

  //r = (s32) (y + 1.402 * (cr - 128));

  cmx_y2r.m[0] = FIX_ONE; //y

  cmx_y2r.m[2] = FLT2FIX(1.402); //cr

  cmx_y2r.m[4] = FLT2FIX(-1.402 * 0.504); //tr

  //g = (s32) (y - 0.344136 * (cb - 128) - 0.714136*(cr-128) );

  cmx_y2r.m[5] = FIX_ONE; //y

  cmx_y2r.m[6] = FLT2FIX(- 0.344136); //cb

  cmx_y2r.m[7] = FLT2FIX(- 0.714136); //cr

  cmx_y2r.m[9] = FLT2FIX(0.344136 * 0.504 + 0.714136*0.504); //tr

  //b = (s32) (y + 1.772 * (cb - 128) );

  cmx_y2r.m[10] = FIX_ONE; //y

  cmx_y2r.m[11] = FLT2FIX(1.772); //cb

  cmx_y2r.m[14] = FLT2FIX(-1.772 * 0.504); //tr

  //y = (u8) (0.299*r + 0.587 * g + 0.114 * b);

  cmx_r2y.m[0] = FLT2FIX(0.299); //r

  cmx_r2y.m[1] = FLT2FIX(0.587); //g

  cmx_r2y.m[2] = FLT2FIX(0.114); //b

  //cb = (u8) (-0.169*(s32)r - 0.331*(s32)g + 0.499*b + 128);

  cmx_r2y.m[5] = FLT2FIX(-0.169); //r

  cmx_r2y.m[6] = FLT2FIX(-0.331); //g

  cmx_r2y.m[7] = FLT2FIX(0.499); //b

  cmx_r2y.m[9] = FLT2FIX(0.504); //tr

  //cr = (u8) (0.499 * r - 0.418*(s32)g - 0.0813*(s32)b + 128);

  cmx_r2y.m[10] = FLT2FIX(0.499); //r

  cmx_r2y.m[11] = FLT2FIX(-0.418); //g

  cmx_r2y.m[12] = FLT2FIX(-0.0813); //b

  cmx_r2y.m[14] = FLT2FIX(0.504); //tr

  gf_cmx_copy(yuv_cmat, &cmx_r2y);

  gf_cmx_multiply(yuv_cmat, cmat);

  gf_cmx_multiply(yuv_cmat, &cmx_y2r);

}

#endif

/*

      YUV420p part

*/

static void overmask_yuv420p(u8 col_a, u8 cy, u8 *dst, u32 alpha)

{

  s32 srca = col_a;

  u32 srcc = cy;

  s32 dstc = (*dst) & 0xFF;

  srca = mul255(srca, alpha);

  *dst = mul255(srca, srcc - dstc) + dstc;

}

static void overmask_yuv420p_const_run(u8 a, u8 val, u8 *ptr, u32 count, short x)

{

  while (count) {

    u8 dst = *(ptr);

    *ptr = (u8) mul255(a, val - dst) + dst;

    ptr ++;

    count--;

  }

}

void evg_yuv420p_flush_uv_const(GF_EVGSurface *surf, EVGRasterCtx *rctx, u8 *surf_uv_alpha, s32 cu, s32 cv, s32 y)

{

  u32 i, a;

  u8 *pU = rctx->surf->pixels + rctx->surf->height * rctx->surf->pitch_y;

  u8 *pV;

  pU +=  y/2 * rctx->surf->pitch_y/2;

  pV = pU + rctx->surf->height/2 * rctx->surf->pitch_y/2;

  //no need to swap u and V in const flush, they have been swaped when setting up the brush

  //we are at an odd line, write uv

  for (i=0; i<rctx->surf->width; i+=2) {

    u8 dst;

    //even line

    a = rctx->uv_alpha[i] + rctx->uv_alpha[i+1];

    //odd line

    a += surf_uv_alpha[i] + surf_uv_alpha[i+1];

    if (a) {

      u8 *s_ptr_u, *s_ptr_v;

      a /= 4;

      s_ptr_u = pU + i / 2;

      s_ptr_v = pV + i / 2;

      if (a==0xFF) {

        *s_ptr_u = (u8) cu;

        *s_ptr_v = (u8) cv;

      } else {

        dst = *(s_ptr_u);

        *s_ptr_u = (u8) mul255(a, cu - dst) + dst;

        dst = *(s_ptr_v);

        *s_ptr_v = (u8) mul255(a, cv - dst) + dst;

      }

    }

  }

  memset(rctx->uv_alpha, 0, rctx->surf->uv_alpha_alloc);

}

void evg_yuv420p_fill_const(s32 y, s32 count, EVG_Span *spans, GF_EVGSurface *surf, EVGRasterCtx *rctx)

{

  u8 *pY = surf->pixels;

  u8 *surf_uv_alpha;

  s32 i;

  u8 cy, cu, cv;

  Bool write_uv = (y%2) ? GF_TRUE : GF_FALSE;

  if (surf->is_422) {

    write_uv = GF_TRUE;

    surf_uv_alpha = rctx->uv_alpha;

  }

  else if (write_uv) {

    surf_uv_alpha = rctx->uv_alpha + surf->width;

  } else {

    surf_uv_alpha = rctx->uv_alpha;

  }

  pY +=  y * surf->pitch_y;

  cy = GF_COL_R(surf->fill_col);

  cu = GF_COL_G(surf->fill_col);

  cv = GF_COL_B(surf->fill_col);

  for (i=0; i<count; i++) {

    u32 a;

    u8 *s_pY;

    u32 len;

    len = spans[i].len;

    s_pY = pY + spans[i].x;

    a = spans[i].coverage;

    if (a != 0xFF) {

      overmask_yuv420p_const_run((u8)a, cy, s_pY, len, 0);

      memset(surf_uv_alpha + spans[i].x, (u8)a, len);

    } else  {

      while (len--) {

        *(s_pY) = cy;

        s_pY ++;

      }

      memset(surf_uv_alpha + spans[i].x, 0xFF, spans[i].len);

    }

  }

  if (write_uv && !rctx->no_yuv_flush) {

    surf->yuv_flush_uv(surf, rctx, surf_uv_alpha, cu, cv, y);

  }

}

void evg_yuv420p_fill_const_a(s32 y, s32 count, EVG_Span *spans, GF_EVGSurface *surf, EVGRasterCtx *rctx)

{

  u32 a;

  u8 *pY = surf->pixels;

  u8 *surf_uv_alpha;

  s32 i;

  u8 cy, cu, cv;

  Bool write_uv = (y%2) ? GF_TRUE : GF_FALSE;

  if (surf->is_422) {

    write_uv = GF_TRUE;

    surf_uv_alpha = rctx->uv_alpha;

  } else if (write_uv) {

    surf_uv_alpha = rctx->uv_alpha + surf->width;

  } else {

    surf_uv_alpha = rctx->uv_alpha;

  }

  pY +=  y * surf->pitch_y;

  cy = GF_COL_R(surf->fill_col);

  cu = GF_COL_G(surf->fill_col);

  cv = GF_COL_B(surf->fill_col);

  a = GF_COL_A(surf->fill_col);

  if (surf->get_alpha) {

    for (i=0; i<count; i++) {

      u32 fin, j;

      for (j=0; j<spans[i].len; j++) {

        s32 x = spans[i].x + j;

        u8 *s_pY = pY + x;

        u8 aa = surf->get_alpha(surf->get_alpha_udta, a, x, y);

        fin = mul255(aa, spans[i].coverage);

        overmask_yuv420p_const_run((u8)fin, cy, s_pY, 1, 0);

        memset(surf_uv_alpha + x, (u8)fin, 1);

      }

    }

  } else {

    for (i=0; i<count; i++) {

      u8 *s_pY;

      u32 fin, len;

      len = spans[i].len;

      s_pY = pY + spans[i].x;

      fin = mul255(a, spans[i].coverage);

      overmask_yuv420p_const_run((u8)fin, cy, s_pY, len, 0);

      memset(surf_uv_alpha + spans[i].x, (u8)fin, len);

    }

  }

  //we are at an odd line, write uv

  if (write_uv && !rctx->no_yuv_flush)

    surf->yuv_flush_uv(surf, rctx, surf_uv_alpha, cu, cv, y);

}

void evg_yuv420p_flush_uv_var(GF_EVGSurface *surf, EVGRasterCtx *rctx, u8 *surf_uv_alpha, s32 _cu, s32 _cv,  s32 y)

{

  u32 i;

  u8 *pU, *pV;

  pU = surf->pixels + surf->height *surf->pitch_y;

  pU += y/2 * surf->pitch_y/2;

  pV = pU + surf->height/2 * surf->pitch_y/2;

  if (surf->swap_uv) {

    u8 *tmp = pU;

    pU = pV;

    pV = tmp;

  }

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

    u32 a, a11, a12, a21, a22;

    u32 idx1 = 3*i;

    u32 idx2 = idx1 + 3;

    gf_assert(idx1 < surf->uv_alpha_alloc );

    gf_assert(idx2 < surf->uv_alpha_alloc );

    //get alpha

    a11 = (u32)rctx->uv_alpha[idx1];

    a12 = (u32)rctx->uv_alpha[idx2];

    a21 = (u32)surf_uv_alpha[idx1];

    a22 = (u32)surf_uv_alpha[idx2];

    a = a11 + a12 + a21 + a22;

    if (a) {

      u8 cdst=0;

      u32 chroma_u, chroma_v, c11, c12, c21, c22;

      a /= 4;

      //get cb

      idx1 += 1;

      idx2 += 1;

      if (a!=0xFF) {

        cdst = *pU;

      }

      c11 = (u32)rctx->uv_alpha[idx1];

      if (a11!=0xFF) c11 = mul255_zero(a11, c11 - cdst) + cdst;

      c12 = (u32)rctx->uv_alpha[idx2];

      if (a12!=0xFF) c12 = mul255_zero(a12, c12 - cdst) + cdst;

      c21 = (u32)surf_uv_alpha[idx1];

      if (a21!=0xFF) c21 = mul255_zero(a21, c21 - cdst) + cdst;

      c22 = (u32)surf_uv_alpha[idx2];

      if (a22!=0xFF) c22 = mul255_zero(a22, c22 - cdst) + cdst;

      chroma_u = c11 + c12 + c21 + c22;

      chroma_u /= 4;

      //get cr

      idx1 += 1;

      idx2 += 1;

      if (a!=0xFF) {

        cdst = *pV;

      }

      c11 = (u32)rctx->uv_alpha[idx1];

      if (a11!=0xFF) c11 = mul255_zero(a11, c11 - cdst) + cdst;

      c12 = (u32)rctx->uv_alpha[idx2];

      if (a12!=0xFF) c12 = mul255_zero(a12, c12 - cdst) + cdst;

      c21 = (u32)surf_uv_alpha[idx1];

      if (a21!=0xFF) c21 = mul255_zero(a21, c21 - cdst) + cdst;

      c22 = (u32)surf_uv_alpha[idx2];

      if (a22!=0xFF) c22 = mul255_zero(a22, c22 - cdst) + cdst;

      chroma_v = c11 + c12 + c21 + c22;

      chroma_v /= 4;

      *pU = chroma_u;

      *pV = chroma_v;

    }

    pU++;

    pV++;

  }

  //reset for next pass

  memset(rctx->uv_alpha, 0, surf->uv_alpha_alloc);

}

void evg_yuv420p_fill_var(s32 y, s32 count, EVG_Span *spans, GF_EVGSurface *surf, EVGRasterCtx *rctx)

{

  s32 i;

  u8 *pY = surf->pixels;

  u8 *surf_uv_alpha;

  Bool write_uv = (y%2) ? GF_TRUE : GF_FALSE;

  if (surf->is_422) {

    write_uv = GF_TRUE;

    surf_uv_alpha = rctx->uv_alpha;

  } else if (write_uv) {

    //second line of storage (we store alpha, cr, cb for each pixel)

    surf_uv_alpha = rctx->uv_alpha + 3*surf->width;

  } else {

    //first line of storage

    surf_uv_alpha = rctx->uv_alpha;

  }

  pY +=  y * surf->pitch_y;

  for (i=0; i<count; i++) {

    u8 spanalpha, col_a;

    u8 *s_pY;

    short x;

    u32 *p_col;

    u32 len;

    len = spans[i].len;

    p_col = surf->fill_run(surf->sten, rctx, &spans[i], y);

    spanalpha = spans[i].coverage;

    s_pY = pY + spans[i].x;

    x = spans[i].x;

    while (len--) {

      u32 col = *p_col;

      col_a = GF_COL_A(col);

      if (col_a) {

        u8 cy, cb, cr;

        u32 idx=3*x;

        //col is directly packed as AYCbCr

        cy = GF_COL_R(col);

        cb = GF_COL_G(col);

        cr = GF_COL_B(col);

        if ((spanalpha!=0xFF) || (col_a != 0xFF)) {

          overmask_yuv420p(col_a, cy, s_pY, spanalpha);

          u8 a = mul255(col_a, spanalpha);

          surf_uv_alpha[idx] = a;

        } else {

          *s_pY = cy;

          surf_uv_alpha[idx] = 0xFF;

        }

        surf_uv_alpha[idx+1] = cb;

        surf_uv_alpha[idx+2] = cr;

      }

      s_pY++;

      p_col++;

      x++;

    }

  }

  //compute final u,v for both lines

  if (write_uv && !rctx->no_yuv_flush) {

    surf->yuv_flush_uv(surf, rctx, surf_uv_alpha, 0, 0, y);

  }

}

GF_Err evg_surface_clear_yuv420p(GF_EVGSurface *_surf, GF_IRect rc, GF_Color col)

{

  s32 i;

  u8 cy, cb, cr;

  GF_EVGSurface *surf = (GF_EVGSurface *)_surf;

  u8 *pY, *pU, *pV;

  pY = surf->pixels + rc.y * surf->pitch_y + rc.x;

  pU = surf->pixels + surf->height * surf->pitch_y + rc.y/2 * surf->pitch_y/2 + rc.x/2;

  pV = surf->pixels + 5*surf->height * surf->pitch_y/4 + rc.y/2 * surf->pitch_y/2 + rc.x/2;

  if (surf->swap_uv) {

    u8 *tmp = pU;

    pU = pV;

    pV = tmp;

  }

  gf_evg_rgb_to_yuv(surf, col, &cy, &cb, &cr);

  if (!rc.x && !rc.y && ((u32) rc.width==_surf->width) && ((u32) rc.height==_surf->height)) {

    memset(pY, cy, _surf->pitch_y * _surf->height);

    memset(pU, cb, _surf->pitch_y/2 * _surf->height/2);

    memset(pV, cr, _surf->pitch_y/2 * _surf->height/2);

    return GF_OK;

  }

  for (i = 0; i < rc.height; i++) {

    memset(pY, cy, rc.width);

    pY += surf->pitch_y;

    if (i%2) {

      memset(pU, cb, rc.width/2);

      pU += surf->pitch_y/2;

      memset(pV, cr, rc.width/2);

      pV += surf->pitch_y/2;

    }

  }

  return GF_OK;

}

/*

      NV12 / NV21 part

*/

void evg_nv12_flush_uv_const(GF_EVGSurface *surf, EVGRasterCtx *rctx, u8 *surf_uv_alpha, s32 cu, s32 cv, s32 y)

{

  u32 i, a;

  u8 *pU = surf->pixels + surf->height *surf->pitch_y;

  pU +=  y/2 * surf->pitch_y;

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

    u8 dst;

    //even line

    a = rctx->uv_alpha[i] + rctx->uv_alpha[i+1];

    //odd line

    a += surf_uv_alpha[i] + surf_uv_alpha[i+1];

    if (a) {

      u8 *s_ptr;

      a /= 4;

      s_ptr = pU + i;

      if (a==0xFF) {

        *s_ptr = cu;

        s_ptr++;

        *s_ptr = cv;

      } else {

        dst = *(s_ptr);

        *s_ptr = (u8) mul255(a, cu - dst) + dst;

        s_ptr++;

        dst = *(s_ptr);

        *s_ptr = (u8) mul255(a, cv - dst) + dst;

      }

    }

  }

  memset(rctx->uv_alpha, 0, surf->uv_alpha_alloc);

}

void evg_nv12_flush_uv_var(GF_EVGSurface *surf, EVGRasterCtx *rctx, u8 *surf_uv_alpha, s32 cu, s32 cv, s32 y)

{

  u32 i;

  u8 *pU;

  pU = surf->pixels + surf->height *surf->pitch_y;

  pU += y/2 * surf->pitch_y;

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

    u32 a, a11, a12, a21, a22;

    u32 idx1=3*i;

    u32 idx2=3*i + 3;

    //get alpha

    a11 = (u32)rctx->uv_alpha[idx1];

    a12 = (u32)rctx->uv_alpha[idx2];

    a21 = (u32)surf_uv_alpha[idx1];

    a22 = (u32)surf_uv_alpha[idx2];

    a = a11+a12+a21+a22;

    if (a) {

      u8 cdst=0;

      u32 chroma_u, chroma_v, c11, c12, c21, c22;

      a /= 4;

      //get cb

      idx1 += 1;

      idx2 += 1;

      if (a!=0xFF)

        cdst = pU[surf->idx_u];

      c11 = (u32)rctx->uv_alpha[idx1];

      if (a11!=0xFF) c11 = mul255_zero(a11, c11 - cdst) + cdst;

      c12 = (u32)rctx->uv_alpha[idx2];

      if (a12!=0xFF) c12 = mul255_zero(a12, c12 - cdst) + cdst;

      c21 = (u32)surf_uv_alpha[idx1];

      if (a21!=0xFF) c21 = mul255_zero(a21, c21 - cdst) + cdst;

      c22 = (u32)surf_uv_alpha[idx2];

      if (a22!=0xFF) c22 = mul255_zero(a22, c22 - cdst) + cdst;

      chroma_u = c11 + c12 + c21 + c22;

      chroma_u /= 4;

      //get cr

      idx1 += 1;

      idx2 += 1;

      if (a!=0xFF)

        cdst = pU[surf->idx_v];

      c11 = (u32)rctx->uv_alpha[idx1];

      if (a11!=0xFF) c11 = mul255_zero(a11, c11 - cdst) + cdst;

      c12 = (u32)rctx->uv_alpha[idx2];

      if (a12!=0xFF) c12 = mul255_zero(a12, c12 - cdst) + cdst;

      c21 = (u32)surf_uv_alpha[idx1];

      if (a21!=0xFF) c21 = mul255_zero(a21, c21 - cdst) + cdst;

      c22 = (u32)surf_uv_alpha[idx2];

      if (a22!=0xFF) c22 = mul255_zero(a22, c22 - cdst) + cdst;

      chroma_v = c11 + c12 + c21 + c22;

      chroma_v /= 4;

      pU[surf->idx_u] = chroma_u;

      pU[surf->idx_v] = chroma_v;

    }

    pU+=2;

  }

  //reset for next pass

  memset(rctx->uv_alpha, 0, surf->uv_alpha_alloc);

}

GF_Err evg_surface_clear_nv12(GF_EVGSurface *_surf, GF_IRect rc, GF_Color col, Bool swap_uv)

{

  s32 i;

  u8 cy, cb, cr;

  GF_EVGSurface *surf = (GF_EVGSurface *)_surf;

  u8 *pY = surf->pixels;

  u8 *pU = surf->pixels + surf->height *surf->pitch_y;

  u8 *pU_first;

  pY += rc.y * surf->pitch_y;

  pU +=  rc.y/2 * surf->pitch_y;

  pY += rc.x;

  pU += rc.x/2;

  pU_first = pU;

  gf_evg_rgb_to_yuv(surf, col, &cy, &cb, &cr);

  if (swap_uv) {

    u8 t = cb;

    cb = cr;

    cr = t;

  }

  for (i = 0; i < rc.height; i++) {

    memset(pY, cy, rc.width);

    pY += surf->pitch_y;

    if (i%2) {

      //first uv line, build it

      if (i==1) {

        s32 j;

        for (j=0; j<rc.width/2; j++) {

          *pU = cb;

          pU++;

          *pU = cr;

          pU++;

        }

      }

      //non-first uv line recopy from first

      else {

        memcpy(pU, pU_first, rc.width);

        pU += surf->pitch_y;

      }

    }

  }

  return GF_OK;

}

/*

      YUV422 part

*/

void evg_yuv422p_flush_uv_const(GF_EVGSurface *surf, EVGRasterCtx *rctx, u8 *surf_uv_alpha, s32 cu, s32 cv, s32 y)

{

  u32 i, a;

  u8 *pU = surf->pixels + surf->height *surf->pitch_y;

  u8 *pV;

  pU +=  y * surf->pitch_y/2;

  pV = pU + surf->height * surf->pitch_y/2;

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

    u8 dst;

    a = rctx->uv_alpha[i] + rctx->uv_alpha[i+1];

    if (a) {

      u8 *s_ptr_u, *s_ptr_v;

      a /= 2;

      s_ptr_u = pU + i / 2;

      s_ptr_v = pV + i / 2;

      if (a==0xFF) {

        *s_ptr_u = (u8) cu;

        *s_ptr_v = (u8) cv;

      } else {

        dst = *(s_ptr_u);

        *s_ptr_u = (u8) mul255(a, cu - dst) + dst;

        dst = *(s_ptr_v);

        *s_ptr_v = (u8) mul255(a, cv - dst) + dst;

      }

    }

  }

  memset(rctx->uv_alpha, 0, surf->uv_alpha_alloc);

}

void evg_yuv422p_flush_uv_var(GF_EVGSurface *surf, EVGRasterCtx *rctx, u8 *surf_uv_alpha, s32 _cu, s32 _cv,  s32 y)

{

  u32 i;

  u8 *pU, *pV;

  pU = surf->pixels + surf->height *surf->pitch_y;

  pU += y * surf->pitch_y/2;

  pV = pU + surf->height * surf->pitch_y/2;

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

    u32 a, a1, a2;

    u32 idx1=3*i;

    u32 idx2=3*i + 3;

    //get alpha

    a1 = (u32)rctx->uv_alpha[idx1];

    a2 = (u32)rctx->uv_alpha[idx2];

    a = a1+a2;

    if (a) {

      u8 cdst=0;

      u32 chroma_u, chroma_v, c1, c2;

      a /= 2;

      //get cb

      if (a != 0xFF)

        cdst = *pU;

      c1 = (u32)rctx->uv_alpha[idx1+1];

      if (a1!=0xFF) c1 = mul255_zero(a1, c1 - cdst) + cdst;

      c2 = (u32)rctx->uv_alpha[idx2+1];

      if (a2!=0xFF) c2 = mul255_zero(a2, c1 - cdst) + cdst;

      chroma_u = c1 + c2;

      chroma_u /= 2;

      //get cb

      if (a != 0xFF)

        cdst = *pV;

      c1 = (u32)rctx->uv_alpha[idx1+2];

      if (a1!=0xFF) c1 = mul255_zero(a1, c1 - cdst) + cdst;

      c2 = (u32)rctx->uv_alpha[idx2+2];

      if (a2!=0xFF) c2 = mul255_zero(a2, c1 - cdst) + cdst;

      chroma_v = c1 + c2;

      chroma_v /= 2;

      *pU = chroma_u;

      *pV = chroma_v;

    }

    pU++;

    pV++;

  }

  //reset for next pass

  memset(rctx->uv_alpha, 0, surf->uv_alpha_alloc);

}

GF_Err evg_surface_clear_yuv422p(GF_EVGSurface *_surf, GF_IRect rc, GF_Color col)

{

  s32 i;

  u8 cy, cb, cr;

  GF_EVGSurface *surf = (GF_EVGSurface *)_surf;

  u8 *pY = surf->pixels;

  u8 *pU = surf->pixels + surf->height *surf->pitch_y;

  u8 *pV;

  pY += rc.y * surf->pitch_y;

  pU +=  rc.y/2 * surf->pitch_y/2;

  pV = pU + surf->height/2 * surf->pitch_y/2;

  pY += rc.x;

  pU += rc.x/2;

  pV += rc.x/2;

  gf_evg_rgb_to_yuv(surf, col, &cy, &cb, &cr);

  if (!rc.x && !rc.y && ((u32) rc.width==_surf->width) && ((u32) rc.height==_surf->height)) {