bit_manager.h

/* ***** BEGIN LICENSE BLOCK *****
*
* $Id: bit_manager.h,v 1.2 2005/01/30 05:11:40 gabest Exp $ $Name:  $
*
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.1 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific language governing rights and limitations under the License.
*
* The Original Code is BBC Research and Development code.
*
* The Initial Developer of the Original Code is the British Broadcasting
* Corporation.
* Portions created by the Initial Developer are Copyright (C) 2004.
* All Rights Reserved.
*
* Contributor(s): Thomas Davies (Original Author),
*                 Robert Scott Ladd,
*                 Tim Borer
*                 Anuradha Suraparaju
*
* Alternatively, the contents of this file may be used under the terms of
* the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
* Public License Version 2.1 (the "LGPL"), in which case the provisions of
* the GPL or the LGPL are applicable instead of those above. If you wish to
* allow use of your version of this file only under the terms of the either
* the GPL or LGPL and not to allow others to use your version of this file
* under the MPL, indicate your decision by deleting the provisions above
* and replace them with the notice and other provisions required by the GPL
* or LGPL. If you do not delete the provisions above, a recipient may use
* your version of this file under the terms of any one of the MPL, the GPL
* or the LGPL.
* ***** END LICENSE BLOCK ***** */

#ifndef _BIT_MANAGER_H_
#define _BIT_MANAGER_H_

#include <libdirac_common/arrays.h>
#include <cstring>
#include <vector>
#include <iostream>

namespace dirac
{
    const unsigned int START_CODE_PREFIX = 0x42424344; //BBCD
    const unsigned int START_CODE_PREFIX_BYTE0 = 
                                        (START_CODE_PREFIX >> 24) & 0xFF;
    const unsigned int START_CODE_PREFIX_BYTE1 = 
                                        (START_CODE_PREFIX >> 16) & 0xFF;
    const unsigned int START_CODE_PREFIX_BYTE2 = 
                                        (START_CODE_PREFIX >>  8) & 0xFF;
    const unsigned int START_CODE_PREFIX_BYTE3 = 
                                        START_CODE_PREFIX & 0xFF;

    const unsigned char RAP_START_CODE = 0xD7;
    const unsigned char IFRAME_START_CODE = 0xD6;
    const unsigned char L1FRAME_START_CODE = 0xD4;
    const unsigned char L2FRAME_START_CODE = 0xD5;
    const unsigned char SEQ_END_CODE = 0xD0;
    const unsigned char NOT_START_CODE = 0xFF;
    const unsigned char BITSTREAM_VERSION = 0x02;  //0.2


    //--------------Bit output stuff--------------//

    class UnitOutputManager;
    class FrameOutputManager;
    class SequenceOutputManager;


    class BasicOutputManager
    {
        // Data cannot be written to file directly, only by other o/p classes
        friend class UnitOutputManager;
        friend class FrameOutputManager;
        friend class SequenceOutputManager;

        public:

            BasicOutputManager(std::ostream* out_data );

            //Copy constructor is default shallow copy

            //Operator= is default shallow=

            ~BasicOutputManager(){}


            void OutputBit(const bool& bit);


            void OutputBit(const bool& bit,int& count);


            void OutputByte(const char& byte);


            void OutputBytes(char* str_array);


            void OutputBytes(char* str_array,int num);


            size_t GetNumBytes() const {return m_num_out_bytes;}


            size_t Size() const {return m_buffer.size();}

        private:
            // Number of output bytes written
            size_t m_num_out_bytes;
            std::ostream* m_op_ptr;
            // Buffer used to store output prior to saving to file
            std::vector<char> m_buffer;
            // Char used for temporary storage of op data bits
            char m_current_byte;
            // Used to set individual bit within the current header byte
            int m_output_mask;

            //functions  


            void WriteToFile();

            //Initialise the output stream.
            void InitOutputStream();

            //Clean out any remaining output bits to the buffer
            void FlushOutput();
            

            void OutputSkipInterpretStartPrefixByte();
    };


    class UnitOutputManager
    {
        // Only the FrameOutputManager can make this class write data to file
        friend class FrameOutputManager;

        public:

            UnitOutputManager(std::ostream* out_data ); 

            //Copy constructor is default shallow copy

            //Operator= is default shallow=

            ~UnitOutputManager(){}


            BasicOutputManager& Header(){return m_header;}


            BasicOutputManager& Data(){return m_data;}


            const size_t GetUnitBytes() const {return m_unit_bytes;}

            const size_t GetUnitHeaderBytes() const {return m_unit_head_bytes;}

        private:
            // basic output managers for the header and data
            BasicOutputManager m_header,m_data;
     
            // total number of bytes written in the last unit coded 
            size_t m_unit_bytes;

            // number of data bytes for the last unit coded
            size_t m_unit_data_bytes;

            // number of data bytes for the last unit coded
            size_t m_unit_head_bytes;

            // functions


            void WriteToFile();
    };

    class FrameOutputManager
    {
    public:

        // Only the SequenceOutputManager can make this class write data to file
        friend class SequenceOutputManager;

        /*
            Constructs a class which manages output for an entire frame.
            \param  out_data  pointer to the output stream 
            \param  num_bands  the number of subbands per component
        */
        FrameOutputManager( std::ostream* out_data , const int num_bands=13 ); 

        ~FrameOutputManager();

        void SetNumBands( const int num_bands );


        UnitOutputManager& BandOutput( const int csort , const int band_num );


        const UnitOutputManager& BandOutput( const int csort , const int band_num ) const;


        UnitOutputManager& MVOutput(){ return *m_mv_data; }


        const UnitOutputManager& MVOutput() const { return *m_mv_data; }

        BasicOutputManager& HeaderOutput(){ return *m_frame_header; }

        const size_t ComponentBytes( const int comp_num ) const { return m_comp_bytes[comp_num];}

        const size_t ComponentHeadBytes( const int comp_num ) const { return m_comp_hdr_bytes[comp_num];}

        const size_t MVBytes() const { return m_mv_bytes;}

        const size_t MVHeadBytes() const { return m_mv_hdr_bytes;}

        const size_t FrameBytes() const { return m_total_bytes;}

        const size_t FrameHeadBytes() const { return m_header_bytes;}

    private:

        // Array of subband outputs, 1 for each component and subband
        TwoDArray< UnitOutputManager* > m_data_array;

        // Motion vector output
        UnitOutputManager* m_mv_data;

        // Frame header output
        BasicOutputManager* m_frame_header;

        // The total number of frame bytes
        size_t m_total_bytes;

        // The total number of header bytes
        size_t m_header_bytes;

        // The total number of MV header bytes
        size_t m_mv_hdr_bytes; 

        // The total number of MV bytes
        size_t m_mv_bytes; 

        // The total number of bytes in each component
        OneDArray< size_t > m_comp_bytes;

        // The total number of header bytes in each component
        OneDArray< size_t > m_comp_hdr_bytes;

        // A copy of a pointer to the output stream
        std::ostream* m_out_stream;

        // Functions

        void Init( const int num_bands );

        void Reset();

        void DeleteAll();

        void WriteToFile();
    };

    class SequenceOutputManager
    {
    public:
        SequenceOutputManager( std::ostream* out_data );

        FrameOutputManager& FrameOutput(){ return m_frame_op_mgr; }

        BasicOutputManager& HeaderOutput(){ return m_seq_header; }

        BasicOutputManager& TrailerOutput(){ return m_seq_end; }

        void ResetFrame(){ m_frame_op_mgr.Reset(); }

        void WriteSeqHeaderToFile();

        void WriteFrameData();

        void WriteSeqTrailerToFile();

        const size_t SequenceBytes() { return m_total_bytes; } 

        const size_t SequenceHeadBytes() { return m_header_bytes; } 

        const size_t MVBytes() { return m_mv_bytes; }

        const size_t ComponentBytes( const int comp_num ) { return m_comp_bytes[comp_num]; }

        void ResetFrameData();


    private:

        // The frame output manager
        FrameOutputManager m_frame_op_mgr;

        // Output manager for the sequence header
        BasicOutputManager m_seq_header;

        // Output manager for the sequence end
        BasicOutputManager m_seq_end;

        // The total number of bytes in each component
        OneDArray< size_t > m_comp_bytes;

        // The total number of header bits in each component
        OneDArray< size_t > m_comp_hdr_bytes;

        // The number of MV header bytes
        size_t m_mv_hdr_bytes;

        // The total number of MV bytes
        size_t m_mv_bytes;

        // The total number of bytes written so far
        size_t m_total_bytes;

        // The total number of header bytes written so far
        size_t m_header_bytes;

        // The total number of trailer bytes written so far
        size_t m_trailer_bytes;
    };

    //--------------Bit input stuff--------------//

    class BitInputManager
    {

        public:

            BitInputManager(std::istream* in_data );

            //Copy constructor is default shallow copy

            //Operator= is default shallow=

            ~BitInputManager(){}

            //input functions
            bool InputBit();

            bool InputBit(int& count);

            bool InputBit(int& count, const int max_count);

            char InputByte();

            void InputBytes(char* cptr,int num);

            void FlushInput();

            bool End() const ;

        private:

            std::istream* m_ip_ptr;
            // Char used for temporary storage of ip bits
            char m_current_byte;     
            // The number of bits left withint the current input byte being decoded
            int m_input_bits_left;

            //used to check if start code is detected
            unsigned int m_shift;
            //functions 
            // Initialise the input stream
            void InitInputStream(); 
    };

} // namespace dirac
#endif

---