EXPERIMENT.h

Go to the documentation of this file.

/* Copyright (C) 2000 KOM/Darmstadt University of Technology
 *
 * You are allowed to use all other parts of the code under the following terms:
 *
 * For non-commercial use, code may be used in unmodified form provided
 * that this copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * This software is provided "as is" and without any express or implied
 * warranties, including, without limitation, the implied warranty of
 * fitness for a particular purpose.
 *
 * The code may be subjected to the GNU General Public License, Version 2,
 * and re-distributed under the terms of this license.
 * As a special exception, permission is granted to link this code
 * with the Qt library and distribute executables, as long as you
 * follow the requirements of the GNU GPL in regard to all of the
 * software in the executable aside from Qt.
 *
 * Commercial use other than under the terms of the GNU General Public
 * License is allowed only after express negotiation of conditions
 * with the authors.
 */
#ifndef EXPERIMENT_H
#define EXPERIMENT_H

#define NO_MN
#ifdef NO_MN
#ifdef linux
typedef unsigned long u_int64;
#endif
typedef unsigned int  u_int32;
typedef unsigned int  u_int32_t;
typedef int           stream_event_t;
#define EV_OK 0
#define EV_EOF -1
#define EV_ERROR -2
#define RTPCODEC_READ_ERROR -3
#define OPTIONAL
#endif

class PlainPacket;

class MNRTPCodecH261
{
    struct GOB
    {
        int            _head_drop;
        int            _tail_drop;
        unsigned char* _buf;
        int            _size;
        int            _number;
        bool           _picture;
        int            _tempref;
        GOB*           _next;

        GOB( int head_drop )
        {
            _head_drop = head_drop;
            _tail_drop = 0;
            _buf       = new unsigned char[4096];
            _size      = 0;
            _number    = 0;
            _next      = NULL;
            _picture   = false;
            _tempref   = 0;
        }

        ~GOB()
        {
            delete [] _buf;
        }

        inline int size() const { return _size; }
        inline int max() const { return 4096; }
        inline void add( int byte )
        {
            _buf[_size] = byte;
            _size++;
        }

        inline int getTempRef() const { return _tempref; }

        void checkPicture( );
        bool isPicture( );

        inline int copy(char* dest)
        {
            memcpy(dest,_buf,_size);
            return _size;
        }

        void fillHeader( char* buffer );
    };

    struct Frame
    {
        int  timestamp;
        GOB* head;
        GOB* tail;

        Frame()
        {
            timestamp = 0;
            head      = NULL;
            tail      = NULL;
        }

        void append( GOB* g )
        {
            assert( head != tail ); // not intended for picture headers
            tail->_next = g;
            tail = g;
        }

        void set_picture_header( GOB* g, int tempref )
        {
            timestamp = g->getTempRef();
            head      = g;
            tail      = g;
        }

        void drop_head()
        {
            if ( head == tail )
            {
                delete head;
                head = tail = NULL;
            }
            else
            {
                GOB* t = head;
                head = head->_next;
                delete t;
            }
        }
    };

    class Movie
    {
        Frame* _current;
        Frame* _next;

    public:
        Movie()
        {
            _current = NULL;
            _next    = NULL;
        }

        bool first() const
        {
            return ( _current == NULL );
        }

        void setFrame( Frame* f )
        {
            if ( _current == NULL ) _current = f;
            else _next = f;
        }

        bool needData() const
        {
            return ( _next == NULL );
        }

        void addToCurrent( GOB* g )
        {
            assert( _current );
            _current->append(g);
        }

        int hasMoreData() const
        {
            return ( _next != NULL );
        }

        int nextGopSize() const
        {
            return _current->head->size();
        }

        inline void fillHeader( char* buffer )
        {
            _current->head->fillHeader( buffer );
        }

        int copyGop(char* dest)
        {
            int size = _current->head->copy(dest);
            _current->drop_head();
            if ( _current->head == NULL )
            {
                delete _current;
                _current = _next;
                _next    = NULL;
            }
            return size;
        }
    };

    Movie        _movie;

    bool         _ok;
    bool         _first;
    int          _last_tail_drop;
    unsigned int _last_gob_marker;
    int          _last_temp_ref;
    unsigned int _bb;

    PlainPacket* _file;

    void callInitializer( int fd );

    void fillHeader( char* buffer,
                     int   previous_head_drop,
                     int   tail_drop,
                     int   gob_number );
    void getGobInfo( char* buffer,
                     int   head_drop,
                     int*  gob_number );
    void updateTimeRef( int newTimeRef );
    int  currentTimeRef( );

public:
    MNRTPCodecH261();

    virtual ~MNRTPCodecH261();

    bool ok() const;

    int get();

    int startCode( int& head_drop );

    /*
     * fillBuffer gives us exactly one GOB
     */
    int  initFirst( );

    int  fillBuffer( GOB* g );
    int  fillBuffer( char* buffer, int max,
                     int* head_drop, int* tail_drop );

    int fillPacket( int fd, char* buffer, int max );

    virtual u_int32_t      get_std_bw(int fd) { return 1000; }
    virtual u_int32_t      get_std_packetsize(int fd) { return 1400; }
    virtual struct timeval get_std_timeout(int fd);

    virtual int get_data( int             fd,
                          u_int64         maxlength,
                          char*           buffer,
                          u_int64*        fpos,
                          int*            marker,
                          int*            ts,
                          struct timeval* codec_next_timeout,
                          bool            seekable,
                          stream_event_t* except,
                          int             packetsize,
                          u_int32         time_offset,
                          u_int32         ts_offset );

    /* standard write functions */
    virtual int write_next_data(int fd, char* buffer, int len) { return -1; }
    int         write_blank(int fd, u_int32 blank_size) { return -1; }
};

#endif /* EXPERIMENT_H */

---