dlib C++ Library - entropy_encoder_model_kernel_3.h

    // Copyright (C) 2004  Davis E. King (davisking@users.sourceforge.net)
    // License: Boost Software License   See LICENSE.txt for the full license.
    #ifndef DLIB_ENTROPY_ENCODER_MODEL_KERNEl_3_
    #define DLIB_ENTROPY_ENCODER_MODEL_KERNEl_3_

    #include "../algs.h"
    #include "entropy_encoder_model_kernel_abstract.h"
    #include "../assert.h"

    namespace dlib
    {

        template <
            unsigned long alphabet_size,
            typename entropy_encoder,
            typename cc,
            typename cc_high
            >
        class entropy_encoder_model_kernel_3
        {
            /*!
                REQUIREMENTS ON cc
                    cc is an implementation of conditioning_class/conditioning_class_kernel_abstract.h
                    cc::get_alphabet_size() == alphabet_size+1

                REQUIREMENTS ON cc_high
                    cc_high is an implementation of conditioning_class/conditioning_class_kernel_abstract.h
                    cc_high::get_alphabet_size() == alphabet_size+1

                INITIAL VALUE
                    - Initially this object's finite context model is empty
                    - previous_symbol == 0
                    - previous_symbol2 == 0
                    - order_1 == pointer to an array of alphabet_size elements
                    - order_2 == pointer to an array of alphabet_size*alphabet_size elements
                    - order_2[i] == 0

                CONVENTION
                    &get_entropy_encoder() == coder
                    &order_0.get_global_state() == &gs
                    &order_1[i]->get_global_state() == &gs

                    if (order_2[i] != 0) then
                        &order_2[i]->get_global_state() == &gs_high

                    This is an order-2-1-0 model. The last symbol in the order-2, order-1 and
                    order-0 contexts is an escape into the lower context.

                    previous_symbol == the last symbol seen
                    previous_symbol2 == the symbol we saw before previous_symbol
            !*/

        public:

            typedef entropy_encoder entropy_encoder_type;

            entropy_encoder_model_kernel_3 (
                entropy_encoder& coder
            );

            virtual ~entropy_encoder_model_kernel_3 (
            );

            inline void clear(
            );

            inline void encode (
                unsigned long symbol
            );

            entropy_encoder& get_entropy_encoder (
            ) { return coder; }

            static unsigned long get_alphabet_size (
            ) { return alphabet_size; }

        private:

            entropy_encoder& coder;
            typename cc::global_state_type gs;
            typename cc_high::global_state_type gs_high;
            cc order_0;
            cc** order_1;
            unsigned long previous_symbol;
            cc_high** order_2;
            unsigned long previous_symbol2;

            // restricted functions
            entropy_encoder_model_kernel_3(entropy_encoder_model_kernel_3&);        // copy constructor
            entropy_encoder_model_kernel_3& operator=(entropy_encoder_model_kernel_3&);    // assignment operator

        };

    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------
        // member function definitions
    // ----------------------------------------------------------------------------------------
    // ----------------------------------------------------------------------------------------

        template <
            unsigned long alphabet_size,
            typename entropy_encoder,
            typename cc,
            typename cc_high
            >
        entropy_encoder_model_kernel_3<alphabet_size,entropy_encoder,cc,cc_high>::
        entropy_encoder_model_kernel_3 (
            entropy_encoder& coder_
        ) :
            coder(coder_),
            order_0(gs),
            order_1(0),
            previous_symbol(0),
            order_2(0),
            previous_symbol2(0)
        {
            COMPILE_TIME_ASSERT( 1 < alphabet_size && alphabet_size < 65535 );

            try
            {
                order_1 = new cc*[alphabet_size];
                order_2 = new cc_high*[alphabet_size*alphabet_size];
            }
            catch (...)
            {
                if (order_1) delete [] order_1;
                if (order_2) delete [] order_2;
                throw;
            }

            unsigned long i;

            for (i = 0; i < (alphabet_size*alphabet_size); ++i)
            {
                order_2[i] = 0;
            }

            try
            {
                for (i = 0; i < alphabet_size; ++i)
                {
                    order_1[i] = new cc(gs);
                }
            }
            catch (...)
            {
                for (unsigned long j = 0; j < i; ++j)
                {
                    delete order_1[j];
                }
                throw;
            }
        }

    // ----------------------------------------------------------------------------------------

        template <
            unsigned long alphabet_size,
            typename entropy_encoder,
            typename cc,
            typename cc_high
            >
        entropy_encoder_model_kernel_3<alphabet_size,entropy_encoder,cc,cc_high>::
        ~entropy_encoder_model_kernel_3 (
        )
        {
            for (unsigned long i = 0; i < alphabet_size; ++i)
            {
                delete order_1[i];
            }

            for (unsigned long i = 0; i < alphabet_size*alphabet_size; ++i)
            {
                if (order_2[i] != 0)
                    delete order_2[i];
            }
            delete [] order_1;
            delete [] order_2;
        }

    // ----------------------------------------------------------------------------------------

        template <
            unsigned long alphabet_size,
            typename entropy_encoder,
            typename cc,
            typename cc_high
            >
        void entropy_encoder_model_kernel_3<alphabet_size,entropy_encoder,cc,cc_high>::
        clear(
        )
        {
            previous_symbol = 0;
            previous_symbol2 = 0;
            order_0.clear();
            for (unsigned long i = 0; i < alphabet_size; ++i)
            {
                order_1[i]->clear();
            }

            for (unsigned long i = 0; i < alphabet_size*alphabet_size; ++i)
            {
                if (order_2[i] != 0)
                {
                    delete order_2[i];
                    order_2[i] = 0;
                }
            }
        }

    // ----------------------------------------------------------------------------------------

        template <
            unsigned long alphabet_size,
            typename entropy_encoder,
            typename cc,
            typename cc_high
            >
        void entropy_encoder_model_kernel_3<alphabet_size,entropy_encoder,cc,cc_high>::
        encode (
            unsigned long symbol
        )
        {
            unsigned long low_count = 0, high_count = 0, total_count = 0;

            // order-2 context stuff
            {
                unsigned long temp = previous_symbol + (previous_symbol2 * alphabet_size);
                previous_symbol2 = previous_symbol;

                if (order_2[temp] != 0)
                {
                    if (order_2[temp]->get_range(symbol,low_count,high_count,total_count))
                    {
                        // there was an entry for this symbol in this context

                        // update the count for this symbol
                        order_2[temp]->increment_count(symbol,2);
                        // encode this symbol
                        coder.encode(low_count,high_count,total_count);
                        previous_symbol = symbol;
                        return;
                    }

                    // there was no entry for this symbol in this context so we must
                    // escape to order-1

                    // escape to the order-1 context
                    order_2[temp]->get_range(alphabet_size,low_count,high_count,total_count);
                    coder.encode(low_count,high_count,total_count);

                    // increment the count for the escape symbol
                    order_2[temp]->increment_count(alphabet_size);

                }
                else
                {
                    order_2[temp] = new cc_high(gs_high);

                    // in this case the decoder knows to escape to order-1 because
                    // there was no conditioning_class object in this context yet.
                    // so we don't need to actually write the escape symbol
                }

                // update the count for this symbol in this context
                order_2[temp]->increment_count(symbol,2);
            }

            // order-1 context stuff
            {
                cc& context = *order_1[previous_symbol];

                // if we have seen this symbol in the order-1 context
                if (context.get_range(symbol,low_count,high_count,total_count))
                {
                    // update the count for this symbol
                    context.increment_count(symbol,2);
                    // encode this symbol
                    coder.encode(low_count,high_count,total_count);
                    previous_symbol = symbol;
                    return;
                }

                // we didn't find the symbol in the order-1 context so we must escape to a
                // lower context.

                // escape to the order-0 context
                context.get_range(alphabet_size,low_count,high_count,total_count);
                coder.encode(low_count,high_count,total_count);

                // increment counts for the escape symbol and the current symbol
                context.increment_count(alphabet_size);
                context.increment_count(symbol,2);
            }

            previous_symbol = symbol;

            // if we have seen this symbol in the order-0 context
            if (order_0.get_range(symbol,low_count,high_count,total_count))
            {
                // update the count for this symbol
                order_0.increment_count(symbol,2);
                // encode this symbol
                coder.encode(low_count,high_count,total_count);
                return;
            }

            // if we are here then the symbol does not appear in the order-0 context

            // since we have never seen the current symbol in this context
            // escape from order-0 context
            order_0.get_range(alphabet_size,low_count,high_count,total_count);
            coder.encode(low_count,high_count,total_count);
            // increment the count for the escape symbol
            order_0.increment_count(alphabet_size);

            // update the count for this symbol
            order_0.increment_count(symbol,2);

            // use order minus one context
            coder.encode(symbol,symbol+1,alphabet_size);

        }

    // ----------------------------------------------------------------------------------------

    }

    #endif // DLIB_ENTROPY_ENCODER_MODEL_KERNEl_3_