← Back to branch summary

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

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Kamal Mostafa
  • Date: 2010-03-13 07:46:01 UTC
  • mfrom: (2.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20100313074601-zjsa893a87bozyh7
Tags: 3.2.2.dfsg-1ubuntu1
https://launchpad.net/bugs/260406
* Fix build for Ubuntu lucid (LP: #260406)
  - add binary package dep for libusrp0, libusrp2-0: adduser
  - debian/rules clean: remove pre-built Qt moc files

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
}