Slice.h

/* The copyright in this software is being made available under the BSD
 * License, included below. This software may be subject to other third party
 * and contributor rights, including patent rights, and no such rights are
 * granted under this license.
 *
 * Copyright (c) 2010-2018, ITU/ISO/IEC
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
 *    be used to endorse or promote products derived from this software without
 *    specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
 * THE POSSIBILITY OF SUCH DAMAGE.
 */

/** \file     Slice.h
    \brief    slice header and SPS class (header)
*/

#ifndef __SLICE__
#define __SLICE__

#include <cstring>
#include <list>
#include <map>
#include <vector>
#include "CommonDef.h"
#include "Rom.h"
#include "ChromaFormat.h"
#include "Common.h"

//! \ingroup CommonLib
//! \{
#if JVET_L0266_HMVP
#include "CommonLib/MotionInfo.h"
struct MotionInfo;
#endif


struct Picture;
class Pic;
class TrQuant;
// ====================================================================================================================
// Constants
// ====================================================================================================================
class PreCalcValues;
static const uint32_t REF_PIC_LIST_NUM_IDX=32;

typedef std::list<Picture*> PicList;

// ====================================================================================================================
// Class definition
// ====================================================================================================================

/// Reference Picture Set class
class ReferencePictureSet
{
private:
  int  m_numberOfPictures;
  int  m_numberOfNegativePictures;
  int  m_numberOfPositivePictures;
  int  m_numberOfLongtermPictures;
  int  m_deltaPOC[MAX_NUM_REF_PICS];
  int  m_POC[MAX_NUM_REF_PICS];
  bool m_used[MAX_NUM_REF_PICS];
  bool m_interRPSPrediction;
  int  m_deltaRIdxMinus1;
  int  m_deltaRPS;
  int  m_numRefIdc;
  int  m_refIdc[MAX_NUM_REF_PICS+1];
  bool m_bCheckLTMSB[MAX_NUM_REF_PICS];
  int  m_pocLSBLT[MAX_NUM_REF_PICS];
  int  m_deltaPOCMSBCycleLT[MAX_NUM_REF_PICS];
  bool m_deltaPocMSBPresentFlag[MAX_NUM_REF_PICS];

public:
          ReferencePictureSet();
  virtual ~ReferencePictureSet();
  int     getPocLSBLT(int i) const                     { return m_pocLSBLT[i];               }
  void    setPocLSBLT(int i, int x)                    { m_pocLSBLT[i] = x;                  }
  int     getDeltaPocMSBCycleLT(int i) const           { return m_deltaPOCMSBCycleLT[i];     }
  void    setDeltaPocMSBCycleLT(int i, int x)          { m_deltaPOCMSBCycleLT[i] = x;        }
  bool    getDeltaPocMSBPresentFlag(int i) const       { return m_deltaPocMSBPresentFlag[i]; }
  void    setDeltaPocMSBPresentFlag(int i, bool x)     { m_deltaPocMSBPresentFlag[i] = x;    }
  void    setUsed(int bufferNum, bool used);
  void    setDeltaPOC(int bufferNum, int deltaPOC);
  void    setPOC(int bufferNum, int deltaPOC);
  void    setNumberOfPictures(int numberOfPictures);
  void    setCheckLTMSBPresent(int bufferNum, bool b );
  bool    getCheckLTMSBPresent(int bufferNum) const;

  int     getUsed(int bufferNum) const;
  int     getDeltaPOC(int bufferNum) const;
  int     getPOC(int bufferNum) const;
  int     getNumberOfPictures() const;

  void    setNumberOfNegativePictures(int number)      { m_numberOfNegativePictures = number; }
  int     getNumberOfNegativePictures() const          { return m_numberOfNegativePictures;   }
  void    setNumberOfPositivePictures(int number)      { m_numberOfPositivePictures = number; }
  int     getNumberOfPositivePictures() const          { return m_numberOfPositivePictures;   }
  void    setNumberOfLongtermPictures(int number)      { m_numberOfLongtermPictures = number; }
  int     getNumberOfLongtermPictures() const          { return m_numberOfLongtermPictures;   }

  void    setInterRPSPrediction(bool flag)             { m_interRPSPrediction = flag;         }
  bool    getInterRPSPrediction() const                { return m_interRPSPrediction;         }
  void    setDeltaRIdxMinus1(int x)                    { m_deltaRIdxMinus1 = x;               }
  int     getDeltaRIdxMinus1() const                   { return m_deltaRIdxMinus1;            }
  void    setDeltaRPS(int x)                           { m_deltaRPS = x;                      }
  int     getDeltaRPS() const                          { return m_deltaRPS;                   }
  void    setNumRefIdc(int x)                          { m_numRefIdc = x;                     }
  int     getNumRefIdc() const                         { return m_numRefIdc;                  }

  void    setRefIdc(int bufferNum, int refIdc);
  int     getRefIdc(int bufferNum) const ;

  void    sortDeltaPOC();
  void    printDeltaPOC() const;
};

/// Reference Picture Set set class
class RPSList
{
private:
  std::vector<ReferencePictureSet> m_referencePictureSets;

public:
                                 RPSList()                                            { }
  virtual                        ~RPSList()                                           { }

  void                           create  (int numberOfEntries)                            { m_referencePictureSets.resize(numberOfEntries);         }
  void                           destroy ()                                               { }


  ReferencePictureSet*       getReferencePictureSet(int referencePictureSetNum)       { return &m_referencePictureSets[referencePictureSetNum]; }
  const ReferencePictureSet* getReferencePictureSet(int referencePictureSetNum) const { return &m_referencePictureSets[referencePictureSetNum]; }

  int                            getNumberOfReferencePictureSets() const                  { return int(m_referencePictureSets.size());              }
};

#if HEVC_USE_SCALING_LISTS
/// SCALING_LIST class
class ScalingList
{
public:
             ScalingList();
  virtual    ~ScalingList()                                                 { }
  int*       getScalingListAddress(uint32_t sizeId, uint32_t listId)                    { return &(m_scalingListCoef[sizeId][listId][0]);            } //!< get matrix coefficient
  const int* getScalingListAddress(uint32_t sizeId, uint32_t listId) const              { return &(m_scalingListCoef[sizeId][listId][0]);            } //!< get matrix coefficient
  void       checkPredMode(uint32_t sizeId, uint32_t listId);

  void       setRefMatrixId(uint32_t sizeId, uint32_t listId, uint32_t u)                   { m_refMatrixId[sizeId][listId] = u;                         } //!< set reference matrix ID
  uint32_t       getRefMatrixId(uint32_t sizeId, uint32_t listId) const                     { return m_refMatrixId[sizeId][listId];                      } //!< get reference matrix ID

  const int* getScalingListDefaultAddress(uint32_t sizeId, uint32_t listId);                                                                           //!< get default matrix coefficient
  void       processDefaultMatrix(uint32_t sizeId, uint32_t listId);

  void       setScalingListDC(uint32_t sizeId, uint32_t listId, uint32_t u)                 { m_scalingListDC[sizeId][listId] = u;                       } //!< set DC value
  int        getScalingListDC(uint32_t sizeId, uint32_t listId) const                   { return m_scalingListDC[sizeId][listId];                    } //!< get DC value

  void       setScalingListPredModeFlag(uint32_t sizeId, uint32_t listId, bool bIsDPCM) { m_scalingListPredModeFlagIsDPCM[sizeId][listId] = bIsDPCM; }
  bool       getScalingListPredModeFlag(uint32_t sizeId, uint32_t listId) const         { return m_scalingListPredModeFlagIsDPCM[sizeId][listId];    }

  void       checkDcOfMatrix();
  void       processRefMatrix(uint32_t sizeId, uint32_t listId , uint32_t refListId );
  bool       xParseScalingList(const std::string &fileName);
  void       setDefaultScalingList();
  bool       checkDefaultScalingList();

private:
  void       outputScalingLists(std::ostream &os) const;
  bool             m_scalingListPredModeFlagIsDPCM [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< reference list index
  int              m_scalingListDC                 [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< the DC value of the matrix coefficient for 16x16
  uint32_t             m_refMatrixId                   [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< RefMatrixID
  std::vector<int> m_scalingListCoef               [SCALING_LIST_SIZE_NUM][SCALING_LIST_NUM]; //!< quantization matrix
};
#endif

class ProfileTierLevel
{
  int               m_profileSpace;
  Level::Tier       m_tierFlag;
  Profile::Name     m_profileIdc;