source: SHVCSoftware/branches/SHM-dev/source/Lib/TLibCommon/Debug.cpp @ 1174

Last change on this file since 1174 was 1029, checked in by seregin, 10 years ago

merge with SHM-upgrade branch
File size: 16.7 KB
Line 
1/* The copyright in this software is being made available under the BSD
2 * License, included below. This software may be subject to other third party
3 * and contributor rights, including patent rights, and no such rights are
4 * granted under this license.
5 *
6 * Copyright (c) 2010-2014, ITU/ISO/IEC
7 * All rights reserved.
8 *
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions are met:
11 *
12 *  * Redistributions of source code must retain the above copyright notice,
13 *    this list of conditions and the following disclaimer.
14 *  * Redistributions in binary form must reproduce the above copyright notice,
15 *    this list of conditions and the following disclaimer in the documentation
16 *    and/or other materials provided with the distribution.
17 *  * Neither the name of the ITU/ISO/IEC nor the names of its contributors may
18 *    be used to endorse or promote products derived from this software without
19 *    specific prior written permission.
20 *
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
22 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
25 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
26 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
27 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
28 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
29 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
30 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
31 * THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34/** \file     Debug.cpp
35    \brief    Defines types and objects for environment-variable-based debugging and feature control
36*/
37
38#include "Debug.h"
39#include <algorithm>
40#include <math.h>
41#include "TComDataCU.h"
42#include "TComPic.h"
43#include "TComYuv.h"
44
45static const UInt settingNameWidth  = 66;
46static const UInt settingHelpWidth  = 84;
47static const UInt settingValueWidth = 3;
48
49#ifdef DEBUG_STRING
50// these strings are used to reorder the debug output so that the encoder and decoder match.
51const Char *debug_reorder_data_inter_token[MAX_NUM_COMPONENT+1]
52 = {"Start of channel 0 inter debug\n", "Start of channel 1 inter debug\n", "Start of channel 2 inter debug\n", "End of inter residual debug\n"} ;
53const Char *partSizeToString[NUMBER_OF_PART_SIZES]={"2Nx2N(0)", "2NxN(1)", "Nx2N(2)", "NxN(3)", "2Nx(N/2+3N/2)(4)", "2Nx(3N/2+N/2)(5)", "(N/2+3N/2)x2N(6)", "(3N/2+N/2)x2N(7)"};
54#endif
55
56// --------------------------------------------------------------------------------------------------------------------- //
57
58//EnvVar definition
59
60std::list<std::pair<std::string, std::string> > &EnvVar::getEnvVarList()
61{
62  static std::list<std::pair<std::string, std::string> > varInfoList;
63  return varInfoList;
64}
65
66std::list<EnvVar*> &EnvVar::getEnvVarInUse()
67{
68  static std::list<EnvVar*> varInUseList;
69  return varInUseList;
70}
71
72static inline Void printPair(const std::pair<std::string, std::string> &p)
73{
74  if (p.second=="")
75  {
76    std::cout << "\n" << std::setw(settingNameWidth) << p.first << "\n" << std::endl;
77  }
78  else
79  {
80    std::cout << std::setw(settingNameWidth) << p.first << ":   " << p.second << "\n" << std::endl;
81  }
82}
83
84static inline Void printVal(const EnvVar* env)
85{
86  std::cout << std::setw(settingNameWidth) << env->getName() << " = " << std::setw(settingValueWidth) << env->getInt() << " (string = " << std::setw(15) << env->getString() << ")" << std::endl;
87}
88
89//static inline Bool sameEnvName( const std::pair<std::string, std::string> &a,
90//                                const std::pair<std::string, std::string> &b )
91//{
92//  // only check env name
93//  return (a.first==b.first);
94//}
95
96Void EnvVar::printEnvVar()
97{
98//  getEnvVarList().unique(sameEnvName);
99  if (getEnvVarList().size()!=0)
100  {
101    std::cout << "--- Environment variables:\n" << std::endl;
102    for_each(getEnvVarList().begin(), getEnvVarList().end(), printPair);
103  }
104  std::cout << std::endl;
105}
106
107Void EnvVar::printEnvVarInUse()
108{
109  if (getEnvVarInUse().size()!=0)
110  {
111    std::cout << "RExt Environment variables set as follows: \n" << std::endl;
112    for_each(getEnvVarInUse().begin(), getEnvVarInUse().end(), printVal);
113  }
114  std::cout << std::endl;
115}
116
117EnvVar::EnvVar(const std::string &sName, const std::string &sDefault, const std::string &sHelp) :
118                                                                m_sName(sName),
119                                                                m_sHelp(sHelp),
120                                                                m_sVal(),
121                                                                m_dVal(0),
122                                                                m_iVal(0),
123                                                                m_bSet(false)
124{
125  if (getenv(m_sName.c_str()))
126  {
127    m_sVal = getenv(m_sName.c_str());
128    m_bSet = true;
129    getEnvVarInUse().push_back(this);
130  }
131  else m_sVal = sDefault;
132
133  m_dVal = strtod(m_sVal.c_str(), 0);
134  m_iVal = Int(m_dVal);
135
136  getEnvVarList().push_back( std::pair<std::string, std::string>(m_sName, indentNewLines(lineWrap(splitOnSettings(m_sHelp), settingHelpWidth), (settingNameWidth + 4))) );
137}
138
139
140// --------------------------------------------------------------------------------------------------------------------- //
141
142// Debug environment variables:
143
144EnvVar Debug("-- Debugging","","");
145
146EnvVar DebugOptionList::DebugSBAC             ("DEBUG_SBAC",        "0", "Output debug data from SBAC entropy coder (coefficient data etc.)"                              );
147EnvVar DebugOptionList::DebugRQT              ("DEBUG_RQT",         "0", "Output RQT debug data from entropy coder"                                                       );
148EnvVar DebugOptionList::DebugPred             ("DEBUG_PRED",        "0", "Output prediction debug"                                                                        );
149EnvVar DebugOptionList::ForceLumaMode         ("FORCE_LUMA_MODE",   "0", "Force a particular intra direction for Luma (0-34)"                                             );
150EnvVar DebugOptionList::ForceChromaMode       ("FORCE_CHROMA_MODE", "0", "Force a particular intra direction for chroma (0-5)"                                            );
151
152#ifdef DEBUG_STRING
153EnvVar DebugOptionList::DebugString_Structure ("DEBUG_STRUCTURE",   "0", "Produce output on chosen structure                        bit0=intra, bit1=inter");
154EnvVar DebugOptionList::DebugString_Pred      ("DEBUG_PRED",        "0", "Produce output on prediction data.                        bit0=intra, bit1=inter");
155EnvVar DebugOptionList::DebugString_Resi      ("DEBUG_RESI",        "0", "Produce output on residual data.                          bit0=intra, bit1=inter");
156EnvVar DebugOptionList::DebugString_Reco      ("DEBUG_RECO",        "0", "Produce output on reconstructed data.                     bit0=intra, bit1=inter");
157EnvVar DebugOptionList::DebugString_InvTran   ("DEBUG_INV_QT",      "0", "Produce output on inverse-quantiser and transform stages. bit0=intra, bit1=inter");
158#endif
159
160// --------------------------------------------------------------------------------------------------------------------- //
161
162//macro value printing function
163
164Void printMacroSettings()
165{
166  std::cout << "Non-environment-variable-controlled macros set as follows: \n" << std::endl;
167
168  //------------------------------------------------
169
170  //setting macros
171
172  PRINT_CONSTANT(RExt__DECODER_DEBUG_BIT_STATISTICS,                                settingNameWidth, settingValueWidth);
173  PRINT_CONSTANT(RExt__HIGH_BIT_DEPTH_SUPPORT,                                      settingNameWidth, settingValueWidth);
174  PRINT_CONSTANT(RExt__HIGH_PRECISION_FORWARD_TRANSFORM,                            settingNameWidth, settingValueWidth);
175
176  PRINT_CONSTANT(O0043_BEST_EFFORT_DECODING,                                        settingNameWidth, settingValueWidth);
177
178  PRINT_CONSTANT(RD_TEST_SAO_DISABLE_AT_PICTURE_LEVEL,                              settingNameWidth, settingValueWidth);
179
180  //------------------------------------------------
181
182  std::cout << std::endl;
183}
184
185
186// --------------------------------------------------------------------------------------------------------------------- //
187
188//Debugging
189
190UInt  g_debugCounter  = 0;
191Bool  g_printDebug    = false;
192Void* g_debugAddr     = NULL;
193
194#ifdef DEBUG_ENCODER_SEARCH_BINS
195const UInt debugEncoderSearchBinTargetLine = 0;
196const UInt debugEncoderSearchBinWindow     = 1000000;
197#endif
198
199#ifdef DEBUG_CABAC_BINS
200const UInt debugCabacBinTargetLine = 0;
201const UInt debugCabacBinWindow     = 1000000;
202#endif
203
204Void printSBACCoeffData(  const UInt          lastX,
205                          const UInt          lastY,
206                          const UInt          width,
207                          const UInt          height,
208                          const UInt          chan,
209                          const UInt          absPart,
210                          const UInt          scanIdx,
211                          const TCoeff *const pCoeff,
212                          const Bool          finalEncode
213                        )
214{
215  if (DebugOptionList::DebugSBAC.getInt()!=0 && finalEncode)
216  {
217    std::cout << "Size: " << width << "x" << height << ", Last X/Y: (" << lastX << ", " << lastY << "), absPartIdx: " << absPart << ", scanIdx: " << scanIdx << ", chan: " << chan << std::endl;
218    for (Int i=0; i<width*height; i++)
219    {
220      std::cout << std::setw(3) << pCoeff[i];// + dcVal;
221      if (i%width == width-1) std::cout << std::endl;
222      else                    std::cout << ",";
223    }
224    std::cout << std::endl;
225  }
226}
227
228Void printCbfArray( TComDataCU* pcCU  )
229{
230  const UInt CUSizeInParts = pcCU->getWidth(0)/4;
231  const UInt numValidComp=pcCU->getPic()->getNumberValidComponents();
232  for (UInt ch=0; ch<numValidComp; ch++)
233  {
234    const ComponentID compID=ComponentID(ch);
235    printf("channel: %d\n", ch);
236    for (Int y=0; y<CUSizeInParts; y++)
237    {
238      for (Int x=0; x<CUSizeInParts; x++)
239      {
240        printf(x+1==CUSizeInParts?"%3d\n":"%3d, ", pcCU->getCbf(compID)[g_auiRasterToZscan[y*CUSizeInParts + x]]);
241      }
242    }
243  }
244}
245
246UInt getDecimalWidth(const Double value)
247{
248  return (value == 0) ? 1 : (UInt(floor(log10(fabs(value)))) + ((value < 0) ? 2 : 1));
249                                                               //for the minus sign
250}
251
252UInt getZScanIndex(const UInt x, const UInt y)
253{
254  UInt remainingX = x;
255  UInt remainingY = y;
256  UInt offset     = 0;
257  UInt result     = 0;
258
259  while ((remainingX != 0) || (remainingY != 0))
260  {
261    result |= ((remainingX & 0x1) << offset) | ((remainingY & 0x1) << (offset + 1));
262
263    remainingX >>= 1;
264    remainingY >>= 1;
265    offset      += 2;
266  }
267
268  return result;
269}
270
271
272// --------------------------------------------------------------------------------------------------------------------- //
273
274//String manipulation functions for aligning and wrapping printed text
275
276
277std::string splitOnSettings(const std::string &input)
278{
279  std::string result = input;
280
281  std::string::size_type searchFromPosition = 0;
282
283  while (searchFromPosition < result.length())
284  {
285    //find the " = " that is used to define each setting
286    std::string::size_type equalsPosition = result.find(" = ", searchFromPosition);
287
288    if (equalsPosition == std::string::npos) break;
289
290    //then find the end of the numeric characters
291    std::string::size_type splitPosition = result.find_last_of("1234567890", equalsPosition);
292
293    //then find the last space before the first numeric character...
294    if (splitPosition != std::string::npos) splitPosition = result.find_last_of(' ', splitPosition);
295
296    //...and replace it with a new line
297    if (splitPosition != std::string::npos) result.replace(splitPosition, 1, 1, '\n');
298
299    //start the next search from the end of the " = " string
300    searchFromPosition = (equalsPosition + 3);
301  }
302
303  return result;
304}
305
306
307std::string lineWrap(const std::string &input, const UInt maximumLineLength)
308{
309  if (maximumLineLength == 0) return input;
310  std::string result = input;
311
312  std::string::size_type lineStartPosition = result.find_first_not_of(' '); //don't wrap any leading spaces in the string
313
314  while (lineStartPosition != std::string::npos)
315  {
316    //------------------------------------------------
317
318    const std::string::size_type searchFromPosition = lineStartPosition + maximumLineLength;
319
320    if (searchFromPosition >= result.length()) break;
321
322    //------------------------------------------------
323
324    //first check to see if there is another new line character before the maximum line length
325    //we can't use find for this unfortunately because it doesn't take both a beginning and an end for its search range
326    std::string::size_type nextLineStartPosition = std::string::npos;
327    for (std::string::size_type currentPosition = lineStartPosition; currentPosition <= searchFromPosition; currentPosition++)
328    {
329      if (result[currentPosition] == '\n') { nextLineStartPosition = currentPosition + 1; break; }
330    }
331
332    //------------------------------------------------
333
334    //if there ia another new line character before the maximum line length, we need to start this loop again from that position
335    if (nextLineStartPosition != std::string::npos) lineStartPosition = nextLineStartPosition;
336    else
337    {
338      std::string::size_type spacePosition = std::string::npos;
339
340      //search backwards for the last space character (must use signed Int because lineStartPosition can be 0)
341      for (Int currentPosition = Int(searchFromPosition); currentPosition >= Int(lineStartPosition); currentPosition--)
342      {
343        if (result[currentPosition] == ' ') { spacePosition = currentPosition; break; }
344      }
345
346      //if we didn't find a space searching backwards, we must hyphenate
347      if (spacePosition == std::string::npos)
348      {
349        result.insert(searchFromPosition, "-\n");
350        lineStartPosition = searchFromPosition + 2; //make sure the next search ignores the hyphen
351      }
352      else //if we found a space to split on, replace it with a new line character
353      {
354        result.replace(spacePosition, 1, 1, '\n');
355        lineStartPosition = spacePosition + 1;
356      }
357    }
358
359    //------------------------------------------------
360  }
361
362  return result;
363}
364
365
366std::string indentNewLines(const std::string &input, const UInt indentBy)
367{
368  std::string result = input;
369
370  const std::string indentString(indentBy, ' ');
371  std::string::size_type offset = 0;
372
373  while ((offset = result.find('\n', offset)) != std::string::npos)
374  {
375    if ((++offset) >= result.length()) break; //increment offset so we don't find the same \n again and do no indentation at the end
376    result.insert(offset, indentString);
377  }
378
379  return result;
380}
381
382
383// --------------------------------------------------------------------------------------------------------------------- //
384
385
386Void printBlockToStream( std::ostream &ss, const Char *pLinePrefix, TComYuv &src, const UInt numSubBlocksAcross, const UInt numSubBlocksUp, const UInt defWidth )
387{
388  const UInt numValidComp=src.getNumberValidComponents();
389
390  for (UInt ch=0; ch<numValidComp ; ch++)
391  {
392    const ComponentID compID = ComponentID(ch);
393    const UInt width  = src.getWidth(compID);
394    const UInt height = src.getHeight(compID);
395    const UInt stride = src.getStride(compID);
396    const Pel* blkSrc = src.getAddr(compID);
397    const UInt subBlockWidth=width/numSubBlocksAcross;
398    const UInt subBlockHeight=height/numSubBlocksUp;
399
400    ss << pLinePrefix << " compID: " << compID << "\n";
401    for (UInt y=0; y<height; y++)
402    {
403      if ((y%subBlockHeight)==0 && y!=0)
404        ss << pLinePrefix << '\n';
405
406      ss << pLinePrefix;
407      for (UInt x=0; x<width; x++)
408      {
409        if ((x%subBlockWidth)==0 && x!=0)
410          ss << std::setw(defWidth+2) << "";
411
412        ss << std::setw(defWidth) << blkSrc[y*stride + x] << ' ';
413      }
414      ss << '\n';
415    }
416    ss << pLinePrefix << " --- \n";
417  }
418}
419
420#ifdef DEBUG_STRING
421Int DebugStringGetPredModeMask(PredMode mode)
422{
423  return (mode==MODE_INTRA)?1:2;
424}
425
426Void DebugInterPredResiReco(std::string &sDebug, TComYuv &pred, TComYuv &resi, TComYuv &reco, Int predmode_mask)
427{
428  if (DebugOptionList::DebugString_Pred.getInt()&predmode_mask)
429  {
430    std::stringstream ss(std::stringstream::out);
431    printBlockToStream(ss, "###inter-pred: ", pred);
432    std::string debugTmp;
433    debugTmp=ss.str();
434    sDebug=debugTmp+sDebug;
435  }
436  if (DebugOptionList::DebugString_Resi.getInt()&predmode_mask)
437  {
438    std::stringstream ss(std::stringstream::out);
439    printBlockToStream(ss, "###inter-resi: ", resi);
440    sDebug+=ss.str();
441  }
442  if (DebugOptionList::DebugString_Reco.getInt()&predmode_mask)
443  {
444    std::stringstream ss(std::stringstream::out);
445    printBlockToStream(ss, "###inter-reco: ", reco);
446    sDebug+=ss.str();
447  }
448}
449#endif
Note: See TracBrowser for help on using the repository browser.