Dirac - A Video Codec

Created by the British Broadcasting Corporation.


arrays.h
Go to the documentation of this file.
1/* ***** BEGIN LICENSE BLOCK *****
2*
3* $Id: arrays.h,v 1.21 2008/03/14 08:17:36 asuraparaju Exp $ $Name: Dirac_1_0_2 $
4*
5* Version: MPL 1.1/GPL 2.0/LGPL 2.1
6*
7* The contents of this file are subject to the Mozilla Public License
8* Version 1.1 (the "License"); you may not use this file except in compliance
9* with the License. You may obtain a copy of the License at
10* http://www.mozilla.org/MPL/
11*
12* Software distributed under the License is distributed on an "AS IS" basis,
13* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
14* the specific language governing rights and limitations under the License.
15*
16* The Original Code is BBC Research and Development code.
17*
18* The Initial Developer of the Original Code is the British Broadcasting
19* Corporation.
20* Portions created by the Initial Developer are Copyright (C) 2004.
21* All Rights Reserved.
22*
23* Contributor(s): Thomas Davies (Original Author),
24* Peter Meerwald (pmeerw@users.sourceforge.net)
25* Mike Ferenduros (mike_ferenzduros@users.sourceforge.net)
26* Anuradha Suraparaju
27*
28* Alternatively, the contents of this file may be used under the terms of
29* the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
30* Public License Version 2.1 (the "LGPL"), in which case the provisions of
31* the GPL or the LGPL are applicable instead of those above. If you wish to
32* allow use of your version of this file only under the terms of the either
33* the GPL or LGPL and not to allow others to use your version of this file
34* under the MPL, indicate your decision by deleting the provisions above
35* and replace them with the notice and other provisions required by the GPL
36* or LGPL. If you do not delete the provisions above, a recipient may use
37* your version of this file under the terms of any one of the MPL, the GPL
38* or the LGPL.
39* ***** END LICENSE BLOCK ***** */
40
41#ifndef _ARRAYS_H_
42#define _ARRAYS_H_
43
44//basic array types used for pictures etc
45
46#include <memory>
47#include <cstddef>
48#include <stdexcept>
49#include <iostream>
50#include <algorithm>
51#include <cstring>
52
53namespace dirac
54{
56
60 class Range
61 {
62 public:
64
67 Range(int s, int e): m_fst(s), m_lst(e){}
68
70 int First() const {return m_fst;}
71
73 int Last() const {return m_lst;}
74
75 private:
77 };
78
80 //One-Dimensional Array type//
82
84
89 template <class T> class OneDArray
90 {
91 public:
93
97
99
102 OneDArray(const int len);
103
105
110 OneDArray(const Range& r);
111
113
117 {
118 FreePtr();
119 }
120
122
126
128
132
134 void Resize(int l);
135
137 T& operator[](const int pos){return m_ptr[pos-m_first];}
138
140 const T& operator[](const int pos) const {return m_ptr[pos-m_first];}
141
143 int Length() const {return m_length;}
144
146 int First() const {return m_first;}
147
149 int Last() const {return m_last;}
150
151 private:
152 void Init(const int len);
153
154 void Init(const Range& r);
155
156 void FreePtr();
157
161 };
162
163 //public member functions//
165
166 template <class T>
168 {
169 Init(0);
170 }
171
172 template <class T>
174 {
175 Init(len);
176 }
177
178 template <class T>
180 {
181 Init(r);
182 }
183
184 template <class T>
186 {
187 m_first = cpy.m_first;
188 m_last = cpy.m_last;
189 m_length = m_last - m_first + 1;
190
191 if (m_first==0)
192 Init(m_length);
193 else
195
196 memcpy( m_ptr , cpy.m_ptr , m_length * sizeof( T ) );
197 }
198
199 template <class T>
201 {
202 if (&rhs != this)
203 {
204 FreePtr();
205 m_first = rhs.m_first;
206 m_last = rhs.m_last;
207 m_length = rhs.m_length;
208
209 if (m_first == 0)
210 Init(m_length);
211 else
213
214 memcpy( m_ptr , rhs.m_ptr , m_length * sizeof( T ) );
215
216 }
217 return *this;
218 }
219
220 template <class T>
222 {
223 if (l != m_length)
224 {
225 FreePtr();
226 Init(l);
227 }
228 }
229
230 //private member functions//
232
233 template <class T>
234 void OneDArray<T>::Init(const int len)
235 {
236 Range r(0 , len-1);
237
238 Init(r);
239
240 }
241
242 template <class T>
244 {
245
246 m_first = r.First();
247 m_last = r.Last();
248 m_length = m_last - m_first + 1;
249
250 if ( m_length>0 )
251 {
252 m_ptr = new T[ m_length ];
253 }
254 else
255 {
256 m_length = 0;
257 m_first = 0;
258 m_last = -1;
259 m_ptr = NULL;
260 }
261 }
262
263 template <class T>
265 {
266 if ( m_length>0 )
267 delete[] m_ptr;
268 }
269
270
272 //Two-Dimensional Array type//
274
276
284 template <class T> class TwoDArray
285 {
286 typedef T* element_type;
287
288 public:
289
291
294 TwoDArray(){ Init(0,0); }
295
297
300 TwoDArray( const int height , const int width ){Init(height , width);}
301
303
307 TwoDArray( const int height , const int width , T val);
308
310
313 virtual ~TwoDArray(){
314 FreeData();
315 }
316
318
322
324
328
330
336 bool CopyContents(TwoDArray<T>& out) const;
337
339
342 void Fill(T val);
343
345 void Resize(const int height, const int width);
346
348
352 inline element_type& operator[](const int pos){return m_array_of_rows[pos];}
353
355
359 inline const element_type& operator[](const int pos) const {return m_array_of_rows[pos];}
360
362 int LengthX() const { return m_length_x; }
363
365 int LengthY() const { return m_length_y; }
366
368 int FirstX() const { return m_first_x; }
369
371 int FirstY() const { return m_first_y; }
372
374 int LastX() const { return m_last_x; }
375
377 int LastY() const { return m_last_y; }
378
379 private:
381 void Init(const int height,const int width);
382
384 void FreeData();
385
388
391
394
396 };
397
398 //public member functions//
400
401 template <class T>
402 TwoDArray<T>::TwoDArray( const int height , const int width , const T val)
403 {
404 Init( height , width );
405 std::fill_n( m_array_of_rows[0], m_length_x*m_length_y, val);
406 }
407
408 template <class T>
410 {
411 m_first_x = Cpy.m_first_x;
412 m_first_y = Cpy.m_first_y;
413 m_last_x = Cpy.m_last_x;
414 m_last_y = Cpy.m_last_y;
415
418
419 if (m_first_x == 0 && m_first_y == 0)
421 else{
422 //based 2D arrays not yet supported
423 }
424
425 memcpy( m_array_of_rows[0] , (Cpy.m_array_of_rows)[0] , m_length_x * m_length_y * sizeof( T ) );
426
427 }
428
429 template <class T>
431 {
432 if (&rhs != this)
433 {
434 FreeData();
435
436 m_first_x = rhs.m_first_x;
437 m_first_y = rhs.m_first_y;
438
439 m_last_x = rhs.m_last_x;
440 m_last_y = rhs.m_last_y;
441
444
445 if (m_first_x == 0 && m_first_y == 0)
447 else
448 {
449 //based 2D arrays not yet supported
450 }
451
452 memcpy( m_array_of_rows[0], (rhs.m_array_of_rows)[0], m_length_x * m_length_y * sizeof( T ) );
453
454 }
455
456 return *this;
457
458 }
459
460 template <class T>
462 {
463 if (&out != this)
464 {
465 int rows = std::min (m_length_y, out.m_length_y);
466 int cols = std::min (m_length_x, out.m_length_x);
467 for (int j = 0; j < rows; ++j)
468 {
469 memcpy( out.m_array_of_rows[j], m_array_of_rows[j], cols * sizeof( T )) ;
470 for (int i = cols; i <out.m_length_x; ++i)
471 out.m_array_of_rows[j][i] = out.m_array_of_rows[j][cols-1];
472 }
473 for (int j = rows; j < out.m_length_y; ++j)
474 {
475 memcpy( out.m_array_of_rows[j], out.m_array_of_rows[rows-1], out.m_length_x * sizeof( T )) ;
476 }
477 }
478 return true;
479 }
480
481 template <class T>
483 {
484 if (m_length_x && m_length_y)
485 std::fill_n( m_array_of_rows[0], m_length_x*m_length_y, val);
486 }
487
488 template <class T>
489 void TwoDArray<T>::Resize(const int height, const int width)
490 {
491 if (height != m_length_y || width != m_length_x)
492 {
493 FreeData();
494 Init(height , width);
495 }
496 }
497
498 //private member functions//
500
501 template <class T>
502 void TwoDArray<T>::Init(const int height , const int width)
503 {
504 m_length_x = width;
505 m_length_y = height;
506 m_first_x = 0;
507 m_first_y = 0;
508
511
512 if (m_length_y>0)
513 {
514 // allocate the array containing ptrs to all the rows
516
517 if ( m_length_x>0 )
518 {
519 // Allocate the whole thing as a single big block
520 m_array_of_rows[0] = new T[ m_length_x * m_length_y ];
521
522 // Point the pointers
523 for (int j=1 ; j<m_length_y ; ++j)
525 }
526 else
527 {
528 m_length_x = 0;
529 m_first_x = 0;
530 m_last_x = -1;
531 }
532 }
533 else
534 {
535 m_length_x = 0;
536 m_length_y = 0;
537 m_first_x = 0;
538 m_first_y = 0;
539 m_last_x = -1;
540 m_last_y = -1;
541 m_array_of_rows = NULL;
542 }
543 }
544
545 template <class T>
547 {
548 if (m_length_y>0)
549 {
550 if (m_length_x>0)
551 {
552 delete[] m_array_of_rows[0];
553 }
554
556 // deallocate the array of rows
557 delete[] m_array_of_rows;
558 }
559 }
560
561 // Related functions
562
564 template <class T >
565 std::ostream & operator<< (std::ostream & stream, TwoDArray<T> & array)
566 {
567 for (int j=0 ; j<array.LengthY() ; ++j)
568 {
569 for (int i=0 ; i<array.LengthX() ; ++i)
570 {
571 stream << array[j][i] << " ";
572 }// i
573 stream << std::endl;
574 }// j
575
576 return stream;
577 }
578
580 template <class T >
581 std::istream & operator>> (std::istream & stream, TwoDArray<T> & array)
582 {
583 for (int j=0 ; j<array.LengthY() ; ++j)
584 {
585 for (int i=0 ; i<array.LengthX() ; ++i)
586 {
587 stream >> array[j][i];
588 }// i
589 }// j
590
591 return stream;
592 }
593
594} //namespace dirac
595#endif
Definition of class SequenceHeaderByteIO.
Definition accessunit_byteio.h:52
std::ostream & operator<<(std::ostream &stream, TwoDArray< T > &array)
A function for extracting array data.
Definition arrays.h:565
std::istream & operator>>(std::istream &stream, TwoDArray< T > &array)
A function for inserting array data.
Definition arrays.h:581
Range type.
Definition arrays.h:61
int First() const
Returns the start of the range.
Definition arrays.h:70
Range(int s, int e)
Constructor.
Definition arrays.h:67
int m_lst
Definition arrays.h:76
int m_fst
Definition arrays.h:76
int Last() const
Returns the end point of the range.
Definition arrays.h:73
~OneDArray()
Destructor.
Definition arrays.h:116
OneDArray< T > & operator=(const OneDArray< T > &rhs)
Assignment=.
Definition arrays.h:200
void FreePtr()
Definition arrays.h:264
int m_first
Definition arrays.h:158
const T & operator[](const int pos) const
Element access.
Definition arrays.h:140
int m_last
Definition arrays.h:158
int m_length
Definition arrays.h:159
int Length() const
Returns the length of the array.
Definition arrays.h:143
int First() const
Returns the index of the first element.
Definition arrays.h:146
void Resize(int l)
Resize the array, throwing away the current data.
Definition arrays.h:221
T * m_ptr
Definition arrays.h:160
int Last() const
Returns the index of the last element.
Definition arrays.h:149
void Init(const int len)
Definition arrays.h:234
T & operator[](const int pos)
Element access.
Definition arrays.h:137
OneDArray()
Default constructor.
Definition arrays.h:167
A template class for two-dimensional arrays.
Definition arrays.h:285
bool CopyContents(TwoDArray< T > &out) const
Copy Contents.
Definition arrays.h:461
int LengthX() const
Returns the width.
Definition arrays.h:362
int LastX() const
Returns the index of the last element of a row.
Definition arrays.h:374
TwoDArray(const int height, const int width)
Constructor.
Definition arrays.h:300
TwoDArray()
Default constructor.
Definition arrays.h:294
TwoDArray< T > & operator=(const TwoDArray< T > &rhs)
Assignment =.
Definition arrays.h:430
int LastY() const
Returns the index of the first element of a column.
Definition arrays.h:377
void Fill(T val)
Fill contents.
Definition arrays.h:482
int m_first_x
Definition arrays.h:386
int m_length_x
Definition arrays.h:392
int FirstX() const
Returns the index of the first element of a row.
Definition arrays.h:368
element_type & operator[](const int pos)
Element access.
Definition arrays.h:352
virtual ~TwoDArray()
Destructor.
Definition arrays.h:313
void FreeData()
Free all the allocated data.
Definition arrays.h:546
const element_type & operator[](const int pos) const
Element access.
Definition arrays.h:359
int LengthY() const
Returns the height.
Definition arrays.h:365
element_type * m_array_of_rows
Definition arrays.h:395
void Resize(const int height, const int width)
Resizes the array, deleting the current data.
Definition arrays.h:489
int m_last_x
Definition arrays.h:389
void Init(const int height, const int width)
Initialise the array.
Definition arrays.h:502
int m_first_y
Definition arrays.h:387
T * element_type
Definition arrays.h:286
TwoDArray(const TwoDArray< T > &Cpy)
Copy constructor.
Definition arrays.h:409
int FirstY() const
Returns the index of the first element of a column.
Definition arrays.h:371
int m_length_y
Definition arrays.h:393
TwoDArray(const int height, const int width, T val)
Constructor.
Definition arrays.h:402
int m_last_y
Definition arrays.h:390
OneDArray< T > & operator=(const OneDArray< T > &rhs)
Assignment=.
Definition arrays.h:200
void FreePtr()
Definition arrays.h:264
void Init(const Range &r)
Definition arrays.h:243
OneDArray(const int len)
'Length' constructor.
Definition arrays.h:173
OneDArray(const OneDArray< T > &cpy)
Copy constructor.
Definition arrays.h:185
void Resize(int l)
Resize the array, throwing away the current data.
Definition arrays.h:221
OneDArray(const Range &r)
Range constructor.
Definition arrays.h:179
void Init(const int len)
Definition arrays.h:234
OneDArray()
Default constructor.
Definition arrays.h:167
MVector * element_type
Definition arrays.h:286

© 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.