# Dirac - A Video Codec

Created by the British Broadcasting Corporation.

# arrays.h

Go to the documentation of this file.

    00001 /* ***** BEGIN LICENSE BLOCK *****
    00002 *
    00003 * $Id: arrays.h,v 1.21 2008/03/14 08:17:36 asuraparaju Exp $ $Name: Dirac_1_0_2 $
    00004 *
    00005 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
    00006 *
    00007 * The contents of this file are subject to the Mozilla Public License
    00008 * Version 1.1 (the "License"); you may not use this file except in compliance
    00009 * with the License. You may obtain a copy of the License at
    00010 * http://www.mozilla.org/MPL/
    00011 *
    00012 * Software distributed under the License is distributed on an "AS IS" basis,
    00013 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
    00014 * the specific language governing rights and limitations under the License.
    00015 *
    00016 * The Original Code is BBC Research and Development code.
    00017 *
    00018 * The Initial Developer of the Original Code is the British Broadcasting
    00019 * Corporation.
    00020 * Portions created by the Initial Developer are Copyright (C) 2004.
    00021 * All Rights Reserved.
    00022 *
    00023 * Contributor(s): Thomas Davies (Original Author),
    00024 *                 Peter Meerwald (pmeerw@users.sourceforge.net)
    00025 *                 Mike Ferenduros (mike_ferenzduros@users.sourceforge.net)
    00026 *                 Anuradha Suraparaju
    00027 *
    00028 * Alternatively, the contents of this file may be used under the terms of
    00029 * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
    00030 * Public License Version 2.1 (the "LGPL"), in which case the provisions of
    00031 * the GPL or the LGPL are applicable instead of those above. If you wish to
    00032 * allow use of your version of this file only under the terms of the either
    00033 * the GPL or LGPL and not to allow others to use your version of this file
    00034 * under the MPL, indicate your decision by deleting the provisions above
    00035 * and replace them with the notice and other provisions required by the GPL
    00036 * or LGPL. If you do not delete the provisions above, a recipient may use
    00037 * your version of this file under the terms of any one of the MPL, the GPL
    00038 * or the LGPL.
    00039 * ***** END LICENSE BLOCK ***** */
    00040
    00041 #ifndef _ARRAYS_H_
    00042 #define _ARRAYS_H_
    00043
    00044 //basic array types used for pictures etc
    00045
    00046 #include <memory>
    00047 #include <cstddef>
    00048 #include <stdexcept>
    00049 #include <iostream>
    00050 #include <algorithm>
    00051 #include <cstring>
    00052
    00053 namespace dirac
    00054 {
    00056
    00060     class Range
    00061     {
    00062     public:
    00064
    00067         Range(int s, int e): m_fst(s), m_lst(e){}
    00068
    00070         int First() const {return m_fst;}
    00071
    00073         int Last() const {return m_lst;}
    00074
    00075     private:
    00076         int m_fst ,m_lst;
    00077     };
    00078
    00080     //One-Dimensional Array type//
    00082
    00084
    00089     template <class T> class OneDArray
    00090     {
    00091     public:
    00093
    00096         OneDArray();
    00097
    00099
    00102         OneDArray(const int len);
    00103
    00105
    00110         OneDArray(const Range& r);
    00111
    00113
    00116         ~OneDArray()
    00117         {
    00118             FreePtr();
    00119         }
    00120
    00122
    00125         OneDArray(const OneDArray<T>& cpy);
    00126
    00128
    00131         OneDArray<T>& operator=(const OneDArray<T>& rhs);
    00132
    00134         void Resize(int l);
    00135
    00137         T& operator[](const int pos){return m_ptr[pos-m_first];}
    00138
    00140         const T& operator[](const int pos) const {return m_ptr[pos-m_first];}
    00141
    00143         int Length() const {return m_length;}
    00144
    00146         int First() const {return m_first;}
    00147
    00149         int Last() const {return m_last;}
    00150
    00151     private:
    00152         void Init(const int len);
    00153
    00154         void Init(const Range& r);
    00155
    00156         void FreePtr();
    00157
    00158         int m_first, m_last;
    00159         int m_length;
    00160         T* m_ptr;
    00161     };
    00162
    00163     //public member functions//
    00165
    00166     template <class T>
    00167     OneDArray<T>::OneDArray()
    00168     {
    00169         Init(0);
    00170     }
    00171
    00172     template <class T>
    00173     OneDArray<T>::OneDArray(const int len)
    00174     {
    00175         Init(len);
    00176     }
    00177
    00178     template <class T>
    00179     OneDArray<T>::OneDArray(const Range& r)
    00180     {
    00181         Init(r);
    00182     }
    00183
    00184     template <class T>
    00185     OneDArray<T>::OneDArray(const OneDArray<T>& cpy)
    00186     {
    00187         m_first = cpy.m_first;
    00188         m_last = cpy.m_last;
    00189         m_length = m_last - m_first + 1;
    00190
    00191         if (m_first==0)
    00192             Init(m_length);
    00193         else
    00194             Init(Range(m_first , m_last));
    00195
    00196         memcpy( m_ptr , cpy.m_ptr , m_length * sizeof( T ) );
    00197     }
    00198
    00199     template <class T>
    00200     OneDArray<T>& OneDArray<T>::operator=(const OneDArray<T>& rhs)
    00201     {
    00202         if (&rhs != this)
    00203         {
    00204             FreePtr();
    00205             m_first = rhs.m_first;
    00206             m_last = rhs.m_last;
    00207             m_length = rhs.m_length;
    00208
    00209             if (m_first == 0)
    00210                 Init(m_length);
    00211             else
    00212                 Init(Range(m_first , m_last));
    00213
    00214             memcpy( m_ptr , rhs.m_ptr , m_length * sizeof( T ) );
    00215
    00216         }
    00217         return *this;
    00218     }
    00219
    00220     template <class T>
    00221     void OneDArray<T>::Resize(int l)
    00222     {
    00223         if (l != m_length)
    00224         {
    00225             FreePtr();
    00226             Init(l);
    00227         }
    00228     }
    00229
    00230     //private member functions//
    00232
    00233     template <class T>
    00234     void OneDArray<T>::Init(const int len)
    00235     {
    00236         Range r(0 , len-1);
    00237
    00238         Init(r);
    00239
    00240     }
    00241
    00242     template <class T>
    00243     void OneDArray<T>::Init(const Range& r)
    00244     {
    00245
    00246         m_first = r.First();
    00247         m_last = r.Last();
    00248         m_length = m_last - m_first + 1;
    00249
    00250         if ( m_length>0 )
    00251         {
    00252             m_ptr = new T[ m_length ];
    00253         }
    00254         else
    00255         {
    00256             m_length = 0;
    00257             m_first = 0;
    00258             m_last = -1;
    00259             m_ptr = NULL;
    00260         }
    00261     }
    00262
    00263     template <class T>
    00264     void OneDArray<T>::FreePtr()
    00265     {
    00266         if ( m_length>0 )
    00267             delete[] m_ptr;
    00268     }
    00269
    00270
    00272     //Two-Dimensional Array type//
    00274
    00276
    00284     template <class T> class TwoDArray
    00285     {
    00286         typedef T* element_type;
    00287
    00288     public:
    00289
    00291
    00294         TwoDArray(){ Init(0,0); }
    00295
    00297
    00300         TwoDArray( const int height , const int width ){Init(height , width);}
    00301
    00303
    00307         TwoDArray( const int height , const int width , T val);
    00308
    00310
    00313         virtual ~TwoDArray(){
    00314             FreeData();
    00315         }
    00316
    00318
    00321         TwoDArray(const TwoDArray<T>& Cpy);
    00322
    00324
    00327         TwoDArray<T>& operator=(const TwoDArray<T>& rhs);
    00328
    00330
    00336         bool CopyContents(TwoDArray<T>& out) const;
    00337
    00339
    00342         void Fill(T val);
    00343
    00345         void Resize(const int height, const int width);
    00346
    00348
    00352         inline element_type& operator[](const int pos){return m_array_of_rows[pos];}
    00353
    00355
    00359         inline const element_type& operator[](const int pos) const {return m_array_of_rows[pos];}
    00360
    00362         int LengthX() const { return m_length_x; }
    00363
    00365         int LengthY() const { return m_length_y; }
    00366
    00368         int FirstX() const { return m_first_x; }
    00369
    00371         int FirstY() const { return m_first_y; }
    00372
    00374         int LastX() const { return m_last_x; }
    00375
    00377         int LastY() const { return m_last_y; }
    00378
    00379     private:
    00381         void Init(const int height,const int width);
    00382
    00384         void FreeData();
    00385
    00386         int m_first_x;
    00387         int m_first_y;
    00388
    00389         int m_last_x;
    00390         int m_last_y;
    00391
    00392         int m_length_x;
    00393         int m_length_y;
    00394
    00395         element_type* m_array_of_rows;
    00396     };
    00397
    00398     //public member functions//
    00400
    00401     template <class T>
    00402     TwoDArray<T>::TwoDArray( const int height , const int width , const T val)
    00403     {
    00404         Init( height , width );
    00405         std::fill_n( m_array_of_rows[0], m_length_x*m_length_y, val);
    00406     }
    00407
    00408     template <class T>
    00409     TwoDArray<T>::TwoDArray(const TwoDArray<T>& Cpy)
    00410     {
    00411         m_first_x = Cpy.m_first_x;
    00412         m_first_y = Cpy.m_first_y;
    00413         m_last_x = Cpy.m_last_x;
    00414         m_last_y = Cpy.m_last_y;
    00415
    00416         m_length_x = m_last_x - m_first_x + 1;
    00417         m_length_y = m_last_y - m_first_y + 1;
    00418
    00419         if (m_first_x == 0 && m_first_y == 0)
    00420             Init(m_length_y , m_length_x);
    00421         else{
    00422                 //based 2D arrays not yet supported
    00423         }
    00424
    00425         memcpy( m_array_of_rows[0] , (Cpy.m_array_of_rows)[0] , m_length_x * m_length_y * sizeof( T ) );
    00426
    00427     }
    00428
    00429     template <class T>
    00430     TwoDArray<T>& TwoDArray<T>::operator=(const TwoDArray<T>& rhs)
    00431     {
    00432         if (&rhs != this)
    00433         {
    00434             FreeData();
    00435
    00436             m_first_x = rhs.m_first_x;
    00437             m_first_y = rhs.m_first_y;
    00438
    00439             m_last_x = rhs.m_last_x;
    00440             m_last_y = rhs.m_last_y;
    00441
    00442             m_length_x = m_last_x - m_first_x + 1;
    00443             m_length_y = m_last_y - m_first_y + 1;
    00444
    00445             if (m_first_x == 0 && m_first_y == 0)
    00446                 Init(m_length_y , m_length_x);
    00447             else
    00448             {
    00449                     //based 2D arrays not yet supported
    00450             }
    00451
    00452             memcpy( m_array_of_rows[0], (rhs.m_array_of_rows)[0], m_length_x * m_length_y * sizeof( T ) );
    00453
    00454         }
    00455
    00456         return *this;
    00457
    00458     }
    00459
    00460     template <class T>
    00461     bool TwoDArray<T>::CopyContents(TwoDArray<T>& out) const
    00462     {
    00463         if (&out != this)
    00464         {
    00465             int rows = std::min (m_length_y, out.m_length_y);
    00466             int cols = std::min (m_length_x, out.m_length_x);
    00467             for (int j = 0; j < rows; ++j)
    00468             {
    00469                 memcpy( out.m_array_of_rows[j], m_array_of_rows[j], cols * sizeof( T )) ;
    00470                 for (int i = cols; i <out.m_length_x; ++i)
    00471                     out.m_array_of_rows[j][i] = out.m_array_of_rows[j][cols-1];
    00472             }
    00473             for (int j = rows; j < out.m_length_y; ++j)
    00474             {
    00475                 memcpy( out.m_array_of_rows[j], out.m_array_of_rows[rows-1], out.m_length_x * sizeof( T )) ;
    00476             }
    00477         }
    00478         return true;
    00479     }
    00480
    00481     template <class T>
    00482     void TwoDArray<T>::Fill( T val)
    00483     {
    00484         if (m_length_x && m_length_y)
    00485             std::fill_n( m_array_of_rows[0], m_length_x*m_length_y, val);
    00486     }
    00487
    00488     template <class T>
    00489     void TwoDArray<T>::Resize(const int height, const int width)
    00490     {
    00491         if (height != m_length_y || width != m_length_x)
    00492         {
    00493             FreeData();
    00494             Init(height , width);
    00495         }
    00496     }
    00497
    00498     //private member functions//
    00500
    00501     template <class T>
    00502     void TwoDArray<T>::Init(const int height , const int width)
    00503     {
    00504         m_length_x = width;
    00505         m_length_y = height;
    00506         m_first_x = 0;
    00507         m_first_y = 0;
    00508
    00509         m_last_x = m_length_x-1;
    00510         m_last_y = m_length_y-1;
    00511
    00512         if (m_length_y>0)
    00513         {
    00514             // allocate the array containing ptrs to all the rows
    00515             m_array_of_rows = new element_type[ m_length_y ];
    00516
    00517             if ( m_length_x>0 )
    00518             {
    00519                 // Allocate the whole thing as a single big block
    00520                 m_array_of_rows[0] = new T[ m_length_x * m_length_y ];
    00521
    00522                 // Point the pointers
    00523                 for (int j=1 ; j<m_length_y ; ++j)
    00524                     m_array_of_rows[j] = m_array_of_rows[0] + j * m_length_x;
    00525             }
    00526             else
    00527             {
    00528                 m_length_x = 0;
    00529                 m_first_x = 0;
    00530                 m_last_x = -1;
    00531             }
    00532         }
    00533         else
    00534         {
    00535             m_length_x = 0;
    00536             m_length_y = 0;
    00537             m_first_x = 0;
    00538             m_first_y = 0;
    00539             m_last_x = -1;
    00540             m_last_y = -1;
    00541             m_array_of_rows = NULL;
    00542         }
    00543     }
    00544
    00545     template <class T>
    00546     void TwoDArray<T>::FreeData()
    00547     {
    00548         if (m_length_y>0)
    00549         {
    00550             if (m_length_x>0)
    00551             {
    00552                 delete[] m_array_of_rows[0];
    00553             }
    00554
    00555             m_length_y = m_length_x = 0;
    00556             // deallocate the array of rows
    00557             delete[] m_array_of_rows;
    00558         }
    00559     }
    00560
    00561     // Related functions
    00562
    00564     template <class T >
    00565     std::ostream & operator<< (std::ostream & stream, TwoDArray<T> & array)
    00566     {
    00567         for (int j=0 ; j<array.LengthY() ; ++j)
    00568         {
    00569             for (int i=0 ; i<array.LengthX() ; ++i)
    00570             {
    00571                 stream << array[j][i] << " ";
    00572             }// i
    00573             stream << std::endl;
    00574         }// j
    00575
    00576         return stream;
    00577     }
    00578
    00580     template <class T >
    00581     std::istream & operator>> (std::istream & stream, TwoDArray<T> & array)
    00582     {
    00583         for (int j=0 ; j<array.LengthY() ; ++j)
    00584         {
    00585             for (int i=0 ; i<array.LengthX() ; ++i)
    00586             {
    00587                 stream >> array[j][i];
    00588             }// i
    00589         }// j
    00590
    00591         return stream;
    00592     }
    00593
    00594 } //namespace dirac
    00595 #endif

© 2004 British Broadcasting Corporation. Dirac code licensed under the Mozilla Public License (MPL) Version 1.1.
HTML documentation generated by Dimitri van Heesch's excellent Doxygen tool.