/* ***** BEGIN LICENSE BLOCK ***** * * $Id: pic_io.h,v 1.13 2006/04/20 10:41:57 asuraparaju Exp $ $Name: Dirac_0_7_0 $ * * 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 #include #include #include #include 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 for outputting pictures /*! Abstract base class for classes that output frames to stream */ class StreamPicOutput { public: //! Default Constructor StreamPicOutput(); //! Constructor /*! Constructor, takes \param sp the sequence parameters */ StreamPicOutput( const SeqParams& sp); //! virtual Destructor virtual ~StreamPicOutput(); //! Write the next frame to the output virtual bool WriteNextFrame(const Frame& myframe); //! Get the sequence parameters SeqParams& GetSeqParams() {return m_sparams;} protected: //! Sequence parameters SeqParams m_sparams; //! Output stream std::ostream* m_op_pic_ptr; //! Write a component to file virtual bool WriteComponent(const PicArray& pic_data, const CompSort& cs); }; /*! Outputs pictures to a memory buffer */ class MemoryStreamOutput : public StreamPicOutput { public: //! Default Constructor MemoryStreamOutput(); //! Destructor ~MemoryStreamOutput(); //! Set sequence parameters void SetSequenceParams ( SeqParams &sparams) { m_sparams = sparams; } //! Set the memory buffer to write the data to void SetMembufReference (unsigned char *buf, int buf_size); //! Returns true if we're at the end of the input, false otherwise bool End() const ; protected: //! Body-less copy constructor MemoryStreamOutput(const MemoryStreamOutput&); //! Body-less assignment operator MemoryStreamOutput & operator =(const MemoryStreamOutput&); protected: //! local memory buffer class OutputMemoryBuffer : public std::streambuf { public: //! Memory buffer constructor OutputMemoryBuffer () : m_op_buf(0), m_op_buf_size(0), m_op_idx(0) {} //! Set the buffer variables /*! Set the memory buffer variables \param buffer buffer to write data to \param buffer_size size of output buffer */ void SetMembufReference (unsigned char *buffer, int buffer_size) { m_op_buf = buffer; m_op_buf_size = buffer_size; m_op_idx = 0; } protected: //! Memory buffer to write data to unsigned char *m_op_buf; //! Memory buffer size int m_op_buf_size; //! Index of first available byte in buffer int m_op_idx; //! Write Overflow method to write one char at a time 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; } //! xsputn method to write one multiple chars at a time to buffer 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: //! Body-less copy constructor OutputMemoryBuffer(const OutputMemoryBuffer&); //! Body-less assignment operator OutputMemoryBuffer& operator =(const OutputMemoryBuffer&); }; //! Output stream Memory buffer OutputMemoryBuffer m_membuf; }; /*! Outputs pictures to a file */ class FileStreamOutput : public StreamPicOutput { public: //! Constructor /*! Constructor, takes \param output_name the name of the output file \param sp the sequence parameters */ FileStreamOutput (const char* output_name, const SeqParams& sp); //! Destructor virtual ~FileStreamOutput (); protected: //! Open picture's YUV data file for output virtual bool OpenYUV(const char* output_name); }; //! Picture input class /*! Abstract Class for reading picture data from a stream. */ class StreamPicInput { public: //! Default Constructor StreamPicInput(); //! Constructor /*! Constructor, takes \param ip_pic_ptr input stream to read from \param sparams Sequence parameters */ StreamPicInput(std::istream *ip_pic_ptr, const SeqParams& sparams); //! Destructor virtual ~StreamPicInput(); //! Skip n frames of input virtual void Skip( const int n) = 0; //! Set padding values to take into account block and transform sizes void SetPadding(const int xpd, const int ypd); //! Read the next frame from the file virtual bool ReadNextFrame(Frame& myframe); //! Get the sequence parameters SeqParams& GetSeqParams() const {return m_sparams;} //! Returns true if we're at the end of the input, false otherwise bool End() const ; protected: //! Sequence parameters mutable SeqParams m_sparams; //! Input stream std::istream* m_ip_pic_ptr; //!padding values int m_xpad,m_ypad; //! Read a component from the file virtual bool ReadComponent(PicArray& pic_data,const CompSort& cs); }; /*! Class for reading picture data from memory */ class MemoryStreamInput : public StreamPicInput { public: //! Default constructor MemoryStreamInput(); //! Destructor ~MemoryStreamInput(); //! Set the seqence parameters void SetSequenceParams ( SeqParams &sparams) { m_sparams = sparams; } //! Set Memory buffer /*! Set the input memory buffer variables \param buf Input Buffer to read data from \param buf_size Input buffer size */ void SetMembufReference (unsigned char *buf, int buf_size); //! Returns true if we're at the end of the input, false otherwise bool End() const ; //! Skip n frame of input. Unimplemented to this class virtual void Skip( const int n); protected: //! Body-less copy constructor MemoryStreamInput(const MemoryStreamInput&); //! Body-less assignment operator MemoryStreamInput & operator =(const MemoryStreamInput&); protected: //! Class that defines the Input Stream Memory Buffer class InputMemoryBuffer : public std::streambuf { public: //! Constructor InputMemoryBuffer() : m_buffer(0), m_buffer_size(0) { setg ((char *)m_buffer, (char *)m_buffer, (char *)m_buffer); } //! Destructor ~InputMemoryBuffer(){} //! Set Input Memory buffer variables /*! Initialises the input memory buffer vars \param buffer Input memory buffer \param buffer_size Input memory buffer size */ 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: //! Body-less copy constructor InputMemoryBuffer (const InputMemoryBuffer& inbuf); //! Body-less assignment operator InputMemoryBuffer& operator = (const InputMemoryBuffer& inbuf); //! Input memory buffer unsigned char *m_buffer; //! Input memory buffer size int m_buffer_size; }; //! Input stream buffer InputMemoryBuffer m_membuf; }; //! Picture input class /*! Class for reading picture data from a file. */ class FileStreamInput : public StreamPicInput { public: //! Constructor /*! Constructor, takes \param input_name the name of the input picture file \param sparams the sequence parameters */ FileStreamInput (const char* input_name, const SeqParams &sparams); //! Destructor virtual ~FileStreamInput (); //! Skip n frames of input virtual void Skip( const int n); }; } // namespace dirac #endif