[Commit-gnuradio] [gnuradio] 54/57: fec: mostly documentation updates, spell check, etc.

[git]

This is an automated email from the git hooks/post-receive script.

trondeau pushed a commit to branch master
in repository gnuradio.

commit 675b74857419a381bd2816778f79022293e96237
Author: Tom Rondeau <address@hidden>
Date:   Tue May 20 13:08:51 2014 -0400

    fec: mostly documentation updates, spell check, etc.
---
 gr-digital/python/digital/packet_utils.py        |   1 +
 gr-fec/doc/fec.dox                               | 221 ++++++++++++++++++-----
 gr-fec/examples/fecapi_tagged_decoders.grc       |   6 +-
 gr-fec/include/gnuradio/fec/async_decoder.h      |  41 ++++-
 gr-fec/include/gnuradio/fec/async_encoder.h      |  43 ++++-
 gr-fec/include/gnuradio/fec/cc_decoder.h         |  33 +++-
 gr-fec/include/gnuradio/fec/cc_encoder.h         |   8 +-
 gr-fec/include/gnuradio/fec/dummy_decoder.h      |   4 +-
 gr-fec/include/gnuradio/fec/dummy_encoder.h      |   4 +-
 gr-fec/include/gnuradio/fec/repetition_decoder.h |   2 +-
 gr-fec/include/gnuradio/fec/repetition_encoder.h |   5 +-
 11 files changed, 298 insertions(+), 70 deletions(-)

diff --git a/gr-digital/python/digital/packet_utils.py 
b/gr-digital/python/digital/packet_utils.py
index a73480b..de7e298 100644
--- a/gr-digital/python/digital/packet_utils.py
+++ b/gr-digital/python/digital/packet_utils.py
@@ -209,6 +209,7 @@ def unmake_packet(whitened_payload_with_crc, 
whitener_offset=0,
         print "payload_with_crc =", string_to_hex_list(payload_with_crc)
         print "ok = %r, len(payload) = %d" % (ok, len(payload))
         print "payload =", string_to_hex_list(payload)
+        print ""
 
     return ok, payload
 
diff --git a/gr-fec/doc/fec.dox b/gr-fec/doc/fec.dox
index eddf1b1..7fbbdda 100644
--- a/gr-fec/doc/fec.dox
+++ b/gr-fec/doc/fec.dox
@@ -22,49 +22,83 @@ by using:
 \endcode
 
 
-\section fec_using Using the FEC Encoders and Decoders
-
-The FECAPI consists of two layers, the coding blocks themselves and
-the coder objects. The coding blocks are the encoders or decoders that
-fit into the GNU Radio flowgraph and act as shells to move data to and
-from the coder objects. It is in the objects that the actual
-coding/decoding gets done. The coding blocks use the API of the coder
-objects to interact with the scheduler and set up the input/output
-item buffers that move data between blocks.
-
-The gr::fec::encoder block is a relatively simple wrapper for the
-encoding objects. It uses the encoding object information about the
-input/output sizes and input/output item sizes to set up the
-interaction with the scheduler. Typically, a coder will add redundancy
-to the stream making the output longer by some amount than the input
-stream. This block simply takes in an encoder object, specifically an
-object that derives from gr::fec::generic_encoder. It also takes in
-the input and output items sizes that the encoder will expect, which
-we can just ask the encoder for. Typically, the encodes expect
-unpacked bytes in and unpacked bytes out.
-
-The gr::fec::decoder block is similarly simple to wrap the decoding
-objects. It uses the decoding object information about the
-input/output sizes and input/output item sizes to set up the
+\section fec_using Using the FEC API
+
+FEC is a complex issue to implement in a generic, generally usable
+way. To help with these issues, the FEC API operates on two levels:
+the coder variables and the coder deployments. The variables implement
+the encoding and decoding methods whereas the deployments set up the
+variables, make sure the input data is formatted properly, run the
+coder variable, and then pass on the data for follow-on processing.
+
+In a GNU Radio flowgraph, the deployments are GNU Radio blocks that we
+insert into the flowgraph. The deployments use the API of the coder
+variables to interact with the scheduler and set up the input/output
+item buffers that move data between blocks. The intent of the API is
+to be able to build the coding variables that are general enough for
+easy use in multiple situations. We then construct deployments to
+control the interaction between the data and the variable. GNU Radio
+provides deployments for a number of situations, but these should not
+be considered the only ways to deploy the decoders.
+
+
+\subsection fec_deployments Deployments
+
+Generally speaking, encoder deployments take in bits and produce
+bits (i.e., unpacked bytes with 1 bit per byte). Decoder deployments
+take in floats and produce bits. The floats are generally meant to
+represent soft decisions. If the demodulator does not produce soft
+decisions, an easy alternative is to convert the hard decision 0's and
+1's to -1 and +1 floats. The main departure from this model is when
+using a PDU-based modulator or demodulator, for which we can look at
+using the asynchronous message passing system. In this instance,
+passing bits is not natural, so we need to create a deployment that
+can handle packed bytes. GNU Radio has the gr::fec::asycn_encoder and
+gr::fec::async_decoder deployments that work in this mode.
+
+Some coding variables handle inputs and outputs differently than the
+described deployments. Using the FEC API provides concepts of input
+and output conversion properties that help us create deployments to
+convert the data streams to the required format of the variable.
+
+\subsubsection fec_deploy_simple Streaming Deployments
+
+For the encoder deployments, the gr::fec::encoder block is a
+relatively simple deployment for the encoding variables. It uses the
+encoding object information about the input/output sizes and
+input/output item sizes to set up the interaction with the
+scheduler. Typically, a coder will add redundancy to the stream making
+the output longer by some amount than the input stream. This block
+simply takes in an encoder object, specifically an object that derives
+from gr::fec::generic_encoder. It also takes in the input and output
+items sizes that the encoder will expect, which we can just ask the
+encoder for. Typically, the encodes expect unpacked bytes in and
+unpacked bytes out.
+
+The gr::fec::decoder block is a similarly simple deployment for the
+decoding variables. It uses the decoding variable information about
+the input/output sizes and input/output item sizes to set up the
 interaction with the scheduler. Since a decoder typically uses the
 redundancy from the input stream to correct for errors, the input
 stream will be longer than the output stream by the rate of the
 code. This block simply takes in an decoder object, specifically an
 object that derives from gr::fec::generic_decoder. It also takes in
 the input and output items sizes that the decoder will expect, which
-we can just ask the encoder for. The decoders may take a float input
-or a byte. The byte may be a hard decision or a quantized soft
-decision, depending on how the decoder object behaves.
-
-Normally, though, we don't work directly with the encoder() or
-decoder() blocks but a wrapper around those blocks. GNU Radio's gr-fec
-package comes with Python classes, fec.extended_encoder and
-fec.extended_decoder, to make things easier. For one thing, these
-extended hier_block2 blocks take care of the puncturing and
-depuncturing operations often found in FEC codes. The other thing that
-these blocks do for us is reads the API of the encoder/decoder objects
-to properly convert the data in or out, depending on how the coding
-object works.
+we can just ask the encoder for. The deployment expects a floating
+point stream input, though the decoder variables may take a float
+input or a byte. If using a byte format, it could be a hard decision
+or a quantized soft decision, depending on how the decoder object
+behaves.
+
+Normally, though, we don't work directly with these simple encoder()
+or decoder() deployments but a wrapper around those blocks. GNU
+Radio's gr-fec package comes with two Python deployments to make
+things easier: fec.extended_encoder and fec.extended_decoder. For one
+thing, these extended hier_block2 blocks take care of the puncturing
+and depuncturing operations often found in FEC codes. The other thing
+that these blocks do for us is read the API of the encoder/decoder
+variables to properly convert the data in or out, depending on how the
+coding object works.
 
 For instance, a generic_decoder takes in floating point values (which
 should be soft decisions). However, a decoder might instead want to
@@ -80,15 +114,116 @@ the particular code we want to use. We can find these 
codes under the
 [Error Coding] category in GRC. The encoders are found under
 [Encoders] and similarly the decoders under the [Decoders]
 categories. Putting these onto the canvas creates a variable that we
-can then pass to the extended encoder or decoder blocks.
+can then pass to the extended encoder or decoder deployment blocks.
 
 Most of the parameters of the encoder and decoder definitions should
 be fairly obvious based on the type of code. See the documentation for
 each coding object for more details. In the following section \ref
 fec_parallelism, we explain the Parallelism and Dimension properties.
 
-
-\section fec_coding_vars Encoding/Decoding Variables
+See fec/fecapi_encoders.grc and fec/fecapi_decoders.grc in the
+installed examples for an example of how to work with these
+deployments given the three initial FEC coders available.
+
+\subsubsection fec_deploy_tag_stream Tagged Stream Deployments
+
+GNU Radio's gr-fec also comes with simple deployments for \ref
+page_tagged_stream_blocks blocks. These deployments work similarly to
+the normal streaming deployments but fit into a tagged stream system
+by setting a tagged stream tag to control the frame size. Like all
+tagged stream blocks, they expect the tag to be located in the stream
+in order to properly function.
+
+The simplest form of the tagged stream deployments are just the C++
+blocks gr::fec::tagged_encoder and gr::fec::tagged_decoder. These do
+not handle any input or output conversion. They expect the inputs to
+be already properly formatted for the encoding/decoding variables, and
+the outputs will be whatever the variable naturally produce.
+
+In the tagged stream deployments, the frame size set for a variable is
+no longer the static frame size like we expected in the streaming data
+implementations. Instead, we look at the frame size of the
+encoder/decoder variable during construction of the deployment as the
+maximum frame size, or a maximum transmission unit (MTU). This allows
+us to set up some internal memory to handle up to the required maximum
+length. When a tagged stream comes into this block, the frame size is
+then set based on that tagged stream information. If the frame is
+larger than the established MTU, a warning is sent out and the
+deployment only handles up to the MTU of the given frame.
+
+The extended Python tagged deployments, fec.extended_tagged_encoder
+and fec.extended_tagged_decoder, offer additional handling of the FEC
+API like we saw with the fec.extended_encoder and
+fec.extended_decoder. These extended deployments wrap up the
+puncturing and depuncturing as well as use the FEC API to do any input
+and output translation for the formatting of data streams. The
+fec.extended_tagged_encoder expects unpacked bits in and produces
+unpacked bits out. The fec.extended_tagged_decoder takes in floats
+(generally soft decisions from -1 to 1) and produces unpacked bits.
+
+See fec/fecapi_tagged_encoders.grc and fec/fecapi_tagged_decoders.grc
+in the installed examples for an example of how to work with these
+deployments given the three initial FEC coders available.
+
+
+
+\subsubsection fec_deploy_async Asynchronous Deployments
+
+The final standard deployment shipped with GNU Radio is for
+asynchronous \ref page_msg_passing and handling PDUs:
+gr::fec::async_encoder and gr::fec::async_decoder.
+
+Unlike the other deployments, these C++ deployments do not also have
+an extended Python deployment. Because this deployment uses message
+passing, we cannot easily build up a hierarchical block of message
+passing blocks to satisfy the input/output translations like we've
+done with the other forms of deployment. Instead, the input/output
+formatting is taken care of inside this deployment itself. Further,
+because this form of moving data anticipates data being moved in
+packets, these deployments cannot work with any FEC code that requires
+a history (see generic_decoder::get_history). Right now, this means
+that the async message passing deployments cannot work with
+convolutional codes (gr::fec::code::cc_encoder and
+gr::fec::code::cc_decoder) in streaming mode because it would require
+data from the next frame to finish off decoding the current frame.
+
+These deployments also work in two distinct modes. They can work in
+unpacked mode where inputs are messages of bits, or they may work in
+packed mode where messages are PDUs. The distinction is that the
+packed mode PDU's are the standard protocol data units (PDUs) that
+encompass full packets of data. This allows these async deployments to
+be used easily within PDU-based applications, such as encoding a
+packet with a CRC attached.
+
+When in packed or PDU mode, the encoder deployment has the option of
+reversing the bits during unpacking and packing. Like the extended
+deployments for the other data modes, these deployments manipulate the
+input data to the format expected by the encoding or decoding
+variables using calls to the FEC API. Because most of the coders work
+off unpacked bits, the incoming PDUs must first be unpacked into bits
+and the repacked again into the original PDU. The
+gr::blocks::kernel::pack_k_bits and gr::blocks::kernel::unpack_k_bits
+kernels are used here, and they can change the direction on how to
+pack and unpack. Because different data processing blocks, framing,
+deframing, and other operations may arbitrarily set the format of the
+bits and the ordering, we provide the options of unpacking and packing
+directions in the deployments. However, the gr::fec::async_decoder
+still expects the input to be soft decisions with one decision per
+item, so we only say whether this deployment outputs packed PDUs or
+not and the packing direction.
+
+For an example of using the asynchronous in PDU mode, see
+fec/fecapi_async_packed_decoders.grc. See
+fec/fecapi_async_to_stream.grc for an example of mixing the packed PDU
+mode encoder with a tagged stream decoder. This example shows the PDU
+input having a CRC32 appended to the uncoded stream that is then
+checked after the packet is decoded.
+
+For an example of the async deployment using unpacked bits, see
+fec/fecapi_async_encoders.grc and fec/fecapi_async_decoders.grc.
+
+
+\subsection fec_coding_vars Encoding/Decoding Variables
 
 GNU Radio currently has a minor subset of coders available:
 
@@ -105,7 +240,7 @@ Decoders:
 \li gr::fec::code::cc_decoder
 
 
-When building a new FECAPI encoder or decoder, the dummy
+When building a new FECAPI encoder or decoder variable, the dummy
 encoder/decoder block would be a good place to start. This coding set
 does no processing on the data. For the encoder, each bit is simply
 passed through directly. For the dummy decoder, the input data are
@@ -128,6 +263,7 @@ more generic for different rates and constraint lengths and 
take this
 particular code implementation as the set CCSDS decoder, much like we
 have the ccsds_encoder class.
 
+
 \subsection fec_parallelism Parallelism
 
 The code variables in GNU Radio Companion have the ability to create
@@ -229,5 +365,8 @@ going into an encoder and the number of bits coming out of 
a decoder.
 \li fecapi_encoders.grc
 \li fecapi_tagged_decoders.grc
 \li fecapi_tagged_encoders.grc
+\li fecapi_async_decoders.grc
+\li fecapi_async_encoders.grc
+\li fecapi_async_to_stream.grc
 
 */
diff --git a/gr-fec/examples/fecapi_tagged_decoders.grc 
b/gr-fec/examples/fecapi_tagged_decoders.grc
index 2c9279f..d2512ce 100644
--- a/gr-fec/examples/fecapi_tagged_decoders.grc
+++ b/gr-fec/examples/fecapi_tagged_decoders.grc
@@ -1,6 +1,6 @@
 <?xml version='1.0' encoding='ASCII'?>
 <flow_graph>
-  <timestamp>Sat May 17 19:22:20 2014</timestamp>
+  <timestamp>Tue May 20 10:51:56 2014</timestamp>
   <block>
     <key>options</key>
     <param>
@@ -1539,10 +1539,6 @@
       <value>False</value>
     </param>
     <param>
-      <key>swap</key>
-      <value>False</value>
-    </param>
-    <param>
       <key>alias</key>
       <value></value>
     </param>
diff --git a/gr-fec/include/gnuradio/fec/async_decoder.h 
b/gr-fec/include/gnuradio/fec/async_decoder.h
index 46fa9be..05eda2f 100644
--- a/gr-fec/include/gnuradio/fec/async_decoder.h
+++ b/gr-fec/include/gnuradio/fec/async_decoder.h
@@ -33,13 +33,48 @@ namespace gr {
 
     /*!
      * \brief Creates the decoder block for use in GNU Radio
-     * flowgraphs from a given FECAPI object derived from the
+     * flowgraphs from a given FEC API object derived from the
      * generic_decoder class.
      * \ingroup error_coding_blk
      *
      * \details
      *
-     * Decodes frames received as a PDU over a message port.
+     * Decodes frames received as async messages over a message
+     * port. This decoder deployment expects messages of soft decision
+     * symbols in and can produce either packed, PDU messages (\p
+     * packed = True) or messages full of unpacked bits (\p packed =
+     * False).
+     *
+     * This decoder works off a full message as one frame or block to
+     * decode. The message length is used to calculate the frame
+     * length. To support this, the decoder variable used will have
+     * had its frame_size set. This block treats that initial
+     * frame_size value as the maximum transmission unit (MTU) and
+     * will not process frames larger than that after being decoded.
+     *
+     * The packed PDU form of this deployment is designed to work well
+     * with other PDU-based blocks to operate within the processing
+     * flow of data packets or frames.
+     *
+     * Due to differences in how data is packed and processed, this
+     * block also offers the ability to change the direction of how
+     * bits are packed. All inputs messages are one soft decision per
+     * item. By default, the \p rev_pack mode is set to True. Using
+     * this setup allows the async block to behave with PDUs in the
+     * same operation and format as the tagged stream decoders. That
+     * is, putting the same data into both the tagged stream decoder
+     * deployment and this with the default setting should produce the
+     * same data.
+     *
+     * Because the block handles data as a full frame per message,
+     * this decoder deployment cannot work with any decoders that
+     * require history. For example, the gr::fec::code::cc_decoder
+     * decoder in streaming mode requires an extra rate*(K-1) bits to
+     * complete the decoding, so it would have to wait for the next
+     * message to come in and finish processing. Therefore, the
+     * streaming mode of the CC decoder is not allowed. The other
+     * three modes will work with this deployment since the frame is
+     * self-contained for decoding.
      */
     class FEC_API async_decoder : virtual public block
     {
@@ -50,7 +85,7 @@ namespace gr {
        * Build the PDU-based FEC decoder block from an FECAPI decoder object.
        *
        * \param my_decoder An FECAPI decoder object child of the 
generic_decoder class.
-       * \param packed Sets output to packed bytes if true; otherwise, 1 bit 
per byte
+       * \param packed Sets output to packed bytes if true; otherwise, 1 bit 
per byte.
        * \param rev_pack If packing bits, should they be reversed?
        */
       static sptr make(generic_decoder::sptr my_decoder,
diff --git a/gr-fec/include/gnuradio/fec/async_encoder.h 
b/gr-fec/include/gnuradio/fec/async_encoder.h
index cbaba97..0310ae4 100644
--- a/gr-fec/include/gnuradio/fec/async_encoder.h
+++ b/gr-fec/include/gnuradio/fec/async_encoder.h
@@ -33,13 +33,42 @@ namespace gr {
 
     /*!
      * \brief Creates the encoder block for use in GNU Radio
-     * flowgraphs from a given FECAPI object derived from the
-     * generic_encoder class.
-     * \ingroup error_coding_blk
+     * flowgraphs with async message from a given FEC API object
+     * derived from the generic_encoder class.  \ingroup
+     * error_coding_blk
      *
      * \details
      *
-     * Encodes frames received as a PDU over a message port.
+     * Encodes frames received as async messages or as a PDU over a
+     * message port. This encoder works off a full message as one
+     * frame or block to encode. The message length is used as the
+     * frame length. To support this, the encoder variable used will
+     * have had its frame_size set. This block treats that initial
+     * frame_size value as the maximum transmission unit (MTU) and
+     * will not process frames larger than that.
+     *
+     * This deployment works off messages and expects them to either
+     * be messages full of unpacked bits or PDU messages, which means
+     * full bytes of a frame from the higher layers, including things
+     * like headers, tails, CRC check bytes, etc. For handling PDUs,
+     * set the \p packed option of this deployment block to True. The
+     * block will then use the FEC API to properly unpack the bits
+     * from the PDU, pass it through the encoder, and repack them to
+     * output the PDUs for the next stage of processing.
+     *
+     * The packed PDU form of this deployment is designed to work well
+     * with other PDU-based blocks to operate within the processing
+     * flow of data packets or frames.
+     *
+     * Due to differences in how data is packed and processed, this
+     * block also offers the ability to change the direction of how
+     * bits are unpacked and packed, where reading or writing from the
+     * LSB or MSB. By default, the \p rev_unpack and \p rev_pack modes
+     * are set to True. Using this setup allows the async block to
+     * behave with PDUs in the same operation and format as the tagged
+     * stream encoders. That is, putting the same data into both the
+     * tagged stream encoder deployment and this with these default
+     * settings should produce the same data.
      */
     class FEC_API async_encoder : virtual public block
     {
@@ -50,9 +79,9 @@ namespace gr {
        * Build the PDU-based FEC encoder block from an FECAPI encoder object.
        *
        * \param my_encoder An FECAPI encoder object child of the 
generic_encoder class.
-       * \param packed True if working on packed bytes (like PDUs)
-       * \param rev_unpack Reverse the unpacking order from input bytes to bits
-       * \param rev_pack Reverse the packing order from bits to output bytes
+       * \param packed True if working on packed bytes (like PDUs).
+       * \param rev_unpack Reverse the unpacking order from input bytes to 
bits.
+       * \param rev_pack Reverse the packing order from bits to output bytes.
        */
       static sptr make(generic_encoder::sptr my_encoder,
                        bool packed=false,
diff --git a/gr-fec/include/gnuradio/fec/cc_decoder.h 
b/gr-fec/include/gnuradio/fec/cc_decoder.h
index 0d0f51b..8f29af9 100644
--- a/gr-fec/include/gnuradio/fec/cc_decoder.h
+++ b/gr-fec/include/gnuradio/fec/cc_decoder.h
@@ -60,18 +60,47 @@ namespace gr {
        * settings, much like the cc_encoder class where the CCSDS
        * settings would be a highly-optimized version of this.
        *
-       * The encoder is set up wtih a number of bits per frame in the
+       * The decoder is set up with a number of bits per frame in the
        * constructor. When not being used in a tagged stream mode,
        * this encoder will only process frames of the length provided
        * here. If used in a tagged stream block, this setting becomes
        * the maximum allowable frame size that the block may process.
+       *
+       * The \p mode is a cc_mode_t that specifies how the convolutional
+       * encoder will behave and under what conditions.
+       *
+       * \li 'CC_STREAMING': mode expects an uninterrupted flow of
+       * samples into the encoder, and the output stream is
+       * continually encoded. This mode is the only mode for this
+       * decoder that has a history requirement because it requires
+       * rate*(K-1) bits more to finish the decoding properly. This
+       * mode does not work with any deployments that do not allow
+       * history.
+       *
+       * \li 'CC_TERMINATED': is a mode designed for packet-based
+       * systems. This mode adds rate*(k-1) bits to the output as a
+       * way to help flush the decoder.
+       *
+       * \li 'CC_TAILBITING': is another packet-based method. Instead of
+       * adding bits onto the end of the packet, this mode will
+       * continue the code between the payloads of packets by
+       * pre-initializing the state of the new packet based on the
+       * state of the last packet for (k-1) bits.
+       *
+       * \li 'CC_TRUNCATED': a truncated code always resets the registers
+       * to the \p start_state between frames.
+       *
+       * A common convolutional encoder uses K=7, Rate=1/2,
+       * Polynomials=[109, 79]. This is the Voyager code from NASA:
+       * \li   109: b(1101101) --> 1 + x   + x^3 + x^4 + x^6
+       * \li   79:  b(1001111) --> 1 + x^3 + x^4 + x^5 + x^6
        */
       class FEC_API cc_decoder : virtual public generic_decoder
       {
       public:
 
         /*!
-         * Build a convolutional code decoding FECAPI object.
+         * Build a convolutional code decoding FEC API object.
          *
          * \param frame_size Number of bits per frame. If using in the
          *        tagged stream style, this is the maximum allowable
diff --git a/gr-fec/include/gnuradio/fec/cc_encoder.h 
b/gr-fec/include/gnuradio/fec/cc_encoder.h
index b8ab0c1..04ce629 100644
--- a/gr-fec/include/gnuradio/fec/cc_encoder.h
+++ b/gr-fec/include/gnuradio/fec/cc_encoder.h
@@ -56,9 +56,9 @@ namespace gr {
        * bit from the input stream and then ANDs the shift register
        * with each polynomial, and places the parity of the result
        * into the output stream. The output stream is therefore also
-       * unpakced bits.
+       * unpacked bits.
        *
-       * The encoder is set up wtih a number of bits per frame in the
+       * The encoder is set up with a number of bits per frame in the
        * constructor. When not being used in a tagged stream mode,
        * this encoder will only process frames of the length provided
        * here. If used in a tagged stream block, this setting becomes
@@ -89,7 +89,7 @@ namespace gr {
        * \li   109: b(1101101) --> 1 + x   + x^3 + x^4 + x^6
        * \li   79:  b(1001111) --> 1 + x^3 + x^4 + x^5 + x^6
        *
-       * Another encoder class is providee with gr-fec called the
+       * Another encoder class is provided with gr-fec called the
        * gr::fec::code::ccsds_encoder, which implements the above code
        * that is more highly optimized for just those specific
        * settings.
@@ -99,7 +99,7 @@ namespace gr {
       public:
 
         /*!
-         * Build a convolutional code encoding FECAPI object.
+         * Build a convolutional code encoding FEC API object.
          *
          * \param frame_size Number of bits per frame. If using in the
          *        tagged stream style, this is the maximum allowable
diff --git a/gr-fec/include/gnuradio/fec/dummy_decoder.h 
b/gr-fec/include/gnuradio/fec/dummy_decoder.h
index 2786536..071b571 100644
--- a/gr-fec/include/gnuradio/fec/dummy_decoder.h
+++ b/gr-fec/include/gnuradio/fec/dummy_decoder.h
@@ -38,7 +38,7 @@ namespace gr {
        *
        * \details
        * A dummy decoder class that simply passes the input to the
-       * output. It is meant to allow us to easily use the FECAPI
+       * output. It is meant to allow us to easily use the FEC API
        * encoder and decoder blocks in an application with no coding.
        */
       class FEC_API dummy_decoder : virtual public generic_decoder
@@ -46,7 +46,7 @@ namespace gr {
       public:
 
         /*!
-         * Build a dummy decoding FECAPI object.
+         * Build a dummy decoding FEC API object.
          *
          * \param frame_size Number of bits per frame. If using in the
          *        tagged stream style, this is the maximum allowable
diff --git a/gr-fec/include/gnuradio/fec/dummy_encoder.h 
b/gr-fec/include/gnuradio/fec/dummy_encoder.h
index 35bcf59..2270d1f 100644
--- a/gr-fec/include/gnuradio/fec/dummy_encoder.h
+++ b/gr-fec/include/gnuradio/fec/dummy_encoder.h
@@ -38,7 +38,7 @@ namespace gr {
        *
        * \details
        * A dummy encoder class that simply passes the input to the
-       * output. It is meant to allow us to easily use the FECAPI
+       * output. It is meant to allow us to easily use the FEC API
        * encoder and decoder blocks in an application with no coding.
        */
       class FEC_API dummy_encoder : virtual public generic_encoder
@@ -46,7 +46,7 @@ namespace gr {
       public:
 
         /*!
-         * Build a dummy encoding FECAPI object.
+         * Build a dummy encoding FEC API object.
          *
          * \param frame_size Number of bits per frame. If using in the
          *        tagged stream style, this is the maximum allowable
diff --git a/gr-fec/include/gnuradio/fec/repetition_decoder.h 
b/gr-fec/include/gnuradio/fec/repetition_decoder.h
index c46ee71..e17f612 100644
--- a/gr-fec/include/gnuradio/fec/repetition_decoder.h
+++ b/gr-fec/include/gnuradio/fec/repetition_decoder.h
@@ -46,7 +46,7 @@ namespace gr {
       public:
 
         /*!
-         * Build a repetition decoding FECAPI object.
+         * Build a repetition decoding FEC API object.
          *
          * \param frame_size Number of bits per frame. If using in the
          *        tagged stream style, this is the maximum allowable
diff --git a/gr-fec/include/gnuradio/fec/repetition_encoder.h 
b/gr-fec/include/gnuradio/fec/repetition_encoder.h
index 700edb8..313dc64 100644
--- a/gr-fec/include/gnuradio/fec/repetition_encoder.h
+++ b/gr-fec/include/gnuradio/fec/repetition_encoder.h
@@ -46,7 +46,7 @@ namespace gr {
       public:
 
         /*!
-         * Build a repetition encoding FECAPI object.
+         * Build a repetition encoding FEC API object.
          *
          * \param frame_size Number of bits per frame. If using in the
          *        tagged stream style, this is the maximum allowable
@@ -54,8 +54,7 @@ namespace gr {
          * \param rep Repetition rate; encoder rate is rep bits out
          *        for each input bit.
          */
-        static generic_encoder::sptr make(int frame_size,
-                                          int rep);
+        static generic_encoder::sptr make(int frame_size, int rep);
 
         /*!
          * Sets the uncoded frame size to \p frame_size. If \p