libdirac_common/band_vlc.cpp

   1 /* ***** BEGIN LICENSE BLOCK *****
   2 *
   3 * $Id$ $Name$
   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): Anuradha Suraparaju (Original Author)
  24 *
  25 * Alternatively, the contents of this file may be used under the terms of
  26 * the GNU General Public License Version 2 (the "GPL"), or the GNU Lesser
  27 * Public License Version 2.1 (the "LGPL"), in which case the provisions of
  28 * the GPL or the LGPL are applicable instead of those above. If you wish to
  29 * allow use of your version of this file only under the terms of the either
  30 * the GPL or LGPL and not to allow others to use your version of this file
  31 * under the MPL, indicate your decision by deleting the provisions above
  32 * and replace them with the notice and other provisions required by the GPL
  33 * or LGPL. If you do not delete the provisions above, a recipient may use
  34 * your version of this file under the terms of any one of the MPL, the GPL
  35 * or the LGPL.
  36 * ***** END LICENSE BLOCK ***** */
  37
  38 // System includes
  39 #include <sstream>
  40
  41 // Dirac includes
  42 #include <libdirac_common/band_vlc.h>
  43 #include <libdirac_byteio/subband_byteio.h>
  44 #include <libdirac_common/dirac_exception.h>
  45
  46 using namespace dirac;
  47
  48 // Constructor for encoding
  49 BandVLC::BandVLC( SubbandByteIO* subband_byteio,
  50                   const SubbandList& band_list,
  51                   int band_num,
  52                   const bool is_intra) :
  53     m_is_intra(is_intra),
  54     m_bnum(band_num),
  55     m_node(band_list(band_num)),
  56     m_last_qf_idx(m_node.QuantIndex()),
  57     m_byteio(subband_byteio)
  58 {
  59 }
  60
  61 // encoding functions
  62 int BandVLC::Compress(CoeffArray &in_data)
  63 {
  64     DoWorkCode(in_data);
  65     return m_byteio->GetSize();
  66 }
  67
  68 void BandVLC::DoWorkCode(CoeffArray &in_data)
  69 {
  70     const TwoDArray<CodeBlock>& block_list( m_node.GetCodeBlocks() );
  71     // coeff blocks can be skipped only if SpatialPartitioning is
  72     // enabled i.e. more than one code-block per subband
  73     bool code_skip = (block_list.LengthX() > 1 || block_list.LengthY() > 1);
  74
  75     for (int j=block_list.FirstY() ; j<=block_list.LastY() ; ++j)
  76     {
  77         CodeBlock *block = block_list[j];
  78         for (int i=block_list.FirstX() ; i<=block_list.LastX() ; ++i)
  79         {
  80             if (code_skip)
  81                 m_byteio->WriteBit(block[i].Skipped()); // encode skip flag
  82             if ( !block[i].Skipped() )
  83             {
  84                 CodeCoeffBlock( block[i] , in_data );
  85             }
  86             else
  87             {
  88                 ClearBlock (block[i] , in_data);
  89             }
  90         }// i
  91     }// j
  92 }
  93
  94 void BandVLC::CodeCoeffBlock(const CodeBlock& code_block , CoeffArray& in_data)
  95 {
  96     //main coding function, using binarisation
  97
  98     const int xbeg = code_block.Xstart();
  99     const int ybeg = code_block.Ystart();
 100     const int xend = code_block.Xend();
 101     const int yend = code_block.Yend();
 102
 103     const int qf_idx = code_block.QuantIndex();
 104
 105     if ( m_node.UsingMultiQuants() )
 106     {
 107           CodeQuantIndexOffset( qf_idx - m_last_qf_idx);
 108           m_last_qf_idx = qf_idx;
 109     }
 110
 111     m_qf = dirac_quantiser_lists.QuantFactor4( qf_idx );
 112     if (m_is_intra)
 113         m_offset =  dirac_quantiser_lists.IntraQuantOffset4( qf_idx );
 114     else
 115         m_offset =  dirac_quantiser_lists.InterQuantOffset4( qf_idx );
 116
 117     for ( int ypos=ybeg; ypos<yend ;++ypos)
 118     {
 119         for ( int xpos=xbeg; xpos<xend ;++xpos)
 120         {
 121             CodeVal( in_data , xpos , ypos , in_data[ypos][xpos] );
 122         }// xpos
 123     }// ypos
 124
 125 }
 126
 127 void BandVLC::CodeQuantIndexOffset( const int offset )
 128 {
 129     m_byteio->WriteSint(offset);
 130 }
 131
 132 inline void BandVLC::CodeVal( CoeffArray& in_data ,
 133                                 const int xpos ,
 134                                 const int ypos ,
 135                                 const CoeffType val )
 136 {
 137     int qval( std::abs(val) );
 138     qval <<= 2;
 139     qval /= m_qf;
 140     in_data[ypos][xpos] = static_cast<CoeffType>( qval );
 141
 142     // Code the quantised value into the bitstream
 143     if (val < 0)
 144         qval = -qval;
 145     m_byteio->WriteSint(qval);
 146
 147     if (qval)
 148     {
 149         // Reconstruct
 150         in_data[ypos][xpos] *= m_qf;
 151         in_data[ypos][xpos] += m_offset+2;
 152         in_data[ypos][xpos] >>= 2;
 153         if (val < 0)
 154             in_data[ypos][xpos]  = -in_data[ypos][xpos];
 155
 156     }
 157
 158
 159 }
 160
 161 // decoding functions
 162 void BandVLC::Decompress(CoeffArray &out_data, int num_bytes)
 163 {
 164     m_byteio->SetBitsLeft(num_bytes * 8);
 165     DoWorkDecode(out_data);
 166     m_byteio->FlushInputB();
 167 }
 168
 169 void BandVLC::DoWorkDecode(CoeffArray& out_data)
 170 {
 171     const TwoDArray<CodeBlock>& block_list( m_node.GetCodeBlocks() );
 172
 173     // coeff blocks can be skipped only if SpatialPartitioning is
 174     // enabled i.e. more than one code-block per subband
 175     bool decode_skip= (block_list.LengthX() > 1 || block_list.LengthY() > 1);
 176     // Now loop over the blocks and decode
 177     for (int j=block_list.FirstY() ; j<=block_list.LastY() ; ++j)
 178     {
 179         CodeBlock *block = block_list[j];
 180         for (int i=block_list.FirstX() ; i<=block_list.LastX() ; ++i)
 181         {
 182             if (decode_skip)
 183                 block[i].SetSkip( m_byteio->ReadBoolB() );
 184             if ( !block[i].Skipped() )
 185             {
 186                 DecodeCoeffBlock( block[i] , out_data );
 187             }
 188             else
 189             {
 190                 ClearBlock (block[i] , out_data);
 191             }
 192
 193         }// i
 194     }// j
 195 }
 196
 197 void BandVLC::DecodeCoeffBlock(const CodeBlock& code_block , CoeffArray& out_data)
 198 {
 199     const int xbeg = code_block.Xstart();
 200     const int ybeg = code_block.Ystart();
 201     const int xend = code_block.Xend();
 202     const int yend = code_block.Yend();
 203
 204     int qf_idx = m_node.QuantIndex();
 205
 206     if ( m_node.UsingMultiQuants() )
 207     {
 208         qf_idx = m_last_qf_idx+DecodeQuantIndexOffset();
 209         m_last_qf_idx = qf_idx;
 210     }
 211
 212     if (qf_idx > (int)dirac_quantiser_lists.MaxQuantIndex())
 213     {
 214         std::ostringstream errstr;
 215         errstr << "Quantiser index out of range [0.."
 216                << (int)dirac_quantiser_lists.MaxQuantIndex() << "]";
 217         DIRAC_THROW_EXCEPTION(
 218             ERR_UNSUPPORTED_STREAM_DATA,
 219             errstr.str(),
 220             SEVERITY_PICTURE_ERROR);
 221     }
 222
 223     m_qf = dirac_quantiser_lists.QuantFactor4( qf_idx );
 224
 225     if (m_is_intra)
 226         m_offset =  dirac_quantiser_lists.IntraQuantOffset4( qf_idx );
 227     else
 228         m_offset =  dirac_quantiser_lists.InterQuantOffset4( qf_idx );
 229
 230     //Work
 231
 232     for ( int ypos=ybeg; ypos<yend ;++ypos)
 233     {
 234         for ( int xpos=xbeg; xpos<xend ;++xpos)
 235         {
 236             DecodeVal( out_data , xpos , ypos );
 237         }// xpos
 238     }// ypos
 239 }
 240
 241 int BandVLC::DecodeQuantIndexOffset( )
 242 {
 243     return m_byteio->ReadSintB();
 244 }
 245
 246 inline void BandVLC::DecodeVal( CoeffArray& out_data , const int xpos , const int ypos )
 247 {
 248     // Read quantised coefs
 249     int quant_coeff = m_byteio->ReadSintB();
 250     CoeffType& out_pixel = out_data[ypos][xpos];
 251
 252     // Reconstruct
 253     out_pixel = std::abs(quant_coeff);
 254     if ( out_pixel )
 255     {
 256         out_pixel *= m_qf;
 257         out_pixel += m_offset+2;
 258         out_pixel >>= 2;
 259
 260         if ( quant_coeff < 0)
 261             out_pixel = -out_pixel;
 262     }
 263 }
 264
 265 // general purpose functions
 266 void BandVLC::ClearBlock( const CodeBlock& code_block , CoeffArray& coeff_data)
 267 {
 268     for (int j=code_block.Ystart() ; j<code_block.Yend() ; j++)
 269     {
 270         CoeffType *pic = &coeff_data[j][code_block.Xstart()];
 271         memset (pic, 0, (code_block.Xend()-code_block.Xstart())*sizeof(CoeffType));
 272     }// j
 273
 274 }
 275
 276 void BandVLC::SetToVal( const CodeBlock& code_block , CoeffArray& pic_data , const CoeffType val)
 277 {
 278     for (int j=code_block.Ystart() ; j<code_block.Yend() ; j++)
 279     {
 280           for (int i=code_block.Xstart() ; i<code_block.Xend() ; i++)
 281            {
 282             pic_data[j][i] = val;
 283            }// i
 284     }// j
 285 }
 286
 287 //////////////////////////////////////////////////////////////////////////////////
 288 //Finally,special class incorporating prediction for the DC band of intra frames//
 289 //////////////////////////////////////////////////////////////////////////////////
 290
 291 void IntraDCBandVLC::DoWorkCode(CoeffArray& in_data)
 292 {
 293     const TwoDArray<CodeBlock>& block_list( m_node.GetCodeBlocks() );
 294
 295     // Now loop over the blocks and code. Note that DC blocks can't be skipped
 296     for (int j=block_list.FirstY() ; j<=block_list.LastY() ; ++j)
 297     {
 298         for (int i=block_list.FirstX() ; i<=block_list.LastX() ; ++i)
 299         {
 300             CodeCoeffBlock( block_list[j][i] , in_data );
 301         }// i
 302     }// j
 303 }
 304
 305 void IntraDCBandVLC::CodeCoeffBlock( const CodeBlock& code_block , CoeffArray& in_data)
 306 {
 307     // Main coding function, using binarisation
 308     const int xbeg = code_block.Xstart();
 309     const int ybeg = code_block.Ystart();
 310     const int xend = code_block.Xend();
 311     const int yend = code_block.Yend();
 312
 313     CoeffType val;
 314
 315     CoeffType prediction;
 316
 317     const int qf_idx = code_block.QuantIndex();
 318
 319     if ( m_node.UsingMultiQuants() )
 320     {
 321           CodeQuantIndexOffset( qf_idx - m_last_qf_idx);
 322           m_last_qf_idx = qf_idx;
 323     }
 324
 325     m_qf = dirac_quantiser_lists.QuantFactor4( qf_idx );
 326
 327     m_offset =  dirac_quantiser_lists.IntraQuantOffset4( qf_idx );
 328
 329     for ( int ypos=ybeg ; ypos < yend; ++ypos )
 330     {
 331         for (int xpos = xbeg ; xpos < xend; ++xpos )
 332         {
 333             prediction = GetPrediction( in_data , xpos , ypos );
 334             val = in_data[ypos][xpos] - prediction;
 335             CodeVal( in_data , xpos , ypos , val );
 336             in_data[ypos][xpos] += prediction;
 337         }//xpos
 338     }//ypos
 339 }
 340
 341
 342 void IntraDCBandVLC::DoWorkDecode(CoeffArray& out_data)
 343 {
 344     const TwoDArray<CodeBlock>& block_list( m_node.GetCodeBlocks() );
 345
 346     // coeff blocks can be skipped only if SpatialPartitioning is
 347     // enabled i.e. more than one code-block per subband
 348     bool decode_skip= (block_list.LengthX() > 1 || block_list.LengthY() > 1);
 349
 350     // Now loop over the blocks and decode
 351     for (int j=block_list.FirstY() ; j<=block_list.LastY() ; ++j)
 352     {
 353         for (int i=block_list.FirstX() ; i<=block_list.LastX() ; ++i)
 354         {
 355             if (decode_skip)
 356                 block_list[j][i].SetSkip( m_byteio->ReadBoolB() );
 357
 358             if ( !block_list[j][i].Skipped() )
 359                 DecodeCoeffBlock( block_list[j][i] , out_data );
 360             else
 361                 ClearBlock( block_list[j][i] , out_data);
 362
 363             DCPrediction( block_list[j][i], out_data);
 364         }// i
 365     }// j
 366 }
 367
 368 void IntraDCBandVLC::DecodeCoeffBlock( const CodeBlock& code_block , CoeffArray& out_data)
 369 {
 370     const int xbeg = code_block.Xstart();
 371     const int ybeg = code_block.Ystart();
 372     const int xend = code_block.Xend();
 373     const int yend = code_block.Yend();
 374
 375     int qf_idx = m_node.QuantIndex();
 376
 377     if ( m_node.UsingMultiQuants() )
 378     {
 379         qf_idx = DecodeQuantIndexOffset()+m_last_qf_idx;
 380         m_last_qf_idx = qf_idx;
 381     }
 382
 383     m_qf = dirac_quantiser_lists.QuantFactor4( qf_idx );
 384
 385     m_offset =  dirac_quantiser_lists.IntraQuantOffset4( qf_idx );
 386
 387     //Work
 388
 389     for ( int ypos=ybeg ; ypos<yend ; ++ypos)
 390     {
 391         for ( int xpos=xbeg ; xpos<xend ; ++xpos)
 392         {
 393             DecodeVal( out_data , xpos , ypos );
 394         }//xpos
 395     }//ypos
 396 }
 397
 398 void IntraDCBandVLC::DCPrediction( const CodeBlock& code_block , CoeffArray& out_data)
 399 {
 400     const int xbeg = code_block.Xstart();
 401     const int ybeg = code_block.Ystart();
 402     const int xend = code_block.Xend();
 403     const int yend = code_block.Yend();
 404
 405     for ( int ypos=ybeg ; ypos<yend ; ++ypos)
 406     {
 407         for ( int xpos=xbeg ; xpos<xend ; ++xpos)
 408         {
 409             out_data[ypos][xpos] += GetPrediction( out_data , xpos , ypos );
 410         }//xpos
 411     }//ypos
 412 }
 413
 414
 415 CoeffType IntraDCBandVLC::GetPrediction( const CoeffArray& data , const int xpos , const int ypos ) const
 416 {
 417     /* NB, 4.5.3 integer division
 418      * numbers are rounded down towards -ve infinity, differing from
 419      * C's convention that rounds towards 0
 420      */
 421
 422     if (ypos!=0)
 423     {
 424         if (xpos!=0)
 425         {
 426             int sum = data[ypos][xpos-1] + data[ypos-1][xpos-1] + data[ypos-1][xpos] + 3/2;
 427             if (sum<0)
 428                 return (sum-2)/3;
 429             else
 430                 return sum/3;
 431         }
 432         else
 433             return data[ypos - 1][0];
 434     }
 435     else
 436     {
 437         if(xpos!=0)
 438             return data[0][xpos - 1];
 439         else
 440             return 0;
 441     }
 442 }