Line data    Source code

       1              : /*
       2              :  * libpoporon - poporon.c
       3              :  * 
       4              :  * Copyright (c) 2025 Go Kudo
       5              :  *
       6              :  * This library is licensed under the BSD 3-Clause License.
       7              :  * For license details, please refer to the LICENSE file.
       8              :  *
       9              :  * SPDX-FileCopyrightText: Go Kudo <zeriyoshi@gmail.com>
      10              :  * SPDX-License-Identifier: BSD-3-Clause
      11              :  */
      12              : 
      13              : #include <poporon.h>
      14              : 
      15              : #include "poporon_internal.h"
      16              : 
      17            5 : extern void poporon_destroy(poporon_t *pprn)
      18              : {
      19            5 :     if (!pprn) {
      20            1 :         return;
      21              :     }
      22              : 
      23            4 :     if (pprn->buffer) {
      24            4 :         decoder_buffer_destroy(pprn->buffer);
      25              :     }
      26              : 
      27            4 :     poporon_rs_destroy(pprn->rs);
      28              : 
      29            4 :     pfree(pprn);
      30              : }
      31              : 
      32            5 : extern poporon_t *poporon_create(uint8_t symbol_size, uint16_t generator_polynomial, uint16_t first_consective_root, uint16_t primitive_element, uint8_t num_roots)
      33              : {
      34              :     poporon_t *pprn;
      35              :     poporon_rs_t *rs;
      36              :     decoder_buffer_t *buffer;
      37              :     uint16_t primitive_inverse;
      38              : 
      39            5 :     rs = poporon_rs_create(symbol_size, generator_polynomial, first_consective_root, primitive_element, num_roots);
      40            5 :     if (!rs) {
      41            1 :         return NULL;
      42              :     }
      43              :  
      44            4 :     buffer = decoder_buffer_create(num_roots);
      45            4 :     if (!buffer) {
      46              :         /* LCOV_EXCL_START */
      47              :         poporon_rs_destroy(rs);
      48              :         return NULL;
      49              :         /* LCOV_EXCL_STOP */
      50              :     }
      51              : 
      52            4 :     for (primitive_inverse = 1; (primitive_inverse % primitive_element) != 0; primitive_inverse += rs->gf->field_size);
      53            4 :     buffer->primitive_inverse = primitive_inverse / primitive_element;
      54              : 
      55            4 :     pprn = (poporon_t *)pmalloc(sizeof(poporon_t));
      56            4 :     if (!pprn) {
      57              :         /* LCOV_EXCL_START */
      58              :         decoder_buffer_destroy(buffer);
      59              :         poporon_rs_destroy(rs);
      60              :         return NULL;
      61              :         /* LCOV_EXCL_STOP */
      62              :     }
      63              : 
      64            4 :     pprn->rs = rs;
      65            4 :     pprn->buffer = buffer;
      66              : 
      67            4 :     return pprn;
      68              : }
      69              : 
      70            1 : extern uint32_t poporon_version_id()
      71              : {
      72            1 :     return (uint32_t)POPORON_VERSION_ID;
      73              : }
      74              : 
      75            1 : extern poporon_buildtime_t poporon_buildtime()
      76              : {
      77            1 :     return (poporon_buildtime_t)POPORON_BUILDTIME;
      78              : }