Line data    Source code

       1              : /*
       2              :  * liblierre - lierre.c
       3              :  *
       4              :  * This file is part of liblierre.
       5              :  *
       6              :  * Author: Go Kudo <zeriyoshi@gmail.com>
       7              :  * SPDX-License-Identifier: MIT
       8              :  */
       9              : 
      10              : #include <stdlib.h>
      11              : #include <string.h>
      12              : 
      13              : #include <lierre.h>
      14              : 
      15              : #include "internal/memory.h"
      16              : 
      17              : #define LIERRE_VERSION_ID 10000000
      18              : 
      19              : #ifndef LIERRE_BUILDTIME
      20              : #define LIERRE_BUILDTIME 0
      21              : #endif
      22              : 
      23              : static const char *const ERROR_MESSAGE_TABLE[] = {
      24              :     "Success",        "Invalid parameters", "Invalid grid size", "Invalid version", "Format ECC error",
      25              :     "Data ECC error", "Unknown data type",  "Data overflow",     "Data underflow",  "Size exceeded"};
      26              : 
      27           13 : extern const char *lierre_strerror(lierre_error_t err)
      28              : {
      29           13 :     if (err < 0 || err >= ERROR_MAX) {
      30            3 :         return "Unknown error";
      31              :     }
      32              : 
      33           10 :     return ERROR_MESSAGE_TABLE[err];
      34              : }
      35              : 
      36            3 : extern uint32_t lierre_version_id()
      37              : {
      38            3 :     return (uint32_t)LIERRE_VERSION_ID;
      39              : }
      40              : 
      41            3 : extern lierre_buildtime_t lierre_buildtime()
      42              : {
      43            3 :     return (lierre_buildtime_t)LIERRE_BUILDTIME;
      44              : }
      45              : 
      46          117 : extern lierre_rgb_data_t *lierre_rgb_create(const uint8_t *data, size_t data_size, size_t width, size_t height)
      47              : {
      48              :     lierre_rgb_data_t *rgb;
      49              : 
      50          117 :     if (!data || data_size == 0 || width == 0 || height == 0) {
      51            4 :         return NULL;
      52              :     }
      53              : 
      54          113 :     if (width > SIZE_MAX / height || width * height > SIZE_MAX / 3 || data_size < width * height * 3) {
      55            1 :         return NULL;
      56              :     }
      57              : 
      58          112 :     rgb = (lierre_rgb_data_t *)lmalloc(sizeof(lierre_rgb_data_t));
      59          112 :     if (!rgb) {
      60            0 :         return NULL;
      61              :     }
      62              : 
      63          112 :     rgb->data = (uint8_t *)lmalloc(data_size);
      64          112 :     if (!rgb->data) {
      65            0 :         lfree(rgb);
      66            0 :         return NULL;
      67              :     }
      68              : 
      69          112 :     lmemcpy(rgb->data, data, data_size);
      70          112 :     rgb->data_size = data_size;
      71          112 :     rgb->width = width;
      72          112 :     rgb->height = height;
      73              : 
      74          112 :     return rgb;
      75              : }
      76              : 
      77          113 : extern void lierre_rgb_destroy(lierre_rgb_data_t *rgb)
      78              : {
      79          113 :     if (!rgb) {
      80            1 :         return;
      81              :     }
      82              : 
      83          112 :     if (rgb->data) {
      84          112 :         lfree(rgb->data);
      85              :     }
      86              : 
      87          112 :     lfree(rgb);
      88              : }