Line data    Source code

       1              : /*
       2              :  * libpoporon - rs.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_internal.h"
      14              : 
      15           13 : void poporon_rs_destroy(poporon_rs_t *rs)
      16              : {
      17           13 :     if (!rs) {
      18            1 :         return;
      19              :     }
      20              : 
      21           12 :     if (rs->gf) {
      22           12 :         poporon_gf_destroy(rs->gf);
      23              :     }
      24              : 
      25           12 :     if (rs->generator_polynomial) {
      26           12 :         pfree(rs->generator_polynomial);
      27              :     }
      28              : 
      29           12 :     pfree(rs);
      30              : }
      31              : 
      32           14 : poporon_rs_t *poporon_rs_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_rs_t *rs;
      35              :     poporon_gf_t *gf;
      36              :     uint16_t i, j, generator_root;
      37              : 
      38           14 :     gf = poporon_gf_create(symbol_size, generator_polynomial);
      39           14 :     if (!gf) {
      40            2 :         return NULL;
      41              :     }
      42              : 
      43           12 :     rs = (poporon_rs_t *)pmalloc(sizeof(poporon_rs_t));
      44           12 :     if (!rs) {
      45              :         /* LCOV_EXCL_START */
      46              :         poporon_gf_destroy(gf);
      47              :         return NULL;
      48              :         /* LCOV_EXCL_STOP */
      49              :     }
      50              : 
      51           12 :     rs->gf = gf;
      52           12 :     rs->first_consective_root = first_consective_root;
      53           12 :     rs->primitive_element = primitive_element;
      54           12 :     rs->num_roots = num_roots;
      55           12 :     rs->generator_polynomial = (uint16_t *)pmalloc((num_roots + 1) * sizeof(uint16_t));
      56           12 :     if (!rs->generator_polynomial) {
      57              :         /* LCOV_EXCL_START */
      58              :         poporon_rs_destroy(rs);
      59              :         return NULL;
      60              :         /* LCOV_EXCL_STOP */
      61              :     }
      62              : 
      63           12 :     rs->generator_polynomial[0] = 1;
      64           12 :     for (i = 0, generator_root = first_consective_root * primitive_element; 
      65          256 :          i < num_roots; 
      66          244 :          i++, generator_root += primitive_element
      67              :         ) {
      68          244 :         rs->generator_polynomial[i + 1] = 1;
      69              : 
      70         3266 :         for (j = i; j > 0; j--) {
      71         3022 :             if (rs->generator_polynomial[j] != 0) {
      72         6044 :                 rs->generator_polynomial[j] = rs->generator_polynomial[j - 1] ^
      73         3022 :                     gf->log2exp[gf_mod(gf, gf->exp2log[rs->generator_polynomial[j]] + generator_root)];
      74              :             } else {
      75            0 :                 rs->generator_polynomial[j] = rs->generator_polynomial[j - 1];
      76              :             }
      77              :         }
      78              : 
      79          244 :         rs->generator_polynomial[0] = 
      80          244 :             gf->log2exp[gf_mod(gf, gf->exp2log[rs->generator_polynomial[0]] + generator_root)];
      81              :     }
      82              : 
      83          268 :     for (i = 0; i <= num_roots; i++) {
      84          256 :         rs->generator_polynomial[i] = gf->exp2log[rs->generator_polynomial[i]];
      85              :     }
      86              : 
      87           12 :     return rs;
      88              : }