#include "egif_fuzz_common.h"

#define GIF_IMAGE_WIDTH 100

// This is rgb byte stream length per horizontal line = GIF_IMAGE_WIDTH * 3

#define GIF_IMAGE_LINE 300

extern "C" void PrintGifError(int ErrorCode);

int stub_output_writer(GifFileType *gifFileType, const uint8_t *buf, int len)

{

  struct gifUserData *gud = (struct gifUserData *)gifFileType->UserData;

  if (gud == NULL || gud->gifData == NULL || len == 0)

    return 0;

  if (gud->allocatedSize < (gud->gifLen + len))

  {

    // Reallocate gifFileType

    int newSize = (gud->gifLen + len) * 2;

    uint8_t *oldGud = gud->gifData;

    gud->gifData = (uint8_t *)realloc(oldGud, newSize);

    // Assert when realloc fails.

    assert(gud->gifData != NULL);

    gud->allocatedSize = newSize;

  }

  memcpy(gud->gifData + gud->gifLen, buf, len);

  gud->gifLen += len;

  return len;

}

// RGB to GIF converter

static bool rgb_to_gif(const uint8_t *data, size_t size)

{

  // Bail if total size is not a multiple of GIF_IMAGE_LINE (see below)

  // Keep a fixed width e.g., GIF_IMAGE_WIDTH

  // size/3 = GIF_IMAGE_WIDTH * height

  // height = size/GIF_IMAGE_LINE

  // Extract height

  int height = size / GIF_IMAGE_LINE;

  // GifByteType is unsigned char (raw byte)

  // mem holds the raw RGB byte stream for the entire image

  GifByteType *mem = (GifByteType *)malloc(sizeof(GifByteType) * height * GIF_IMAGE_WIDTH * 3);

  if (!mem)

    return false;

  // Copy RGB data to mem

  memcpy(mem, data, size);

  GifByteType *red_buf = mem;

  GifByteType *green_buf = mem + (GIF_IMAGE_WIDTH * height);

  GifByteType *blue_buf = mem + (GIF_IMAGE_WIDTH * height * 2);

  // ColorMapObject *GifMakeMapObject(int ColorCount, GifColorType *ColorMap)

  // Allocate storage for a color map object with the given number of RGB triplet slots.

  // If the second argument is non-NULL, initialize the color table portion of

  // the new map from it. Returns NULL if memory is exhausted or if the size is

  // not a power of 2 <= 256.

  // TODO: Fuzz color map size (has to be a power of 2 less than equal to 256)

  // TODO: Fuzz color table initialization

  int color_map_size = 256;

  ColorMapObject *output_color_map = GifMakeMapObject(color_map_size, NULL);

  if (!output_color_map)

  {

    free(mem);

    return false;

  }

  // gif output will be written to output_buf

  size_t out_size = sizeof(GifByteType) * GIF_IMAGE_WIDTH * height;

  GifByteType *output_buf = (GifByteType *)malloc(out_size);

  if (!output_buf)

  {

    GifFreeMapObject(output_color_map);

    free(mem);

    return false;

  }

  if (GifQuantizeBuffer(GIF_IMAGE_WIDTH, height, &color_map_size,

              red_buf, green_buf, blue_buf,

              output_buf, output_color_map->Colors) == GIF_ERROR)

  {

    GifFreeMapObject(output_color_map);

    free(output_buf);

    free(mem);

    return false;

  }

  // Now that raw RGB data has been quantized, we no longer need it.

  free(mem);

  GifFileType *GifFile;

  int Error;

  // We start with 1024, but resize dynamically

  // see stub_output_writer

  uint8_t *gifData = (uint8_t *)malloc(1024);

  struct gifUserData gUData = {0, 1024, gifData};

  /* GifFileType *EGifOpen(void *userPtr, OutputFunc writeFunc, int *ErrorCode)

   * Description:

   *  Open a new GIF file using the given userPtr (in binary mode, if under Windows).

   *  writeFunc is a function pointer that writes to output gif file.

   *  If any error occurs, NULL is returned and the ErrorCode is set.

   */

  GifFile = EGifOpen((void *)&gUData, stub_output_writer, &Error);

  if (GifFile == NULL)

  {

    PrintGifError(GifFile->Error);

    GifFreeMapObject(output_color_map);

    free(output_buf);

    free(gUData.gifData);

    return false;

  }

  /* void EGifSetGifVersion(GifFileType *GifFile, bool gif89)

   * Description:

   *  Set the GIF type, to GIF89 if the argument is true and GIF87 if it is false.

   *  The default type is GIF87. This function may be called after the GifFile

   *  record is allocated but before EGifPutScreenDesc().

   */

  EGifSetGifVersion(GifFile, false);

  /* int EGifPutScreenDesc(GifFileType *GifFile,

     *   const int GifWidth, const GifHeight,

     *   const int GifColorRes, const int GifBackGround,

     *   ColorMapObject *GifColorMap)

     *

   *  Update the GifFile Screen parameters, in GifFile structure and in the real file.

   *  If error occurs, returns GIF_ERROR (see gif_lib.h), otherwise GIF_OK.

   *  This routine should be called immediately after the GIF file was opened.

   */

  if (EGifPutScreenDesc(GifFile, GIF_IMAGE_WIDTH, height, color_map_size, 0, output_color_map) == GIF_ERROR)

  {

    PrintGifError(GifFile->Error);

    GifFreeMapObject(output_color_map);

    free(output_buf);

    EGifCloseFile(GifFile, &Error);

    free(gUData.gifData);

    return false;

  }

  /* int EGifPutImageDesc(GifFileType *GifFile, const int GifLeft, const int GifTop,

   * const int GifWidth, const GifHeight, const bool GifInterlace, ColorMapObject *GifColorMap)

   * Description

   *  Update GifFile Image parameters, in GifFile structure and in the real file.

   *  if error occurs returns GIF_ERROR (see gif_lib.h), otherwise GIF_OK.

   *  This routine should be called each time a new image must be dumped to the file.

   */

  if (EGifPutImageDesc(GifFile, 0, 0, GIF_IMAGE_WIDTH, height, false, NULL) == GIF_ERROR)

  {

    PrintGifError(GifFile->Error);

    GifFreeMapObject(output_color_map);

    free(output_buf);

    EGifCloseFile(GifFile, &Error);

    free(gUData.gifData);

    return false;

  }

  GifByteType *output_bufp = output_buf;

  for (int i = 0; i < height; i++)

  {

    /* int EGifPutLine(GifFileType *GifFile, PixelType *GifLine, int GifLineLen)

     * Description:

     *  Dumps a block of pixels out to the GIF file. The slab can be of any length.

     *  More than that, this routine may be interleaved with EGifPutPixel(),

     *  until all pixels have been sent.

     *  Returns GIF_ERROR if something went wrong, GIF_OK otherwise.

     */

    if (EGifPutLine(GifFile, output_bufp, GIF_IMAGE_WIDTH) == GIF_ERROR)

    {

      PrintGifError(GifFile->Error);

      GifFreeMapObject(output_color_map);

      free(output_buf);

      EGifCloseFile(GifFile, &Error);

      free(gUData.gifData);

      return false;

    }

    output_bufp += GIF_IMAGE_WIDTH;

  }

  /* void GifFreeMapObject(ColorMapObject *Object)

   * Description

   *  Free the storage occupied by a ColorMapObject that is no longer needed.

   */

  GifFreeMapObject(output_color_map);

  free(output_buf);

  EGifCloseFile(GifFile, &Error);

  free(gUData.gifData);

  return true;

}

int fuzz_egif(const uint8_t *Data, size_t Size)

{

  // We treat fuzzed data as a raw RGB stream for a picture

  // with a fixed width of GIF_IMAGE_WIDTH.

  // Since we need 3 color bytes per pixel (RGB), height = size/GIF_IMAGE_LINE

  //      where GIF_IMAGE_LINE = GIF_IMAGE_WIDTH * 3

  // For integral height, we need Size to be a multiple of GIF_IMAGE_LINE

  if ((Size == 0) || ((Size % GIF_IMAGE_LINE) != 0))

    return 0;

  bool status = rgb_to_gif(Data, Size);

  return 0;

}