Implementation for FEC encoder module

src/fec/fec_encoder.cpp

@@ -0,0 +1,149 @@
+#include "fec_encoder.h"
+
+#include "log.h"
+
+FecEncoder::FecEncoder() {}
+
+FecEncoder::~FecEncoder() {}
+
+int FecEncoder::Init() {
+  fec_codec_id_ = OF_CODEC_REED_SOLOMON_GF_2_M_STABLE;
+
+  fec_rs_params_ = (of_rs_2_m_parameters_t *)calloc(1, sizeof(*fec_params_));
+  if (nullptr == fec_rs_params_) {
+    LOG_ERROR("Create FEC codec params failed");
+    return -1;
+  }
+
+  fec_rs_params_->m = 8;
+  fec_params_ = (of_parameters_t *)fec_rs_params_;
+
+  if (OF_STATUS_OK !=
+      of_create_codec_instance(&fec_session_, fec_codec_id_, OF_ENCODER, 2)) {
+    LOG_ERROR("Create FEC codec instance failed");
+    return -1;
+  }
+
+  return 0;
+}
+
+int FecEncoder::Release() {
+  if (!fec_session_) {
+    LOG_ERROR("Invalid FEC codec instance");
+    return -1;
+  }
+
+  {
+    if (OF_STATUS_OK != of_release_codec_instance(fec_session_)) {
+      LOG_ERROR("Release FEC codec instance failed");
+      return -1;
+    }
+  }
+
+  return 0;
+}
+
+uint8_t **FecEncoder::Encode(const char *data, size_t len) {
+  uint8_t **fec_packets = nullptr;
+
+  unsigned int last_packet_size = len % max_size_of_packet_;
+  unsigned int num_of_source_packets =
+      len / max_size_of_packet_ + (last_packet_size ? 1 : 0);
+  unsigned int num_of_total_packets =
+      (unsigned int)floor((double)num_of_source_packets / code_rate_);
+
+  fec_params_->nb_source_symbols = num_of_source_packets;
+  fec_params_->nb_repair_symbols = num_of_total_packets - num_of_source_packets;
+
+  fec_params_->encoding_symbol_length = max_size_of_packet_;
+
+  if (OF_STATUS_OK != of_set_fec_parameters(fec_session_, fec_params_)) {
+    LOG_ERROR("Set FEC params failed for codec_id {}", fec_codec_id_);
+    return nullptr;
+  }
+
+  fec_packets = (uint8_t **)calloc(num_of_total_packets, sizeof(uint8_t *));
+
+  if (nullptr == fec_packets) {
+    LOG_ERROR("Calloc failed for fec_packets with size [{}])",
+              num_of_total_packets);
+    return nullptr;
+  }
+
+  for (unsigned int esi = 0; esi < num_of_source_packets; esi++) {
+    if (esi != num_of_source_packets - 1) {
+      fec_packets[esi] =
+          (uint8_t *)calloc(max_size_of_packet_, sizeof(uint8_t));
+      if (nullptr == fec_packets[esi]) {
+        LOG_ERROR("Calloc failed for fec_packets[{}] with size [{}])", esi,
+                  max_size_of_packet_);
+        ReleaseFecPackets(fec_packets, len);
+        return nullptr;
+      }
+      memcpy(fec_packets[esi], data + esi * max_size_of_packet_,
+             max_size_of_packet_);
+    } else {
+      fec_packets[esi] =
+          (uint8_t *)calloc(max_size_of_packet_, sizeof(uint8_t));
+      if (nullptr == fec_packets[esi]) {
+        LOG_ERROR("Calloc failed for fec_packets[{}] with size [{}])", esi,
+                  last_packet_size);
+        ReleaseFecPackets(fec_packets, len);
+        return nullptr;
+      }
+      memcpy(fec_packets[esi], data + esi * max_size_of_packet_,
+             last_packet_size);
+    }
+  }
+
+  for (unsigned int esi = num_of_source_packets; esi < num_of_total_packets;
+       esi++) {
+    fec_packets[esi] = (uint8_t *)calloc(max_size_of_packet_, sizeof(uint8_t));
+    if (nullptr == fec_packets[esi]) {
+      LOG_ERROR("Calloc failed for fec_packets[{}] with size [{}])", esi,
+                max_size_of_packet_);
+      ReleaseFecPackets(fec_packets, len);
+      return nullptr;
+    }
+    if (OF_STATUS_OK !=
+        of_build_repair_symbol(fec_session_, (void **)fec_packets, esi)) {
+      LOG_ERROR("Build repair symbols failed for esi [{}]", esi);
+      ReleaseFecPackets(fec_packets, len);
+      return nullptr;
+    }
+  }
+
+  return fec_packets;
+}
+
+int FecEncoder::ReleaseFecPackets(uint8_t **fec_packets, size_t len) {
+  if (nullptr == fec_packets) {
+    LOG_ERROR("Release Fec packets failed, due to fec_packets is nullptr");
+    return -1;
+  }
+  unsigned int last_packet_size = len % max_size_of_packet_;
+  unsigned int num_of_source_packets =
+      len / max_size_of_packet_ + (last_packet_size ? 1 : 0);
+  unsigned int num_of_total_packets =
+      (unsigned int)floor((double)num_of_source_packets / code_rate_);
+
+  for (unsigned int esi = 0; esi < num_of_total_packets; esi++) {
+    if (fec_packets[esi]) {
+      free(fec_packets[esi]);
+    }
+  }
+  free(fec_packets);
+
+  return 0;
+}
+
+void FecEncoder::GetFecPacketsParams(unsigned int source_length,
+                                     unsigned int &num_of_total_packets,
+                                     unsigned int &num_of_source_packets,
+                                     unsigned int &last_packet_size) {
+  last_packet_size = source_length % max_size_of_packet_;
+  num_of_source_packets =
+      source_length / max_size_of_packet_ + (last_packet_size ? 1 : 0);
+  num_of_total_packets =
+      (unsigned int)floor((double)num_of_source_packets / code_rate_);
+}

src/fec/fec_encoder.h

@@ -0,0 +1,49 @@
+/*
+ * @Author: DI JUNKUN
+ * @Date: 2023-11-13
+ * Copyright (c) 2023 by DI JUNKUN, All Rights Reserved.
+ */
+
+#ifndef _FEC_ENCODER_H_
+#define _FEC_ENCODER_H_
+
+#include <stdint.h>
+
+#include <vector>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+#include "lib_common/of_openfec_api.h"
+#ifdef __cplusplus
+};
+#endif
+
+class FecEncoder {
+ public:
+  FecEncoder();
+  ~FecEncoder();
+
+ public:
+  int Init();
+  int Release();
+  uint8_t **Encode(const char *data, size_t len);
+  int ReleaseFecPackets(uint8_t **fec_packets, size_t len);
+  void GetFecPacketsParams(unsigned int source_length,
+                           unsigned int &num_of_total_packets,
+                           unsigned int &num_of_source_packets,
+                           unsigned int &last_packet_size);
+
+ private:
+  double code_rate_ = 0.667;
+  int max_size_of_packet_ = 1400;
+
+ private:
+  of_codec_id_t fec_codec_id_ = OF_CODEC_REED_SOLOMON_GF_2_M_STABLE;
+  of_session_t *fec_session_ = nullptr;
+  of_parameters_t *fec_params_ = nullptr;
+  of_rs_2_m_parameters_t *fec_rs_params_ = nullptr;
+  of_ldpc_parameters_t *fec_ldpc_params_ = nullptr;
+};
+
+#endif