pic_io.h

/* ***** BEGIN LICENSE BLOCK *****
*
* $Id: pic_io.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),
*                 Scott Robert Ladd,
*                 Stuart Cunningham,
*                 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 _PIC_IO_H_
#define _PIC_IO_H_

#include <iostream>
#include <fstream>
#include <streambuf>

#include <libdirac_common/common.h>
#include <libdirac_common/frame.h>

namespace dirac
{
    //--------------------------------------//
    //-                                    -//
    //-Uncompressed picture file IO wrapper-//
    //-                                    -//
    //--------------------------------------//

    // Stream classes for writing/reading frames of uncompressed/decoded data
    // to stream. Streams currently supported are Memory based streams and
    // File based streams. These classes need further restructuring. 
    // Anu - 19-11-2004

    // Subclass these to provide functionality for different file formats and 
    // for streaming.




    class StreamPicOutput
    {
        public:

            StreamPicOutput();

            StreamPicOutput( const SeqParams& sp);

            virtual ~StreamPicOutput();

            virtual bool WriteNextFrame(const Frame& myframe);

            SeqParams& GetSeqParams() {return m_sparams;}

        protected:

            SeqParams m_sparams;
            std::ostream* m_op_pic_ptr;

            virtual bool WriteComponent(const PicArray& pic_data, 
                                        const CompSort& cs);
    };

    class MemoryStreamOutput : public StreamPicOutput
    {
        public:
            MemoryStreamOutput();

            ~MemoryStreamOutput();

            void SetSequenceParams ( SeqParams &sparams)
            { m_sparams = sparams; }

            void SetMembufReference (unsigned char *buf, int buf_size);

            bool End() const ;

        protected:
            MemoryStreamOutput(const MemoryStreamOutput&);
            MemoryStreamOutput & operator =(const MemoryStreamOutput&);

        protected:

            class OutputMemoryBuffer : public std::streambuf
            {
            public:
                OutputMemoryBuffer () : 
                m_op_buf(0), 
                m_op_buf_size(0), 
                m_op_idx(0)
                {}


                void SetMembufReference (unsigned char *buffer, int buffer_size)
                {
                    m_op_buf = buffer;
                    m_op_buf_size = buffer_size;
                    m_op_idx = 0;
                }

            protected:
                unsigned char *m_op_buf;
                int m_op_buf_size;
                int m_op_idx;

                virtual int overflow (int c)
                {
                    if ( c != EOF)
                    {
                        if (m_op_idx == m_op_buf_size)
                            return EOF;

                        m_op_buf[m_op_idx] = (char)c;
                        m_op_idx++;
                    }
                    return c;
                }

                virtual std::streamsize xsputn (const char *s, 
                                            std::streamsize num)
                {
                    std::streamsize bytes_left = m_op_buf_size - m_op_idx;
                    std::streamsize bytes_written = bytes_left > num 
                                                        ? num : bytes_left;
                    memcpy (&m_op_buf[m_op_idx], (unsigned char *)s, 
                            bytes_written);
                    m_op_idx += bytes_written;
                    return bytes_written;
                }

            private:
                OutputMemoryBuffer(const OutputMemoryBuffer&);
                OutputMemoryBuffer& operator =(const OutputMemoryBuffer&);
            };

            OutputMemoryBuffer m_membuf;
    };

    class FileStreamOutput : public StreamPicOutput
    {
        public:


            FileStreamOutput (const char* output_name,
              const SeqParams& sp,
              bool write_header_only = false);

            virtual ~FileStreamOutput ();

            virtual bool WritePicHeader();

        protected:

            std::ofstream* m_op_head_ptr;

            virtual bool OpenHeader(const char* output_name);

            virtual bool OpenYUV(const char* output_name);
    };


    class StreamPicInput
    {
        public:

            StreamPicInput();

            StreamPicInput(std::istream *ip_pic_ptr, const SeqParams& sparams);

            virtual ~StreamPicInput();

            virtual void Skip( const int n) = 0;

            void SetPadding(const int xpd, const int ypd);

            virtual bool ReadNextFrame(Frame& myframe);

            const SeqParams& GetSeqParams() const {return m_sparams;}

            bool End() const ;

        protected:

            SeqParams m_sparams;

            std::istream* m_ip_pic_ptr;

            int m_xpad,m_ypad;

            virtual bool ReadComponent(PicArray& pic_data,const CompSort& cs);
    };

    class MemoryStreamInput : public StreamPicInput
    {
        public:
            MemoryStreamInput();

            ~MemoryStreamInput();

            void SetSequenceParams ( SeqParams &sparams)
            { m_sparams = sparams; }


            void SetMembufReference (unsigned char *buf, int buf_size);

            bool End() const ;

            virtual void Skip( const int n);

        protected:
            MemoryStreamInput(const MemoryStreamInput&);
            MemoryStreamInput & operator =(const MemoryStreamInput&);

        protected:
            class InputMemoryBuffer : public std::streambuf
            {
            public:
                InputMemoryBuffer() : m_buffer(0), m_buffer_size(0)
                {
                    setg ((char *)m_buffer, (char *)m_buffer, (char *)m_buffer);
                }

                ~InputMemoryBuffer(){}


                void SetMembufReference (unsigned char *buffer, int buffer_size)
                {
                    m_buffer = buffer;
                    m_buffer_size = buffer_size;

                    setg ((char *)m_buffer, (char *)m_buffer, 
                                (char *)(m_buffer + buffer_size));
                }

            private:
                InputMemoryBuffer (const InputMemoryBuffer& inbuf);
                InputMemoryBuffer& operator = (const InputMemoryBuffer& inbuf);

                unsigned char *m_buffer;
                int m_buffer_size;
            };

            InputMemoryBuffer m_membuf;
    };


    class FileStreamInput : public StreamPicInput
    {
        public:


            FileStreamInput (const char* input_name);

            virtual ~FileStreamInput ();

            virtual bool ReadPicHeader();

            virtual void Skip( const int n);


        protected:
            std::ifstream* m_ip_head_ptr;
    };

} // namespace dirac

#endif

---