← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gnuradio/trusty-updates

« back to all changes in this revision

Viewing changes to gnuradio-core/src/lib/general/gr_ofdm_insert_preamble.cc

  • Committer: Package Import Robot
  • Author(s): A. Maitland Bottoms
  • Date: 2012-02-26 21:26:16 UTC
  • mfrom: (1.1.4)
  • Revision ID: package-import@ubuntu.com-20120226212616-vsfkbi1158xshdql
Tags: 3.5.1-1
http://bugs.debian.org/642716
http://bugs.debian.org/645332
http://bugs.debian.org/394849
http://bugs.debian.org/616832
http://bugs.debian.org/590048
http://bugs.debian.org/642580
* new upstream version, re-packaged from scratch with modern tools
    closes: #642716, #645332, #394849, #616832, #590048, #642580,
    #647018, #557050, #559640, #631863
* CMake build

Show diffs side-by-side

added added

removed removed

Lines of Context:
gnuradio-core/src/lib/general/gr_ofdm_insert_preamble.cc
1
 
/* -*- c++ -*- */
2
 
/*
3
 
 * Copyright 2007 Free Software Foundation, Inc.
4
 
 * 
5
 
 * This file is part of GNU Radio
6
 
 * 
7
 
 * GNU Radio is free software; you can redistribute it and/or modify
8
 
 * it under the terms of the GNU General Public License as published by
9
 
 * the Free Software Foundation; either version 3, or (at your option)
10
 
 * any later version.
11
 
 * 
12
 
 * GNU Radio is distributed in the hope that it will be useful,
13
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
 * GNU General Public License for more details.
16
 
 * 
17
 
 * You should have received a copy of the GNU General Public License along
18
 
 * with this program; if not, write to the Free Software Foundation, Inc.,
19
 
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20
 
 */
21
 
 
22
 
#ifdef HAVE_CONFIG_H
23
 
#include <config.h>
24
 
#endif
25
 
 
26
 
#include <gr_ofdm_insert_preamble.h>
27
 
#include <gr_io_signature.h>
28
 
#include <stdexcept>
29
 
#include <iostream>
30
 
#include <string.h>
31
 
 
32
 
gr_ofdm_insert_preamble_sptr
33
 
gr_make_ofdm_insert_preamble(int fft_length,
34
 
                             const std::vector<std::vector<gr_complex> > &preamble)
35
 
{
36
 
  return gr_ofdm_insert_preamble_sptr(new gr_ofdm_insert_preamble(fft_length,
37
 
                                                                  preamble));
38
 
}
39
 
 
40
 
gr_ofdm_insert_preamble::gr_ofdm_insert_preamble
41
 
       (int fft_length,
42
 
        const std::vector<std::vector<gr_complex> > &preamble)
43
 
  : gr_block("ofdm_insert_preamble",
44
 
             gr_make_io_signature2(2, 2,
45
 
                                   sizeof(gr_complex)*fft_length,
46
 
                                   sizeof(char)),
47
 
             gr_make_io_signature2(1, 2,
48
 
                                   sizeof(gr_complex)*fft_length,
49
 
                                   sizeof(char))),
50
 
    d_fft_length(fft_length),
51
 
    d_preamble(preamble),
52
 
    d_state(ST_IDLE),
53
 
    d_nsymbols_output(0),
54
 
    d_pending_flag(0)
55
 
{
56
 
  // sanity check preamble symbols
57
 
  for (size_t i = 0; i < d_preamble.size(); i++){
58
 
    if (d_preamble[i].size() != (size_t) d_fft_length)
59
 
      throw std::invalid_argument("gr_ofdm_insert_preamble: invalid length for preamble symbol");
60
 
  }
61
 
 
62
 
  enter_idle();
63
 
}
64
 
 
65
 
 
66
 
gr_ofdm_insert_preamble::~gr_ofdm_insert_preamble()
67
 
{
68
 
}
69
 
 
70
 
int
71
 
gr_ofdm_insert_preamble::general_work (int noutput_items,
72
 
                                       gr_vector_int &ninput_items_v,
73
 
                                       gr_vector_const_void_star &input_items,
74
 
                                       gr_vector_void_star &output_items)
75
 
{
76
 
  int ninput_items = std::min(ninput_items_v[0], ninput_items_v[1]);
77
 
  const gr_complex *in_sym = (const gr_complex *) input_items[0];
78
 
  const unsigned char *in_flag = (const unsigned char *) input_items[1];
79
 
 
80
 
  gr_complex *out_sym = (gr_complex *) output_items[0];
81
 
  unsigned char *out_flag = 0;
82
 
  if (output_items.size() == 2)
83
 
    out_flag = (unsigned char *) output_items[1];
84
 
 
85
 
 
86
 
  int no = 0;   // number items output
87
 
  int ni = 0;   // number items read from input
88
 
 
89
 
 
90
 
#define write_out_flag()                        \
91
 
  do { if (out_flag)                            \
92
 
          out_flag[no] = d_pending_flag;        \
93
 
       d_pending_flag = 0;                      \
94
 
  } while(0)
95
 
 
96
 
 
97
 
  while (no < noutput_items && ni < ninput_items){
98
 
    switch(d_state){
99
 
    case ST_IDLE:
100
 
      if (in_flag[ni] & 0x1)    // this is first symbol of new payload
101
 
        enter_preamble();
102
 
      else
103
 
        ni++;                   // eat one input symbol
104
 
      break;
105
 
      
106
 
    case ST_PREAMBLE:
107
 
      assert(in_flag[ni] & 0x1);
108
 
      if (d_nsymbols_output >= (int) d_preamble.size()){
109
 
        // we've output all the preamble
110
 
        enter_first_payload();
111
 
      }
112
 
      else {
113
 
        memcpy(&out_sym[no * d_fft_length],
114
 
               &d_preamble[d_nsymbols_output][0],
115
 
               d_fft_length*sizeof(gr_complex));
116
 
 
117
 
        write_out_flag();
118
 
        no++;
119
 
        d_nsymbols_output++;
120
 
      }
121
 
      break;
122
 
      
123
 
    case ST_FIRST_PAYLOAD:
124
 
      // copy first payload symbol from input to output
125
 
      memcpy(&out_sym[no * d_fft_length],
126
 
             &in_sym[ni * d_fft_length],
127
 
             d_fft_length * sizeof(gr_complex));
128
 
 
129
 
      write_out_flag();
130
 
      no++;
131
 
      ni++;
132
 
      enter_payload();
133
 
      break;
134
 
      
135
 
    case ST_PAYLOAD:
136
 
      if (in_flag[ni] & 0x1){   // this is first symbol of a new payload
137
 
        enter_preamble();
138
 
        break;
139
 
      }
140
 
 
141
 
      // copy a symbol from input to output
142
 
      memcpy(&out_sym[no * d_fft_length],
143
 
             &in_sym[ni * d_fft_length],
144
 
             d_fft_length * sizeof(gr_complex));
145
 
 
146
 
      write_out_flag();
147
 
      no++;
148
 
      ni++;
149
 
      break;
150
 
 
151
 
    default:
152
 
      std::cerr << "gr_ofdm_insert_preamble: (can't happen) invalid state, resetting\n";
153
 
      enter_idle();
154
 
    }
155
 
  }
156
 
 
157
 
  consume_each(ni);
158
 
  return no;
159
 
}
160
 
 
161
 
void
162
 
gr_ofdm_insert_preamble::enter_idle()
163
 
{
164
 
  d_state = ST_IDLE;
165
 
  d_nsymbols_output = 0;
166
 
  d_pending_flag = 0;
167
 
}
168
 
 
169
 
void
170
 
gr_ofdm_insert_preamble::enter_preamble()
171
 
{
172
 
  d_state = ST_PREAMBLE;
173
 
  d_nsymbols_output = 0;
174
 
  d_pending_flag = 1;
175
 
}
176
 
 
177
 
void
178
 
gr_ofdm_insert_preamble::enter_first_payload()
179
 
{
180
 
  d_state = ST_FIRST_PAYLOAD;
181
 
}
182
 
 
183
 
void
184
 
gr_ofdm_insert_preamble::enter_payload()
185
 
{
186
 
  d_state = ST_PAYLOAD;
187
 
}