/*

 * lws abstract display

 *

 * Copyright (C) 2019 - 2022 Andy Green <andy@warmcat.com>

 *

 * Permission is hereby granted, free of charge, to any person obtaining a copy

 * of this software and associated documentation files (the "Software"), to

 * deal in the Software without restriction, including without limitation the

 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

 * sell copies of the Software, and to permit persons to whom the Software is

 * furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS

 * IN THE SOFTWARE.

 *

 * Display List Object: JPEG

 */

#include <private-lib-core.h>

#include "private-lib-drivers-display-dlo.h"

void

lws_display_dlo_jpeg_destroy(struct lws_dlo *dlo)

{

  lws_dlo_jpeg_t *dlo_jpeg = lws_container_of(dlo, lws_dlo_jpeg_t, dlo);

#if defined(LWS_WITH_CLIENT) && defined(LWS_WITH_SECURE_STREAMS)

  lws_ss_destroy(&dlo_jpeg->flow.h);

#endif

  lws_buflist_destroy_all_segments(&dlo_jpeg->flow.bl);

  if (dlo_jpeg->j)

    lws_jpeg_free(&dlo_jpeg->j);

}

lws_stateful_ret_t

lws_display_render_jpeg(struct lws_display_render_state *rs)

{

  lws_dlo_t *dlo = rs->st[rs->sp].dlo;

  lws_dlo_jpeg_t *dlo_jpeg = lws_container_of(dlo, lws_dlo_jpeg_t, dlo);

  lws_display_colour_t pc;

  lws_fx_t ax, ay, t, t1;

  lws_stateful_ret_t r;

  const uint8_t *pix;

  int s, e;

  lws_fx_add(&ax, &rs->st[rs->sp].co.x, &dlo->box.x);

  lws_fx_add(&t, &ax, &dlo->box.w);

  lws_fx_add(&ay, &rs->st[rs->sp].co.y, &dlo->box.y);

  lws_fx_add(&t1, &ay, &dlo->box.h);

  if (!lws_jpeg_get_height(dlo_jpeg->j)) {

    if (dlo_jpeg->flow.state == LWSDLOFLOW_STATE_READ_COMPLETED)

      return LWS_SRET_OK;

    lwsl_notice("%s: jpeg does not have dimensions yet\n", __func__);

    if (rs->html == 2)

      return LWS_SRET_OK;

    return LWS_SRET_WANT_INPUT;

  }

  s = ax.whole;

  e = lws_fx_roundup(&t);

  if (rs->curr > lws_fx_roundup(&t1))

    return LWS_SRET_OK;

  if (rs->curr - lws_fx_roundup(&ay) >

      (int)lws_jpeg_get_height(dlo_jpeg->j))

    return LWS_SRET_OK;

  if (s < 0)

    s = 0;

  if (s > rs->ic->wh_px[0].whole)

    return LWS_SRET_OK; /* off to the right */

  if (e > rs->ic->wh_px[0].whole)

    e = rs->ic->wh_px[0].whole - 1;

  if (e <= 0)

    return LWS_SRET_OK; /* off to the left */

  do {

    if (lws_flow_feed(&dlo_jpeg->flow))

      /* if he says WANT_INPUT, we have nothing in the buflist */

      return LWS_SRET_WANT_INPUT;

    pix = NULL;

    r = lws_jpeg_emit_next_line(dlo_jpeg->j, &pix, &dlo_jpeg->flow.data,

              &dlo_jpeg->flow.len, rs->html == 1);

    if (r & LWS_SRET_NO_FURTHER_IN)

      dlo_jpeg->flow.state = LWSDLOFLOW_STATE_READ_COMPLETED;

    if (r & LWS_SRET_FATAL || r == LWS_SRET_OK)

      return r;

    r = lws_flow_req(&dlo_jpeg->flow);

    if (r & LWS_SRET_WANT_INPUT)

      return r;

  } while (!pix);

  /*

   * What's in pix is either 24-bit RGB 3 bytes/px, or 8-bit grayscale

   * 1 byte/px, we have to map it on to either 32-bit RGBA or 16-bit YA

   * composition buf

   */

  pix = pix + (( (unsigned int)(s - ax.whole) *

      (lws_jpeg_get_pixelsize(dlo_jpeg->j) / 8)));

  while (s < e && s >= ax.whole && s < lws_fx_roundup(&t) &&

         (s - ax.whole) < (int)lws_jpeg_get_width(dlo_jpeg->j)) {

    if (lws_jpeg_get_pixelsize(dlo_jpeg->j) == 8)

      pc = LWSDC_RGBA(pix[0], pix[0], pix[0], 255);

    else

      pc = LWSDC_RGBA(pix[0], pix[1], pix[2], 255);

    lws_surface_set_px(rs->ic, rs->line, s, &pc);

    s++;

    pix += lws_jpeg_get_pixelsize(dlo_jpeg->j) / 8;

  }

  return LWS_SRET_OK;

}

lws_stateful_ret_t

lws_display_dlo_jpeg_metadata_scan(lws_dlo_jpeg_t *dlo_jpeg)

{

  lws_stateful_ret_t r;

  size_t l, l1;

  const uint8_t *pix;

  /*

   * If we don't have the image metadata yet, provide small chunks of the

   * source data until we do have the image metadata, but small enough

   * we can't produce any decoded pixels too early.

   */

  while (!lws_jpeg_get_height(dlo_jpeg->j) && dlo_jpeg->flow.len) {

    l1 = l = dlo_jpeg->flow.len > 128 ? 128 : dlo_jpeg->flow.len;

    r = lws_jpeg_emit_next_line(dlo_jpeg->j, &pix, &dlo_jpeg->flow.data, &l, 1);

    if (r >= LWS_SRET_FATAL) {

      lwsl_err("%s: hdr parse failed %d\n", __func__, r);

      return r;

    }

    dlo_jpeg->flow.len -= l1 - l;

    if (lws_jpeg_get_height(dlo_jpeg->j)) {

      lwsl_info("jpeg: w %d, h %d\n",

          lws_jpeg_get_width(dlo_jpeg->j),

          lws_jpeg_get_height(dlo_jpeg->j));

      return LWS_SRET_OK;

    }

  }

  return LWS_SRET_WANT_INPUT;

}

lws_dlo_jpeg_t *

lws_display_dlo_jpeg_new(lws_displaylist_t *dl, lws_dlo_t *dlo_parent,

       lws_box_t *box, const char *name, size_t len)

{

  lws_dlo_jpeg_t *dlo_jpeg = lws_zalloc(sizeof(*dlo_jpeg), __func__);

  if (!dlo_jpeg)

    return NULL;

  dlo_jpeg->j = lws_jpeg_new();

  if (!dlo_jpeg->j)

    goto bail;

  lws_strnncpy(dlo_jpeg->name, name, len, sizeof(dlo_jpeg->name)); 

  dlo_jpeg->dlo.box = *box;

  dlo_jpeg->dlo.render = lws_display_render_jpeg;

  dlo_jpeg->dlo._destroy = lws_display_dlo_jpeg_destroy;

  lws_display_dlo_add(dl, dlo_parent, &dlo_jpeg->dlo);

  return dlo_jpeg;

bail:

  lwsl_err("%s: bailed\n", __func__);

  if (dlo_jpeg->j)

    lws_jpeg_free(&dlo_jpeg->j);

  lws_free(dlo_jpeg);

  return NULL;

}