UseFEC.h

Go to the documentation of this file.

/*******************************************************************************
 *
 * Copyright (c) 2009-2010 Philipp Werner <philipp.werner@st.ovgu.de>
 * All rights reserved.
 *
 *    Redistribution and use in source and binary forms, with or without
 *    modification, are permitted provided that the following conditions
 *    are met:
 *
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the
 *      distribution.
 *
 *    * Neither the name of the copyright holders nor the names of
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 *
 *    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 *    IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 *    TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 *    PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * $Id$
 *
 ******************************************************************************/


#ifndef __USEFEC_H_C5A7E8776574FE__
#define __USEFEC_H_C5A7E8776574FE__


#if !defined(__AVR__)
// Non-AVR version

#include "debug.h"
#include "util/endianness.h"

#include "mw/afp/shared/expandrange_cast.h"
#include "mw/afp/shared/div_round_up.h"

#include <string.h>


namespace famouso {
    namespace mw {
        namespace afp {
            namespace frag {


                namespace vandermonde_fec {
                    extern "C" {
// Forward error correction library (packet erasure code based on vandermonde matrices)
#include "fec.h"
                    }
                }


                template <class FCP>
                class UseFEC {

                        typedef typename FCP::SizeProp::elen_t   elen_t;
                        typedef typename FCP::SizeProp::flen_t   flen_t;
                        typedef typename FCP::SizeProp::fcount_t fcount_t;

                        typedef typename FCP::FECRedundancy Redundancy;
                        typedef typename FCP::Allocator Allocator;


                        elen_t event_length;

                        fcount_t k;

                        fcount_t n;

                        const uint8_t ** nonred_fragments;

                        fcount_t next_fragment_idx;

                        bool smaller_fragment;

                        flen_t payload_length;

                        void * fec_code;

                        struct __attribute__((packed)) Header1001 {
                            uint8_t head;           
                            uint8_t red;            
                            uint32_t k;             
                            uint16_t len_rest;      
                        };

                        uint16_t header_len_rest;


                        static fcount_t get_redundancy_fragment_count(fcount_t k, uint8_t redundancy) {
                            return shared::div_round_up(shared::expandrange_cast(k) * redundancy,
                                                        shared::expandrange_cast((fcount_t)100));
                        }

                    public:

                        enum { header_length = sizeof(Header1001) };


                        static fcount_t k2n(fcount_t k) {
                            return k + get_redundancy_fragment_count(k, Redundancy::value());
                        }

                        UseFEC() :
                                nonred_fragments(0), next_fragment_idx(0),
                                smaller_fragment(false), fec_code(0) {
                        }

                        ~UseFEC() {
                            if (smaller_fragment)
                                Allocator::free(const_cast<uint8_t *>(nonred_fragments[k-1]));
                            if (fec_code)
                                vandermonde_fec::fec_free(fec_code);
                            if (nonred_fragments)
                                Allocator::free_array(nonred_fragments);
                        }

                        void init(elen_t event_length, flen_t payload_length, fcount_t k) {
                            FAMOUSO_ASSERT(payload_length > 0);

                            this->event_length = event_length;
                            this->k = k;
                            this->n = k2n(k);
                            this->payload_length = payload_length;
                            this->nonred_fragments = Allocator::template alloc_array<const uint8_t *>(k);
                            FAMOUSO_ASSERT(nonred_fragments);

                            ::logging::log::emit< ::logging::Info>()
                                << PROGMEMSTRING("AFP: Fragmenter FEC: ")
                                << ::logging::log::dec << (unsigned long)k
                                << PROGMEMSTRING(" data fragments, ")
                                << (unsigned long)(n - k)
                                << PROGMEMSTRING(" redundancy fragments (from ")
                                << (unsigned long)Redundancy::value()
                                << PROGMEMSTRING("% red)")
                                << ::logging::log::endl;

                            // Following is very expensive for big k and n... in case many events with
                            // same k and n are sent, it would be nice to have fec_code sharing (low priority TODO)
                            fec_code = vandermonde_fec::fec_new(k, n);
                            FAMOUSO_ASSERT(fec_code);

                            header_len_rest = htons(((event_length - 1) % payload_length) + 1);
                        }

                        void get_header(uint8_t * data, bool more_headers) {
                            Header1001 * h = reinterpret_cast<Header1001 *>(data);
                            h->head = (more_headers ? 0x40 | 0x29 : 0x29);
                            h->red = Redundancy::value();
                            h->k = htonl(k);
                            h->len_rest = header_len_rest;
                        }


                        void put_nonred_fragment(const uint8_t * data) {
                            FAMOUSO_ASSERT(next_fragment_idx < k);
                            nonred_fragments[next_fragment_idx++] = data;
                        }

                        void put_smaller_nonred_fragment(const uint8_t * data, flen_t length) {
                            FAMOUSO_ASSERT(next_fragment_idx == k - 1);
                            FAMOUSO_ASSERT(length < payload_length);
                            FAMOUSO_ASSERT(event_length % payload_length == length);

                            // Make it same size for encoding library and pad with zero.
                            uint8_t * last_nonred_frag = Allocator::alloc(payload_length);
                            FAMOUSO_ASSERT(nonred_fragments);
                            memcpy(last_nonred_frag, data, length);
                            memset(last_nonred_frag + length, 0, payload_length - length);

                            nonred_fragments[next_fragment_idx++] = last_nonred_frag;
                            smaller_fragment = true;
                        }

                        void get_red_fragment(uint8_t * data) {
                            FAMOUSO_ASSERT(next_fragment_idx < n);

                            vandermonde_fec::fec_encode(fec_code,
                                                        reinterpret_cast<void **>(
                                                            const_cast<uint8_t **>(nonred_fragments)
                                                        ),
                                                        data,
                                                        next_fragment_idx++,
                                                        payload_length);
                        }
                };


            } // namespace frag
        } // namespace afp
    } // namespace mw
} // namespace famouso


#else
// AVR version

#include "assert/staticerror.h"

namespace famouso {
    namespace mw {
        namespace afp {
            namespace frag {
                template <class FCP>
                class UseFEC {
                    FAMOUSO_STATIC_ASSERT_ERROR(false, FEC_not_supported_on_AVR, ());
                };
            } // namespace frag
        } // namespace afp
    } // namespace mw
} // namespace famouso

#endif


#endif // __USEFEC_H_C5A7E8776574FE__