GNU Radio之OFDM Carrier Allocator底层C++实现

ofdm_carrier_allocator_cvc::sptr ofdm_carrier_allocator_cvc::make(
    int fft_len,
    const std::vector<std::vector<int>>& occupied_carriers,
    const std::vector<std::vector<int>>& pilot_carriers,
    const std::vector<std::vector<gr_complex>>& pilot_symbols,
    const std::vector<std::vector<gr_complex>>& sync_words,
    const std::string& len_tag_key,
    const bool output_is_shifted)
{
    return gnuradio::get_initial_sptr(
        new ofdm_carrier_allocator_cvc_impl(fft_len,
                                            occupied_carriers,
                                            pilot_carriers,
                                            pilot_symbols,
                                            sync_words,
                                            len_tag_key,
                                            output_is_shifted));
}

ofdm_carrier_allocator_cvc_impl::ofdm_carrier_allocator_cvc_impl(
  // 参数说明：
    int fft_len,                        // FFT（快速傅里叶变换）的长度。
    const std::vector<std::vector<int>>& occupied_carriers,   // 被占用的载波，即用于传输数据的频率位置。
    const std::vector<std::vector<int>>& pilot_carriers,    // 导频载波，用于辅助接收端的信道估计。
    const std::vector<std::vector<gr_complex>>& pilot_symbols,  // 导频符号，已知的信号，用于帮助接收端进行信道估计。
    const std::vector<std::vector<gr_complex>>& sync_words,   // 同步字，用于帧同步。
    const std::string& len_tag_key,               // 长度标签键，用于标记流的长度。
    const bool output_is_shifted)               // 指示输出是否被移位的布尔值。
    
  // 构造函数初始化列表 tagged_stream_block 表明该组件是一个标记流块，用于处理带有特定标记的数据流。
  : tagged_stream_block("ofdm_carrier_allocator_cvc",
                          io_signature::make(1, 1, sizeof(gr_complex)),
                          io_signature::make(1, 1, sizeof(gr_complex) * fft_len),
                          len_tag_key),
    // 成员变量初始化：
      d_fft_len(fft_len),           // FFT长度
      d_occupied_carriers(occupied_carriers), // 被占用的载波
      d_pilot_carriers(pilot_carriers),     // 导频载波
      d_pilot_symbols(pilot_symbols),     // 导频符号
      d_sync_words(sync_words),         // 同步字
      d_symbols_per_set(0),           // 记录在一个OFDM符号集中，所有被占用的载波上分配的数据和导频符号的总数；"集"指的是一个OFDM帧
      d_output_is_shifted(output_is_shifted)  // 指示输出是否被移位的布尔值。
{
    // Sanity checks
    // If that is is null, the input is wrong -> force user to use ((),) in python
    
    // 检查被占用的载波是否为空，如果是，则抛出异常。
    if (d_occupied_carriers.empty()) {
        throw std::invalid_argument(
            "Occupied carriers must be of type vector of vector i.e. ((),).");
    }
  // 检查每个数据载波索引是否在有效范围内（即非负且小于FFT长度），并对于output_is_shifted为真的情况，调整载波索引
    for (unsigned i = 0; i < d_occupied_carriers.size(); i++) {
        for (unsigned j = 0; j < d_occupied_carriers[i].size(); j++) {
            if (occupied_carriers[i][j] < 0) {
                d_occupied_carriers[i][j] += d_fft_len;
            }
            if (d_occupied_carriers[i][j] > d_fft_len || d_occupied_carriers[i][j] < 0) {
                throw std::invalid_argument("data carrier index out of bounds");
            }
            if (d_output_is_shifted) {
                d_occupied_carriers[i][j] =
                    (d_occupied_carriers[i][j] + fft_len / 2) % fft_len;
            }
        }
    }
  // 检查  导频载波是否为空，如果是，则抛出异常。
    if (d_pilot_carriers.empty()) {
        throw std::invalid_argument(
            "Pilot carriers must be of type vector of vector i.e. ((),).");
    }
  // 检查每个导频载波索引是否在有效范围内（即非负且小于FFT长度），并对于output_is_shifted为真的情况，调整载波索引
    for (unsigned i = 0; i < d_pilot_carriers.size(); i++) {
        for (unsigned j = 0; j < d_pilot_carriers[i].size(); j++) {
            if (d_pilot_carriers[i][j] < 0) {
                d_pilot_carriers[i][j] += d_fft_len;
            }
            if (d_pilot_carriers[i][j] > d_fft_len || d_pilot_carriers[i][j] < 0) {
                throw std::invalid_argument("pilot carrier index out of bounds");
            }
            if (d_output_is_shifted) {
                d_pilot_carriers[i][j] = (d_pilot_carriers[i][j] + fft_len / 2) % fft_len;
            }
        }
    }
  // 检查导频符号是否为空，如果是，则抛出异常。
    if (d_pilot_symbols.empty()) {
        throw std::invalid_argument(
            "Pilot symbols must be of type vector of vector i.e. ((),).");
    }
  // 确保每个导频载波的大小与相应的导频符号向量的大小匹配。
    for (unsigned i = 0; i < std::max(d_pilot_carriers.size(), d_pilot_symbols.size());
         i++) {
        if (d_pilot_carriers[i % d_pilot_carriers.size()].size() !=
            d_pilot_symbols[i % d_pilot_symbols.size()].size()) {
            throw std::invalid_argument("pilot_carriers do not match pilot_symbols");
        }
    }
  // 验证同步字的长度与 FFT 长度相匹配。
    for (unsigned i = 0; i < d_sync_words.size(); i++) {
        if (d_sync_words[i].size() != (unsigned)d_fft_len) {
            throw std::invalid_argument("sync words must be fft length");
        }
    }
  // 计算每组被占用的符号总数。
    for (unsigned i = 0; i < d_occupied_carriers.size(); i++) {
        d_symbols_per_set += d_occupied_carriers[i].size();
    }
    set_tag_propagation_policy(TPP_DONT); // 置标记传播策略为 TPP_DONT，不传播任何标记。
    set_relative_rate((uint64_t)d_symbols_per_set, (uint64_t)d_occupied_carriers.size()); // 设置相对速率，影响处理数据的速率。
}

int ofdm_carrier_allocator_cvc_impl::calculate_output_stream_length(
    const gr_vector_int& ninput_items)  // 一个整数向量，其中每个元素代表对应输入流中的项目数目; 对于大多数基于流的处理模块，这个向量可能只有一个元素，因为它们通常只处理一个输入流。
{
    int nin = ninput_items[0];      // 表示输入流中的项目数
    int nout = (nin / d_symbols_per_set) * d_occupied_carriers.size();  // 计算的输出项的基本数目
    int k = 0;
  // 处理余下的输入项; 使用一个循环来处理不足以形成一个完整 OFDM 符号集的余下输入项。
    for (int i = 0; i < nin % d_symbols_per_set; k++) { // i 变量用于累加当前处理的输入项数目，而 k 变量用于迭代被占用的载波集合。
        nout++;
        i += d_occupied_carriers[k % d_occupied_carriers.size()].size();  // 确保了即使在处理最后一批输入项时，也能正确考虑每个被占用载波集合的大小
    }
    return nout + d_sync_words.size();  // 这个长度包括了基于输入项的计算结果，以及为同步字预留的额外输出项
}

int ofdm_carrier_allocator_cvc_impl::work(int noutput_items,
                                          gr_vector_int& ninput_items,
                                          gr_vector_const_void_star& input_items,
                                          gr_vector_void_star& output_items)
{
  // 输入输出数据类型转换，以便于处理复数数据
    const gr_complex* in = (const gr_complex*)input_items[0];
    gr_complex* out = (gr_complex*)output_items[0];
    std::vector<tag_t> tags;
    memset((void*)out, 0x00, sizeof(gr_complex) * d_fft_len * noutput_items); // 初始化输出缓冲区
    // Copy Sync word
    for (unsigned i = 0; i < d_sync_words.size(); i++) {
        memcpy((void*)out, (void*)&d_sync_words[i][0], sizeof(gr_complex) * d_fft_len); // 将预定义的同步字复制到输出流的开始部分，这些同步字用于接收端的帧同步。
        out += d_fft_len;
    }
    // Copy data symbols
    // 将输入数据符号映射到被占用的 OFDM 载波上。这一过程考虑了载波的集合配置和当前处理的数据符号集合。
    long n_ofdm_symbols = 0; // Number of output items
    int curr_set = 0;
    int symbols_to_allocate = d_occupied_carriers[0].size();
    int symbols_allocated = 0;
    for (int i = 0; i < ninput_items[0]; i++) {
        if (symbols_allocated == 0) {
            // Copy all tags associated with these input symbols onto this OFDM symbol
            // 复制与输入符号相关联的所有标签到输出 OFDM 符号上，保持流标签系统中的信息。
            get_tags_in_range(
                tags,
                0,
                nitems_read(0) + i,
                nitems_read(0) + std::min(i + symbols_to_allocate, (int)ninput_items[0]));
            for (unsigned t = 0; t < tags.size(); t++) {
                add_item_tag(0,
                             nitems_written(0) + n_ofdm_symbols +
                                 (n_ofdm_symbols == 0 ? 0 : d_sync_words.size()),
                             tags[t].key,
                             tags[t].value);
            }
            n_ofdm_symbols++;
        }
        out[(n_ofdm_symbols - 1) * d_fft_len +
            d_occupied_carriers[curr_set][symbols_allocated]] = in[i];
        symbols_allocated++;
        if (symbols_allocated == symbols_to_allocate) {
            curr_set = (curr_set + 1) % d_occupied_carriers.size();
            symbols_to_allocate = d_occupied_carriers[curr_set].size();
            symbols_allocated = 0;
        }
    }
    // Copy pilot symbols
    // 在数据符号映射完成后，将导频符号映射到指定的导频载波上。这些导频符号对于接收端的信道估计至关重要。
    for (int i = 0; i < n_ofdm_symbols; i++) {
        for (unsigned k = 0; k < d_pilot_carriers[i % d_pilot_carriers.size()].size();
             k++) {
            out[i * d_fft_len + d_pilot_carriers[i % d_pilot_carriers.size()][k]] =
                d_pilot_symbols[i % d_pilot_symbols.size()][k];
        }
    }
    return n_ofdm_symbols + d_sync_words.size();  // 返回处理完成的OFDM符号数量，包括数据符号和同步字。
}

ofdm_carrier_allocator_cvc_impl::~ofdm_carrier_allocator_cvc_impl() {}