[x265] [PATCH] Merged TEncCfg into Encoder. A few VUI tweaks and fixes
dave
dtyx265 at gmail.com
Wed Mar 5 01:49:54 CET 2014
On 03/04/2014 09:55 AM, Steve Borho wrote:
> On Mon, Mar 3, 2014 at 4:27 PM, <dtyx265 at gmail.com> wrote:
>> # HG changeset patch
>> # User David T Yuen <dtyx265 at gmail.com>
>> # Date 1393885474 28800
>> # Node ID 56fa912d6e7c1d53cd4f677d4afa9580af067ab5
>> # Parent 6662df480e39c83ab138d831f883d11fc5b052c5
>> Merged TEncCfg into Encoder. A few VUI tweaks and fixes.
> I'm planning to push the patch with a few fixups.
>
> Some comments inlined below, some follow-up cleanups would be greatly
> appreciated.
>
>> diff -r 6662df480e39 -r 56fa912d6e7c source/Lib/TLibCommon/TComPic.cpp
>> --- a/source/Lib/TLibCommon/TComPic.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/Lib/TLibCommon/TComPic.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -38,7 +38,6 @@
>> #include "TComPic.h"
>> #include "SEI.h"
>> #include "mv.h"
>> -#include "TLibEncoder/TEncCfg.h"
>>
>> using namespace x265;
>>
>> @@ -86,13 +85,13 @@
>> TComPic::~TComPic()
>> {}
>>
>> -bool TComPic::create(TEncCfg* cfg)
>> +bool TComPic::create(Encoder* cfg)
>> {
>> /* store conformance window parameters with picture */
>> m_conformanceWindow = cfg->m_conformanceWindow;
>>
>> /* store display window parameters with picture */
>> - m_defaultDisplayWindow = cfg->getDefaultDisplayWindow();
>> + m_defaultDisplayWindow = cfg->m_defaultDisplayWindow;
>>
>> m_picSym = new TComPicSym;
>> m_origPicYuv = new TComPicYuv;
>> @@ -101,18 +100,18 @@
>> return false;
>>
>> bool ok = true;
>> - ok &= m_picSym->create(cfg->param.sourceWidth, cfg->param.sourceHeight, cfg->param.internalCsp, g_maxCUWidth, g_maxCUHeight, g_maxCUDepth);
>> - ok &= m_origPicYuv->create(cfg->param.sourceWidth, cfg->param.sourceHeight, cfg->param.internalCsp, g_maxCUWidth, g_maxCUHeight, g_maxCUDepth);
>> - ok &= m_reconPicYuv->create(cfg->param.sourceWidth, cfg->param.sourceHeight, cfg->param.internalCsp, g_maxCUWidth, g_maxCUHeight, g_maxCUDepth);
>> - ok &= m_lowres.create(m_origPicYuv, cfg->param.bframes, !!cfg->param.rc.aqMode);
>> + ok &= m_picSym->create(cfg->param->sourceWidth, cfg->param->sourceHeight, cfg->param->internalCsp, g_maxCUWidth, g_maxCUHeight, g_maxCUDepth);
>> + ok &= m_origPicYuv->create(cfg->param->sourceWidth, cfg->param->sourceHeight, cfg->param->internalCsp, g_maxCUWidth, g_maxCUHeight, g_maxCUDepth);
>> + ok &= m_reconPicYuv->create(cfg->param->sourceWidth, cfg->param->sourceHeight, cfg->param->internalCsp, g_maxCUWidth, g_maxCUHeight, g_maxCUDepth);
>> + ok &= m_lowres.create(m_origPicYuv, cfg->param->bframes, !!cfg->param->rc.aqMode);
>>
>> - bool isVbv = cfg->param.rc.vbvBufferSize > 0 && cfg->param.rc.vbvMaxBitrate > 0;
>> - if (ok && (isVbv || cfg->param.rc.aqMode))
>> + bool isVbv = cfg->param->rc.vbvBufferSize > 0 && cfg->param->rc.vbvMaxBitrate > 0;
>> + if (ok && (isVbv || cfg->param->rc.aqMode))
>> {
>> int numRows = m_picSym->getFrameHeightInCU();
>> int numCols = m_picSym->getFrameWidthInCU();
>>
>> - if (cfg->param.rc.aqMode)
>> + if (cfg->param->rc.aqMode)
>> CHECKED_MALLOC(m_qpaAq, double, numRows);
>> if (isVbv)
>> {
>> @@ -135,9 +134,9 @@
>> return ok;
>> }
>>
>> -void TComPic::reInit(TEncCfg* cfg)
>> +void TComPic::reInit(Encoder* cfg)
>> {
>> - if (cfg->param.rc.vbvBufferSize > 0 && cfg->param.rc.vbvMaxBitrate > 0)
>> + if (cfg->param->rc.vbvBufferSize > 0 && cfg->param->rc.vbvMaxBitrate > 0)
>> {
>> int numRows = m_picSym->getFrameHeightInCU();
>> int numCols = m_picSym->getFrameWidthInCU();
>> @@ -150,7 +149,7 @@
>> memset(m_cuCostsForVbv, 0, numRows * numCols * sizeof(uint32_t));
>> memset(m_qpaRc, 0, numRows * sizeof(double));
>> }
>> - if (cfg->param.rc.aqMode)
>> + if (cfg->param->rc.aqMode)
>> memset(m_qpaAq, 0, m_picSym->getFrameHeightInCU() * sizeof(double));
>> }
>>
>> diff -r 6662df480e39 -r 56fa912d6e7c source/Lib/TLibCommon/TComPic.h
>> --- a/source/Lib/TLibCommon/TComPic.h Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/Lib/TLibCommon/TComPic.h Mon Mar 03 14:24:34 2014 -0800
>> @@ -45,11 +45,12 @@
>> #include "lowres.h"
>> #include "threading.h"
>> #include "md5.h"
>> +#include "../../source/encoder/encoder.h"
> You could just include "encoder.h" here, the relative paths are
> unnecessary. However, since Encoder is forward decl'd below, there's
> no need to include it here anyway. So I've added the include to
> TComPic.cpp
no problem here.
>> namespace x265 {
>> // private namespace
>>
>> -class TEncCfg;
>> +class Encoder;
>>
>> //! \ingroup TLibCommon
>> //! \{
>> @@ -118,9 +119,9 @@
>> TComPic();
>> virtual ~TComPic();
>>
>> - bool create(TEncCfg* cfg);
>> + bool create(Encoder* cfg);
>> virtual void destroy(int bframes);
>> - void reInit(TEncCfg* cfg);
>> + void reInit(Encoder* cfg);
>>
>> bool getUsedByCurr() { return m_bUsedByCurr; }
>>
>> diff -r 6662df480e39 -r 56fa912d6e7c source/Lib/TLibCommon/TComSlice.cpp
>> --- a/source/Lib/TLibCommon/TComSlice.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/Lib/TLibCommon/TComSlice.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -613,12 +613,9 @@
>> timingInfo->setTimeScale(fpsNum);
>>
>> bool rateCnt = (bitRate > 0);
>> - hrd->setNalHrdParametersPresentFlag(rateCnt);
>> hrd->setVclHrdParametersPresentFlag(rateCnt);
>>
>> - hrd->setSubPicCpbParamsPresentFlag((numDU > 1));
>> -
>> - if (hrd->getSubPicCpbParamsPresentFlag())
>> + if (hrd->getSubPicHrdParamsPresentFlag())
>> {
>> hrd->setTickDivisorMinus2(100 - 2);
>> hrd->setDuCpbRemovalDelayLengthMinus1(7); // 8-bit precision ( plus 1 for last DU in AU )
>> diff -r 6662df480e39 -r 56fa912d6e7c source/Lib/TLibCommon/TComSlice.h
>> --- a/source/Lib/TLibCommon/TComSlice.h Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/Lib/TLibCommon/TComSlice.h Mon Mar 03 14:24:34 2014 -0800
>> @@ -298,7 +298,7 @@
>>
>> bool m_nalHrdParametersPresentFlag;
>> bool m_vclHrdParametersPresentFlag;
>> - bool m_subPicCpbParamsPresentFlag;
>> + bool m_subPicHrdParamsPresentFlag;
>> uint32_t m_tickDivisorMinus2;
>> uint32_t m_duCpbRemovalDelayLengthMinus1;
>> bool m_subPicCpbParamsInPicTimingSEIFlag;
>> @@ -316,7 +316,7 @@
>> TComHRD()
>> : m_nalHrdParametersPresentFlag(0)
>> , m_vclHrdParametersPresentFlag(0)
>> - , m_subPicCpbParamsPresentFlag(false)
>> + , m_subPicHrdParamsPresentFlag(false)
>> , m_tickDivisorMinus2(0)
>> , m_duCpbRemovalDelayLengthMinus1(0)
>> , m_subPicCpbParamsInPicTimingSEIFlag(false)
>> @@ -338,9 +338,9 @@
>>
>> bool getVclHrdParametersPresentFlag() { return m_vclHrdParametersPresentFlag; }
>>
>> - void setSubPicCpbParamsPresentFlag(bool flag) { m_subPicCpbParamsPresentFlag = flag; }
>> + void setSubPicHrdParamsPresentFlag(bool flag) { m_subPicHrdParamsPresentFlag = flag; }
>>
>> - bool getSubPicCpbParamsPresentFlag() { return m_subPicCpbParamsPresentFlag; }
>> + bool getSubPicHrdParamsPresentFlag() { return m_subPicHrdParamsPresentFlag; }
>>
>> void setTickDivisorMinus2(uint32_t value) { m_tickDivisorMinus2 = value; }
>>
>> diff -r 6662df480e39 -r 56fa912d6e7c source/Lib/TLibEncoder/SEIwrite.cpp
>> --- a/source/Lib/TLibEncoder/SEIwrite.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/Lib/TLibEncoder/SEIwrite.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -295,7 +295,7 @@
>> TComHRD *hrd = vui->getHrdParameters();
>>
>> WRITE_UVLC(sei.m_bpSeqParameterSetId, "bp_seq_parameter_set_id");
>> - if (!hrd->getSubPicCpbParamsPresentFlag())
>> + if (!hrd->getSubPicHrdParamsPresentFlag())
>> {
>> WRITE_FLAG(sei.m_rapCpbParamsPresentFlag, "rap_cpb_params_present_flag");
>> }
>> @@ -315,7 +315,7 @@
>> {
>> WRITE_CODE(sei.m_initialCpbRemovalDelay[i][nalOrVcl], (hrd->getInitialCpbRemovalDelayLengthMinus1() + 1), "initial_cpb_removal_delay");
>> WRITE_CODE(sei.m_initialCpbRemovalDelayOffset[i][nalOrVcl], (hrd->getInitialCpbRemovalDelayLengthMinus1() + 1), "initial_cpb_removal_delay_offset");
>> - if (hrd->getSubPicCpbParamsPresentFlag() || sei.m_rapCpbParamsPresentFlag)
>> + if (hrd->getSubPicHrdParamsPresentFlag() || sei.m_rapCpbParamsPresentFlag)
>> {
>> WRITE_CODE(sei.m_initialAltCpbRemovalDelay[i][nalOrVcl], (hrd->getInitialCpbRemovalDelayLengthMinus1() + 1), "initial_alt_cpb_removal_delay");
>> WRITE_CODE(sei.m_initialAltCpbRemovalDelayOffset[i][nalOrVcl], (hrd->getInitialCpbRemovalDelayLengthMinus1() + 1), "initial_alt_cpb_removal_delay_offset");
>> @@ -344,11 +344,11 @@
>> {
>> WRITE_CODE(sei.m_auCpbRemovalDelay - 1, (hrd->getCpbRemovalDelayLengthMinus1() + 1), "au_cpb_removal_delay_minus1");
>> WRITE_CODE(sei.m_picDpbOutputDelay, (hrd->getDpbOutputDelayLengthMinus1() + 1), "pic_dpb_output_delay");
>> - if (hrd->getSubPicCpbParamsPresentFlag())
>> + if (hrd->getSubPicHrdParamsPresentFlag())
>> {
>> WRITE_CODE(sei.m_picDpbOutputDuDelay, hrd->getDpbOutputDelayDuLengthMinus1() + 1, "pic_dpb_output_du_delay");
>> }
>> - if (hrd->getSubPicCpbParamsPresentFlag() && hrd->getSubPicCpbParamsInPicTimingSEIFlag())
>> + if (hrd->getSubPicHrdParamsPresentFlag() && hrd->getSubPicCpbParamsInPicTimingSEIFlag())
>> {
>> WRITE_UVLC(sei.m_numDecodingUnitsMinus1, "num_decoding_units_minus1");
>> WRITE_FLAG(sei.m_duCommonCpbRemovalDelayFlag, "du_common_cpb_removal_delay_flag");
>> diff -r 6662df480e39 -r 56fa912d6e7c source/Lib/TLibEncoder/TEncCfg.h
>> --- a/source/Lib/TLibEncoder/TEncCfg.h Mon Mar 03 11:28:22 2014 +0530
>> +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
>> @@ -1,336 +0,0 @@
> I love patches that delete HM files, especially ugly ones like this one.
>
yeah, that's cutting some cruft.
>> -/* 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-2013, 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 TEncCfg.h
>> - \brief encoder configuration class (header)
>> -*/
>> -
>> -#ifndef X265_TENCCFG_H
>> -#define X265_TENCCFG_H
>> -
>> -#include "TLibCommon/CommonDef.h"
>> -#include "TLibCommon/TComSlice.h"
>> -#include <assert.h>
>> -
>> -namespace x265 {
>> -// private namespace
>> -
>> -//! \ingroup TLibEncoder
>> -//! \{
>> -
>> -// ====================================================================================================================
>> -// Class definition
>> -// ====================================================================================================================
>> -
>> -/// encoder configuration class
>> -class TEncCfg
>> -{
>> -protected:
>> -
>> - //==== File I/O ========
>> - int m_conformanceMode;
>> - Window m_defaultDisplayWindow; ///< Represents the default display window parameters
>> - TComVPS m_vps;
>> -
>> - /* profile & level */
>> - Profile::Name m_profile;
>> - Level::Tier m_levelTier;
>> - Level::Name m_level;
>> -
>> - bool m_progressiveSourceFlag;
>> - bool m_interlacedSourceFlag;
>> - bool m_nonPackedConstraintFlag;
>> - bool m_frameOnlyConstraintFlag;
>> -
>> - //====== Coding Structure ========
>> - int m_maxDecPicBuffering[MAX_TLAYER];
>> - int m_numReorderPics[MAX_TLAYER];
>> - int m_maxRefPicNum; ///< this is used to mimic the sliding mechanism used by the decoder
>> - // TODO: We need to have a common sliding mechanism used by both the encoder and decoder
>> -
>> - //======= Transform =============
>> - uint32_t m_quadtreeTULog2MaxSize;
>> - uint32_t m_quadtreeTULog2MinSize;
>> -
>> - //====== Loop/Deblock Filter ========
>> - bool m_loopFilterOffsetInPPS;
>> - int m_loopFilterBetaOffsetDiv2;
>> - int m_loopFilterTcOffsetDiv2;
>> - int m_maxNumOffsetsPerPic;
>> -
>> - //====== Lossless ========
>> - bool m_useLossless;
>> -
>> - //====== Quality control ========
>> - int m_maxCuDQPDepth; // Max. depth for a minimum CuDQP (0:default)
>> -
>> - //====== Tool list ========
>> - bool m_bUseASR;
>> - bool m_usePCM;
>> - uint32_t m_pcmLog2MaxSize;
>> - uint32_t m_pcmLog2MinSize;
>> -
>> - bool m_bPCMInputBitDepthFlag;
>> - uint32_t m_pcmBitDepthLuma;
>> - uint32_t m_pcmBitDepthChroma;
>> - bool m_bPCMFilterDisableFlag;
>> - bool m_loopFilterAcrossTilesEnabledFlag;
>> -
>> - int m_bufferingPeriodSEIEnabled;
>> - int m_pictureTimingSEIEnabled;
>> - int m_recoveryPointSEIEnabled;
>> - int m_displayOrientationSEIAngle;
>> - int m_gradualDecodingRefreshInfoEnabled;
>> - int m_decodingUnitInfoSEIEnabled;
>> - int m_csp;
>> -
>> - //====== Weighted Prediction ========
>> -
>> - uint32_t m_log2ParallelMergeLevelMinus2; ///< Parallel merge estimation region
>> -
>> - int m_useScalingListId; ///< Using quantization matrix i.e. 0=off, 1=default.
>> -
>> - bool m_TransquantBypassEnableFlag; ///< transquant_bypass_enable_flag setting in PPS.
>> - bool m_CUTransquantBypassFlagValue; ///< if transquant_bypass_enable_flag, the fixed value to use for the per-CU cu_transquant_bypass_flag.
>> - int m_activeParameterSetsSEIEnabled; ///< enable active parameter set SEI message
>> - bool m_vuiParametersPresentFlag; ///< enable generation of VUI parameters
>> - bool m_aspectRatioInfoPresentFlag; ///< Signals whether aspect_ratio_idc is present
>> - int m_aspectRatioIdc; ///< aspect_ratio_idc
>> - int m_sarWidth; ///< horizontal size of the sample aspect ratio
>> - int m_sarHeight; ///< vertical size of the sample aspect ratio
>> - bool m_overscanInfoPresentFlag; ///< Signals whether overscan_appropriate_flag is present
>> - bool m_overscanAppropriateFlag; ///< Indicates whether conformant decoded pictures are suitable for display using overscan
>> - bool m_videoSignalTypePresentFlag; ///< Signals whether video_format, video_full_range_flag, and colour_description_present_flag are present
>> - int m_videoFormat; ///< Indicates representation of pictures
>> - bool m_videoFullRangeFlag; ///< Indicates the black level and range of luma and chroma signals
>> - bool m_colourDescriptionPresentFlag; ///< Signals whether colour_primaries, transfer_characteristics and matrix_coefficients are present
>> - int m_colourPrimaries; ///< Indicates chromaticity coordinates of the source primaries
>> - int m_transferCharacteristics; ///< Indicates the opto-electronic transfer characteristics of the source
>> - int m_matrixCoefficients; ///< Describes the matrix coefficients used in deriving luma and chroma from RGB primaries
>> - bool m_chromaLocInfoPresentFlag; ///< Signals whether chroma_sample_loc_type_top_field and chroma_sample_loc_type_bottom_field are present
>> - int m_chromaSampleLocTypeTopField; ///< Specifies the location of chroma samples for top field
>> - int m_chromaSampleLocTypeBottomField; ///< Specifies the location of chroma samples for bottom field
>> - bool m_neutralChromaIndicationFlag; ///< Indicates that the value of all decoded chroma samples is equal to 1<<(BitDepthCr-1)
>> - bool m_frameFieldInfoPresentFlag; ///< Indicates that pic_struct and other field coding related values are present in picture timing SEI messages
>> - bool m_pocProportionalToTimingFlag; ///< Indicates that the POC value is proportional to the output time w.r.t. first picture in CVS
>> - int m_numTicksPocDiffOneMinus1; ///< Number of ticks minus 1 that for a POC difference of one
>> - bool m_bitstreamRestrictionFlag; ///< Signals whether bitstream restriction parameters are present
>> - bool m_motionVectorsOverPicBoundariesFlag; ///< Indicates that no samples outside the picture boundaries are used for inter prediction
>> - int m_minSpatialSegmentationIdc; ///< Indicates the maximum size of the spatial segments in the pictures in the coded video sequence
>> - int m_maxBytesPerPicDenom; ///< Indicates a number of bytes not exceeded by the sum of the sizes of the VCL NAL units associated with any coded picture
>> - int m_maxBitsPerMinCuDenom; ///< Indicates an upper bound for the number of bits of coding_unit() data
>> - int m_log2MaxMvLengthHorizontal; ///< Indicate the maximum absolute value of a decoded horizontal MV component in quarter-pel luma units
>> - int m_log2MaxMvLengthVertical; ///< Indicate the maximum absolute value of a decoded vertical MV component in quarter-pel luma units
>> - bool m_fieldSeqFlag; ///< Indicates that each picture is a field and has its own SEI timing message
>> - bool m_vuiTimingInfoPresentFlag; ///< Indicates that timing info is added to the VUI
>> - int m_vuiNumUnitsInTick; ///< The number of system ticks in an h265 tick where an h265 tick is in units of system ticks per frame
>> - int m_vuiTimeScale; ///< The number of system ticks per second
>> - bool m_vuiHrdParametersPresentFlag; ///< Indicates HRD parameters are to be added to the VUI
>> - bool m_subPicHrdParamsPresentFlag; ///< Indicates that sub pic parameters should be added to the HRD
>> - bool m_restrictedRefPicListsFlag; ///< Indicates all P and B slices have the same reference pic list 0 and all B slices have the same reference pic list 1
>> - bool m_tilesFixedStructureFlag; ///< Indicates each PPS in the CVS have the same tile structure fields
>> -
>> -public:
>> -
>> - /* copy of parameters used to create encoder */
>> - x265_param param;
>> -
>> - int bEnableRDOQ;
>> - int bEnableRDOQTS;
>> -
>> - int m_pad[2];
>> - Window m_conformanceWindow;
>> -
>> - TEncCfg()
>> - {}
>> -
>> - virtual ~TEncCfg()
>> - {}
>> -
>> - TComVPS *getVPS() { return &m_vps; }
>> -
>> - //====== Coding Structure ========
>> -
>> - int getMaxRefPicNum() { return m_maxRefPicNum; }
>> -
>> - //==== Coding Structure ========
>> -
>> - int getMaxDecPicBuffering(uint32_t tlayer) { return m_maxDecPicBuffering[tlayer]; }
>> -
>> - int getNumReorderPics(uint32_t tlayer) { return m_numReorderPics[tlayer]; }
>> -
>> - //======== Transform =============
>> - uint32_t getQuadtreeTULog2MaxSize() const { return m_quadtreeTULog2MaxSize; }
>> -
>> - uint32_t getQuadtreeTULog2MinSize() const { return m_quadtreeTULog2MinSize; }
>> -
>> - //==== Loop/Deblock Filter ========
>> - bool getLoopFilterOffsetInPPS() { return m_loopFilterOffsetInPPS; }
>> -
>> - int getLoopFilterBetaOffset() { return m_loopFilterBetaOffsetDiv2; }
>> -
>> - int getLoopFilterTcOffset() { return m_loopFilterTcOffsetDiv2; }
>> -
>> - //==== Quality control ========
>> - int getMaxCuDQPDepth() { return m_maxCuDQPDepth; }
>> -
>> - //====== Lossless ========
>> - bool getUseLossless() { return m_useLossless; }
>> -
>> - //==== Tool list ========
>> - bool getUseASR() { return m_bUseASR; }
>> -
>> - bool getPCMInputBitDepthFlag() { return m_bPCMInputBitDepthFlag; }
>> -
>> - bool getPCMFilterDisableFlag() { return m_bPCMFilterDisableFlag; }
>> -
>> - bool getUsePCM() { return m_usePCM; }
>> -
>> - uint32_t getPCMLog2MaxSize() { return m_pcmLog2MaxSize; }
>> -
>> - uint32_t getPCMLog2MinSize() { return m_pcmLog2MinSize; }
>> -
>> - int getMaxNumOffsetsPerPic() { return m_maxNumOffsetsPerPic; }
>> -
>> - bool getLFCrossTileBoundaryFlag() { return m_loopFilterAcrossTilesEnabledFlag; }
>> -
>> - int getBufferingPeriodSEIEnabled() { return m_bufferingPeriodSEIEnabled; }
>> -
>> - int getPictureTimingSEIEnabled() { return m_pictureTimingSEIEnabled; }
>> -
>> - int getRecoveryPointSEIEnabled() { return m_recoveryPointSEIEnabled; }
>> -
>> - int getDisplayOrientationSEIAngle() { return m_displayOrientationSEIAngle; }
>> -
>> - int getGradualDecodingRefreshInfoEnabled() { return m_gradualDecodingRefreshInfoEnabled; }
>> -
>> - int getDecodingUnitInfoSEIEnabled() { return m_decodingUnitInfoSEIEnabled; }
>> -
>> - uint32_t getLog2ParallelMergeLevelMinus2() { return m_log2ParallelMergeLevelMinus2; }
>> -
>> - int getUseScalingListId() { return m_useScalingListId; }
>> -
>> - bool getTransquantBypassEnableFlag() { return m_TransquantBypassEnableFlag; }
>> -
>> - bool getCUTransquantBypassFlagValue() { return m_CUTransquantBypassFlagValue; }
>> -
>> - int getActiveParameterSetsSEIEnabled() { return m_activeParameterSetsSEIEnabled; }
>> -
>> - bool getVuiParametersPresentFlag() { return m_vuiParametersPresentFlag; }
>> -
>> - bool getAspectRatioInfoPresentFlag() { return m_aspectRatioInfoPresentFlag; }
>> -
>> - int getAspectRatioIdc() { return m_aspectRatioIdc; }
>> -
>> - int getSarWidth() { return m_sarWidth; }
>> -
>> - int getSarHeight() { return m_sarHeight; }
>> -
>> - bool getOverscanInfoPresentFlag() { return m_overscanInfoPresentFlag; }
>> -
>> - bool getOverscanAppropriateFlag() { return m_overscanAppropriateFlag; }
>> -
>> - bool getVideoSignalTypePresentFlag() { return m_videoSignalTypePresentFlag; }
>> -
>> - int getVideoFormat() { return m_videoFormat; }
>> -
>> - int getColorFormat() { return m_csp; }
>> -
>> - bool getVideoFullRangeFlag() { return m_videoFullRangeFlag; }
>> -
>> - bool getColourDescriptionPresentFlag() { return m_colourDescriptionPresentFlag; }
>> -
>> - int getColourPrimaries() { return m_colourPrimaries; }
>> -
>> - int getTransferCharacteristics() { return m_transferCharacteristics; }
>> -
>> - int getMatrixCoefficients() { return m_matrixCoefficients; }
>> -
>> - bool getChromaLocInfoPresentFlag() { return m_chromaLocInfoPresentFlag; }
>> -
>> - int getChromaSampleLocTypeTopField() { return m_chromaSampleLocTypeTopField; }
>> -
>> - int getChromaSampleLocTypeBottomField() { return m_chromaSampleLocTypeBottomField; }
>> -
>> - bool getNeutralChromaIndicationFlag() { return m_neutralChromaIndicationFlag; }
>> -
>> - Window &getDefaultDisplayWindow() { return m_defaultDisplayWindow; }
>> -
>> - bool getFrameFieldInfoPresentFlag() { return m_frameFieldInfoPresentFlag; }
>> -
>> - bool getPocProportionalToTimingFlag() { return m_pocProportionalToTimingFlag; }
>> -
>> - int getNumTicksPocDiffOneMinus1() { return m_numTicksPocDiffOneMinus1; }
>> -
>> - bool getBitstreamRestrictionFlag() { return m_bitstreamRestrictionFlag; }
>> -
>> - bool getMotionVectorsOverPicBoundariesFlag() { return m_motionVectorsOverPicBoundariesFlag; }
>> -
>> - int getMinSpatialSegmentationIdc() { return m_minSpatialSegmentationIdc; }
>> -
>> - int getMaxBytesPerPicDenom() { return m_maxBytesPerPicDenom; }
>> -
>> - int getMaxBitsPerMinCuDenom() { return m_maxBitsPerMinCuDenom; }
>> -
>> - int getLog2MaxMvLengthHorizontal() { return m_log2MaxMvLengthHorizontal; }
>> -
>> - int getLog2MaxMvLengthVertical() { return m_log2MaxMvLengthVertical; }
>> -
>> - bool getProgressiveSourceFlag() const { return m_progressiveSourceFlag; }
>> -
>> - bool getInterlacedSourceFlag() const { return m_interlacedSourceFlag; }
>> -
>> - bool getNonPackedConstraintFlag() const { return m_nonPackedConstraintFlag; }
>> -
>> - bool getFrameOnlyConstraintFlag() const { return m_frameOnlyConstraintFlag; }
>> -
>> - bool getFieldSeqFlag() const { return m_fieldSeqFlag; }
>> -
>> - bool getVuiTimingInfoPresentFlag() const { return m_vuiTimingInfoPresentFlag; }
>> -
>> - int getVuiNumUnitsInTick() const { return m_vuiNumUnitsInTick; }
>> -
>> - int getVuiTimeScale() const { return m_vuiTimeScale; }
>> -
>> - bool getVuiHrdParametersPresentFlag() const { return m_vuiHrdParametersPresentFlag; }
>> -
>> - bool getSubPicHrdParamsPresentFlag() const { return m_subPicHrdParamsPresentFlag; }
>> -
>> - bool getRestrictedRefPicListsFlag() const { return m_restrictedRefPicListsFlag; }
>> -
>> - bool getTilesFixedStructureFlag() const { return m_tilesFixedStructureFlag; }
>> -};
>> -}
>> -//! \}
>> -
>> -#endif // ifndef X265_TENCCFG_H
>> diff -r 6662df480e39 -r 56fa912d6e7c source/Lib/TLibEncoder/TEncCu.cpp
>> --- a/source/Lib/TLibEncoder/TEncCu.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/Lib/TLibEncoder/TEncCu.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -103,7 +103,7 @@
>>
>> m_origYuv = new TComYuv*[m_totalDepth - 1];
>>
>> - int csp = m_cfg->param.internalCsp;
>> + int csp = m_cfg->param->internalCsp;
>>
>> bool ok = true;
>> for (int i = 0; i < m_totalDepth - 1; i++)
>> @@ -383,7 +383,7 @@
>> }
>> else
>> {
>> - if (m_cfg->param.rdLevel < 5)
>> + if (m_cfg->param->rdLevel < 5)
>> {
>> TComDataCU* outBestCU = NULL;
>>
>> @@ -734,7 +734,7 @@
>> if (outBestCU->getSlice()->getSliceType() != I_SLICE)
>> {
>> // 2Nx2N
>> - if (m_cfg->param.bEnableEarlySkip)
>> + if (m_cfg->param->bEnableEarlySkip)
>> {
>> xCheckRDCostInter(outBestCU, outTempCU, SIZE_2Nx2N);
>> outTempCU->initEstData(depth, qp); // by competition for inter_2Nx2N
>> @@ -744,12 +744,12 @@
>>
>> outTempCU->initEstData(depth, qp);
>>
>> - if (!m_cfg->param.bEnableEarlySkip)
>> + if (!m_cfg->param->bEnableEarlySkip)
>> {
>> // 2Nx2N, NxN
>> xCheckRDCostInter(outBestCU, outTempCU, SIZE_2Nx2N);
>> outTempCU->initEstData(depth, qp);
>> - if (m_cfg->param.bEnableCbfFastMode)
>> + if (m_cfg->param->bEnableCbfFastMode)
>> {
>> doNotBlockPu = outBestCU->getQtRootCbf(0) != 0;
>> }
>> @@ -773,14 +773,14 @@
>> }
>> }
>>
>> - if (m_cfg->param.bEnableRectInter)
>> + if (m_cfg->param->bEnableRectInter)
>> {
>> // 2NxN, Nx2N
>> if (doNotBlockPu)
>> {
>> xCheckRDCostInter(outBestCU, outTempCU, SIZE_Nx2N);
>> outTempCU->initEstData(depth, qp);
>> - if (m_cfg->param.bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_Nx2N)
>> + if (m_cfg->param->bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_Nx2N)
>> {
>> doNotBlockPu = outBestCU->getQtRootCbf(0) != 0;
>> }
>> @@ -789,7 +789,7 @@
>> {
>> xCheckRDCostInter(outBestCU, outTempCU, SIZE_2NxN);
>> outTempCU->initEstData(depth, qp);
>> - if (m_cfg->param.bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_2NxN)
>> + if (m_cfg->param->bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_2NxN)
>> {
>> doNotBlockPu = outBestCU->getQtRootCbf(0) != 0;
>> }
>> @@ -811,7 +811,7 @@
>> {
>> xCheckRDCostInter(outBestCU, outTempCU, SIZE_2NxnU);
>> outTempCU->initEstData(depth, qp);
>> - if (m_cfg->param.bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_2NxnU)
>> + if (m_cfg->param->bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_2NxnU)
>> {
>> doNotBlockPu = outBestCU->getQtRootCbf(0) != 0;
>> }
>> @@ -820,7 +820,7 @@
>> {
>> xCheckRDCostInter(outBestCU, outTempCU, SIZE_2NxnD);
>> outTempCU->initEstData(depth, qp);
>> - if (m_cfg->param.bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_2NxnD)
>> + if (m_cfg->param->bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_2NxnD)
>> {
>> doNotBlockPu = outBestCU->getQtRootCbf(0) != 0;
>> }
>> @@ -832,7 +832,7 @@
>> {
>> xCheckRDCostInter(outBestCU, outTempCU, SIZE_2NxnU, true);
>> outTempCU->initEstData(depth, qp);
>> - if (m_cfg->param.bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_2NxnU)
>> + if (m_cfg->param->bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_2NxnU)
>> {
>> doNotBlockPu = outBestCU->getQtRootCbf(0) != 0;
>> }
>> @@ -841,7 +841,7 @@
>> {
>> xCheckRDCostInter(outBestCU, outTempCU, SIZE_2NxnD, true);
>> outTempCU->initEstData(depth, qp);
>> - if (m_cfg->param.bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_2NxnD)
>> + if (m_cfg->param->bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_2NxnD)
>> {
>> doNotBlockPu = outBestCU->getQtRootCbf(0) != 0;
>> }
>> @@ -855,7 +855,7 @@
>> {
>> xCheckRDCostInter(outBestCU, outTempCU, SIZE_nLx2N);
>> outTempCU->initEstData(depth, qp);
>> - if (m_cfg->param.bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_nLx2N)
>> + if (m_cfg->param->bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_nLx2N)
>> {
>> doNotBlockPu = outBestCU->getQtRootCbf(0) != 0;
>> }
>> @@ -872,7 +872,7 @@
>> {
>> xCheckRDCostInter(outBestCU, outTempCU, SIZE_nLx2N, true);
>> outTempCU->initEstData(depth, qp);
>> - if (m_cfg->param.bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_nLx2N)
>> + if (m_cfg->param->bEnableCbfFastMode && outBestCU->getPartitionSize(0) == SIZE_nLx2N)
>> {
>> doNotBlockPu = outBestCU->getQtRootCbf(0) != 0;
>> }
>> @@ -1231,7 +1231,7 @@
>>
>> UChar depth = outTempCU->getDepth(0);
>> outTempCU->setPartSizeSubParts(SIZE_2Nx2N, 0, depth); // interprets depth relative to LCU level
>> - outTempCU->setCUTransquantBypassSubParts(m_cfg->getCUTransquantBypassFlagValue(), 0, depth);
>> + outTempCU->setCUTransquantBypassSubParts(m_cfg->m_CUTransquantBypassFlagValue, 0, depth);
>> outTempCU->getInterMergeCandidates(0, 0, mvFieldNeighbours, interDirNeighbours, numValidMergeCand);
>>
>> int mergeCandBuffer[MRG_MAX_NUM_CANDS];
>> @@ -1257,8 +1257,8 @@
>> for (uint32_t mergeCand = 0; mergeCand < numValidMergeCand; ++mergeCand)
>> {
>> /* TODO: check only necessary when -F>1, and ref pixels available is in units of LCU rows */
>> - if (mvFieldNeighbours[0 + 2 * mergeCand].mv.y >= (m_cfg->param.searchRange + 1) * 4
>> - || mvFieldNeighbours[1 + 2 * mergeCand].mv.y >= (m_cfg->param.searchRange + 1) * 4)
>> + if (mvFieldNeighbours[0 + 2 * mergeCand].mv.y >= (m_cfg->param->searchRange + 1) * 4
>> + || mvFieldNeighbours[1 + 2 * mergeCand].mv.y >= (m_cfg->param->searchRange + 1) * 4)
>> {
>> continue;
>> }
>> @@ -1268,7 +1268,7 @@
>> {
>> // set MC parameters
>> outTempCU->setPredModeSubParts(MODE_INTER, 0, depth); // interprets depth relative to LCU level
>> - outTempCU->setCUTransquantBypassSubParts(m_cfg->getCUTransquantBypassFlagValue(), 0, depth);
>> + outTempCU->setCUTransquantBypassSubParts(m_cfg->m_CUTransquantBypassFlagValue, 0, depth);
>> outTempCU->setPartSizeSubParts(SIZE_2Nx2N, 0, depth); // interprets depth relative to LCU level
>> outTempCU->setMergeFlag(0, true);
>> outTempCU->setMergeIndex(0, mergeCand);
>> @@ -1324,7 +1324,7 @@
>> }
>> }
>>
>> - if (noResidual == 0 && m_cfg->param.bEnableEarlySkip)
>> + if (noResidual == 0 && m_cfg->param->bEnableEarlySkip)
>> {
>> if (outBestCU->getQtRootCbf(0) == 0)
>> {
>> @@ -1364,7 +1364,7 @@
>> outTempCU->setSkipFlagSubParts(false, 0, depth);
>> outTempCU->setPartSizeSubParts(partSize, 0, depth);
>> outTempCU->setPredModeSubParts(MODE_INTER, 0, depth);
>> - outTempCU->setCUTransquantBypassSubParts(m_cfg->getCUTransquantBypassFlagValue(), 0, depth);
>> + outTempCU->setCUTransquantBypassSubParts(m_cfg->m_CUTransquantBypassFlagValue, 0, depth);
>>
>> m_tmpRecoYuv[depth]->clear();
>> m_tmpResiYuv[depth]->clear();
>> @@ -1385,7 +1385,7 @@
>> outTempCU->setSkipFlagSubParts(false, 0, depth);
>> outTempCU->setPartSizeSubParts(partSize, 0, depth);
>> outTempCU->setPredModeSubParts(MODE_INTRA, 0, depth);
>> - outTempCU->setCUTransquantBypassSubParts(m_cfg->getCUTransquantBypassFlagValue(), 0, depth);
>> + outTempCU->setCUTransquantBypassSubParts(m_cfg->m_CUTransquantBypassFlagValue, 0, depth);
>>
>> m_search->estIntraPredQT(outTempCU, m_origYuv[depth], m_tmpPredYuv[depth], m_tmpResiYuv[depth], m_tmpRecoYuv[depth], preCalcDistC, true);
>>
>> @@ -1425,7 +1425,7 @@
>> outTempCU->setSkipFlagSubParts(false, 0, depth);
>> outTempCU->setPartSizeSubParts(partSize, 0, depth);
>> outTempCU->setPredModeSubParts(MODE_INTRA, 0, depth);
>> - outTempCU->setCUTransquantBypassSubParts(m_cfg->getCUTransquantBypassFlagValue(), 0, depth);
>> + outTempCU->setCUTransquantBypassSubParts(m_cfg->m_CUTransquantBypassFlagValue, 0, depth);
>>
>> bool bSeparateLumaChroma = true; // choose estimation mode
>> uint32_t preCalcDistC = 0;
>> @@ -1482,7 +1482,7 @@
>> outTempCU->setPartSizeSubParts(SIZE_2Nx2N, 0, depth);
>> outTempCU->setPredModeSubParts(MODE_INTRA, 0, depth);
>> outTempCU->setTrIdxSubParts(0, 0, depth);
>> - outTempCU->setCUTransquantBypassSubParts(m_cfg->getCUTransquantBypassFlagValue(), 0, depth);
>> + outTempCU->setCUTransquantBypassSubParts(m_cfg->m_CUTransquantBypassFlagValue, 0, depth);
>>
>> m_search->IPCMSearch(outTempCU, m_origYuv[depth], m_tmpPredYuv[depth], m_tmpResiYuv[depth], m_tmpRecoYuv[depth]);
>>
>> diff -r 6662df480e39 -r 56fa912d6e7c source/Lib/TLibEncoder/TEncCu.h
>> --- a/source/Lib/TLibEncoder/TEncCu.h Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/Lib/TLibEncoder/TEncCu.h Mon Mar 03 14:24:34 2014 -0800
>> @@ -111,7 +111,7 @@
>> TComYuv** m_bestMergeRecoYuv;
>> TComYuv** m_origYuv; ///< Original Yuv at each depth
>>
>> - TEncCfg* m_cfg;
>> + Encoder* m_cfg;
> It's a bit of a layering violation to have a top-level encoder pointer
> way down here in the guts. But this can be cleaned up later.
>> TEncSearch* m_search;
>> TComTrQuant* m_trQuant;
>> TComRdCost* m_rdCost;
>> diff -r 6662df480e39 -r 56fa912d6e7c source/Lib/TLibEncoder/TEncSbac.cpp
>> --- a/source/Lib/TLibEncoder/TEncSbac.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/Lib/TLibEncoder/TEncSbac.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -685,8 +685,8 @@
>> WRITE_FLAG(hrd->getVclHrdParametersPresentFlag() ? 1 : 0, "vcl_hrd_parameters_present_flag");
>> if (hrd->getNalHrdParametersPresentFlag() || hrd->getVclHrdParametersPresentFlag())
>> {
>> - WRITE_FLAG(hrd->getSubPicCpbParamsPresentFlag() ? 1 : 0, "sub_pic_cpb_params_present_flag");
>> - if (hrd->getSubPicCpbParamsPresentFlag())
>> + WRITE_FLAG(hrd->getSubPicHrdParamsPresentFlag() ? 1 : 0, "sub_pic_hrd_params_present_flag");
>> + if (hrd->getSubPicHrdParamsPresentFlag())
>> {
>> WRITE_CODE(hrd->getTickDivisorMinus2(), 8, "tick_divisor_minus2");
>> WRITE_CODE(hrd->getDuCpbRemovalDelayLengthMinus1(), 5, "du_cpb_removal_delay_length_minus1");
>> @@ -695,7 +695,7 @@
>> }
>> WRITE_CODE(hrd->getBitRateScale(), 4, "bit_rate_scale");
>> WRITE_CODE(hrd->getCpbSizeScale(), 4, "cpb_size_scale");
>> - if (hrd->getSubPicCpbParamsPresentFlag())
>> + if (hrd->getSubPicHrdParamsPresentFlag())
>> {
>> WRITE_CODE(hrd->getDuCpbSizeScale(), 4, "du_cpb_size_scale");
>> }
>> @@ -738,7 +738,7 @@
>> {
>> WRITE_UVLC(hrd->getBitRateValueMinus1(i, j, nalOrVcl), "bit_rate_value_minus1");
>> WRITE_UVLC(hrd->getCpbSizeValueMinus1(i, j, nalOrVcl), "cpb_size_value_minus1");
>> - if (hrd->getSubPicCpbParamsPresentFlag())
>> + if (hrd->getSubPicHrdParamsPresentFlag())
>> {
>> WRITE_UVLC(hrd->getDuCpbSizeValueMinus1(i, j, nalOrVcl), "cpb_size_du_value_minus1");
>> WRITE_UVLC(hrd->getDuBitRateValueMinus1(i, j, nalOrVcl), "bit_rate_du_value_minus1");
>> diff -r 6662df480e39 -r 56fa912d6e7c source/Lib/TLibEncoder/TEncSearch.cpp
>> --- a/source/Lib/TLibEncoder/TEncSearch.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/Lib/TLibEncoder/TEncSearch.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -80,7 +80,7 @@
>> {
>> if (m_cfg)
>> {
>> - const uint32_t numLayersToAllocate = m_cfg->getQuadtreeTULog2MaxSize() - m_cfg->getQuadtreeTULog2MinSize() + 1;
>> + const uint32_t numLayersToAllocate = m_cfg->m_quadtreeTULog2MaxSize - m_cfg->m_quadtreeTULog2MinSize + 1;
>> for (uint32_t i = 0; i < numLayersToAllocate; ++i)
>> {
>> X265_FREE(m_qtTempCoeffY[i]);
>> @@ -108,30 +108,30 @@
>> m_tmpYuvPred.destroy();
>> }
>>
>> -bool TEncSearch::init(TEncCfg* cfg, TComRdCost* rdCost, TComTrQuant* trQuant)
>> +bool TEncSearch::init(Encoder* cfg, TComRdCost* rdCost, TComTrQuant* trQuant)
>> {
>> m_cfg = cfg;
>> m_trQuant = trQuant;
>> m_rdCost = rdCost;
>>
>> - initTempBuff(cfg->param.internalCsp);
>> - m_me.setSearchMethod(cfg->param.searchMethod);
>> - m_me.setSubpelRefine(cfg->param.subpelRefine);
>> + initTempBuff(cfg->param->internalCsp);
> Hmm, cfg->m_csp and cfg->param->internalCsp are redundant, I believe
I will remove m_csp and replace it with param->internalCsp.
>
>> + m_me.setSearchMethod(cfg->param->searchMethod);
>> + m_me.setSubpelRefine(cfg->param->subpelRefine);
>>
>> /* When frame parallelism is active, only 'refLagPixels' of reference frames will be guaranteed
>> * available for motion reference. See refLagRows in FrameEncoder::compressCTURows() */
>> - m_refLagPixels = cfg->param.frameNumThreads > 1 ? cfg->param.searchRange : cfg->param.sourceHeight;
>> + m_refLagPixels = cfg->param->frameNumThreads > 1 ? cfg->param->searchRange : cfg->param->sourceHeight;
>>
>> // default to no adaptive range
>> for (int dir = 0; dir < 2; dir++)
>> {
>> for (int ref = 0; ref < MAX_NUM_REF; ref++)
>> {
>> - m_adaptiveRange[dir][ref] = cfg->param.searchRange;
>> + m_adaptiveRange[dir][ref] = cfg->param->searchRange;
>> }
>> }
>>
>> - const uint32_t numLayersToAllocate = cfg->getQuadtreeTULog2MaxSize() - cfg->getQuadtreeTULog2MinSize() + 1;
>> + const uint32_t numLayersToAllocate = cfg->m_quadtreeTULog2MaxSize - cfg->m_quadtreeTULog2MinSize + 1;
>> m_qtTempCoeffY = new TCoeff*[numLayersToAllocate];
>> m_qtTempCoeffCb = new TCoeff*[numLayersToAllocate];
>> m_qtTempCoeffCr = new TCoeff*[numLayersToAllocate];
>> @@ -141,7 +141,7 @@
>> m_qtTempCoeffY[i] = X265_MALLOC(TCoeff, g_maxCUWidth * g_maxCUHeight);
>> m_qtTempCoeffCb[i] = X265_MALLOC(TCoeff, (g_maxCUWidth >> m_hChromaShift) * (g_maxCUHeight >> m_vChromaShift));
>> m_qtTempCoeffCr[i] = X265_MALLOC(TCoeff, (g_maxCUWidth >> m_hChromaShift) * (g_maxCUHeight >> m_vChromaShift));
>> - m_qtTempShortYuv[i].create(MAX_CU_SIZE, MAX_CU_SIZE, cfg->param.internalCsp);
>> + m_qtTempShortYuv[i].create(MAX_CU_SIZE, MAX_CU_SIZE, cfg->param->internalCsp);
>> }
>>
>> const uint32_t numPartitions = 1 << (g_maxCUDepth << 1);
>> @@ -160,8 +160,8 @@
>> CHECKED_MALLOC(m_qtTempTUCoeffCb, TCoeff, MAX_TS_WIDTH * MAX_TS_HEIGHT);
>> CHECKED_MALLOC(m_qtTempTUCoeffCr, TCoeff, MAX_TS_WIDTH * MAX_TS_HEIGHT);
>>
>> - return m_qtTempTransformSkipYuv.create(g_maxCUWidth, g_maxCUHeight, cfg->param.internalCsp) &&
>> - m_tmpYuvPred.create(MAX_CU_SIZE, MAX_CU_SIZE, cfg->param.internalCsp);
>> + return m_qtTempTransformSkipYuv.create(g_maxCUWidth, g_maxCUHeight, cfg->param->internalCsp) &&
>> + m_tmpYuvPred.create(MAX_CU_SIZE, MAX_CU_SIZE, cfg->param->internalCsp);
>>
>> fail:
>> return false;
>> @@ -670,13 +670,13 @@
>> // don't check split if TU size is less or equal to max TU size
>> bool noSplitIntraMaxTuSize = bCheckFull;
>>
>> - if (m_cfg->param.rdPenalty && !isIntraSlice)
>> + if (m_cfg->param->rdPenalty && !isIntraSlice)
>> {
>> // in addition don't check split if TU size is less or equal to 16x16 TU size for non-intra slice
>> noSplitIntraMaxTuSize = (trSizeLog2 <= X265_MIN(maxTuSize, 4));
>>
>> // if maximum RD-penalty don't check TU size 32x32
>> - if (m_cfg->param.rdPenalty == 2)
>> + if (m_cfg->param->rdPenalty == 2)
>> {
>> bCheckFull = (trSizeLog2 <= X265_MIN(maxTuSize, 4));
>> }
>> @@ -701,7 +701,7 @@
>> checkTransformSkip &= (widthTransformSkip == 4 && heightTransformSkip == 4);
>> checkTransformSkip &= (!cu->getCUTransquantBypass(0));
>> checkTransformSkip &= (!((cu->getQP(0) == 0) && (cu->getSlice()->getSPS()->getUseLossless())));
>> - if (m_cfg->param.bEnableTSkipFast)
>> + if (m_cfg->param->bEnableTSkipFast)
>> {
>> checkTransformSkip &= (cu->getPartitionSize(absPartIdx) == SIZE_NxN);
>> }
>> @@ -851,7 +851,7 @@
>> }
>> //----- determine rate and r-d cost -----
>> uint32_t singleBits = xGetIntraBitsQT(cu, trDepth, absPartIdx, true, !bLumaOnly);
>> - if (m_cfg->param.rdPenalty && (trSizeLog2 == 5) && !isIntraSlice)
>> + if (m_cfg->param->rdPenalty && (trSizeLog2 == 5) && !isIntraSlice)
>> {
>> singleBits = singleBits * 4;
>> }
>> @@ -988,10 +988,10 @@
>> int maxTuSize = cu->getSlice()->getSPS()->getQuadtreeTULog2MaxSize();
>> int isIntraSlice = (cu->getSlice()->getSliceType() == I_SLICE);
>>
>> - if (m_cfg->param.rdPenalty && !isIntraSlice)
>> + if (m_cfg->param->rdPenalty && !isIntraSlice)
>> {
>> // if maximum RD-penalty don't check TU size 32x32
>> - if (m_cfg->param.rdPenalty == 2)
>> + if (m_cfg->param->rdPenalty == 2)
>> {
>> bCheckFull = (trSizeLog2 <= X265_MIN(maxTuSize, 4));
>> }
>> @@ -1406,7 +1406,7 @@
>> }
>>
>> checkTransformSkip &= (trSizeLog2 <= 3);
>> - if (m_cfg->param.bEnableTSkipFast)
>> + if (m_cfg->param->bEnableTSkipFast)
>> {
>> checkTransformSkip &= (trSizeLog2 < 3);
>> if (checkTransformSkip)
>> @@ -1689,8 +1689,8 @@
>> assert(((uint32_t)(size_t)residual & (width - 1)) == 0);
>> assert(width <= 32);
>> int part = partitionFromSizes(cu->getWidth(0) >> (trDepth), cu->getHeight(0) >> (trDepth));
>> - primitives.chroma[m_cfg->param.internalCsp].add_ps[part](recon, stride, pred, residual, stride, stride);
>> - primitives.chroma[m_cfg->param.internalCsp].copy_pp[part](reconIPred, reconIPredStride, recon, stride);
>> + primitives.chroma[m_cfg->param->internalCsp].add_ps[part](recon, stride, pred, residual, stride, stride);
>> + primitives.chroma[m_cfg->param->internalCsp].copy_pp[part](reconIPred, reconIPredStride, recon, stride);
>> }
>> }
>> else
>> @@ -2504,7 +2504,7 @@
>>
>> costCand = xGetInterPredictionError(cu, puIdx);
>> bitsCand = mergeCand + 1;
>> - if (mergeCand == m_cfg->param.maxNumMergeCand - 1)
>> + if (mergeCand == m_cfg->param->maxNumMergeCand - 1)
>> {
>> bitsCand--;
>> }
>> diff -r 6662df480e39 -r 56fa912d6e7c source/Lib/TLibEncoder/TEncSearch.h
>> --- a/source/Lib/TLibEncoder/TEncSearch.h Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/Lib/TLibEncoder/TEncSearch.h Mon Mar 03 14:24:34 2014 -0800
>> @@ -47,8 +47,7 @@
>> #include "TLibCommon/TComPic.h"
>> #include "TEncEntropy.h"
>> #include "TEncSbac.h"
>> -#include "TEncCfg.h"
>> -
>> +#include "../../encoder/encoder.h"
> again, relative path unnecessary. fixed
removed...
>> #include "primitives.h"
>> #include "bitcost.h"
>> #include "motion.h"
>> @@ -99,7 +98,7 @@
>> TComYuv m_qtTempTransformSkipYuv;
>>
>> // interface to option
>> - TEncCfg* m_cfg;
>> + Encoder* m_cfg;
>>
>> // interface to classes
>> TComTrQuant* m_trQuant;
>> @@ -136,7 +135,7 @@
>> TEncSearch();
>> virtual ~TEncSearch();
>>
>> - bool init(TEncCfg* cfg, TComRdCost* rdCost, TComTrQuant *trQuant);
>> + bool init(Encoder* cfg, TComRdCost* rdCost, TComTrQuant *trQuant);
>>
>> protected:
>>
>> diff -r 6662df480e39 -r 56fa912d6e7c source/common/param.cpp
>> --- a/source/common/param.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/common/param.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -170,6 +170,7 @@
>> param->defDispWinBottomOffset = 0;
>> param->bEnableVuiTimingInfoPresentFlag = 0;
>> param->bEnableVuiHrdParametersPresentFlag = 0;
>> + param->bEnableNalHrdParametersPresentFlag = 0;
>> param->bEnableBitstreamRestrictionFlag = 0;
>> param->bEnableSubPicHrdParamsPresentFlag = 0;
>> }
>> @@ -669,11 +670,18 @@
>> p->bEnableVuiParametersPresentFlag = 1;
>> p->bEnableVuiTimingInfoPresentFlag = atobool(value);
>> }
>> + OPT("hrd")
>> + {
>> + p->bEnableVuiParametersPresentFlag = 1;
>> + p->bEnableVuiTimingInfoPresentFlag = 1;
>> + p->bEnableVuiHrdParametersPresentFlag = atobool(value);
>> + }
>> OPT("nal-hrd")
>> {
>> p->bEnableVuiParametersPresentFlag = 1;
>> p->bEnableVuiTimingInfoPresentFlag = 1;
>> - p->bEnableVuiHrdParametersPresentFlag = atobool(value);
>> + p->bEnableVuiHrdParametersPresentFlag = 1;
>> + p->bEnableNalHrdParametersPresentFlag = parseName(value, x265_nal_hrd_names, bError);
>> }
>> OPT("bitstreamrestriction")
>> {
>> @@ -682,8 +690,9 @@
>> }
>> OPT("subpichrd")
>> {
>> - p->bEnableVuiParametersPresentFlag = 1;
>> - p->bEnableVuiHrdParametersPresentFlag = 1;
>> + p->bEnableVuiParametersPresentFlag = 1;
>> + p->bEnableVuiHrdParametersPresentFlag = 1;
>> + p->bEnableNalHrdParametersPresentFlag = 1;
> there were tab characters here
Removed and replaced with spaces.
>> p->bEnableSubPicHrdParamsPresentFlag = atobool(value);
>> }
>> else
>> @@ -950,6 +959,9 @@
>> "Default Display Window Top Offset must be 0 or greater");
>> CHECK(param->defDispWinBottomOffset < 0,
>> "Default Display Window Bottom Offset must be 0 or greater");
>> + CHECK(param->bEnableNalHrdParametersPresentFlag
>> + && param->rc.vbvBufferSize <= 0,
>> + "If nal-hrd specified then vbv buffersize must also be specified");
>> CHECK(param->rc.rfConstant < 0 || param->rc.rfConstant > 51,
>> "Valid quality based VBR range 0 - 51");
>> CHECK(param->bFrameAdaptive < 0 || param->bFrameAdaptive > 2,
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/api.cpp
>> --- a/source/encoder/api.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/api.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -49,9 +49,6 @@
>> encoder->determineLevelAndProfile(param);
>> encoder->configure(param);
>>
>> - // save a copy of final parameters in TEncCfg
>> - memcpy(&encoder->param, param, sizeof(*param));
>> -
>> x265_print_params(param);
>> encoder->create();
>> encoder->init();
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/compress.cpp
>> --- a/source/encoder/compress.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/compress.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -80,7 +80,7 @@
>>
>> cu->setPartSizeSubParts(partSize, 0, depth);
>> cu->setPredModeSubParts(MODE_INTRA, 0, depth);
>> - cu->setCUTransquantBypassSubParts(m_cfg->getCUTransquantBypassFlagValue(), 0, depth);
>> + cu->setCUTransquantBypassSubParts(m_cfg->m_CUTransquantBypassFlagValue, 0, depth);
>>
>> uint32_t initTrDepth = cu->getPartitionSize(0) == SIZE_2Nx2N ? 0 : 1;
>> uint32_t width = cu->getWidth(0) >> initTrDepth;
>> @@ -198,7 +198,7 @@
>>
>> outTempCU->setPartSizeSubParts(partSize, 0, depth);
>> outTempCU->setPredModeSubParts(MODE_INTER, 0, depth);
>> - outTempCU->setCUTransquantBypassSubParts(m_cfg->getCUTransquantBypassFlagValue(), 0, depth);
>> + outTempCU->setCUTransquantBypassSubParts(m_cfg->m_CUTransquantBypassFlagValue, 0, depth);
>>
>> //do motion compensation only for Luma since luma cost alone is calculated
>> outTempCU->m_totalBits = 0;
>> @@ -224,13 +224,13 @@
>>
>> UChar depth = outTempCU->getDepth(0);
>> outTempCU->setPartSizeSubParts(SIZE_2Nx2N, 0, depth); // interprets depth relative to LCU level
>> - outTempCU->setCUTransquantBypassSubParts(m_cfg->getCUTransquantBypassFlagValue(), 0, depth);
>> + outTempCU->setCUTransquantBypassSubParts(m_cfg->m_CUTransquantBypassFlagValue, 0, depth);
>> outTempCU->getInterMergeCandidates(0, 0, mvFieldNeighbours, interDirNeighbours, numValidMergeCand);
>> outTempCU->setPredModeSubParts(MODE_INTER, 0, depth);
>> outTempCU->setMergeFlag(0, true);
>>
>> outBestCU->setPartSizeSubParts(SIZE_2Nx2N, 0, depth); // interprets depth relative to LCU level
>> - outBestCU->setCUTransquantBypassSubParts(m_cfg->getCUTransquantBypassFlagValue(), 0, depth);
>> + outBestCU->setCUTransquantBypassSubParts(m_cfg->m_CUTransquantBypassFlagValue, 0, depth);
>> outBestCU->setPredModeSubParts(MODE_INTER, 0, depth);
>> outBestCU->setMergeFlag(0, true);
>>
>> @@ -241,8 +241,8 @@
>> for (int mergeCand = 0; mergeCand < numValidMergeCand; ++mergeCand)
>> {
>> /* TODO: check only necessary when -F>1, and ref pixels available is in units of LCU rows */
>> - if (mvFieldNeighbours[0 + 2 * mergeCand].mv.y < (m_cfg->param.searchRange + 1) * 4
>> - && mvFieldNeighbours[1 + 2 * mergeCand].mv.y < (m_cfg->param.searchRange + 1) * 4)
>> + if (mvFieldNeighbours[0 + 2 * mergeCand].mv.y < (m_cfg->param->searchRange + 1) * 4
>> + && mvFieldNeighbours[1 + 2 * mergeCand].mv.y < (m_cfg->param->searchRange + 1) * 4)
>> {
>> // set MC parameters, interprets depth relative to LCU level
>> outTempCU->setMergeIndex(0, mergeCand);
>> @@ -253,7 +253,7 @@
>> // do MC only for Luma part
>> m_search->motionCompensation(outTempCU, m_tmpPredYuv[depth], REF_PIC_LIST_X, 0, true, false);
>> bitsCand = mergeCand + 1;
>> - if (mergeCand == (int)m_cfg->param.maxNumMergeCand - 1)
>> + if (mergeCand == (int)m_cfg->param->maxNumMergeCand - 1)
>> {
>> bitsCand--;
>> }
>> @@ -293,7 +293,7 @@
>> outTempCU->m_totalCost = m_rdCost->calcRdSADCost(outTempCU->m_totalDistortion, outTempCU->m_totalBits);
>> outTempCU->m_sa8dCost = outTempCU->m_totalCost;
>> outBestCU->m_sa8dCost = outTempCU->m_sa8dCost;
>> - if (m_cfg->param.rdLevel >= 1)
>> + if (m_cfg->param->rdLevel >= 1)
>> {
>> //calculate the motion compensation for chroma for the best mode selected
>> int numPart = outBestCU->getNumPartInter();
>> @@ -359,7 +359,7 @@
>> bool bInsidePicture = (rpelx < outTempCU->getSlice()->getSPS()->getPicWidthInLumaSamples()) &&
>> (bpely < outTempCU->getSlice()->getSPS()->getPicHeightInLumaSamples());
>>
>> - if (depth == 0 && m_cfg->param.rdLevel == 0)
>> + if (depth == 0 && m_cfg->param->rdLevel == 0)
>> {
>> m_origYuv[depth]->copyToPicYuv(cu->getPic()->getPicYuvRec(), cu->getAddr(), 0, 0, 0);
>> }
>> @@ -426,8 +426,8 @@
>> /* Compute Merge Cost */
>> xComputeCostMerge2Nx2N(m_bestMergeCU[depth], m_mergeCU[depth], m_modePredYuv[3][depth], m_bestMergeRecoYuv[depth]);
>> bool earlyskip = false;
>> - if (m_cfg->param.rdLevel >= 1)
>> - earlyskip = (m_cfg->param.bEnableEarlySkip && m_bestMergeCU[depth]->isSkipped(0));
>> + if (m_cfg->param->rdLevel >= 1)
>> + earlyskip = (m_cfg->param->bEnableEarlySkip && m_bestMergeCU[depth]->isSkipped(0));
>>
>> if (!earlyskip)
>> {
>> @@ -442,7 +442,7 @@
>> }
>>
>> /*Compute Rect costs*/
>> - if (m_cfg->param.bEnableRectInter)
>> + if (m_cfg->param->bEnableRectInter)
>> {
>> xComputeCostInter(m_interCU_Nx2N[depth], m_modePredYuv[1][depth], SIZE_Nx2N);
>> xComputeCostInter(m_interCU_2NxN[depth], m_modePredYuv[2][depth], SIZE_2NxN);
>> @@ -464,7 +464,7 @@
>> m_modePredYuv[2][depth] = m_bestPredYuv[depth];
>> m_bestPredYuv[depth] = tempYuv;
>> }
>> - if (m_cfg->param.rdLevel > 2)
>> + if (m_cfg->param->rdLevel > 2)
>> {
>> //calculate the motion compensation for chroma for the best mode selected
>> int numPart = outBestCU->getNumPartInter();
>> @@ -493,7 +493,7 @@
>> {
>> /*compute intra cost */
>> bool bdoIntra = true;
>> - if (m_cfg->param.rdLevel > 2)
>> + if (m_cfg->param->rdLevel > 2)
>> {
>> bdoIntra = (outBestCU->getCbf(0, TEXT_LUMA) || outBestCU->getCbf(0, TEXT_CHROMA_U) ||
>> outBestCU->getCbf(0, TEXT_CHROMA_V));
>> @@ -501,7 +501,7 @@
>> if (bdoIntra)
>> {
>> xComputeCostIntraInInter(m_intraInInterCU[depth], SIZE_2Nx2N);
>> - if (m_cfg->param.rdLevel > 2)
>> + if (m_cfg->param->rdLevel > 2)
>> {
>> xEncodeIntraInInter(m_intraInInterCU[depth], m_origYuv[depth], m_modePredYuv[5][depth],
>> m_tmpResiYuv[depth], m_tmpRecoYuv[depth]);
>> @@ -519,7 +519,7 @@
>> }
>> }
>> }
>> - if (m_cfg->param.rdLevel == 2)
>> + if (m_cfg->param->rdLevel == 2)
>> {
>> if (m_bestMergeCU[depth]->m_sa8dCost < outBestCU->m_totalCost)
>> {
>> @@ -548,7 +548,7 @@
>> xEncodeIntraInInter(outBestCU, m_origYuv[depth], m_bestPredYuv[depth], m_tmpResiYuv[depth], m_bestRecoYuv[depth]);
>> }
>> }
>> - if (m_cfg->param.rdLevel == 1)
>> + if (m_cfg->param->rdLevel == 1)
>> {
>> if (m_bestMergeCU[depth]->m_sa8dCost < outBestCU->m_totalCost)
>> {
>> @@ -577,7 +577,7 @@
>> m_search->generateCoeffRecon(outBestCU, m_origYuv[depth], m_bestPredYuv[depth], m_tmpResiYuv[depth], m_bestRecoYuv[depth], false);
>> }
>> }
>> - if (m_cfg->param.rdLevel == 0)
>> + if (m_cfg->param->rdLevel == 0)
>> {
>> if (outBestCU->getPredictionMode(0) == MODE_INTER)
>> {
>> @@ -601,7 +601,7 @@
>> m_bestMergeRecoYuv[depth] = tempYuv;
>> }
>>
>> - if (m_cfg->param.rdLevel > 0) //checkDQP can be done only after residual encoding is done
>> + if (m_cfg->param->rdLevel > 0) //checkDQP can be done only after residual encoding is done
>> xCheckDQP(outBestCU);
>> /* Disable recursive analysis for whole CUs temporarily */
>> if ((outBestCU != 0) && (outBestCU->isSkipped(0)))
>> @@ -609,7 +609,7 @@
>> else
>> bSubBranch = true;
>>
>> - if (m_cfg->param.rdLevel > 1)
>> + if (m_cfg->param->rdLevel > 1)
>> {
>> m_entropyCoder->resetBits();
>> m_entropyCoder->encodeSplitFlag(outBestCU, 0, depth, true);
>> @@ -678,7 +678,7 @@
>> outBestCU->copyToPic((UChar)depth);
>>
>> /* Copy Yuv data to picture Yuv */
>> - if (m_cfg->param.rdLevel != 0)
>> + if (m_cfg->param->rdLevel != 0)
>> xCopyYuv2Pic(outBestCU->getPic(), outBestCU->getAddr(), outBestCU->getZorderIdxInCU(), depth, depth, outBestCU, lpelx, tpely);
>> return;
>> }
>> @@ -717,9 +717,9 @@
>> #endif // if EARLY_EXIT
>> /* Adding costs from best SUbCUs */
>> outTempCU->copyPartFrom(subBestPartCU, nextDepth_partIndex, nextDepth, true); // Keep best part data to current temporary data.
>> - if (m_cfg->param.rdLevel != 0)
>> + if (m_cfg->param->rdLevel != 0)
>> xCopyYuv2Tmp(subBestPartCU->getTotalNumPart() * nextDepth_partIndex, nextDepth);
>> - if (m_cfg->param.rdLevel == 0)
>> + if (m_cfg->param->rdLevel == 0)
>> m_bestPredYuv[nextDepth]->copyToPartYuv(m_tmpPredYuv[depth], subBestPartCU->getTotalNumPart() * nextDepth_partIndex);
>> }
>> else if (bInSlice)
>> @@ -731,14 +731,14 @@
>>
>> if (!bBoundary)
>> {
>> - if (m_cfg->param.rdLevel > 1)
>> + if (m_cfg->param->rdLevel > 1)
>> {
>> m_entropyCoder->resetBits();
>> m_entropyCoder->encodeSplitFlag(outTempCU, 0, depth, true);
>> outTempCU->m_totalBits += m_entropyCoder->getNumberOfWrittenBits(); // split bits
>> }
>> }
>> - if (m_cfg->param.rdLevel > 1)
>> + if (m_cfg->param->rdLevel > 1)
>> outTempCU->m_totalCost = m_rdCost->calcRdCost(outTempCU->m_totalDistortion, outTempCU->m_totalBits);
>> else
>> outTempCU->m_totalCost = m_rdCost->calcRdSADCost(outTempCU->m_totalDistortion, outTempCU->m_totalBits);
>> @@ -811,11 +811,11 @@
>> /* Copy Best data to Picture for next partition prediction. */
>> outBestCU->copyToPic((UChar)depth);
>>
>> - if (m_cfg->param.rdLevel == 0 && depth == 0)
>> + if (m_cfg->param->rdLevel == 0 && depth == 0)
>> {
>> encodeResidue(outBestCU, outBestCU, 0, 0);
>> }
>> - else if (m_cfg->param.rdLevel != 0)
>> + else if (m_cfg->param->rdLevel != 0)
>> {
>> /* Copy Yuv data to picture Yuv */
>> xCopyYuv2Pic(outBestCU->getPic(), outBestCU->getAddr(), outBestCU->getZorderIdxInCU(), depth, depth, outBestCU, lpelx, tpely);
>> @@ -874,13 +874,13 @@
>> src2stride = m_bestPredYuv[0]->getCStride();
>> src1stride = m_origYuv[0]->getCStride();
>> dststride = m_tmpResiYuv[depth]->m_cwidth;
>> - primitives.chroma[m_cfg->param.internalCsp].sub_ps[part](dst, dststride, src1, src2, src1stride, src2stride);
>> + primitives.chroma[m_cfg->param->internalCsp].sub_ps[part](dst, dststride, src1, src2, src1stride, src2stride);
>>
>> src2 = m_bestPredYuv[0]->getCrAddr(absPartIdx);
>> src1 = m_origYuv[0]->getCrAddr(absPartIdx);
>> dst = m_tmpResiYuv[depth]->getCrAddr(0);
>> dststride = m_tmpResiYuv[depth]->m_cwidth;
>> - primitives.chroma[m_cfg->param.internalCsp].sub_ps[part](dst, dststride, src1, src2, src1stride, src2stride);
>> + primitives.chroma[m_cfg->param->internalCsp].sub_ps[part](dst, dststride, src1, src2, src1stride, src2stride);
>>
>> //Residual encoding
>> m_search->residualTransformQuantInter(cu, 0, 0, m_tmpResiYuv[depth], cu->getDepth(0), true);
>> @@ -910,12 +910,12 @@
>> dststride = m_bestRecoYuv[depth]->getCStride();
>> src1stride = m_bestPredYuv[0]->getCStride();
>> src2stride = m_tmpResiYuv[depth]->m_cwidth;
>> - primitives.chroma[m_cfg->param.internalCsp].add_ps[part](reco, dststride, pred, res, src1stride, src2stride);
>> + primitives.chroma[m_cfg->param->internalCsp].add_ps[part](reco, dststride, pred, res, src1stride, src2stride);
>>
>> pred = m_bestPredYuv[0]->getCrAddr(absPartIdx);
>> res = m_tmpResiYuv[depth]->getCrAddr(0);
>> reco = m_bestRecoYuv[depth]->getCrAddr(0);
>> - primitives.chroma[m_cfg->param.internalCsp].add_ps[part](reco, dststride, pred, res, src1stride, src2stride);
>> + primitives.chroma[m_cfg->param->internalCsp].add_ps[part](reco, dststride, pred, res, src1stride, src2stride);
>> m_bestRecoYuv[depth]->copyToPicYuv(lcu->getPic()->getPicYuvRec(), lcu->getAddr(), absPartIdx, 0, 0);
>> return;
>> }
>> @@ -934,11 +934,11 @@
>> dst = rec->getCbAddr(cu->getAddr(), absPartIdx);
>> srcstride = m_bestPredYuv[0]->getCStride();
>> dststride = rec->getCStride();
>> - primitives.chroma[m_cfg->param.internalCsp].copy_pp[part](dst, dststride, src, srcstride);
>> + primitives.chroma[m_cfg->param->internalCsp].copy_pp[part](dst, dststride, src, srcstride);
>>
>> src = m_bestPredYuv[0]->getCrAddr(absPartIdx);
>> dst = rec->getCrAddr(cu->getAddr(), absPartIdx);
>> - primitives.chroma[m_cfg->param.internalCsp].copy_pp[part](dst, dststride, src, srcstride);
>> + primitives.chroma[m_cfg->param->internalCsp].copy_pp[part](dst, dststride, src, srcstride);
>> }
>> else
>> {
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/cturow.cpp
>> --- a/source/encoder/cturow.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/cturow.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -33,7 +33,7 @@
>> {
>> m_rdGoOnSbacCoder.init(&m_rdGoOnBinCodersCABAC);
>> m_sbacCoder.init(&m_binCoderCABAC);
>> - m_trQuant.init(1 << top->getQuadtreeTULog2MaxSize(), top->bEnableRDOQ, top->bEnableRDOQTS, top->param.bEnableTSkipFast);
>> + m_trQuant.init(1 << top->m_quadtreeTULog2MaxSize, top->bEnableRDOQ, top->bEnableRDOQTS, top->param->bEnableTSkipFast);
>>
>> m_rdSbacCoders = new TEncSbac * *[g_maxCUDepth + 1];
>> m_binCodersCABAC = new TEncBinCABAC * *[g_maxCUDepth + 1];
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/dpb.cpp
>> --- a/source/encoder/dpb.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/dpb.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -23,7 +23,7 @@
>>
>> #include "TLibCommon/TComPic.h"
>> #include "TLibCommon/TComSlice.h"
>> -#include "TLibEncoder/TEncCfg.h"
>> +#include "encoder.h"
>>
>> #include "PPA/ppa.h"
>> #include "dpb.h"
>> @@ -36,7 +36,7 @@
>> while (!m_picList.empty())
>> {
>> TComPic* pic = m_picList.popFront();
>> - pic->destroy(m_cfg->param.bframes);
>> + pic->destroy(m_cfg->param->bframes);
>> delete pic;
>> }
>> }
>> @@ -380,7 +380,7 @@
>> }
>> if (pic->m_lowres.bKeyframe)
>> {
>> - if (m_cfg->param.bOpenGOP)
>> + if (m_cfg->param->bOpenGOP)
>> {
>> return NAL_UNIT_CODED_SLICE_CRA;
>> }
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/dpb.h
>> --- a/source/encoder/dpb.h Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/dpb.h Mon Mar 03 14:24:34 2014 -0800
>> @@ -32,7 +32,7 @@
>> class FrameEncoder;
>> class TComPic;
>> class TComSlice;
>> -class TEncCfg;
>> +class Encoder;
>>
>> class DPB
>> {
>> @@ -41,18 +41,18 @@
>> int m_lastIDR;
>> int m_pocCRA;
>> bool m_bRefreshPending;
>> - TEncCfg* m_cfg;
>> + Encoder* m_cfg;
> Can we just pass a param to dpb?
If you mean remove m_cfg from DPB then yes, that can be done but I would
prefer to do it in a separate patch.
>
>> PicList m_picList;
>> int m_maxRefL0;
>> int m_maxRefL1;
>>
>> - DPB(TEncCfg *cfg)
>> + DPB(Encoder *cfg)
>> : m_cfg(cfg)
>> {
>> m_lastIDR = 0;
>> m_pocCRA = 0;
>> m_bRefreshPending = false;
>> - m_maxRefL0 = cfg->param.maxNumReferences;
>> + m_maxRefL0 = cfg->param->maxNumReferences;
>> m_maxRefL1 = 1;
>> }
>>
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/encoder.cpp
>> --- a/source/encoder/encoder.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/encoder.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -93,14 +93,14 @@
>> if (!primitives.sad[0])
>> {
>> // this should be an impossible condition when using our public API, and indicates a serious bug.
>> - x265_log(¶m, X265_LOG_ERROR, "Primitives must be initialized before encoder is created\n");
>> + x265_log(param, X265_LOG_ERROR, "Primitives must be initialized before encoder is created\n");
>> abort();
>> }
>>
>> - m_frameEncoder = new FrameEncoder[param.frameNumThreads];
>> + m_frameEncoder = new FrameEncoder[param->frameNumThreads];
>> if (m_frameEncoder)
>> {
>> - for (int i = 0; i < param.frameNumThreads; i++)
>> + for (int i = 0; i < param->frameNumThreads; i++)
>> {
>> m_frameEncoder[i].setThreadPool(m_threadPool);
>> }
>> @@ -111,22 +111,22 @@
>> m_numWPFrames = 0;
>>
>> /* Try to open CSV file handle */
>> - if (param.csvfn)
>> + if (param->csvfn)
>> {
>> - m_csvfpt = fopen(param.csvfn, "r");
>> + m_csvfpt = fopen(param->csvfn, "r");
>> if (m_csvfpt)
>> {
>> // file already exists, re-open for append
>> fclose(m_csvfpt);
>> - m_csvfpt = fopen(param.csvfn, "ab");
>> + m_csvfpt = fopen(param->csvfn, "ab");
>> }
>> else
>> {
>> // new CSV file, write header
>> - m_csvfpt = fopen(param.csvfn, "wb");
>> + m_csvfpt = fopen(param->csvfn, "wb");
>> if (m_csvfpt)
>> {
>> - if (param.logLevel >= X265_LOG_DEBUG)
>> + if (param->logLevel >= X265_LOG_DEBUG)
>> fprintf(m_csvfpt, "Encode Order, Type, POC, QP, Bits, Y PSNR, U PSNR, V PSNR, YUV PSNR, SSIM, SSIM (dB), Encoding time, Elapsed time, List 0, List 1\n");
>> else
>> fprintf(m_csvfpt, "Command, Date/Time, Elapsed Time, FPS, Bitrate, Y PSNR, U PSNR, V PSNR, Global PSNR, SSIM, SSIM (dB), Version\n");
>> @@ -139,7 +139,7 @@
>> {
>> if (m_frameEncoder)
>> {
>> - for (int i = 0; i < param.frameNumThreads; i++)
>> + for (int i = 0; i < param->frameNumThreads; i++)
>> {
>> // Ensure frame encoder is idle before destroying it
>> m_frameEncoder[i].getEncodedPicture(NULL);
>> @@ -152,7 +152,7 @@
>> while (!m_freeList.empty())
>> {
>> TComPic* pic = m_freeList.popFront();
>> - pic->destroy(param.bframes);
>> + pic->destroy(param->bframes);
>> delete pic;
>> }
>>
>> @@ -179,12 +179,12 @@
>> {
>> if (m_frameEncoder)
>> {
>> - int numRows = (param.sourceHeight + g_maxCUHeight - 1) / g_maxCUHeight;
>> - for (int i = 0; i < param.frameNumThreads; i++)
>> + int numRows = (param->sourceHeight + g_maxCUHeight - 1) / g_maxCUHeight;
>> + for (int i = 0; i < param->frameNumThreads; i++)
>> {
>> if (!m_frameEncoder[i].init(this, numRows))
>> {
>> - x265_log(¶m, X265_LOG_ERROR, "Unable to initialize frame encoder, aborting\n");
>> + x265_log(param, X265_LOG_ERROR, "Unable to initialize frame encoder, aborting\n");
>> m_aborted = true;
>> }
>> }
>> @@ -200,7 +200,7 @@
>> * this picture */
>> void Encoder::signalReconRowCompleted(int poc)
>> {
>> - for (int i = 0; i < param.frameNumThreads; i++)
>> + for (int i = 0; i < param->frameNumThreads; i++)
>> {
>> if (m_frameEncoder[i].m_blockRefPOC == poc)
>> m_frameEncoder[i].m_reconRowWait.trigger();
>> @@ -216,8 +216,8 @@
>> {
>> int encIdx, curIdx;
>>
>> - curIdx = (m_curEncoder + param.frameNumThreads - 1) % param.frameNumThreads;
>> - encIdx = (curIdx + 1) % param.frameNumThreads;
>> + curIdx = (m_curEncoder + param->frameNumThreads - 1) % param->frameNumThreads;
>> + encIdx = (curIdx + 1) % param->frameNumThreads;
>> while (encIdx != curIdx)
>> {
>> FrameEncoder *encoder = &m_frameEncoder[encIdx];
>> @@ -228,7 +228,7 @@
>> rc->bufferFill = X265_MAX(rc->bufferFill, 0);
>> rc->bufferFill += encoder->m_rce.bufferRate;
>> rc->bufferFill = X265_MIN(rc->bufferFill, rc->bufferSize);
>> - encIdx = (encIdx + 1) % param.frameNumThreads;
>> + encIdx = (encIdx + 1) % param->frameNumThreads;
>> }
>> }
>>
>> @@ -280,15 +280,15 @@
>>
>> if (pic_in)
>> {
>> - if (pic_in->colorSpace != param.internalCsp)
>> + if (pic_in->colorSpace != param->internalCsp)
>> {
>> - x265_log(¶m, X265_LOG_ERROR, "Unsupported color space (%d) on input\n",
>> + x265_log(param, X265_LOG_ERROR, "Unsupported color space (%d) on input\n",
>> pic_in->colorSpace);
>> return -1;
>> }
>> if (pic_in->bitDepth < 8 || pic_in->bitDepth > 16)
>> {
>> - x265_log(¶m, X265_LOG_ERROR, "Input bit depth (%d) must be between 8 and 16\n",
>> + x265_log(param, X265_LOG_ERROR, "Input bit depth (%d) must be between 8 and 16\n",
>> pic_in->bitDepth);
>> return -1;
>> }
>> @@ -300,15 +300,15 @@
>> if (!pic || !pic->create(this))
>> {
>> m_aborted = true;
>> - x265_log(¶m, X265_LOG_ERROR, "memory allocation failure, aborting encode\n");
>> + x265_log(param, X265_LOG_ERROR, "memory allocation failure, aborting encode\n");
>> if (pic)
>> {
>> - pic->destroy(param.bframes);
>> + pic->destroy(param->bframes);
>> delete pic;
>> }
>> return -1;
>> }
>> - if (param.bEnableSAO)
>> + if (param->bEnableSAO)
>> {
>> // TODO: these should be allocated on demand within the encoder
>> // NOTE: the SAO pointer from m_frameEncoder for read m_maxSplitLevel, etc, we can remove it later
>> @@ -331,7 +331,7 @@
>>
>> // Encoder holds a reference count until collecting stats
>> ATOMIC_INC(&pic->m_countRefEncoders);
>> - if (param.rc.aqMode || param.bEnableWeightedPred)
>> + if (param->rc.aqMode || param->bEnableWeightedPred)
>> m_rateControl->calcAdaptiveQuantFrame(pic);
>> m_lookahead->addPicture(pic, pic_in->sliceType);
>> }
>> @@ -340,7 +340,7 @@
>> m_lookahead->flush();
>>
>> FrameEncoder *curEncoder = &m_frameEncoder[m_curEncoder];
>> - m_curEncoder = (m_curEncoder + 1) % param.frameNumThreads;
>> + m_curEncoder = (m_curEncoder + 1) % param->frameNumThreads;
>> int ret = 0;
>>
>> // getEncodedPicture() should block until the FrameEncoder has completed
>> @@ -359,7 +359,7 @@
>> do
>> {
>> curEncoder = &m_frameEncoder[m_curEncoder];
>> - m_curEncoder = (m_curEncoder + 1) % param.frameNumThreads;
>> + m_curEncoder = (m_curEncoder + 1) % param->frameNumThreads;
>> out = curEncoder->getEncodedPicture(nalunits);
>> }
>> while (!out && flushed != m_curEncoder);
>> @@ -486,21 +486,21 @@
>>
>> char* Encoder::statsString(EncStats& stat, char* buffer)
>> {
>> - double fps = (double)param.fpsNum / param.fpsDenom;
>> + double fps = (double)param->fpsNum / param->fpsDenom;
>> double scale = fps / 1000 / (double)stat.m_numPics;
>>
>> int len = sprintf(buffer, "%-6d ", stat.m_numPics);
>>
>> len += sprintf(buffer + len, "Avg QP:%2.2lf", stat.m_totalQp / (double)stat.m_numPics);
>> len += sprintf(buffer + len, " kb/s: %-8.2lf", stat.m_accBits * scale);
>> - if (param.bEnablePsnr)
>> + if (param->bEnablePsnr)
>> {
>> len += sprintf(buffer + len, " PSNR Mean: Y:%.3lf U:%.3lf V:%.3lf",
>> stat.m_psnrSumY / (double)stat.m_numPics,
>> stat.m_psnrSumU / (double)stat.m_numPics,
>> stat.m_psnrSumV / (double)stat.m_numPics);
>> }
>> - if (param.bEnableSsim)
>> + if (param->bEnableSsim)
>> {
>> sprintf(buffer + len, " SSIM Mean: %.6lf (%.3lfdB)",
>> stat.m_globalSsim / (double)stat.m_numPics,
>> @@ -522,7 +522,7 @@
>> StatisticLog finalLog;
>> for (int depth = 0; depth < (int)g_maxCUDepth; depth++)
>> {
>> - for (int j = 0; j < param.frameNumThreads; j++)
>> + for (int j = 0; j < param->frameNumThreads; j++)
>> {
>> for (int row = 0; row < m_frameEncoder[0].m_numRows; row++)
>> {
>> @@ -622,13 +622,13 @@
>> if (cntInter)
>> {
>> len += sprintf(stats + len, " Inter "LL "%%", cntInter);
>> - if (param.bEnableAMP)
>> + if (param->bEnableAMP)
>> len += sprintf(stats + len, "(%dx%d "LL "%% %dx%d "LL "%% %dx%d "LL "%% AMP "LL "%%)",
>> cuSize, cuSize, cuInterDistribution[0],
>> cuSize / 2, cuSize, cuInterDistribution[2],
>> cuSize, cuSize / 2, cuInterDistribution[1],
>> cuInterDistribution[3]);
>> - else if (param.bEnableRectInter)
>> + else if (param->bEnableRectInter)
>> len += sprintf(stats + len, "(%dx%d "LL "%% %dx%d "LL "%% %dx%d "LL "%%)",
>> cuSize, cuSize, cuInterDistribution[0],
>> cuSize / 2, cuSize, cuInterDistribution[2],
>> @@ -654,36 +654,36 @@
>> }
>> const char slicechars[] = "BPI";
>> if (stats[0])
>> - x265_log(¶m, X265_LOG_INFO, "%c%-2d: %s\n", slicechars[sliceType], cuSize, stats);
>> + x265_log(param, X265_LOG_INFO, "%c%-2d: %s\n", slicechars[sliceType], cuSize, stats);
>> }
>> }
>>
>> #endif // if LOG_CU_STATISTICS
>> - if (param.logLevel >= X265_LOG_INFO)
>> + if (param->logLevel >= X265_LOG_INFO)
>> {
>> char buffer[200];
>> if (m_analyzeI.m_numPics)
>> - x265_log(¶m, X265_LOG_INFO, "frame I: %s\n", statsString(m_analyzeI, buffer));
>> + x265_log(param, X265_LOG_INFO, "frame I: %s\n", statsString(m_analyzeI, buffer));
>> if (m_analyzeP.m_numPics)
>> - x265_log(¶m, X265_LOG_INFO, "frame P: %s\n", statsString(m_analyzeP, buffer));
>> + x265_log(param, X265_LOG_INFO, "frame P: %s\n", statsString(m_analyzeP, buffer));
>> if (m_analyzeB.m_numPics)
>> - x265_log(¶m, X265_LOG_INFO, "frame B: %s\n", statsString(m_analyzeB, buffer));
>> + x265_log(param, X265_LOG_INFO, "frame B: %s\n", statsString(m_analyzeB, buffer));
>> if (m_analyzeAll.m_numPics)
>> - x265_log(¶m, X265_LOG_INFO, "global : %s\n", statsString(m_analyzeAll, buffer));
>> - if (param.bEnableWeightedPred && m_analyzeP.m_numPics)
>> + x265_log(param, X265_LOG_INFO, "global : %s\n", statsString(m_analyzeAll, buffer));
>> + if (param->bEnableWeightedPred && m_analyzeP.m_numPics)
>> {
>> - x265_log(¶m, X265_LOG_INFO, "%d of %d (%.2f%%) P frames weighted\n",
>> + x265_log(param, X265_LOG_INFO, "%d of %d (%.2f%%) P frames weighted\n",
>> m_numWPFrames, m_analyzeP.m_numPics, (float)100.0 * m_numWPFrames / m_analyzeP.m_numPics);
>> }
>> int pWithB = 0;
>> - for (int i = 0; i <= param.bframes; i++)
>> + for (int i = 0; i <= param->bframes; i++)
>> pWithB += m_lookahead->histogram[i];
>> if (pWithB)
>> {
>> int p = 0;
>> - for (int i = 0; i <= param.bframes; i++)
>> + for (int i = 0; i <= param->bframes; i++)
>> p += sprintf(buffer + p, "%.1f%% ", 100. * m_lookahead->histogram[i] / pWithB);
>> - x265_log(¶m, X265_LOG_INFO, "consecutive B-frames: %s\n", buffer);
>> + x265_log(param, X265_LOG_INFO, "consecutive B-frames: %s\n", buffer);
>> }
>> }
>> }
>> @@ -703,7 +703,7 @@
>> {
>> stats->globalSsim = m_analyzeAll.m_globalSsim / stats->encodedPictureCount;
>> stats->globalPsnr = (stats->globalPsnrY * 6 + stats->globalPsnrU + stats->globalPsnrV) / (8 * stats->encodedPictureCount);
>> - stats->elapsedVideoTime = (double)stats->encodedPictureCount * param.fpsDenom / param.fpsNum;
>> + stats->elapsedVideoTime = (double)stats->encodedPictureCount * param->fpsDenom / param->fpsNum;
>> stats->bitrate = (0.001f * stats->accBits) / stats->elapsedVideoTime;
>> }
>> else
>> @@ -722,9 +722,9 @@
>>
>> void Encoder::writeLog(int argc, char **argv)
>> {
>> - if (param.logLevel <= X265_LOG_DEBUG && m_csvfpt)
>> + if (param->logLevel <= X265_LOG_DEBUG && m_csvfpt)
>> {
>> - if (param.logLevel == X265_LOG_DEBUG)
>> + if (param->logLevel == X265_LOG_DEBUG)
>> {
>> fprintf(m_csvfpt, "Summary\n");
>> fprintf(m_csvfpt, "Command, Date/Time, Elapsed Time, FPS, Bitrate, Y PSNR, U PSNR, V PSNR, Global PSNR, SSIM, SSIM (dB), Version\n");
>> @@ -752,13 +752,13 @@
>> fprintf(m_csvfpt, "%.2f, %.2f, %.2f,",
>> stats.elapsedEncodeTime, stats.encodedPictureCount / stats.elapsedEncodeTime, stats.bitrate);
>>
>> - if (param.bEnablePsnr)
>> + if (param->bEnablePsnr)
>> fprintf(m_csvfpt, " %.3lf, %.3lf, %.3lf, %.3lf,",
>> stats.globalPsnrY / stats.encodedPictureCount, stats.globalPsnrU / stats.encodedPictureCount,
>> stats.globalPsnrV / stats.encodedPictureCount, stats.globalPsnr);
>> else
>> fprintf(m_csvfpt, " -, -, -, -,");
>> - if (param.bEnableSsim)
>> + if (param->bEnableSsim)
>> fprintf(m_csvfpt, " %.6f, %6.3f,", stats.globalSsim, x265_ssim(stats.globalSsim));
>> else
>> fprintf(m_csvfpt, " -, -,");
>> @@ -821,13 +821,13 @@
>> m_analyzeAll.addBits(bits);
>> m_analyzeAll.addQP(pic->m_avgQpAq);
>>
>> - if (param.bEnablePsnr)
>> + if (param->bEnablePsnr)
>> {
>> m_analyzeAll.addPsnr(psnrY, psnrU, psnrV);
>> }
>>
>> double ssim = 0.0;
>> - if (param.bEnableSsim && pic->m_ssimCnt > 0)
>> + if (param->bEnableSsim && pic->m_ssimCnt > 0)
>> {
>> ssim = pic->m_ssim / pic->m_ssimCnt;
>> m_analyzeAll.addSsim(ssim);
>> @@ -836,32 +836,32 @@
>> {
>> m_analyzeI.addBits(bits);
>> m_analyzeI.addQP(pic->m_avgQpAq);
>> - if (param.bEnablePsnr)
>> + if (param->bEnablePsnr)
>> m_analyzeI.addPsnr(psnrY, psnrU, psnrV);
>> - if (param.bEnableSsim)
>> + if (param->bEnableSsim)
>> m_analyzeI.addSsim(ssim);
>> }
>> else if (slice->isInterP())
>> {
>> m_analyzeP.addBits(bits);
>> m_analyzeP.addQP(pic->m_avgQpAq);
>> - if (param.bEnablePsnr)
>> + if (param->bEnablePsnr)
>> m_analyzeP.addPsnr(psnrY, psnrU, psnrV);
>> - if (param.bEnableSsim)
>> + if (param->bEnableSsim)
>> m_analyzeP.addSsim(ssim);
>> }
>> else if (slice->isInterB())
>> {
>> m_analyzeB.addBits(bits);
>> m_analyzeB.addQP(pic->m_avgQpAq);
>> - if (param.bEnablePsnr)
>> + if (param->bEnablePsnr)
>> m_analyzeB.addPsnr(psnrY, psnrU, psnrV);
>> - if (param.bEnableSsim)
>> + if (param->bEnableSsim)
>> m_analyzeB.addSsim(ssim);
>> }
>>
>> // if debug log level is enabled, per frame logging is performed
>> - if (param.logLevel >= X265_LOG_DEBUG)
>> + if (param->logLevel >= X265_LOG_DEBUG)
>> {
>> char c = (slice->isIntra() ? 'I' : slice->isInterP() ? 'P' : 'B');
>> int poc = slice->getPOC();
>> @@ -871,9 +871,9 @@
>> char buf[1024];
>> int p;
>> p = sprintf(buf, "POC:%d %c QP %2.2lf(%d) %10d bits", poc, c, pic->m_avgQpAq, slice->getSliceQp(), (int)bits);
>> - if (param.bEnablePsnr)
>> + if (param->bEnablePsnr)
>> p += sprintf(buf + p, " [Y:%6.2lf U:%6.2lf V:%6.2lf]", psnrY, psnrU, psnrV);
>> - if (param.bEnableSsim)
>> + if (param->bEnableSsim)
>> p += sprintf(buf + p, " [SSIM: %.3lfdB]", x265_ssim(ssim));
>>
>> if (!slice->isIntra())
>> @@ -897,11 +897,11 @@
>> {
>> fprintf(m_csvfpt, "%d, %c-SLICE, %4d, %2.2lf, %10d,", m_outputCount++, c, poc, pic->m_avgQpAq, (int)bits);
>> double psnr = (psnrY * 6 + psnrU + psnrV) / 8;
>> - if (param.bEnablePsnr)
>> + if (param->bEnablePsnr)
>> fprintf(m_csvfpt, "%.3lf, %.3lf, %.3lf, %.3lf,", psnrY, psnrU, psnrV, psnr);
>> else
>> fprintf(m_csvfpt, " -, -, -, -,");
>> - if (param.bEnableSsim)
>> + if (param->bEnableSsim)
>> fprintf(m_csvfpt, " %.6f, %6.3f,", ssim, x265_ssim(ssim));
>> else
>> fprintf(m_csvfpt, " -, -,");
>> @@ -927,26 +927,26 @@
>> fprintf(m_csvfpt, "\n");
>> }
>>
>> - if (param.decodedPictureHashSEI && param.logLevel >= X265_LOG_FULL)
>> + if (param->decodedPictureHashSEI && param->logLevel >= X265_LOG_FULL)
>> {
>> const char* digestStr = NULL;
>> - if (param.decodedPictureHashSEI == 1)
>> + if (param->decodedPictureHashSEI == 1)
>> {
>> digestStr = digestToString(curEncoder->m_seiReconPictureDigest.digest, 16);
>> p += sprintf(buf + p, " [MD5:%s]", digestStr);
>> }
>> - else if (param.decodedPictureHashSEI == 2)
>> + else if (param->decodedPictureHashSEI == 2)
>> {
>> digestStr = digestToString(curEncoder->m_seiReconPictureDigest.digest, 2);
>> p += sprintf(buf + p, " [CRC:%s]", digestStr);
>> }
>> - else if (param.decodedPictureHashSEI == 3)
>> + else if (param->decodedPictureHashSEI == 3)
>> {
>> digestStr = digestToString(curEncoder->m_seiReconPictureDigest.digest, 4);
>> p += sprintf(buf + p, " [Checksum:%s]", digestStr);
>> }
>> }
>> - x265_log(¶m, X265_LOG_DEBUG, "%s\n", buf);
>> + x265_log(param, X265_LOG_DEBUG, "%s\n", buf);
>> fflush(stderr);
>> }
>> }
>> @@ -984,10 +984,10 @@
>> /* XXX: may be a good idea to refactor the above into a function
>> * that chooses the actual compatibility based upon options */
>>
>> - sps->setPicWidthInLumaSamples(param.sourceWidth);
>> - sps->setPicHeightInLumaSamples(param.sourceHeight);
>> + sps->setPicWidthInLumaSamples(param->sourceWidth);
>> + sps->setPicHeightInLumaSamples(param->sourceHeight);
>> sps->setConformanceWindow(m_conformanceWindow);
>> - sps->setChromaFormatIdc(param.internalCsp);
>> + sps->setChromaFormatIdc(param->internalCsp);
>> sps->setMaxCUWidth(g_maxCUWidth);
>> sps->setMaxCUHeight(g_maxCUHeight);
>> sps->setMaxCUDepth(g_maxCUDepth);
>> @@ -1009,8 +1009,8 @@
>>
>> sps->setQuadtreeTULog2MaxSize(m_quadtreeTULog2MaxSize);
>> sps->setQuadtreeTULog2MinSize(m_quadtreeTULog2MinSize);
>> - sps->setQuadtreeTUMaxDepthInter(param.tuQTMaxInterDepth);
>> - sps->setQuadtreeTUMaxDepthIntra(param.tuQTMaxIntraDepth);
>> + sps->setQuadtreeTUMaxDepthInter(param->tuQTMaxInterDepth);
>> + sps->setQuadtreeTUMaxDepthIntra(param->tuQTMaxIntraDepth);
>>
>> sps->setTMVPFlagsPresent(false);
>> sps->setUseLossless(m_useLossless);
>> @@ -1019,10 +1019,10 @@
>>
>> for (uint32_t i = 0; i < g_maxCUDepth - g_addCUDepth; i++)
>> {
>> - sps->setAMPAcc(i, param.bEnableAMP);
>> + sps->setAMPAcc(i, param->bEnableAMP);
>> }
>>
>> - sps->setUseAMP(param.bEnableAMP);
>> + sps->setUseAMP(param->bEnableAMP);
>>
>> for (uint32_t i = g_maxCUDepth - g_addCUDepth; i < g_maxCUDepth; i++)
>> {
>> @@ -1035,7 +1035,7 @@
>> sps->setQpBDOffsetY(6 * (X265_DEPTH - 8));
>> sps->setQpBDOffsetC(6 * (X265_DEPTH - 8));
>>
>> - sps->setUseSAO(param.bEnableSAO);
>> + sps->setUseSAO(param->bEnableSAO);
>>
>> // TODO: hard-code these values in SPS code
>> sps->setMaxTLayers(1);
>> @@ -1054,67 +1054,69 @@
>>
>> sps->setScalingListFlag((m_useScalingListId == 0) ? 0 : 1);
>>
>> - sps->setUseStrongIntraSmoothing(param.bEnableStrongIntraSmoothing);
>> + sps->setUseStrongIntraSmoothing(param->bEnableStrongIntraSmoothing);
>>
>> - sps->setVuiParametersPresentFlag(getVuiParametersPresentFlag());
>> + sps->setVuiParametersPresentFlag(param->bEnableVuiParametersPresentFlag);
>> if (sps->getVuiParametersPresentFlag())
>> {
>> TComVUI* vui = sps->getVuiParameters();
>> - vui->setAspectRatioInfoPresentFlag(getAspectRatioInfoPresentFlag());
>> - vui->setAspectRatioIdc(getAspectRatioIdc());
>> - vui->setSarWidth(getSarWidth());
>> - vui->setSarHeight(getSarHeight());
>> - vui->setOverscanInfoPresentFlag(getOverscanInfoPresentFlag());
>> - vui->setOverscanAppropriateFlag(getOverscanAppropriateFlag());
>> - vui->setVideoSignalTypePresentFlag(getVideoSignalTypePresentFlag());
>> - vui->setVideoFormat(getVideoFormat());
>> - vui->setVideoFullRangeFlag(getVideoFullRangeFlag());
>> - vui->setColourDescriptionPresentFlag(getColourDescriptionPresentFlag());
>> - vui->setColourPrimaries(getColourPrimaries());
>> - vui->setTransferCharacteristics(getTransferCharacteristics());
>> - vui->setMatrixCoefficients(getMatrixCoefficients());
>> - vui->setChromaLocInfoPresentFlag(getChromaLocInfoPresentFlag());
>> - vui->setChromaSampleLocTypeTopField(getChromaSampleLocTypeTopField());
>> - vui->setChromaSampleLocTypeBottomField(getChromaSampleLocTypeBottomField());
>> - vui->setNeutralChromaIndicationFlag(getNeutralChromaIndicationFlag());
>> - vui->setDefaultDisplayWindow(getDefaultDisplayWindow());
>> - vui->setFrameFieldInfoPresentFlag(getFrameFieldInfoPresentFlag());
>> - vui->setFieldSeqFlag(getFieldSeqFlag());
>> - vui->setHrdParametersPresentFlag(getVuiHrdParametersPresentFlag());
>> - vui->getTimingInfo()->setTimingInfoPresentFlag(getVuiTimingInfoPresentFlag());
>> - vui->getTimingInfo()->setNumUnitsInTick(getVuiNumUnitsInTick());
>> - vui->getTimingInfo()->setTimeScale(getVuiTimeScale());
>> - vui->getTimingInfo()->setPocProportionalToTimingFlag(getPocProportionalToTimingFlag());
>> - vui->getTimingInfo()->setNumTicksPocDiffOneMinus1(getNumTicksPocDiffOneMinus1());
>> - vui->setBitstreamRestrictionFlag(getBitstreamRestrictionFlag());
>> - vui->setTilesFixedStructureFlag(getTilesFixedStructureFlag());
>> - vui->setMotionVectorsOverPicBoundariesFlag(getMotionVectorsOverPicBoundariesFlag());
>> - vui->setRestrictedRefPicListsFlag(getRestrictedRefPicListsFlag());
>> - vui->setMinSpatialSegmentationIdc(getMinSpatialSegmentationIdc());
>> - vui->setMaxBytesPerPicDenom(getMaxBytesPerPicDenom());
>> - vui->setMaxBitsPerMinCuDenom(getMaxBitsPerMinCuDenom());
>> - vui->setLog2MaxMvLengthHorizontal(getLog2MaxMvLengthHorizontal());
>> - vui->setLog2MaxMvLengthVertical(getLog2MaxMvLengthVertical());
>> + vui->setAspectRatioInfoPresentFlag(param->bEnableAspectRatioIdc);
>> + vui->setAspectRatioIdc(param->aspectRatioIdc);
>> + vui->setSarWidth(param->sarWidth);
>> + vui->setSarHeight(param->sarHeight);
>> + vui->setOverscanInfoPresentFlag(param->bEnableOverscanInfoPresentFlag);
>> + vui->setOverscanAppropriateFlag(param->bEnableOverscanAppropriateFlag);
>> + vui->setVideoSignalTypePresentFlag(param->bEnableVideoSignalTypePresentFlag);
>> + vui->setVideoFormat(param->videoFormat);
>> + vui->setVideoFullRangeFlag(param->bEnableVideoFullRangeFlag);
>> + vui->setColourDescriptionPresentFlag(param->bEnableColorDescriptionPresentFlag);
>> + vui->setColourPrimaries(param->colorPrimaries);
>> + vui->setTransferCharacteristics(param->transferCharacteristics);
>> + vui->setMatrixCoefficients(param->matrixCoeffs);
>> + vui->setChromaLocInfoPresentFlag(param->bEnableChromaLocInfoPresentFlag);
>> + vui->setChromaSampleLocTypeTopField(param->chromaSampleLocTypeTopField);
>> + vui->setChromaSampleLocTypeBottomField(param->chromaSampleLocTypeBottomField);
>> + vui->setNeutralChromaIndicationFlag(m_neutralChromaIndicationFlag);
>> + vui->setDefaultDisplayWindow(m_defaultDisplayWindow);
>> + vui->setFrameFieldInfoPresentFlag(param->bEnableFrameFieldInfoPresentFlag);
>> + vui->setFieldSeqFlag(param->bEnableFieldSeqFlag);
>> + vui->setHrdParametersPresentFlag(param->bEnableVuiHrdParametersPresentFlag);
>> + vui->getHrdParameters()->setNalHrdParametersPresentFlag(param->bEnableNalHrdParametersPresentFlag);
>> + vui->getHrdParameters()->setSubPicHrdParamsPresentFlag(param->bEnableSubPicHrdParamsPresentFlag);
>> + vui->getTimingInfo()->setTimingInfoPresentFlag(param->bEnableVuiTimingInfoPresentFlag);
>> + vui->getTimingInfo()->setNumUnitsInTick(param->fpsDenom);
>> + vui->getTimingInfo()->setTimeScale(param->fpsNum);
>> + vui->getTimingInfo()->setPocProportionalToTimingFlag(m_pocProportionalToTimingFlag);
>> + vui->getTimingInfo()->setNumTicksPocDiffOneMinus1(m_numTicksPocDiffOneMinus1);
>> + vui->setBitstreamRestrictionFlag(param->bEnableBitstreamRestrictionFlag);
>> + vui->setTilesFixedStructureFlag(m_tilesFixedStructureFlag);
>> + vui->setMotionVectorsOverPicBoundariesFlag(m_motionVectorsOverPicBoundariesFlag);
>> + vui->setRestrictedRefPicListsFlag(m_restrictedRefPicListsFlag);
>> + vui->setMinSpatialSegmentationIdc(m_minSpatialSegmentationIdc);
>> + vui->setMaxBytesPerPicDenom(m_maxBytesPerPicDenom);
>> + vui->setMaxBitsPerMinCuDenom(m_maxBitsPerMinCuDenom);
>> + vui->setLog2MaxMvLengthHorizontal(m_log2MaxMvLengthHorizontal);
>> + vui->setLog2MaxMvLengthVertical(m_log2MaxMvLengthVertical);
> blech, but one thing at a time I suppose
yeah, I guess there could be an initVUI and initHRD
>
>> }
>>
>> /* set the VPS profile information */
>> - *getVPS()->getPTL() = *sps->getPTL();
>> - TimingInfo *t = getVPS()->getTimingInfo();
>> + *m_vps.getPTL() = *sps->getPTL();
>> + TimingInfo *t = m_vps.getTimingInfo();
>> t->setTimingInfoPresentFlag(true);
>> - t->setNumUnitsInTick(param.fpsDenom);
>> - t->setTimeScale(param.fpsNum);
>> + t->setNumUnitsInTick(param->fpsDenom);
>> + t->setTimeScale(param->fpsNum);
>> }
>>
>> void Encoder::initPPS(TComPPS *pps)
>> {
>> - pps->setConstrainedIntraPred(param.bEnableConstrainedIntra);
>> - bool bUseDQP = ((getMaxCuDQPDepth() > 0) || param.rc.aqMode) ? true : false;
>> + pps->setConstrainedIntraPred(param->bEnableConstrainedIntra);
>> + bool bUseDQP = (m_maxCuDQPDepth > 0 || param->rc.aqMode) ? true : false;
>>
>> int lowestQP = -(6 * (X265_DEPTH - 8)); //m_cSPS.getQpBDOffsetY();
>>
>> - if (getUseLossless())
>> + if (m_useLossless)
>> {
>> - if ((getMaxCuDQPDepth() == 0) && (param.rc.qp == lowestQP))
>> + if ((m_maxCuDQPDepth == 0) && (param->rc.qp == lowestQP))
>> {
>> bUseDQP = false;
>> }
>> @@ -1137,25 +1139,25 @@
>> pps->setMinCuDQPSize(pps->getSPS()->getMaxCUWidth() >> (pps->getMaxCuDQPDepth()));
>> }
>>
>> - pps->setChromaCbQpOffset(param.cbQpOffset);
>> - pps->setChromaCrQpOffset(param.crQpOffset);
>> + pps->setChromaCbQpOffset(param->cbQpOffset);
>> + pps->setChromaCrQpOffset(param->crQpOffset);
>>
>> - pps->setEntropyCodingSyncEnabledFlag(param.bEnableWavefront);
>> - pps->setUseWP(param.bEnableWeightedPred);
>> - pps->setWPBiPred(param.bEnableWeightedBiPred);
>> + pps->setEntropyCodingSyncEnabledFlag(param->bEnableWavefront);
>> + pps->setUseWP(param->bEnableWeightedPred);
>> + pps->setWPBiPred(param->bEnableWeightedBiPred);
>> pps->setOutputFlagPresentFlag(false);
>> - pps->setSignHideFlag(param.bEnableSignHiding);
>> - pps->setDeblockingFilterControlPresentFlag(!param.bEnableLoopFilter);
>> + pps->setSignHideFlag(param->bEnableSignHiding);
>> + pps->setDeblockingFilterControlPresentFlag(!param->bEnableLoopFilter);
>> pps->setDeblockingFilterOverrideEnabledFlag(!m_loopFilterOffsetInPPS);
>> - pps->setPicDisableDeblockingFilterFlag(!param.bEnableLoopFilter);
>> + pps->setPicDisableDeblockingFilterFlag(!param->bEnableLoopFilter);
>> pps->setLog2ParallelMergeLevelMinus2(m_log2ParallelMergeLevelMinus2);
>> - pps->setCabacInitPresentFlag(param.frameNumThreads > 1 ? 0 : CABAC_INIT_PRESENT_FLAG);
>> + pps->setCabacInitPresentFlag(param->frameNumThreads > 1 ? 0 : CABAC_INIT_PRESENT_FLAG);
>>
>> pps->setNumRefIdxL0DefaultActive(1);
>> pps->setNumRefIdxL1DefaultActive(1);
>>
>> - pps->setTransquantBypassEnableFlag(getTransquantBypassEnableFlag());
>> - pps->setUseTransformSkip(param.bEnableTransformSkip);
>> + pps->setTransquantBypassEnableFlag(m_TransquantBypassEnableFlag);
>> + pps->setUseTransformSkip(param->bEnableTransformSkip);
>> pps->setLoopFilterAcrossTilesEnabledFlag(m_loopFilterAcrossTilesEnabledFlag);
>> }
>>
>> @@ -1467,21 +1469,19 @@
>> m_loopFilterTcOffsetDiv2 = 0;
>> m_loopFilterAcrossTilesEnabledFlag = 1;
>>
>> - TComVPS vps;
>> - vps.setMaxTLayers(1);
>> - vps.setTemporalNestingFlag(true);
>> - vps.setMaxLayers(1);
>> + m_vps.setMaxTLayers(1);
>> + m_vps.setTemporalNestingFlag(true);
>> + m_vps.setMaxLayers(1);
>> for (int i = 0; i < MAX_TLAYER; i++)
>> {
>> /* Increase the DPB size and reorder picture if bpyramid is enabled */
>> m_numReorderPics[i] = (p->bBPyramid && p->bframes > 1) ? 2 : 1;
>> m_maxDecPicBuffering[i] = X265_MIN(MAX_NUM_REF, X265_MAX(m_numReorderPics[i] + 1, p->maxNumReferences) + m_numReorderPics[i]);
>>
>> - vps.setNumReorderPics(m_numReorderPics[i], i);
>> - vps.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
>> + m_vps.setNumReorderPics(m_numReorderPics[i], i);
>> + m_vps.setMaxDecPicBuffering(m_maxDecPicBuffering[i], i);
>> }
>>
>> - m_vps = vps;
>> m_maxCuDQPDepth = 0;
>> m_maxNumOffsetsPerPic = 2048;
>> m_log2ParallelMergeLevelMinus2 = 0;
>> @@ -1499,29 +1499,10 @@
>> m_decodingUnitInfoSEIEnabled = 0;
>> m_useScalingListId = 0;
>> m_activeParameterSetsSEIEnabled = 0;
>> - m_vuiParametersPresentFlag = p->bEnableVuiParametersPresentFlag;
>> m_minSpatialSegmentationIdc = 0;
>> - m_aspectRatioInfoPresentFlag = p->bEnableAspectRatioIdc;
>> - m_aspectRatioIdc = p->aspectRatioIdc;
>> - m_sarWidth = p->sarWidth;
>> - m_sarHeight = p->sarHeight;
>> - m_overscanInfoPresentFlag = p->bEnableOverscanInfoPresentFlag;
>> - m_overscanAppropriateFlag = p->bEnableOverscanAppropriateFlag;
>> - m_videoSignalTypePresentFlag = p->bEnableVideoSignalTypePresentFlag;
>> - m_videoFormat = p->videoFormat;
>> - m_videoFullRangeFlag = p->bEnableVideoFullRangeFlag;
>> - m_colourDescriptionPresentFlag = p->bEnableColorDescriptionPresentFlag;
>> - m_colourPrimaries = p->colorPrimaries;
>> - m_transferCharacteristics = p->transferCharacteristics;
>> - m_matrixCoefficients = p->matrixCoeffs;
>> - m_chromaLocInfoPresentFlag = p->bEnableChromaLocInfoPresentFlag;
>> - m_chromaSampleLocTypeTopField = p->chromaSampleLocTypeTopField;
>> - m_chromaSampleLocTypeBottomField = p->chromaSampleLocTypeBottomField;
>> m_neutralChromaIndicationFlag = false;
>> - m_frameFieldInfoPresentFlag = p->bEnableFrameFieldInfoPresentFlag;
>> m_pocProportionalToTimingFlag = false;
>> m_numTicksPocDiffOneMinus1 = 0;
>> - m_bitstreamRestrictionFlag = false;
>> m_motionVectorsOverPicBoundariesFlag = false;
>> m_maxBytesPerPicDenom = 2;
>> m_maxBitsPerMinCuDenom = 1;
>> @@ -1536,11 +1517,8 @@
>> m_useLossless = false; // x264 configures this via --qp=0
>> m_TransquantBypassEnableFlag = false;
>> m_CUTransquantBypassFlagValue = false;
>> - m_fieldSeqFlag = p->bEnableFieldSeqFlag;
>> - m_vuiTimingInfoPresentFlag = p->bEnableVuiTimingInfoPresentFlag;
>> - m_vuiHrdParametersPresentFlag = p->bEnableVuiHrdParametersPresentFlag;
>> - m_bitstreamRestrictionFlag = p->bEnableBitstreamRestrictionFlag;
>> - m_subPicHrdParamsPresentFlag = p->bEnableSubPicHrdParamsPresentFlag;
>> +
>> + param = p;
>> }
>>
>> int Encoder::extractNalData(NALUnitEBSP **nalunits)
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/encoder.h
>> --- a/source/encoder/encoder.h Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/encoder.h Mon Mar 03 14:24:34 2014 -0800
>> @@ -26,7 +26,7 @@
>>
>> #include "x265.h"
>>
>> -#include "TLibEncoder/TEncCfg.h"
>> +#include "TLibCommon/TComSlice.h"
>>
>> #include "piclist.h"
>>
>> @@ -69,7 +69,7 @@
>> class ThreadPool;
>> struct NALUnitEBSP;
>>
>> -class Encoder : public TEncCfg, public x265_encoder
>> +class Encoder : public x265_encoder
>> {
>> private:
>>
>> @@ -107,6 +107,93 @@
>>
>> public:
>>
>> + int m_conformanceMode;
>> + TComVPS m_vps;
>> +
>> + /* profile & level */
>> + Profile::Name m_profile;
>> + Level::Tier m_levelTier;
>> + Level::Name m_level;
>> +
>> + bool m_progressiveSourceFlag;
>> + bool m_interlacedSourceFlag;
>> + bool m_nonPackedConstraintFlag;
>> + bool m_frameOnlyConstraintFlag;
>> +
>> + //====== Coding Structure ========
>> + int m_maxDecPicBuffering[MAX_TLAYER];
>> + int m_numReorderPics[MAX_TLAYER];
>> + int m_maxRefPicNum; ///< this is used to mimic the sliding mechanism used by the decoder
>> + // TODO: We need to have a common sliding mechanism used by both the encoder and decoder
>> +
>> + //======= Transform =============
>> + uint32_t m_quadtreeTULog2MaxSize;
>> + uint32_t m_quadtreeTULog2MinSize;
>> +
>> + //====== Loop/Deblock Filter ========
>> + bool m_loopFilterOffsetInPPS;
>> + int m_loopFilterBetaOffset;
>> + int m_loopFilterBetaOffsetDiv2;
>> + int m_loopFilterTcOffset;
>> + int m_loopFilterTcOffsetDiv2;
>> + int m_maxNumOffsetsPerPic;
>> +
>> + //====== Lossless ========
>> + bool m_useLossless;
>> +
>> + //====== Quality control ========
>> + int m_maxCuDQPDepth; // Max. depth for a minimum CuDQP (0:default)
>> +
>> + //====== Tool list ========
>> + bool m_bUseASR;
>> + bool m_usePCM;
>> + uint32_t m_pcmLog2MaxSize;
>> + uint32_t m_pcmLog2MinSize;
>> +
>> + bool m_bPCMInputBitDepthFlag; //unused field
>> + uint32_t m_pcmBitDepthLuma; // unused field, TComSPS has it's own version defaulted to 8
>> + uint32_t m_pcmBitDepthChroma;// unused field, TComSPS has it's own version defaulted to 8
>> +
>> + bool m_bPCMFilterDisableFlag;
>> + bool m_loopFilterAcrossTilesEnabledFlag;
>> +
>> + int m_bufferingPeriodSEIEnabled;
>> + int m_pictureTimingSEIEnabled;
>> + int m_recoveryPointSEIEnabled;
>> + int m_displayOrientationSEIAngle;
>> + int m_gradualDecodingRefreshInfoEnabled;
>> + int m_decodingUnitInfoSEIEnabled;
>> + int m_csp;
>> +
>> + uint32_t m_log2ParallelMergeLevelMinus2; ///< Parallel merge estimation region
>> +
>> + int m_useScalingListId; ///< Using quantization matrix i.e. 0=off, 1=default.
>> +
>> + bool m_TransquantBypassEnableFlag; ///< transquant_bypass_enable_flag setting in PPS.
>> + bool m_CUTransquantBypassFlagValue; ///< if transquant_bypass_enable_flag, the fixed value to use for the per-CU cu_transquant_bypass_flag.
>> + int m_activeParameterSetsSEIEnabled;///< enable active parameter set SEI message
>> +
>> + bool m_neutralChromaIndicationFlag;
>> + bool m_pocProportionalToTimingFlag;
>> + int m_numTicksPocDiffOneMinus1;
>> + bool m_tilesFixedStructureFlag;
>> + bool m_motionVectorsOverPicBoundariesFlag;
>> + bool m_restrictedRefPicListsFlag;
>> + int m_minSpatialSegmentationIdc;
>> + int m_maxBytesPerPicDenom;
>> + int m_maxBitsPerMinCuDenom;
>> + int m_log2MaxMvLengthHorizontal;
>> + int m_log2MaxMvLengthVertical;
>> +
>> + x265_param *param;
>> +
>> + int bEnableRDOQ;
>> + int bEnableRDOQTS;
>> +
>> + int m_pad[2];
>> + Window m_conformanceWindow;
>> + Window m_defaultDisplayWindow;
>> +
>> x265_nal* m_nals;
>> char* m_packetData;
>>
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/frameencoder.cpp
>> --- a/source/encoder/frameencoder.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/frameencoder.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -103,8 +103,8 @@
>> m_top = top;
>> m_cfg = top;
>> m_numRows = numRows;
>> - m_filterRowDelay = (m_cfg->param.saoLcuBasedOptimization && m_cfg->param.saoLcuBoundary) ?
>> - 2 : (m_cfg->param.bEnableSAO || m_cfg->param.bEnableLoopFilter ? 1 : 0);
>> + m_filterRowDelay = (m_cfg->param->saoLcuBasedOptimization && m_cfg->param->saoLcuBoundary) ?
>> + 2 : (m_cfg->param->bEnableSAO || m_cfg->param->bEnableLoopFilter ? 1 : 0);
>>
>> m_rows = new CTURow[m_numRows];
>> for (int i = 0; i < m_numRows; ++i)
>> @@ -123,7 +123,7 @@
>> // NOTE: 2 times of numRows because both Encoder and Filter in same queue
>> if (!WaveFront::init(m_numRows * 2))
>> {
>> - x265_log(&m_cfg->param, X265_LOG_ERROR, "unable to initialize wavefront queue\n");
>> + x265_log(m_cfg->param, X265_LOG_ERROR, "unable to initialize wavefront queue\n");
>> m_pool = NULL;
>> }
>>
>> @@ -138,11 +138,11 @@
>> top->initPPS(&m_pps);
>>
>> m_sps.setNumLongTermRefPicSPS(0);
>> - if (m_cfg->getPictureTimingSEIEnabled() || m_cfg->getDecodingUnitInfoSEIEnabled())
>> + if (m_cfg->m_pictureTimingSEIEnabled || m_cfg->m_decodingUnitInfoSEIEnabled)
>> {
>> - m_sps.setHrdParameters(m_cfg->param.fpsNum, m_cfg->param.fpsDenom, 0, m_cfg->param.rc.bitrate, m_cfg->param.bframes > 0);
>> + m_sps.setHrdParameters(m_cfg->param->fpsNum, m_cfg->param->fpsDenom, 0, m_cfg->param->rc.bitrate, m_cfg->param->bframes > 0);
>> }
>> - if (m_cfg->getBufferingPeriodSEIEnabled() || m_cfg->getPictureTimingSEIEnabled() || m_cfg->getDecodingUnitInfoSEIEnabled())
>> + if (m_cfg->m_bufferingPeriodSEIEnabled || m_cfg->m_pictureTimingSEIEnabled || m_cfg->m_decodingUnitInfoSEIEnabled)
>> {
>> m_sps.getVuiParameters()->setHrdParametersPresentFlag(true);
>> }
>> @@ -150,7 +150,7 @@
>> m_sps.setTMVPFlagsPresent(true);
>>
>> // set default slice level flag to the same as SPS level flag
>> - if (m_cfg->getUseScalingListId() == SCALING_LIST_OFF)
>> + if (m_cfg->m_useScalingListId == SCALING_LIST_OFF)
>> {
>> for (int i = 0; i < m_numRows; i++)
>> {
>> @@ -161,7 +161,7 @@
>> m_sps.setScalingListPresentFlag(false);
>> m_pps.setScalingListPresentFlag(false);
>> }
>> - else if (m_cfg->getUseScalingListId() == SCALING_LIST_DEFAULT)
>> + else if (m_cfg->m_useScalingListId == SCALING_LIST_DEFAULT)
>> {
>> for (int i = 0; i < m_numRows; i++)
>> {
>> @@ -174,7 +174,7 @@
>> }
>> else
>> {
>> - x265_log(&m_cfg->param, X265_LOG_ERROR, "ScalingList == %d not supported\n", m_top->getUseScalingListId());
>> + x265_log(m_cfg->param, X265_LOG_ERROR, "ScalingList == %d not supported\n", m_top->m_useScalingListId);
>> ok = false;
>> }
>>
>> @@ -192,7 +192,7 @@
>> /* headers for start of bitstream */
>> OutputNALUnit nalu(NAL_UNIT_VPS);
>> entropyCoder->setBitstream(&nalu.m_bitstream);
>> - entropyCoder->encodeVPS(m_cfg->getVPS());
>> + entropyCoder->encodeVPS(&m_cfg->m_vps);
>> writeRBSPTrailingBits(nalu.m_bitstream);
>> CHECKED_MALLOC(nalunits[count], NALUnitEBSP, 1);
>> nalunits[count]->init(nalu);
>> @@ -214,10 +214,10 @@
>> nalunits[count]->init(nalu);
>> count++;
>>
>> - if (m_cfg->getActiveParameterSetsSEIEnabled())
>> + if (m_cfg->m_activeParameterSetsSEIEnabled)
>> {
>> SEIActiveParameterSets sei;
>> - sei.activeVPSId = m_cfg->getVPS()->getVPSId();
>> + sei.activeVPSId = m_cfg->m_vps.getVPSId();
>> sei.m_fullRandomAccessFlag = false;
>> sei.m_noParamSetUpdateFlag = false;
>> sei.numSpsIdsMinus1 = 0;
>> @@ -231,13 +231,13 @@
>> count++;
>> }
>>
>> - if (m_cfg->getDisplayOrientationSEIAngle())
>> + if (m_cfg->m_displayOrientationSEIAngle)
>> {
>> SEIDisplayOrientation sei;
>> sei.cancelFlag = false;
>> sei.horFlip = false;
>> sei.verFlip = false;
>> - sei.anticlockwiseRotation = m_cfg->getDisplayOrientationSEIAngle();
>> + sei.anticlockwiseRotation = m_cfg->m_displayOrientationSEIAngle;
>>
>> nalu.resetToType(NAL_UNIT_PREFIX_SEI);
>> entropyCoder->setBitstream(&nalu.m_bitstream);
>> @@ -277,16 +277,16 @@
>> #endif
>> if (slice->getPPS()->getDeblockingFilterControlPresentFlag())
>> {
>> - slice->getPPS()->setDeblockingFilterOverrideEnabledFlag(!m_cfg->getLoopFilterOffsetInPPS());
>> - slice->setDeblockingFilterOverrideFlag(!m_cfg->getLoopFilterOffsetInPPS());
>> - slice->getPPS()->setPicDisableDeblockingFilterFlag(!m_cfg->param.bEnableLoopFilter);
>> - slice->setDeblockingFilterDisable(!m_cfg->param.bEnableLoopFilter);
>> + slice->getPPS()->setDeblockingFilterOverrideEnabledFlag(!m_cfg->m_loopFilterOffsetInPPS);
>> + slice->setDeblockingFilterOverrideFlag(!m_cfg->m_loopFilterOffsetInPPS);
>> + slice->getPPS()->setPicDisableDeblockingFilterFlag(!m_cfg->param->bEnableLoopFilter);
>> + slice->setDeblockingFilterDisable(!m_cfg->param->bEnableLoopFilter);
>> if (!slice->getDeblockingFilterDisable())
>> {
>> - slice->getPPS()->setDeblockingFilterBetaOffsetDiv2(m_cfg->getLoopFilterBetaOffset());
>> - slice->getPPS()->setDeblockingFilterTcOffsetDiv2(m_cfg->getLoopFilterTcOffset());
>> - slice->setDeblockingFilterBetaOffsetDiv2(m_cfg->getLoopFilterBetaOffset());
>> - slice->setDeblockingFilterTcOffsetDiv2(m_cfg->getLoopFilterTcOffset());
>> + slice->getPPS()->setDeblockingFilterBetaOffsetDiv2(m_cfg->m_loopFilterBetaOffset);
>> + slice->getPPS()->setDeblockingFilterTcOffsetDiv2(m_cfg->m_loopFilterTcOffset);
>> + slice->setDeblockingFilterBetaOffsetDiv2(m_cfg->m_loopFilterBetaOffset);
>> + slice->setDeblockingFilterTcOffsetDiv2(m_cfg->m_loopFilterTcOffset);
>> }
>> }
>> else
>> @@ -297,7 +297,7 @@
>> slice->setDeblockingFilterTcOffsetDiv2(0);
>> }
>>
>> - slice->setMaxNumMergeCand(m_cfg->param.maxNumMergeCand);
>> + slice->setMaxNumMergeCand(m_cfg->param->maxNumMergeCand);
>> }
>>
>> void FrameEncoder::threadMain()
>> @@ -422,15 +422,15 @@
>> slice->setSliceQpDeltaCb(0);
>> slice->setSliceQpDeltaCr(0);
>>
>> - int numSubstreams = m_cfg->param.bEnableWavefront ? m_pic->getPicSym()->getFrameHeightInCU() : 1;
>> + int numSubstreams = m_cfg->param->bEnableWavefront ? m_pic->getPicSym()->getFrameHeightInCU() : 1;
>> // TODO: these two items can likely be FrameEncoder member variables to avoid re-allocs
>> TComOutputBitstream* bitstreamRedirect = new TComOutputBitstream;
>> TComOutputBitstream* outStreams = new TComOutputBitstream[numSubstreams];
>>
>> - if (m_cfg->getUseASR() && !slice->isIntra())
>> + if (m_cfg->m_bUseASR && !slice->isIntra())
>> {
>> int pocCurr = slice->getPOC();
>> - int maxSR = m_cfg->param.searchRange;
>> + int maxSR = m_cfg->param->searchRange;
>> int numPredDir = slice->isInterP() ? 1 : 2;
>>
>> for (int dir = 0; dir <= numPredDir; dir++)
>> @@ -457,7 +457,7 @@
>> if ((slice->getSliceType() == P_SLICE && slice->getPPS()->getUseWP()) || (slice->getSliceType() == B_SLICE && slice->getPPS()->getWPBiPred()))
>> {
>> assert(slice->getPPS()->getUseWP());
>> - weightAnalyse(*slice, m_cfg->param);
>> + weightAnalyse(*slice, *m_cfg->param);
>> }
>>
>> // Generate motion references
>> @@ -481,14 +481,14 @@
>> // wave-front behind the CU compression and reconstruction
>> compressCTURows();
>>
>> - if (m_cfg->param.bEnableWavefront)
>> + if (m_cfg->param->bEnableWavefront)
>> {
>> slice->setNextSlice(true);
>> }
>>
>> - if ((m_cfg->getRecoveryPointSEIEnabled()) && (slice->getSliceType() == I_SLICE))
>> + if ((m_cfg->m_recoveryPointSEIEnabled) && (slice->getSliceType() == I_SLICE))
>> {
>> - if (m_cfg->getGradualDecodingRefreshInfoEnabled() && !slice->getRapPicFlag())
>> + if (m_cfg->m_gradualDecodingRefreshInfoEnabled && !slice->getRapPicFlag())
>> {
>> // Gradual decoding refresh SEI
>> OutputNALUnit nalu(NAL_UNIT_PREFIX_SEI);
>> @@ -668,9 +668,9 @@
>> }
>>
>> /* write decoded picture hash SEI messages */
>> - if (m_cfg->param.decodedPictureHashSEI)
>> + if (m_cfg->param->decodedPictureHashSEI)
>> {
>> - if (m_cfg->param.decodedPictureHashSEI == 1)
>> + if (m_cfg->param->decodedPictureHashSEI == 1)
>> {
>> m_seiReconPictureDigest.method = SEIDecodedPictureHash::MD5;
>> for (int i = 0; i < 3; i++)
>> @@ -678,7 +678,7 @@
>> MD5Final(&(m_pic->m_state[i]), m_seiReconPictureDigest.digest[i]);
>> }
>> }
>> - else if (m_cfg->param.decodedPictureHashSEI == 2)
>> + else if (m_cfg->param->decodedPictureHashSEI == 2)
>> {
>> m_seiReconPictureDigest.method = SEIDecodedPictureHash::CRC;
>> for (int i = 0; i < 3; i++)
>> @@ -686,7 +686,7 @@
>> crcFinish((m_pic->m_crc[i]), m_seiReconPictureDigest.digest[i]);
>> }
>> }
>> - else if (m_cfg->param.decodedPictureHashSEI == 3)
>> + else if (m_cfg->param->decodedPictureHashSEI == 3)
>> {
>> m_seiReconPictureDigest.method = SEIDecodedPictureHash::CHECKSUM;
>> for (int i = 0; i < 3; i++)
>> @@ -754,7 +754,7 @@
>> g_bJustDoIt = g_bEncDecTraceDisable;
>> #endif
>>
>> - const int bWaveFrontsynchro = m_cfg->param.bEnableWavefront;
>> + const int bWaveFrontsynchro = m_cfg->param->bEnableWavefront;
>> const uint32_t heightInLCUs = m_pic->getPicSym()->getFrameHeightInCU();
>> const int numSubstreams = (bWaveFrontsynchro ? heightInLCUs : 1);
>> uint32_t bitsOriginallyInSubstreams = 0;
>> @@ -932,7 +932,7 @@
>> m_rows[i].m_busy = false;
>> }
>>
>> - int range = m_cfg->param.searchRange; /* fpel search */
>> + int range = m_cfg->param->searchRange; /* fpel search */
>> range += 1; /* diamond search range check lag */
>> range += 2; /* subpel refine */
>> range += NTAPS_LUMA / 2; /* subpel filter half-length */
>> @@ -945,7 +945,7 @@
>>
>> m_frameFilter.start(m_pic);
>>
>> - if (m_pool && m_cfg->param.bEnableWavefront)
>> + if (m_pool && m_cfg->param->bEnableWavefront)
>> {
>> WaveFront::clearEnabledRowMask();
>> WaveFront::enqueue();
>> @@ -1048,18 +1048,18 @@
>> * the same CU row, which often resulted in bad pointer accesses. We
>> * believe the problem is fixed, but are leaving this check in place
>> * to prevent crashes in case it is not. */
>> - x265_log(&m_cfg->param, X265_LOG_WARNING,
>> + x265_log(m_cfg->param, X265_LOG_WARNING,
>> "internal error - simulaneous row access detected. Please report HW to x265-devel at videolan.org");
>> return;
>> }
>> curRow.m_busy = true;
>>
>> int64_t startTime = x265_mdate();
>> - CTURow& codeRow = m_rows[m_cfg->param.bEnableWavefront ? row : 0];
>> + CTURow& codeRow = m_rows[m_cfg->param->bEnableWavefront ? row : 0];
>> const uint32_t numCols = m_pic->getPicSym()->getFrameWidthInCU();
>> const uint32_t lineStartCUAddr = row * numCols;
>> double qpBase = m_pic->m_avgQpRc;
>> - bool isVbv = m_cfg->param.rc.vbvBufferSize > 0 && m_cfg->param.rc.vbvMaxBitrate > 0;
>> + bool isVbv = m_cfg->param->rc.vbvBufferSize > 0 && m_cfg->param->rc.vbvMaxBitrate > 0;
>> for (uint32_t col = curRow.m_completed; col < numCols; col++)
>> {
>> const uint32_t cuAddr = lineStartCUAddr + col;
>> @@ -1068,22 +1068,22 @@
>>
>> codeRow.m_entropyCoder.setEntropyCoder(&m_sbacCoder, m_pic->getSlice());
>> codeRow.m_entropyCoder.resetEntropy();
>> - TEncSbac *bufSbac = (m_cfg->param.bEnableWavefront && col == 0 && row > 0) ? &m_rows[row - 1].m_bufferSbacCoder : NULL;
>> + TEncSbac *bufSbac = (m_cfg->param->bEnableWavefront && col == 0 && row > 0) ? &m_rows[row - 1].m_bufferSbacCoder : NULL;
>>
>> if ((uint32_t)row >= col && (row != 0) && isVbv)
>> qpBase = m_pic->getCU(cuAddr - numCols + 1)->m_baseQp;
>>
>> - if (m_cfg->param.rc.aqMode || isVbv)
>> + if (m_cfg->param->rc.aqMode || isVbv)
>> {
>> int qp = calcQpForCu(m_pic, cuAddr, qpBase);
>> setLambda(qp, row);
>> qp = X265_MIN(qp, MAX_QP);
>> cu->setQP(0, char(qp));
>> cu->m_baseQp = qpBase;
>> - if (m_cfg->param.rc.aqMode)
>> + if (m_cfg->param->rc.aqMode)
>> m_pic->m_qpaAq[row] += qp;
>> }
>> - codeRow.processCU(cu, m_pic->getSlice(), bufSbac, m_cfg->param.bEnableWavefront && col == 1);
>> + codeRow.processCU(cu, m_pic->getSlice(), bufSbac, m_cfg->param->bEnableWavefront && col == 1);
>> if (isVbv)
>> {
>> // Update encoded bits, satdCost, baseQP for each CU
>> @@ -1160,19 +1160,19 @@
>> int block_y = (cuAddr / pic->getPicSym()->getFrameWidthInCU()) * noOfBlocks;
>> int block_x = (cuAddr * noOfBlocks) - block_y * pic->getPicSym()->getFrameWidthInCU();
>>
>> - double *qpoffs = (pic->getSlice()->isReferenced() && m_cfg->param.rc.cuTree) ? pic->m_lowres.qpOffset : pic->m_lowres.qpAqOffset;
>> + double *qpoffs = (pic->getSlice()->isReferenced() && m_cfg->param->rc.cuTree) ? pic->m_lowres.qpOffset : pic->m_lowres.qpAqOffset;
>> int cnt = 0, idx = 0;
>> for (int h = 0; h < noOfBlocks && block_y < maxBlockRows; h++, block_y++)
>> {
>> for (int w = 0; w < noOfBlocks && (block_x + w) < maxBlockCols; w++)
>> {
>> idx = block_x + w + (block_y * maxBlockCols);
>> - if (m_cfg->param.rc.aqMode)
>> + if (m_cfg->param->rc.aqMode)
>> qp_offset += qpoffs[idx];
>> - if (m_cfg->param.rc.vbvBufferSize > 0 && m_cfg->param.rc.vbvMaxBitrate > 0)
>> + if (m_cfg->param->rc.vbvBufferSize > 0 && m_cfg->param->rc.vbvMaxBitrate > 0)
>> {
>> m_pic->m_cuCostsForVbv[cuAddr] += m_pic->m_lowres.lowresCostForRc[idx];
>> - if (!m_cfg->param.rc.cuTree)
>> + if (!m_cfg->param->rc.cuTree)
>> m_pic->m_cuCostsForVbv[cuAddr] += m_pic->m_lowres.intraCost[idx];
>> }
>> cnt++;
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/frameencoder.h
>> --- a/source/encoder/frameencoder.h Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/frameencoder.h Mon Mar 03 14:24:34 2014 -0800
>> @@ -175,7 +175,7 @@
>> void determineSliceBounds();
>> int calcQpForCu(TComPic *pic, uint32_t cuAddr, double baseQp);
>> Encoder* m_top;
>> - TEncCfg* m_cfg;
>> + Encoder* m_cfg;
>>
>> MotionReference m_mref[2][MAX_NUM_REF + 1];
>> TEncSbac m_sbacCoder;
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/framefilter.cpp
>> --- a/source/encoder/framefilter.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/framefilter.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -45,12 +45,12 @@
>>
>> void FrameFilter::destroy()
>> {
>> - if (m_cfg->param.bEnableLoopFilter)
>> + if (m_cfg->param->bEnableLoopFilter)
>> {
>> m_loopFilter.destroy();
>> }
>>
>> - if (m_cfg->param.bEnableSAO)
>> + if (m_cfg->param->bEnableSAO)
>> {
>> // NOTE: I don't check sao flag since loopfilter and sao have same control status
>> m_sao.destroy();
>> @@ -64,42 +64,42 @@
>> m_top = top;
>> m_cfg = top;
>> m_numRows = numRows;
>> - m_hChromaShift = CHROMA_H_SHIFT(m_cfg->getColorFormat());
>> - m_vChromaShift = CHROMA_V_SHIFT(m_cfg->getColorFormat());
>> + m_hChromaShift = CHROMA_H_SHIFT(m_cfg->m_csp);
>> + m_vChromaShift = CHROMA_V_SHIFT(m_cfg->m_csp);
>>
>> // NOTE: for sao only, I write this code because I want to exact match with HM's bug bitstream
>> m_rdGoOnSbacCoderRow0 = rdGoOnSbacCoder;
>>
>> - if (top->param.bEnableLoopFilter)
>> + if (top->param->bEnableLoopFilter)
>> {
>> m_loopFilter.create(g_maxCUDepth);
>> }
>>
>> - if (top->param.bEnableSAO)
>> + if (top->param->bEnableSAO)
>> {
>> - m_sao.setSaoLcuBoundary(top->param.saoLcuBoundary);
>> - m_sao.setSaoLcuBasedOptimization(top->param.saoLcuBasedOptimization);
>> - m_sao.setMaxNumOffsetsPerPic(top->getMaxNumOffsetsPerPic());
>> - m_sao.create(top->param.sourceWidth, top->param.sourceHeight, g_maxCUWidth, g_maxCUHeight, m_cfg->getColorFormat());
>> + m_sao.setSaoLcuBoundary(top->param->saoLcuBoundary);
>> + m_sao.setSaoLcuBasedOptimization(top->param->saoLcuBasedOptimization);
>> + m_sao.setMaxNumOffsetsPerPic(top->m_maxNumOffsetsPerPic);
>> + m_sao.create(top->param->sourceWidth, top->param->sourceHeight, g_maxCUWidth, g_maxCUHeight, m_cfg->m_csp);
>> m_sao.createEncBuffer();
>> }
>>
>> - if (m_cfg->param.bEnableSsim)
>> - m_ssimBuf = (int*)x265_malloc(sizeof(int) * 8 * (m_cfg->param.sourceWidth / 4 + 3));
>> + if (m_cfg->param->bEnableSsim)
>> + m_ssimBuf = (int*)x265_malloc(sizeof(int) * 8 * (m_cfg->param->sourceWidth / 4 + 3));
>> }
>>
>> void FrameFilter::start(TComPic *pic)
>> {
>> m_pic = pic;
>>
>> - m_saoRowDelay = m_cfg->param.bEnableLoopFilter ? 1 : 0;
>> + m_saoRowDelay = m_cfg->param->bEnableLoopFilter ? 1 : 0;
>> m_loopFilter.setCfg(pic->getSlice()->getPPS()->getLoopFilterAcrossTilesEnabledFlag());
>> m_rdGoOnSbacCoder.init(&m_rdGoOnBinCodersCABAC);
>> m_entropyCoder.setEntropyCoder(&m_rdGoOnSbacCoder, pic->getSlice());
>> m_entropyCoder.setBitstream(&m_bitCounter);
>> m_rdGoOnBinCodersCABAC.m_fracBits = 0;
>>
>> - if (m_cfg->param.bEnableSAO)
>> + if (m_cfg->param->bEnableSAO)
>> {
>> m_sao.resetStats();
>> m_sao.createPicSaoInfo(pic);
>> @@ -110,7 +110,7 @@
>>
>> // NOTE: Disable SAO automatic turn-off when frame parallelism is
>> // enabled for output exact independent of frame thread count
>> - if (m_cfg->param.frameNumThreads > 1)
>> + if (m_cfg->param->frameNumThreads > 1)
>> {
>> saoParam->bSaoFlag[0] = true;
>> saoParam->bSaoFlag[1] = true;
>> @@ -120,7 +120,7 @@
>>
>> void FrameFilter::end()
>> {
>> - if (m_cfg->param.bEnableSAO)
>> + if (m_cfg->param->bEnableSAO)
>> {
>> m_sao.destroyPicSaoInfo();
>> }
>> @@ -130,14 +130,14 @@
>> {
>> PPAScopeEvent(Thread_filterCU);
>>
>> - if (!m_cfg->param.bEnableLoopFilter && !m_cfg->param.bEnableSAO)
>> + if (!m_cfg->param->bEnableLoopFilter && !m_cfg->param->bEnableSAO)
>> {
>> processRowPost(row);
>> return;
>> }
>>
>> // NOTE: We are here only active both of loopfilter and sao, the row 0 always finished, so we can safe to copy row[0]'s data
>> - if (row == 0 && m_cfg->param.bEnableSAO)
>> + if (row == 0 && m_cfg->param->bEnableSAO)
>> {
>> // NOTE: not need, seems HM's bug, I want to keep output exact matched.
>> m_rdGoOnBinCodersCABAC.m_fracBits = ((TEncBinCABAC*)((TEncSbac*)m_rdGoOnSbacCoderRow0->m_binIf))->m_fracBits;
>> @@ -148,12 +148,12 @@
>> const uint32_t lineStartCUAddr = row * numCols;
>>
>> // SAO parameter estimation using non-deblocked pixels for LCU bottom and right boundary areas
>> - if (m_cfg->param.bEnableSAO && m_cfg->param.saoLcuBasedOptimization && m_cfg->param.saoLcuBoundary)
>> + if (m_cfg->param->bEnableSAO && m_cfg->param->saoLcuBasedOptimization && m_cfg->param->saoLcuBoundary)
>> {
>> m_sao.calcSaoStatsRowCus_BeforeDblk(m_pic, row);
>> }
>>
>> - if (m_cfg->param.bEnableLoopFilter)
>> + if (m_cfg->param->bEnableLoopFilter)
>> {
>> for (uint32_t col = 0; col < numCols; col++)
>> {
>> @@ -177,7 +177,7 @@
>>
>> // SAO
>> SAOParam* saoParam = m_pic->getPicSym()->getSaoParam();
>> - if (m_cfg->param.bEnableSAO && m_sao.getSaoLcuBasedOptimization())
>> + if (m_cfg->param->bEnableSAO && m_sao.getSaoLcuBasedOptimization())
>> {
>> m_sao.rdoSaoUnitRow(saoParam, row);
>>
>> @@ -191,7 +191,7 @@
>> // this row of CTUs has been encoded
>>
>> // NOTE: in --sao-lcu-opt=0 mode, we do it later
>> - if (m_cfg->param.bEnableSAO && !m_sao.getSaoLcuBasedOptimization())
>> + if (m_cfg->param->bEnableSAO && !m_sao.getSaoLcuBasedOptimization())
>> return;
>>
>> if (row > 0)
>> @@ -201,7 +201,7 @@
>>
>> if (row == m_numRows - 1)
>> {
>> - if (m_cfg->param.bEnableSAO && m_sao.getSaoLcuBasedOptimization())
>> + if (m_cfg->param->bEnableSAO && m_sao.getSaoLcuBasedOptimization())
>> {
>> m_sao.rdoSaoUnitRowEnd(saoParam, m_pic->getNumCUsInFrame());
>>
>> @@ -274,7 +274,7 @@
>> m_top->signalReconRowCompleted(m_pic->getPOC());
>>
>> int cuAddr = lineStartCUAddr;
>> - if (m_cfg->param.bEnablePsnr)
>> + if (m_cfg->param->bEnablePsnr)
>> {
>> TComPicYuv* orig = m_pic->getPicYuvOrg();
>>
>> @@ -299,7 +299,7 @@
>> m_pic->m_SSDU += ssdU;
>> m_pic->m_SSDV += ssdV;
>> }
>> - if (m_cfg->param.bEnableSsim && m_ssimBuf)
>> + if (m_cfg->param->bEnableSsim && m_ssimBuf)
>> {
>> pixel *rec = (pixel*)m_pic->getPicYuvRec()->getLumaAddr();
>> pixel *org = (pixel*)m_pic->getPicYuvOrg()->getLumaAddr();
>> @@ -316,10 +316,10 @@
>> * to avoid alignment of ssim blocks with DCT blocks. */
>> minPixY += bStart ? 2 : -6;
>> m_pic->m_ssim += calculateSSIM(rec + 2 + minPixY * stride1, stride1, org + 2 + minPixY * stride2, stride2,
>> - m_cfg->param.sourceWidth - 2, maxPixY - minPixY, m_ssimBuf, &ssim_cnt);
>> + m_cfg->param->sourceWidth - 2, maxPixY - minPixY, m_ssimBuf, &ssim_cnt);
>> m_pic->m_ssimCnt += ssim_cnt;
>> }
>> - if (m_cfg->param.decodedPictureHashSEI == 1)
>> + if (m_cfg->param->decodedPictureHashSEI == 1)
>> {
>> uint32_t width = recon->getWidth();
>> uint32_t height = recon->getCUHeight(row);
>> @@ -342,7 +342,7 @@
>>
>> updateMD5Plane(m_pic->m_state[2], recon->getCrAddr(cuAddr), width, height, stride);
>> }
>> - else if (m_cfg->param.decodedPictureHashSEI == 2)
>> + else if (m_cfg->param->decodedPictureHashSEI == 2)
>> {
>> uint32_t width = recon->getWidth();
>> uint32_t height = recon->getCUHeight(row);
>> @@ -359,7 +359,7 @@
>> updateCRC(recon->getCbAddr(cuAddr), m_pic->m_crc[1], height, width, stride);
>> updateCRC(recon->getCrAddr(cuAddr), m_pic->m_crc[2], height, width, stride);
>> }
>> - else if (m_cfg->param.decodedPictureHashSEI == 3)
>> + else if (m_cfg->param->decodedPictureHashSEI == 3)
>> {
>> uint32_t width = recon->getWidth();
>> uint32_t height = recon->getCUHeight(row);
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/framefilter.h
>> --- a/source/encoder/framefilter.h Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/framefilter.h Mon Mar 03 14:24:34 2014 -0800
>> @@ -57,7 +57,7 @@
>> protected:
>>
>> Encoder* m_top;
>> - TEncCfg* m_cfg;
>> + Encoder* m_cfg;
> ditto here and in ratecontrol.cpp and slicetype.cpp. it would be
> greatly preferred to just pass param to these files instead of Encoder
yes, but in another patch. These will take more time.
>> TComPic* m_pic;
>> int m_hChromaShift;
>> int m_vChromaShift;
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/ratecontrol.cpp
>> --- a/source/encoder/ratecontrol.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/ratecontrol.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -24,7 +24,7 @@
>> *****************************************************************************/
>>
>> #include "TLibCommon/TComPic.h"
>> -#include "TLibEncoder/TEncCfg.h"
>> +#include "encoder.h"
>> #include "encoder.h"
>> #include "slicetype.h"
>> #include "ratecontrol.h"
>> @@ -75,7 +75,7 @@
>> int stride = pic->getPicYuvOrg()->getStride();
>> int cStride = pic->getPicYuvOrg()->getCStride();
>> uint32_t blockOffsetLuma = block_x + (block_y * stride);
>> - int colorFormat = cfg->param.internalCsp;
>> + int colorFormat = cfg->param->internalCsp;
>> int hShift = CHROMA_H_SHIFT(colorFormat);
>> int vShift = CHROMA_V_SHIFT(colorFormat);
>> uint32_t blockOffsetChroma = (block_x >> hShift) + ((block_y >> vShift) * cStride);
>> @@ -105,14 +105,14 @@
>> int block_xy = 0;
>> int block_x = 0, block_y = 0;
>> double strength = 0.f;
>> - if (cfg->param.rc.aqMode == X265_AQ_NONE || cfg->param.rc.aqStrength == 0)
>> + if (cfg->param->rc.aqMode == X265_AQ_NONE || cfg->param->rc.aqStrength == 0)
>> {
>> /* Need to init it anyways for CU tree */
>> int cuWidth = ((maxCol / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> int cuHeight = ((maxRow / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> int cuCount = cuWidth * cuHeight;
>>
>> - if (cfg->param.rc.aqMode && cfg->param.rc.aqStrength == 0)
>> + if (cfg->param->rc.aqMode && cfg->param->rc.aqStrength == 0)
>> {
>> memset(pic->m_lowres.qpOffset, 0, cuCount * sizeof(double));
>> memset(pic->m_lowres.qpAqOffset, 0, cuCount * sizeof(double));
>> @@ -123,7 +123,7 @@
>> }
>>
>> /* Need variance data for weighted prediction */
>> - if (cfg->param.bEnableWeightedPred)
>> + if (cfg->param->bEnableWeightedPred)
>> {
>> for (block_y = 0; block_y < maxRow; block_y += 16)
>> {
>> @@ -138,7 +138,7 @@
>> {
>> block_xy = 0;
>> double avg_adj_pow2 = 0, avg_adj = 0, qp_adj = 0;
>> - if (cfg->param.rc.aqMode == X265_AQ_AUTO_VARIANCE)
>> + if (cfg->param->rc.aqMode == X265_AQ_AUTO_VARIANCE)
>> {
>> double bit_depth_correction = pow(1 << (X265_DEPTH - 8), 0.5);
>> for (block_y = 0; block_y < maxRow; block_y += 16)
>> @@ -156,18 +156,18 @@
>>
>> avg_adj /= ncu;
>> avg_adj_pow2 /= ncu;
>> - strength = cfg->param.rc.aqStrength * avg_adj / bit_depth_correction;
>> + strength = cfg->param->rc.aqStrength * avg_adj / bit_depth_correction;
>> avg_adj = avg_adj - 0.5f * (avg_adj_pow2 - (14.f * bit_depth_correction)) / avg_adj;
>> }
>> else
>> - strength = cfg->param.rc.aqStrength * 1.0397f;
>> + strength = cfg->param->rc.aqStrength * 1.0397f;
>>
>> block_xy = 0;
>> for (block_y = 0; block_y < maxRow; block_y += 16)
>> {
>> for (block_x = 0; block_x < maxCol; block_x += 16)
>> {
>> - if (cfg->param.rc.aqMode == X265_AQ_AUTO_VARIANCE)
>> + if (cfg->param->rc.aqMode == X265_AQ_AUTO_VARIANCE)
>> {
>> qp_adj = pic->m_lowres.qpOffset[block_xy];
>> qp_adj = strength * (qp_adj - avg_adj);
>> @@ -185,10 +185,10 @@
>> }
>> }
>>
>> - if (cfg->param.bEnableWeightedPred)
>> + if (cfg->param->bEnableWeightedPred)
>> {
>> - int hShift = CHROMA_H_SHIFT(cfg->param.internalCsp);
>> - int vShift = CHROMA_V_SHIFT(cfg->param.internalCsp);
>> + int hShift = CHROMA_H_SHIFT(cfg->param->internalCsp);
>> + int vShift = CHROMA_V_SHIFT(cfg->param->internalCsp);
>> maxCol = ((maxCol + 8) >> 4) << 4;
>> maxRow = ((maxRow + 8) >> 4) << 4;
>> int width[3] = { maxCol, maxCol >> hShift, maxCol >> hShift };
>> @@ -204,50 +204,50 @@
>> }
>> }
>>
>> -RateControl::RateControl(TEncCfg * _cfg)
>> +RateControl::RateControl(Encoder * _cfg)
>> {
>> this->cfg = _cfg;
>> - int lowresCuWidth = ((cfg->param.sourceWidth / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> - int lowresCuHeight = ((cfg->param.sourceHeight / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> + int lowresCuWidth = ((cfg->param->sourceWidth / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> + int lowresCuHeight = ((cfg->param->sourceHeight / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> ncu = lowresCuWidth * lowresCuHeight;
>> - if (cfg->param.rc.cuTree)
>> + if (cfg->param->rc.cuTree)
>> {
>> qCompress = 1;
>> - cfg->param.rc.pbFactor = 1;
>> + cfg->param->rc.pbFactor = 1;
>> }
>> else
>> - qCompress = cfg->param.rc.qCompress;
>> + qCompress = cfg->param->rc.qCompress;
>>
>> - // validate for cfg->param.rc, maybe it is need to add a function like x265_parameters_valiate()
>> - cfg->param.rc.rfConstant = Clip3((double)-QP_BD_OFFSET, (double)51, cfg->param.rc.rfConstant);
>> - cfg->param.rc.rfConstantMax = Clip3((double)-QP_BD_OFFSET, (double)51, cfg->param.rc.rfConstantMax);
>> + // validate for cfg->param->rc, maybe it is need to add a function like x265_parameters_valiate()
>> + cfg->param->rc.rfConstant = Clip3((double)-QP_BD_OFFSET, (double)51, cfg->param->rc.rfConstant);
>> + cfg->param->rc.rfConstantMax = Clip3((double)-QP_BD_OFFSET, (double)51, cfg->param->rc.rfConstantMax);
>> rateFactorMaxIncrement = 0;
>> vbvMinRate = 0;
>>
>> - if (cfg->param.rc.rateControlMode == X265_RC_CRF)
>> + if (cfg->param->rc.rateControlMode == X265_RC_CRF)
>> {
>> - cfg->param.rc.qp = (int)cfg->param.rc.rfConstant + QP_BD_OFFSET;
>> - cfg->param.rc.bitrate = 0;
>> + cfg->param->rc.qp = (int)cfg->param->rc.rfConstant + QP_BD_OFFSET;
>> + cfg->param->rc.bitrate = 0;
>>
>> - double baseCplx = ncu * (cfg->param.bframes ? 120 : 80);
>> - double mbtree_offset = cfg->param.rc.cuTree ? (1.0 - cfg->param.rc.qCompress) * 13.5 : 0;
>> + double baseCplx = ncu * (cfg->param->bframes ? 120 : 80);
>> + double mbtree_offset = cfg->param->rc.cuTree ? (1.0 - cfg->param->rc.qCompress) * 13.5 : 0;
>> rateFactorConstant = pow(baseCplx, 1 - qCompress) /
>> - qp2qScale(cfg->param.rc.rfConstant + mbtree_offset);
>> - if (cfg->param.rc.rfConstantMax)
>> + qp2qScale(cfg->param->rc.rfConstant + mbtree_offset);
>> + if (cfg->param->rc.rfConstantMax)
>> {
>> - rateFactorMaxIncrement = cfg->param.rc.rfConstantMax - cfg->param.rc.rfConstant;
>> + rateFactorMaxIncrement = cfg->param->rc.rfConstantMax - cfg->param->rc.rfConstant;
>> if (rateFactorMaxIncrement <= 0)
>> {
>> - x265_log(&cfg->param, X265_LOG_WARNING, "CRF max must be greater than CRF\n");
>> + x265_log(cfg->param, X265_LOG_WARNING, "CRF max must be greater than CRF\n");
>> rateFactorMaxIncrement = 0;
>> }
>> }
>> }
>>
>> - isAbr = cfg->param.rc.rateControlMode != X265_RC_CQP; // later add 2pass option
>> - bitrate = cfg->param.rc.bitrate * 1000;
>> - frameDuration = (double)cfg->param.fpsDenom / cfg->param.fpsNum;
>> - qp = cfg->param.rc.qp;
>> + isAbr = cfg->param->rc.rateControlMode != X265_RC_CQP; // later add 2pass option
>> + bitrate = cfg->param->rc.bitrate * 1000;
>> + frameDuration = (double)cfg->param->fpsDenom / cfg->param->fpsNum;
>> + qp = cfg->param->rc.qp;
>> lastRceq = 1; /* handles the cmplxrsum when the previous frame cost is zero */
>> shortTermCplxSum = 0;
>> shortTermCplxCount = 0;
>> @@ -256,97 +256,97 @@
>> lastAbrResetPoc = -1;
>> frameSizeEstimated = 0;
>> // vbv initialization
>> - cfg->param.rc.vbvBufferSize = Clip3(0, 2000000, cfg->param.rc.vbvBufferSize);
>> - cfg->param.rc.vbvMaxBitrate = Clip3(0, 2000000, cfg->param.rc.vbvMaxBitrate);
>> - cfg->param.rc.vbvBufferInit = Clip3(0.0, 2000000.0, cfg->param.rc.vbvBufferInit);
>> + cfg->param->rc.vbvBufferSize = Clip3(0, 2000000, cfg->param->rc.vbvBufferSize);
>> + cfg->param->rc.vbvMaxBitrate = Clip3(0, 2000000, cfg->param->rc.vbvMaxBitrate);
>> + cfg->param->rc.vbvBufferInit = Clip3(0.0, 2000000.0, cfg->param->rc.vbvBufferInit);
>> vbvMinRate = 0;
>> - if (cfg->param.rc.vbvBufferSize)
>> + if (cfg->param->rc.vbvBufferSize)
>> {
>> - if (cfg->param.rc.rateControlMode == X265_RC_CQP)
>> + if (cfg->param->rc.rateControlMode == X265_RC_CQP)
>> {
>> - x265_log(&cfg->param, X265_LOG_WARNING, "VBV is incompatible with constant QP, ignored.\n");
>> - cfg->param.rc.vbvBufferSize = 0;
>> - cfg->param.rc.vbvMaxBitrate = 0;
>> + x265_log(cfg->param, X265_LOG_WARNING, "VBV is incompatible with constant QP, ignored.\n");
>> + cfg->param->rc.vbvBufferSize = 0;
>> + cfg->param->rc.vbvMaxBitrate = 0;
>> }
>> - else if (cfg->param.rc.vbvMaxBitrate == 0)
>> + else if (cfg->param->rc.vbvMaxBitrate == 0)
>> {
>> - if (cfg->param.rc.rateControlMode == X265_RC_ABR)
>> + if (cfg->param->rc.rateControlMode == X265_RC_ABR)
>> {
>> - x265_log(&cfg->param, X265_LOG_WARNING, "VBV maxrate unspecified, assuming CBR\n");
>> - cfg->param.rc.vbvMaxBitrate = cfg->param.rc.bitrate;
>> + x265_log(cfg->param, X265_LOG_WARNING, "VBV maxrate unspecified, assuming CBR\n");
>> + cfg->param->rc.vbvMaxBitrate = cfg->param->rc.bitrate;
>> }
>> else
>> {
>> - x265_log(&cfg->param, X265_LOG_WARNING, "VBV bufsize set but maxrate unspecified, ignored\n");
>> - cfg->param.rc.vbvBufferSize = 0;
>> + x265_log(cfg->param, X265_LOG_WARNING, "VBV bufsize set but maxrate unspecified, ignored\n");
>> + cfg->param->rc.vbvBufferSize = 0;
>> }
>> }
>> - else if (cfg->param.rc.vbvMaxBitrate < cfg->param.rc.bitrate &&
>> - cfg->param.rc.rateControlMode == X265_RC_ABR)
>> + else if (cfg->param->rc.vbvMaxBitrate < cfg->param->rc.bitrate &&
>> + cfg->param->rc.rateControlMode == X265_RC_ABR)
>> {
>> - x265_log(&cfg->param, X265_LOG_WARNING, "max bitrate less than average bitrate, assuming CBR\n");
>> - cfg->param.rc.bitrate = cfg->param.rc.vbvMaxBitrate;
>> + x265_log(cfg->param, X265_LOG_WARNING, "max bitrate less than average bitrate, assuming CBR\n");
>> + cfg->param->rc.bitrate = cfg->param->rc.vbvMaxBitrate;
>> }
>> }
>> - else if (cfg->param.rc.vbvMaxBitrate)
>> + else if (cfg->param->rc.vbvMaxBitrate)
>> {
>> - x265_log(&cfg->param, X265_LOG_WARNING, "VBV maxrate specified, but no bufsize, ignored\n");
>> - cfg->param.rc.vbvMaxBitrate = 0;
>> + x265_log(cfg->param, X265_LOG_WARNING, "VBV maxrate specified, but no bufsize, ignored\n");
>> + cfg->param->rc.vbvMaxBitrate = 0;
>> }
>>
>> - isVbv = cfg->param.rc.vbvMaxBitrate > 0 && cfg->param.rc.vbvBufferSize > 0;
>> - double fps = (double)cfg->param.fpsNum / cfg->param.fpsDenom;
>> + isVbv = cfg->param->rc.vbvMaxBitrate > 0 && cfg->param->rc.vbvBufferSize > 0;
>> + double fps = (double)cfg->param->fpsNum / cfg->param->fpsDenom;
>> if (isVbv)
>> {
>> /* We don't support changing the ABR bitrate right now,
>> so if the stream starts as CBR, keep it CBR. */
>> - if (cfg->param.rc.vbvBufferSize < (int)(cfg->param.rc.vbvMaxBitrate / fps))
>> + if (cfg->param->rc.vbvBufferSize < (int)(cfg->param->rc.vbvMaxBitrate / fps))
>> {
>> - cfg->param.rc.vbvBufferSize = (int)(cfg->param.rc.vbvMaxBitrate / fps);
>> - x265_log(&cfg->param, X265_LOG_WARNING, "VBV buffer size cannot be smaller than one frame, using %d kbit\n",
>> - cfg->param.rc.vbvBufferSize);
>> + cfg->param->rc.vbvBufferSize = (int)(cfg->param->rc.vbvMaxBitrate / fps);
>> + x265_log(cfg->param, X265_LOG_WARNING, "VBV buffer size cannot be smaller than one frame, using %d kbit\n",
>> + cfg->param->rc.vbvBufferSize);
>> }
>> - int vbvBufferSize = cfg->param.rc.vbvBufferSize * 1000;
>> - int vbvMaxBitrate = cfg->param.rc.vbvMaxBitrate * 1000;
>> + int vbvBufferSize = cfg->param->rc.vbvBufferSize * 1000;
>> + int vbvMaxBitrate = cfg->param->rc.vbvMaxBitrate * 1000;
>>
>> bufferRate = vbvMaxBitrate / fps;
>> vbvMaxRate = vbvMaxBitrate;
>> bufferSize = vbvBufferSize;
>> singleFrameVbv = bufferRate * 1.1 > bufferSize;
>>
>> - if (cfg->param.rc.vbvBufferInit > 1.)
>> - cfg->param.rc.vbvBufferInit = Clip3(0.0, 1.0, cfg->param.rc.vbvBufferInit / cfg->param.rc.vbvBufferSize);
>> - cfg->param.rc.vbvBufferInit = Clip3(0.0, 1.0, X265_MAX(cfg->param.rc.vbvBufferInit, bufferRate / bufferSize));
>> - bufferFillFinal = bufferSize * cfg->param.rc.vbvBufferInit;
>> - vbvMinRate = /*!rc->b_2pass && */ cfg->param.rc.rateControlMode == X265_RC_ABR
>> - && cfg->param.rc.vbvMaxBitrate <= cfg->param.rc.bitrate;
>> + if (cfg->param->rc.vbvBufferInit > 1.)
>> + cfg->param->rc.vbvBufferInit = Clip3(0.0, 1.0, cfg->param->rc.vbvBufferInit / cfg->param->rc.vbvBufferSize);
>> + cfg->param->rc.vbvBufferInit = Clip3(0.0, 1.0, X265_MAX(cfg->param->rc.vbvBufferInit, bufferRate / bufferSize));
>> + bufferFillFinal = bufferSize * cfg->param->rc.vbvBufferInit;
>> + vbvMinRate = /*!rc->b_2pass && */ cfg->param->rc.rateControlMode == X265_RC_ABR
>> + && cfg->param->rc.vbvMaxBitrate <= cfg->param->rc.bitrate;
>> }
>>
>> - bframes = cfg->param.bframes;
>> + bframes = cfg->param->bframes;
>> bframeBits = 0;
>> leadingNoBSatd = 0;
>> - if (cfg->param.rc.rateControlMode == X265_RC_ABR)
>> + if (cfg->param->rc.rateControlMode == X265_RC_ABR)
>> {
>> /* Adjust the first frame in order to stabilize the quality level compared to the rest */
>> #define ABR_INIT_QP_MIN (24 + QP_BD_OFFSET)
>> #define ABR_INIT_QP_MAX (34 + QP_BD_OFFSET)
>> }
>> - else if (cfg->param.rc.rateControlMode == X265_RC_CRF)
>> + else if (cfg->param->rc.rateControlMode == X265_RC_CRF)
>> {
>> -#define ABR_INIT_QP ((int)cfg->param.rc.rfConstant)
>> +#define ABR_INIT_QP ((int)cfg->param->rc.rfConstant)
>> }
>> reInit();
>>
>> - ipOffset = 6.0 * X265_LOG2(cfg->param.rc.ipFactor);
>> - pbOffset = 6.0 * X265_LOG2(cfg->param.rc.pbFactor);
>> + ipOffset = 6.0 * X265_LOG2(cfg->param->rc.ipFactor);
>> + pbOffset = 6.0 * X265_LOG2(cfg->param->rc.pbFactor);
>> for (int i = 0; i < 3; i++)
>> {
>> - lastQScaleFor[i] = qp2qScale(cfg->param.rc.rateControlMode == X265_RC_CRF ? ABR_INIT_QP : ABR_INIT_QP_MIN);
>> + lastQScaleFor[i] = qp2qScale(cfg->param->rc.rateControlMode == X265_RC_CRF ? ABR_INIT_QP : ABR_INIT_QP_MIN);
>> lmin[i] = qp2qScale(MIN_QP);
>> lmax[i] = qp2qScale(MAX_MAX_QP);
>> }
>>
>> - if (cfg->param.rc.rateControlMode == X265_RC_CQP)
>> + if (cfg->param->rc.rateControlMode == X265_RC_CQP)
>> {
>> qpConstant[P_SLICE] = qp;
>> qpConstant[I_SLICE] = Clip3(0, MAX_MAX_QP, (int)(qp - ipOffset + 0.5));
>> @@ -354,7 +354,7 @@
>> }
>>
>> /* qstep - value set as encoder specific */
>> - lstep = pow(2, cfg->param.rc.qpStep / 6.0);
>> + lstep = pow(2, cfg->param->rc.qpStep / 6.0);
>> }
>>
>> void RateControl::reInit()
>> @@ -366,7 +366,7 @@
>> cplxrSum = .01 * pow(7.0e5, qCompress) * pow(ncu, 0.5);
>> wantedBitsWindow = bitrate * frameDuration;
>> accumPNorm = .01;
>> - accumPQp = (cfg->param.rc.rateControlMode == X265_RC_CRF ? ABR_INIT_QP : ABR_INIT_QP_MIN) * accumPNorm;
>> + accumPQp = (cfg->param->rc.rateControlMode == X265_RC_CRF ? ABR_INIT_QP : ABR_INIT_QP_MIN) * accumPNorm;
>>
>> /* Frame Predictors and Row predictors used in vbv */
>> for (int i = 0; i < 5; i++)
>> @@ -504,7 +504,7 @@
>> }
>> else
>> {
>> - double abrBuffer = 2 * cfg->param.rc.rateTolerance * bitrate;
>> + double abrBuffer = 2 * cfg->param->rc.rateTolerance * bitrate;
>>
>> /* 1pass ABR */
>>
>> @@ -530,7 +530,7 @@
>> rce->mvBits = 0;
>> rce->sliceType = sliceType;
>>
>> - if (cfg->param.rc.rateControlMode == X265_RC_CRF)
>> + if (cfg->param->rc.rateControlMode == X265_RC_CRF)
>> {
>> q = getQScale(rce, rateFactorConstant);
>> }
>> @@ -546,7 +546,7 @@
>> if (!vbvMinRate && currentSatd)
>> {
>> /* use framesDone instead of POC as poc count is not serial with bframes enabled */
>> - double timeDone = (double)(framesDone - cfg->param.frameNumThreads + 1) * frameDuration;
>> + double timeDone = (double)(framesDone - cfg->param->frameNumThreads + 1) * frameDuration;
>> wantedBits = timeDone * bitrate;
>> if (wantedBits > 0 && totalBits > 0)
>> {
>> @@ -557,14 +557,14 @@
>> }
>> }
>>
>> - if (sliceType == I_SLICE && cfg->param.keyframeMax > 1
>> + if (sliceType == I_SLICE && cfg->param->keyframeMax > 1
>> && lastNonBPictType != I_SLICE && !isAbrReset)
>> {
>> q = qp2qScale(accumPQp / accumPNorm);
>> - q /= fabs(cfg->param.rc.ipFactor);
>> + q /= fabs(cfg->param->rc.ipFactor);
>> }
>>
>> - if (cfg->param.rc.rateControlMode != X265_RC_CRF)
>> + if (cfg->param->rc.rateControlMode != X265_RC_CRF)
>> {
>> double lqmin = 0, lqmax = 0;
>> if (totalBits == 0 && !isVbv)
>> @@ -587,7 +587,7 @@
>> else
>> {
>> if (qCompress != 1 && framesDone == 0)
>> - q = qp2qScale(ABR_INIT_QP) / fabs(cfg->param.rc.ipFactor);
>> + q = qp2qScale(ABR_INIT_QP) / fabs(cfg->param->rc.ipFactor);
>> }
>> double lmin1 = lmin[sliceType];
>> double lmax1 = lmax[sliceType];
>> @@ -599,7 +599,7 @@
>> lastQScaleFor[sliceType] = q;
>>
>> if (curSlice->getPOC() == 0 || (isAbrReset && sliceType == I_SLICE))
>> - lastQScaleFor[P_SLICE] = q * fabs(cfg->param.rc.ipFactor);
>> + lastQScaleFor[P_SLICE] = q * fabs(cfg->param->rc.ipFactor);
>>
>> rce->frameSizePlanned = predictSize(&pred[sliceType], q, (double)currentSatd);
>>
>> @@ -609,7 +609,7 @@
>>
>> void RateControl::checkAndResetABR(RateControlEntry* rce, bool isFrameDone)
>> {
>> - double abrBuffer = 2 * cfg->param.rc.rateTolerance * bitrate;
>> + double abrBuffer = 2 * cfg->param->rc.rateTolerance * bitrate;
>>
>> // Check if current Slice is a scene cut that follows low detailed/blank frames
>> if (rce->lastSatd > 4 * rce->movingAvgSum)
>> @@ -656,7 +656,7 @@
>> // since they are controlled by the P-frames' QPs.
>> if (isVbv && currentSatd > 0)
>> {
>> - if (cfg->param.lookaheadDepth)
>> + if (cfg->param->lookaheadDepth)
>> {
>> int terminate = 0;
>>
>> @@ -668,9 +668,9 @@
>> double bufferFillCur = bufferFill - curBits;
>> double targetFill;
>> double totalDuration = 0;
>> - frameQ[P_SLICE] = sliceType == I_SLICE ? q * cfg->param.rc.ipFactor : q;
>> - frameQ[B_SLICE] = frameQ[P_SLICE] * cfg->param.rc.pbFactor;
>> - frameQ[I_SLICE] = frameQ[P_SLICE] / cfg->param.rc.ipFactor;
>> + frameQ[P_SLICE] = sliceType == I_SLICE ? q * cfg->param->rc.ipFactor : q;
>> + frameQ[B_SLICE] = frameQ[P_SLICE] * cfg->param->rc.pbFactor;
>> + frameQ[I_SLICE] = frameQ[P_SLICE] / cfg->param->rc.ipFactor;
>> /* Loop over the planned future frames. */
>> for (int j = 0; bufferFillCur >= 0 && bufferFillCur <= bufferSize; j++)
>> {
>> @@ -744,7 +744,7 @@
>> {
>> int nb = bframes;
>> double bits = predictSize(&pred[sliceType], q, (double)currentSatd);
>> - double bbits = predictSize(&predBfromP, q * cfg->param.rc.pbFactor, (double)currentSatd);
>> + double bbits = predictSize(&predBfromP, q * cfg->param->rc.pbFactor, (double)currentSatd);
>> double space;
>> if (bbits > bufferRate)
>> nb = 0;
>> @@ -861,8 +861,8 @@
>> double qpAbsoluteMax = MAX_MAX_QP;
>> if (rateFactorMaxIncrement)
>> qpAbsoluteMax = X265_MIN(qpAbsoluteMax, rce->qpNoVbv + rateFactorMaxIncrement);
>> - double qpMax = X265_MIN(prevRowQp + cfg->param.rc.qpStep, qpAbsoluteMax);
>> - double qpMin = X265_MAX(prevRowQp - cfg->param.rc.qpStep, MIN_QP);
>> + double qpMax = X265_MIN(prevRowQp + cfg->param->rc.qpStep, qpAbsoluteMax);
>> + double qpMin = X265_MAX(prevRowQp - cfg->param->rc.qpStep, MIN_QP);
>> double stepSize = 0.5;
>> double bufferLeftPlanned = rce->bufferFill - rce->frameSizePlanned;
>>
>> @@ -879,7 +879,7 @@
>> qpVbv = X265_MAX(qpVbv, qpMin);
>> }
>> /* More threads means we have to be more cautious in letting ratecontrol use up extra bits. */
>> - double rcTol = bufferLeftPlanned / cfg->param.frameNumThreads * cfg->param.rc.rateTolerance;
>> + double rcTol = bufferLeftPlanned / cfg->param->frameNumThreads * cfg->param->rc.rateTolerance;
>> int32_t encodedBitsSoFar = 0;
>> double accFrameBits = predictRowsSizeSum(pic, qpVbv, encodedBitsSoFar);
>>
>> @@ -953,14 +953,14 @@
>> {
>> double q;
>>
>> - if (cfg->param.rc.cuTree)
>> + if (cfg->param->rc.cuTree)
>> {
>> // Scale and units are obtained from rateNum and rateDenom for videos with fixed frame rates.
>> - double timescale = (double)cfg->param.fpsDenom / (2 * cfg->param.fpsNum);
>> - q = pow(BASE_FRAME_DURATION / CLIP_DURATION(2 * timescale), 1 - cfg->param.rc.qCompress);
>> + double timescale = (double)cfg->param->fpsDenom / (2 * cfg->param->fpsNum);
>> + q = pow(BASE_FRAME_DURATION / CLIP_DURATION(2 * timescale), 1 - cfg->param->rc.qCompress);
>> }
>> else
>> - q = pow(rce->blurredComplexity, 1 - cfg->param.rc.qCompress);
>> + q = pow(rce->blurredComplexity, 1 - cfg->param->rc.qCompress);
>>
>> // avoid NaN's in the rc_eq
>> if (rce->texBits + rce->mvBits == 0)
>> @@ -1004,7 +1004,7 @@
>> bufferFillFinal -= bits;
>>
>> if (bufferFillFinal < 0)
>> - x265_log(&cfg->param, X265_LOG_WARNING, "poc:%d, VBV underflow (%.0f bits)\n", rce->poc, bufferFillFinal);
>> + x265_log(cfg->param, X265_LOG_WARNING, "poc:%d, VBV underflow (%.0f bits)\n", rce->poc, bufferFillFinal);
>>
>> bufferFillFinal = X265_MAX(bufferFillFinal, 0);
>> bufferFillFinal += bufferRate;
>> @@ -1016,13 +1016,13 @@
>> {
>> if (isAbr)
>> {
>> - if (cfg->param.rc.rateControlMode == X265_RC_ABR)
>> + if (cfg->param->rc.rateControlMode == X265_RC_ABR)
>> {
>> checkAndResetABR(rce, true);
>> }
>> if (!isAbrReset)
>> {
>> - if (cfg->param.rc.aqMode || isVbv)
>> + if (cfg->param->rc.aqMode || isVbv)
>> {
>> if (pic->m_qpaRc)
>> {
>> @@ -1050,7 +1050,7 @@
>> {
>> /* Depends on the fact that B-frame's QP is an offset from the following P-frame's.
>> * Not perfectly accurate with B-refs, but good enough. */
>> - cplxrSum += bits * qp2qScale(rce->qpaRc) / (rce->qRceq * fabs(cfg->param.rc.pbFactor));
>> + cplxrSum += bits * qp2qScale(rce->qpaRc) / (rce->qRceq * fabs(cfg->param->rc.pbFactor));
>> }
>> wantedBitsWindow += frameDuration * bitrate;
>> totalBits += bits;
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/ratecontrol.h
>> --- a/source/encoder/ratecontrol.h Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/ratecontrol.h Mon Mar 03 14:24:34 2014 -0800
>> @@ -34,7 +34,6 @@
>> struct Lookahead;
>> class Encoder;
>> class TComPic;
>> -class TEncCfg;
>>
>> #define BASE_FRAME_DURATION 0.04
>>
>> @@ -76,7 +75,7 @@
>> struct RateControl
>> {
>> TComSlice *curSlice; /* all info about the current frame */
>> - TEncCfg *cfg;
>> + Encoder *cfg;
>> SliceType sliceType; /* Current frame type */
>> int ncu; /* number of CUs in a frame */
>> int keyFrameInterval; /* TODO: need to initialize in init */
>> @@ -125,7 +124,7 @@
>> double qCompress;
>> double qpNoVbv; /* QP for the current frame if 1-pass VBV was disabled. */
>> double frameSizeEstimated; /* hold synched frameSize, updated from cu level vbv rc */
>> - RateControl(TEncCfg * _cfg);
>> + RateControl(Encoder * _cfg);
>>
>> // to be called for each frame to process RateControl and set QP
>> void rateControlStart(TComPic* pic, Lookahead *, RateControlEntry* rce, Encoder* enc);
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/slicetype.cpp
>> --- a/source/encoder/slicetype.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/slicetype.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -27,7 +27,7 @@
>> #include "primitives.h"
>> #include "lowres.h"
>>
>> -#include "TLibEncoder/TEncCfg.h"
>> +#include "encoder.h"
>> #include "slicetype.h"
>> #include "motion.h"
>> #include "mv.h"
>> @@ -56,14 +56,14 @@
>> dst.y = median(a.y, b.y, c.y);
>> }
>>
>> -Lookahead::Lookahead(TEncCfg *_cfg, ThreadPool* pool)
>> +Lookahead::Lookahead(Encoder *_cfg, ThreadPool* pool)
>> : est(pool)
>> {
>> this->cfg = _cfg;
>> - lastKeyframe = -cfg->param.keyframeMax;
>> + lastKeyframe = -cfg->param->keyframeMax;
>> lastNonB = NULL;
>> - widthInCU = ((cfg->param.sourceWidth / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> - heightInCU = ((cfg->param.sourceHeight / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> + widthInCU = ((cfg->param->sourceWidth / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> + heightInCU = ((cfg->param->sourceHeight / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> scratch = (int*)x265_malloc(widthInCU * sizeof(int));
>> memset(histogram, 0, sizeof(histogram));
>> }
>> @@ -78,14 +78,14 @@
>> while (!inputQueue.empty())
>> {
>> TComPic* pic = inputQueue.popFront();
>> - pic->destroy(cfg->param.bframes);
>> + pic->destroy(cfg->param->bframes);
>> delete pic;
>> }
>>
>> while (!outputQueue.empty())
>> {
>> TComPic* pic = outputQueue.popFront();
>> - pic->destroy(cfg->param.bframes);
>> + pic->destroy(cfg->param->bframes);
>> delete pic;
>> }
>>
>> @@ -96,10 +96,10 @@
>> {
>> TComPicYuv *orig = pic->getPicYuvOrg();
>>
>> - pic->m_lowres.init(orig, pic->getSlice()->getPOC(), sliceType, cfg->param.bframes);
>> + pic->m_lowres.init(orig, pic->getSlice()->getPOC(), sliceType, cfg->param->bframes);
>> inputQueue.pushBack(*pic);
>>
>> - if (inputQueue.size() >= cfg->param.lookaheadDepth)
>> + if (inputQueue.size() >= cfg->param->lookaheadDepth)
>> slicetypeDecide();
>> }
>>
>> @@ -172,23 +172,23 @@
>> cost.estimateFrameCost(frames, p0, p1, b, false);
>> cost.flush();
>> }
>> - if (cfg->param.rc.cuTree)
>> + if (cfg->param->rc.cuTree)
>> {
>> pic->m_lowres.satdCost = frameCostRecalculate(frames, p0, p1, b);
>> - if (b && cfg->param.rc.vbvBufferSize)
>> + if (b && cfg->param->rc.vbvBufferSize)
>> frameCostRecalculate(frames, b, b, b);
>> }
>>
>> - else if (cfg->param.rc.aqMode)
>> + else if (cfg->param->rc.aqMode)
>> pic->m_lowres.satdCost = pic->m_lowres.costEstAq[b - p0][p1 - b];
>> else
>> pic->m_lowres.satdCost = pic->m_lowres.costEst[b - p0][p1 - b];
>>
>> - if (cfg->param.rc.vbvBufferSize > 0 && cfg->param.rc.vbvMaxBitrate > 0)
>> + if (cfg->param->rc.vbvBufferSize > 0 && cfg->param->rc.vbvMaxBitrate > 0)
>> {
>> pic->m_lowres.lowresCostForRc = pic->m_lowres.lowresCosts[b - p0][p1 - b];
>> uint32_t lowresRow = 0, lowresCol = 0, lowresCuIdx = 0, sum = 0;
>> - uint32_t scale = cfg->param.maxCUSize / (2 * X265_LOWRES_CU_SIZE);
>> + uint32_t scale = cfg->param->maxCUSize / (2 * X265_LOWRES_CU_SIZE);
>> uint32_t widthInLowresCu = (uint32_t)widthInCU, heightInLowresCu = (uint32_t)heightInCU;
>>
>> for (uint32_t row = 0; row < pic->getFrameHeightInCU(); row++)
>> @@ -215,14 +215,14 @@
>> Lowres *frames[X265_LOOKAHEAD_MAX];
>> TComPic *list[X265_LOOKAHEAD_MAX];
>> TComPic *ipic = inputQueue.first();
>> - bool isKeyFrameAnalyse = (cfg->param.rc.cuTree || (cfg->param.rc.vbvBufferSize && cfg->param.lookaheadDepth));
>> + bool isKeyFrameAnalyse = (cfg->param->rc.cuTree || (cfg->param->rc.vbvBufferSize && cfg->param->lookaheadDepth));
>>
>> if (!est.rows && ipic)
>> est.init(cfg, ipic);
>>
>> - if ((cfg->param.bFrameAdaptive && cfg->param.bframes) ||
>> - cfg->param.rc.cuTree || cfg->param.scenecutThreshold ||
>> - (cfg->param.lookaheadDepth && cfg->param.rc.vbvBufferSize))
>> + if ((cfg->param->bFrameAdaptive && cfg->param->bframes) ||
>> + cfg->param->rc.cuTree || cfg->param->scenecutThreshold ||
>> + (cfg->param->lookaheadDepth && cfg->param->rc.vbvBufferSize))
>> {
>> slicetypeAnalyse(frames, false);
>> }
>> @@ -230,7 +230,7 @@
>> frames[0] = lastNonB;
>>
>> int j;
>> - for (j = 0; ipic && j < cfg->param.bframes + 2; ipic = ipic->m_next)
>> + for (j = 0; ipic && j < cfg->param->bframes + 2; ipic = ipic->m_next)
>> {
>> list[j++] = ipic;
>> }
>> @@ -242,40 +242,40 @@
>> {
>> Lowres& frm = list[bframes]->m_lowres;
>>
>> - if (frm.sliceType == X265_TYPE_BREF && !cfg->param.bBPyramid && brefs == cfg->param.bBPyramid)
>> + if (frm.sliceType == X265_TYPE_BREF && !cfg->param->bBPyramid && brefs == cfg->param->bBPyramid)
>> {
>> frm.sliceType = X265_TYPE_B;
>> - x265_log(&cfg->param, X265_LOG_WARNING, "B-ref at frame %d incompatible with B-pyramid\n",
>> + x265_log(cfg->param, X265_LOG_WARNING, "B-ref at frame %d incompatible with B-pyramid\n",
>> frm.frameNum);
>> }
>>
>> /* pyramid with multiple B-refs needs a big enough dpb that the preceding P-frame stays available.
>> smaller dpb could be supported by smart enough use of mmco, but it's easier just to forbid it.*/
>> - else if (frm.sliceType == X265_TYPE_BREF && cfg->param.bBPyramid && brefs &&
>> - cfg->param.maxNumReferences <= (brefs + 3))
>> + else if (frm.sliceType == X265_TYPE_BREF && cfg->param->bBPyramid && brefs &&
>> + cfg->param->maxNumReferences <= (brefs + 3))
>> {
>> frm.sliceType = X265_TYPE_B;
>> - x265_log(&cfg->param, X265_LOG_WARNING, "B-ref at frame %d incompatible with B-pyramid and %d reference frames\n",
>> - frm.sliceType, cfg->param.maxNumReferences);
>> + x265_log(cfg->param, X265_LOG_WARNING, "B-ref at frame %d incompatible with B-pyramid and %d reference frames\n",
>> + frm.sliceType, cfg->param->maxNumReferences);
>> }
>>
>> - if ( /*(!cfg->param.intraRefresh || frm.frameNum == 0) && */ frm.frameNum - lastKeyframe >= cfg->param.keyframeMax)
>> + if ( /*(!cfg->param->intraRefresh || frm.frameNum == 0) && */ frm.frameNum - lastKeyframe >= cfg->param->keyframeMax)
>> {
>> if (frm.sliceType == X265_TYPE_AUTO || frm.sliceType == X265_TYPE_I)
>> - frm.sliceType = cfg->param.bOpenGOP && lastKeyframe >= 0 ? X265_TYPE_I : X265_TYPE_IDR;
>> + frm.sliceType = cfg->param->bOpenGOP && lastKeyframe >= 0 ? X265_TYPE_I : X265_TYPE_IDR;
>> bool warn = frm.sliceType != X265_TYPE_IDR;
>> - if (warn && cfg->param.bOpenGOP)
>> + if (warn && cfg->param->bOpenGOP)
>> warn &= frm.sliceType != X265_TYPE_I;
>> if (warn)
>> {
>> - x265_log(&cfg->param, X265_LOG_WARNING, "specified frame type (%d) at %d is not compatible with keyframe interval\n",
>> + x265_log(cfg->param, X265_LOG_WARNING, "specified frame type (%d) at %d is not compatible with keyframe interval\n",
>> frm.sliceType, frm.frameNum);
>> - frm.sliceType = cfg->param.bOpenGOP && lastKeyframe >= 0 ? X265_TYPE_I : X265_TYPE_IDR;
>> + frm.sliceType = cfg->param->bOpenGOP && lastKeyframe >= 0 ? X265_TYPE_I : X265_TYPE_IDR;
>> }
>> }
>> - if (frm.sliceType == X265_TYPE_I && frm.frameNum - lastKeyframe >= cfg->param.keyframeMin)
>> + if (frm.sliceType == X265_TYPE_I && frm.frameNum - lastKeyframe >= cfg->param->keyframeMin)
>> {
>> - if (cfg->param.bOpenGOP)
>> + if (cfg->param->bOpenGOP)
>> {
>> lastKeyframe = frm.frameNum;
>> frm.bKeyframe = true;
>> @@ -294,10 +294,10 @@
>> bframes--;
>> }
>> }
>> - if (bframes == cfg->param.bframes || !list[bframes + 1])
>> + if (bframes == cfg->param->bframes || !list[bframes + 1])
>> {
>> if (IS_X265_TYPE_B(frm.sliceType))
>> - x265_log(&cfg->param, X265_LOG_WARNING, "specified frame type is not compatible with max B-frames\n");
>> + x265_log(cfg->param, X265_LOG_WARNING, "specified frame type is not compatible with max B-frames\n");
>> if (frm.sliceType == X265_TYPE_AUTO || IS_X265_TYPE_B(frm.sliceType))
>> frm.sliceType = X265_TYPE_P;
>> }
>> @@ -316,14 +316,14 @@
>> histogram[bframes]++;
>>
>> /* insert a bref into the sequence */
>> - if (cfg->param.bBPyramid && bframes > 1 && !brefs)
>> + if (cfg->param->bBPyramid && bframes > 1 && !brefs)
>> {
>> list[bframes / 2]->m_lowres.sliceType = X265_TYPE_BREF;
>> brefs++;
>> }
>>
>> /* calculate the frame costs ahead of time for x264_rc_analyse_slice while we still have lowres */
>> - if (cfg->param.rc.rateControlMode != X265_RC_CQP)
>> + if (cfg->param->rc.rateControlMode != X265_RC_CQP)
>> {
>> int p0, p1, b;
>> p1 = b = bframes + 1;
>> @@ -340,7 +340,7 @@
>>
>> est.estimateFrameCost(frames, p0, p1, b, 0);
>>
>> - if ((p0 != p1 || bframes) && cfg->param.rc.vbvBufferSize)
>> + if ((p0 != p1 || bframes) && cfg->param->rc.vbvBufferSize)
>> {
>> // We need the intra costs for row SATDs
>> est.estimateFrameCost(frames, b, b, b, 0);
>> @@ -381,7 +381,7 @@
>> outputQueue.pushBack(*list[bframes]);
>>
>> /* Add B-ref frame next to P frame in output queue, the B-ref encode before non B-ref frame */
>> - if (bframes > 1 && cfg->param.bBPyramid)
>> + if (bframes > 1 && cfg->param->bBPyramid)
>> {
>> for (int i = 0; i < bframes; i++)
>> {
>> @@ -453,9 +453,9 @@
>> {
>> int64_t cost = est.estimateFrameCost(frames, p0, p1, b, 0);
>>
>> - if (cfg->param.rc.aqMode)
>> + if (cfg->param->rc.aqMode)
>> {
>> - if (cfg->param.rc.cuTree)
>> + if (cfg->param->rc.cuTree)
>> return frameCostRecalculate(frames, p0, p1, b);
>> else
>> return frames[b]->costEstAq[b - p0][p1 - b];
>> @@ -466,10 +466,10 @@
>> void Lookahead::slicetypeAnalyse(Lowres **frames, bool bKeyframe)
>> {
>> int numFrames, origNumFrames, keyintLimit, framecnt;
>> - int maxSearch = X265_MIN(cfg->param.lookaheadDepth, X265_LOOKAHEAD_MAX);
>> + int maxSearch = X265_MIN(cfg->param->lookaheadDepth, X265_LOOKAHEAD_MAX);
>> int cuCount = NUM_CUS;
>> int resetStart;
>> - bool bIsVbvLookahead = cfg->param.rc.vbvBufferSize && cfg->param.lookaheadDepth;
>> + bool bIsVbvLookahead = cfg->param->rc.vbvBufferSize && cfg->param->lookaheadDepth;
>>
>> if (!lastNonB)
>> return;
>> @@ -484,19 +484,19 @@
>>
>> if (!framecnt)
>> {
>> - if (cfg->param.rc.cuTree)
>> + if (cfg->param->rc.cuTree)
>> cuTree(frames, 0, bKeyframe);
>> return;
>> }
>>
>> frames[framecnt + 1] = NULL;
>>
>> - keyintLimit = cfg->param.keyframeMax - frames[0]->frameNum + lastKeyframe - 1;
>> + keyintLimit = cfg->param->keyframeMax - frames[0]->frameNum + lastKeyframe - 1;
>> origNumFrames = numFrames = X265_MIN(framecnt, keyintLimit);
>>
>> if (bIsVbvLookahead)
>> numFrames = framecnt;
>> - else if (cfg->param.bOpenGOP && numFrames < framecnt)
>> + else if (cfg->param->bOpenGOP && numFrames < framecnt)
>> numFrames++;
>> else if (numFrames == 0)
>> {
>> @@ -506,15 +506,15 @@
>>
>> int numBFrames = 0;
>> int numAnalyzed = numFrames;
>> - if (cfg->param.scenecutThreshold && scenecut(frames, 0, 1, true, origNumFrames, maxSearch))
>> + if (cfg->param->scenecutThreshold && scenecut(frames, 0, 1, true, origNumFrames, maxSearch))
>> {
>> frames[1]->sliceType = X265_TYPE_I;
>> return;
>> }
>>
>> - if (cfg->param.bframes)
>> + if (cfg->param->bframes)
>> {
>> - if (cfg->param.bFrameAdaptive == X265_B_ADAPT_TRELLIS)
>> + if (cfg->param->bFrameAdaptive == X265_B_ADAPT_TRELLIS)
>> {
>> if (numFrames > 1)
>> {
>> @@ -537,7 +537,7 @@
>> }
>> frames[numFrames]->sliceType = X265_TYPE_P;
>> }
>> - else if (cfg->param.bFrameAdaptive == X265_B_ADAPT_FAST)
>> + else if (cfg->param->bFrameAdaptive == X265_B_ADAPT_FAST)
>> {
>> int64_t cost1p0, cost2p0, cost1b1, cost2p1;
>>
>> @@ -565,11 +565,11 @@
>>
>> // arbitrary and untuned
>> #define INTER_THRESH 300
>> -#define P_SENS_BIAS (50 - cfg->param.bFrameBias)
>> +#define P_SENS_BIAS (50 - cfg->param->bFrameBias)
>> frames[i + 1]->sliceType = X265_TYPE_B;
>>
>> int j;
>> - for (j = i + 2; j <= X265_MIN(i + cfg->param.bframes, numFrames - 1); j++)
>> + for (j = i + 2; j <= X265_MIN(i + cfg->param->bframes, numFrames - 1); j++)
>> {
>> int64_t pthresh = X265_MAX(INTER_THRESH - P_SENS_BIAS * (j - i - 1), INTER_THRESH / 10);
>> int64_t pcost = est.estimateFrameCost(frames, i + 0, j + 1, j + 1, 1);
>> @@ -590,7 +590,7 @@
>> }
>> else
>> {
>> - numBFrames = X265_MIN(numFrames - 1, cfg->param.bframes);
>> + numBFrames = X265_MIN(numFrames - 1, cfg->param->bframes);
>> for (int j = 1; j < numFrames; j++)
>> {
>> frames[j]->sliceType = (j % (numBFrames + 1)) ? X265_TYPE_B : X265_TYPE_P;
>> @@ -601,7 +601,7 @@
>> /* Check scenecut on the first minigop. */
>> for (int j = 1; j < numBFrames + 1; j++)
>> {
>> - if (cfg->param.scenecutThreshold && scenecut(frames, j, j + 1, false, origNumFrames, maxSearch))
>> + if (cfg->param->scenecutThreshold && scenecut(frames, j, j + 1, false, origNumFrames, maxSearch))
>> {
>> frames[j]->sliceType = X265_TYPE_P;
>> numAnalyzed = j;
>> @@ -621,11 +621,11 @@
>> resetStart = bKeyframe ? 1 : 2;
>> }
>>
>> - if (cfg->param.rc.cuTree)
>> - cuTree(frames, X265_MIN(numFrames, cfg->param.keyframeMax), bKeyframe);
>> + if (cfg->param->rc.cuTree)
>> + cuTree(frames, X265_MIN(numFrames, cfg->param->keyframeMax), bKeyframe);
>>
>> - // if (!cfg->param.bIntraRefresh)
>> - for (int j = keyintLimit + 1; j <= numFrames; j += cfg->param.keyframeMax)
>> + // if (!cfg->param->bIntraRefresh)
>> + for (int j = keyintLimit + 1; j <= numFrames; j += cfg->param->keyframeMax)
>> {
>> frames[j]->sliceType = X265_TYPE_I;
>> resetStart = X265_MIN(resetStart, j + 1);
>> @@ -644,13 +644,13 @@
>> bool Lookahead::scenecut(Lowres **frames, int p0, int p1, bool bRealScenecut, int numFrames, int maxSearch)
>> {
>> /* Only do analysis during a normal scenecut check. */
>> - if (bRealScenecut && cfg->param.bframes)
>> + if (bRealScenecut && cfg->param->bframes)
>> {
>> int origmaxp1 = p0 + 1;
>> /* Look ahead to avoid coding short flashes as scenecuts. */
>> - if (cfg->param.bFrameAdaptive == X265_B_ADAPT_TRELLIS)
>> + if (cfg->param->bFrameAdaptive == X265_B_ADAPT_TRELLIS)
>> /* Don't analyse any more frames than the trellis would have covered. */
>> - origmaxp1 += cfg->param.bframes;
>> + origmaxp1 += cfg->param->bframes;
>> else
>> origmaxp1++;
>> int maxp1 = X265_MIN(origmaxp1, numFrames);
>> @@ -696,24 +696,24 @@
>> int64_t icost = frame->costEst[0][0];
>> int64_t pcost = frame->costEst[p1 - p0][0];
>> int gopSize = frame->frameNum - lastKeyframe;
>> - float threshMax = (float)(cfg->param.scenecutThreshold / 100.0);
>> + float threshMax = (float)(cfg->param->scenecutThreshold / 100.0);
>>
>> /* magic numbers pulled out of thin air */
>> float threshMin = (float)(threshMax * 0.25);
>> float bias;
>>
>> - if (cfg->param.keyframeMin == cfg->param.keyframeMax)
>> + if (cfg->param->keyframeMin == cfg->param->keyframeMax)
>> threshMin = threshMax;
>> - if (gopSize <= cfg->param.keyframeMin / 4)
>> + if (gopSize <= cfg->param->keyframeMin / 4)
>> bias = threshMin / 4;
>> - else if (gopSize <= cfg->param.keyframeMin)
>> - bias = threshMin * gopSize / cfg->param.keyframeMin;
>> + else if (gopSize <= cfg->param->keyframeMin)
>> + bias = threshMin * gopSize / cfg->param->keyframeMin;
>> else
>> {
>> bias = threshMin
>> + (threshMax - threshMin)
>> - * (gopSize - cfg->param.keyframeMin)
>> - / (cfg->param.keyframeMax - cfg->param.keyframeMin);
>> + * (gopSize - cfg->param->keyframeMin)
>> + / (cfg->param->keyframeMax - cfg->param->keyframeMin);
>> }
>>
>> bool res = pcost >= (1.0 - bias) * icost;
>> @@ -721,7 +721,7 @@
>> {
>> int imb = frame->intraMbs[p1 - p0];
>> int pmb = NUM_CUS - imb;
>> - x265_log(&cfg->param, X265_LOG_DEBUG, "scene cut at %d Icost:%d Pcost:%d ratio:%.4f bias:%.4f gop:%d (imb:%d pmb:%d)\n",
>> + x265_log(cfg->param, X265_LOG_DEBUG, "scene cut at %d Icost:%d Pcost:%d ratio:%.4f bias:%.4f gop:%d (imb:%d pmb:%d)\n",
>> frame->frameNum, icost, pcost, 1. - (double)pcost / icost, bias, gopSize, imb, pmb);
>> }
>> return res;
>> @@ -730,7 +730,7 @@
>> void Lookahead::slicetypePath(Lowres **frames, int length, char(*best_paths)[X265_LOOKAHEAD_MAX + 1])
>> {
>> char paths[2][X265_LOOKAHEAD_MAX + 1];
>> - int num_paths = X265_MIN(cfg->param.bframes + 1, length);
>> + int num_paths = X265_MIN(cfg->param->bframes + 1, length);
>> int64_t best_cost = 1LL << 62;
>> int idx = 0;
>>
>> @@ -778,7 +778,7 @@
>> if (cost > threshold)
>> break;
>>
>> - if (cfg->param.bBPyramid && next_p - cur_p > 2)
>> + if (cfg->param->bBPyramid && next_p - cur_p > 2)
>> {
>> int middle = cur_p + (next_p - cur_p) / 2;
>> cost += est.estimateFrameCost(frames, cur_p, next_p, middle, 0);
>> @@ -817,7 +817,7 @@
>> double totalDuration = 0.0;
>> for (int j = 0; j <= numframes; j++)
>> {
>> - totalDuration += (double)cfg->param.fpsDenom / cfg->param.fpsNum;
>> + totalDuration += (double)cfg->param->fpsDenom / cfg->param->fpsNum;
>> }
>>
>> double averageDuration = totalDuration / (numframes + 1);
>> @@ -838,7 +838,7 @@
>> /* Lookaheadless MB-tree is not a theoretically distinct case; the same extrapolation could
>> * be applied to the end of a lookahead buffer of any size. However, it's most needed when
>> * lookahead=0, so that's what's currently implemented. */
>> - if (!cfg->param.lookaheadDepth)
>> + if (!cfg->param->lookaheadDepth)
>> {
>> if (bIntra)
>> {
>> @@ -870,7 +870,7 @@
>> est.estimateFrameCost(frames, curnonb, lastnonb, lastnonb, 0);
>> memset(frames[curnonb]->propagateCost, 0, cuCount * sizeof(uint16_t));
>> bframes = lastnonb - curnonb - 1;
>> - if (cfg->param.bBPyramid && bframes > 1)
>> + if (cfg->param->bBPyramid && bframes > 1)
>> {
>> int middle = (bframes + 1) / 2 + curnonb;
>> est.estimateFrameCost(frames, curnonb, lastnonb, middle, 0);
>> @@ -902,7 +902,7 @@
>> lastnonb = curnonb;
>> }
>>
>> - if (!cfg->param.lookaheadDepth)
>> + if (!cfg->param->lookaheadDepth)
>> {
>> est.estimateFrameCost(frames, 0, lastnonb, lastnonb, 0);
>> estimateCUPropagate(frames, averageDuration, 0, lastnonb, lastnonb, 1);
>> @@ -910,7 +910,7 @@
>> }
>>
>> cuTreeFinish(frames[lastnonb], averageDuration, lastnonb);
>> - if (cfg->param.bBPyramid && bframes > 1 && !cfg->param.rc.vbvBufferSize)
>> + if (cfg->param->bBPyramid && bframes > 1 && !cfg->param->rc.vbvBufferSize)
>> cuTreeFinish(frames[lastnonb + (bframes + 1) / 2], averageDuration, 0);
>> }
>>
>> @@ -918,7 +918,7 @@
>> {
>> uint16_t *refCosts[2] = { frames[p0]->propagateCost, frames[p1]->propagateCost };
>> int32_t distScaleFactor = (((b - p0) << 8) + ((p1 - p0) >> 1)) / (p1 - p0);
>> - int32_t bipredWeight = cfg->param.bEnableWeightedBiPred ? 64 - (distScaleFactor >> 2) : 32;
>> + int32_t bipredWeight = cfg->param->bEnableWeightedBiPred ? 64 - (distScaleFactor >> 2) : 32;
>> MV *mvs[2] = { frames[b]->lowresMvs[0][b - p0 - 1], frames[b]->lowresMvs[1][p1 - b - 1] };
>> int32_t bipredWeights[2] = { bipredWeight, 64 - bipredWeight };
>>
>> @@ -927,7 +927,7 @@
>> uint16_t *propagateCost = frames[b]->propagateCost;
>>
>> x265_emms();
>> - double fpsFactor = CLIP_DURATION((double)cfg->param.fpsDenom / cfg->param.fpsNum) / CLIP_DURATION(averageDuration);
>> + double fpsFactor = CLIP_DURATION((double)cfg->param->fpsDenom / cfg->param->fpsNum) / CLIP_DURATION(averageDuration);
>>
>> /* For non-refferd frames the source costs are always zero, so just memset one row and re-use it. */
>> if (!referenced)
>> @@ -1011,13 +1011,13 @@
>> }
>> }
>>
>> - if (cfg->param.rc.vbvBufferSize && cfg->param.logLevel && referenced)
>> + if (cfg->param->rc.vbvBufferSize && cfg->param->logLevel && referenced)
>> cuTreeFinish(frames[b], averageDuration, b == p1 ? b - p0 : 0);
>> }
>>
>> void Lookahead::cuTreeFinish(Lowres *frame, double averageDuration, int ref0Distance)
>> {
>> - int fpsFactor = (int)(CLIP_DURATION(averageDuration) / CLIP_DURATION((double)cfg->param.fpsDenom / cfg->param.fpsNum) * 256);
>> + int fpsFactor = (int)(CLIP_DURATION(averageDuration) / CLIP_DURATION((double)cfg->param->fpsDenom / cfg->param->fpsNum) * 256);
>> double weightdelta = 0.0;
>>
>> if (ref0Distance && frame->weightedCostDelta[ref0Distance - 1] > 0)
>> @@ -1027,7 +1027,7 @@
>> * concepts are very similar. */
>>
>> int cuCount = widthInCU * heightInCU;
>> - double strength = 5.0 * (1.0 - cfg->param.rc.qCompress);
>> + double strength = 5.0 * (1.0 - cfg->param->rc.qCompress);
>>
>> for (int cuIndex = 0; cuIndex < cuCount; cuIndex++)
>> {
>> @@ -1112,11 +1112,11 @@
>> delete[] rows;
>> }
>>
>> -void CostEstimate::init(TEncCfg *_cfg, TComPic *pic)
>> +void CostEstimate::init(Encoder *_cfg, TComPic *pic)
>> {
>> cfg = _cfg;
>> - widthInCU = ((cfg->param.sourceWidth / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> - heightInCU = ((cfg->param.sourceHeight / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> + widthInCU = ((cfg->param->sourceWidth / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>> + heightInCU = ((cfg->param->sourceHeight / 2) + X265_LOWRES_CU_SIZE - 1) >> X265_LOWRES_CU_BITS;
>>
>> rows = new EstimateRow[heightInCU];
>> for (int i = 0; i < heightInCU; i++)
>> @@ -1134,7 +1134,7 @@
>> WaveFront::enableAllRows();
>> }
>>
>> - if (cfg->param.bEnableWeightedPred)
>> + if (cfg->param->bEnableWeightedPred)
>> {
>> TComPicYuv *orig = pic->getPicYuvOrg();
>> paddedLines = pic->m_lowres.lines + 2 * orig->getLumaMarginY();
>> @@ -1164,7 +1164,7 @@
>> else
>> {
>> weightedRef.isWeighted = false;
>> - if (cfg->param.bEnableWeightedPred && b == p1 && b != p0 && fenc->lowresMvs[0][b - p0 - 1][0].x == 0x7FFF)
>> + if (cfg->param->bEnableWeightedPred && b == p1 && b != p0 && fenc->lowresMvs[0][b - p0 - 1][0].x == 0x7FFF)
>> {
>> if (!fenc->bIntraCalculated)
>> estimateFrameCost(frames, b, b, b, 0);
>> @@ -1221,7 +1221,7 @@
>> {
>> score += rows[row].costEst;
>> fenc->costEst[0][0] += rows[row].costIntra;
>> - if (cfg->param.rc.aqMode)
>> + if (cfg->param->rc.aqMode)
>> {
>> fenc->costEstAq[0][0] += rows[row].costIntraAq;
>> fenc->costEstAq[b - p0][p1 - b] += rows[row].costEstAq;
>> @@ -1232,7 +1232,7 @@
>> fenc->bIntraCalculated = true;
>>
>> if (b != p1)
>> - score = (uint64_t)score * 100 / (130 + cfg->param.bFrameBias);
>> + score = (uint64_t)score * 100 / (130 + cfg->param->bFrameBias);
>> if (b != p0 || b != p1) //Not Intra cost
>> fenc->costEst[b - p0][p1 - b] = score;
>> }
>> diff -r 6662df480e39 -r 56fa912d6e7c source/encoder/slicetype.h
>> --- a/source/encoder/slicetype.h Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/encoder/slicetype.h Mon Mar 03 14:24:34 2014 -0800
>> @@ -33,7 +33,7 @@
>>
>> struct Lowres;
>> class TComPic;
>> -class TEncCfg;
>> +class Encoder;
>>
>> #define SET_WEIGHT(w, b, s, d, o) \
>> { \
>> @@ -89,9 +89,9 @@
>> {
>> CostEstimate(ThreadPool *p);
>> ~CostEstimate();
>> - void init(TEncCfg *, TComPic *);
>> + void init(Encoder *, TComPic *);
>>
>> - TEncCfg *cfg;
>> + Encoder *cfg;
>> EstimateRow *rows;
>> pixel *wbuffer[4];
>> Lowres **curframes;
>> @@ -118,7 +118,7 @@
>>
>> struct Lookahead
>> {
>> - Lookahead(TEncCfg *, ThreadPool *pool);
>> + Lookahead(Encoder *, ThreadPool *pool);
>> ~Lookahead();
>> void init();
>> void destroy();
>> @@ -127,7 +127,7 @@
>> PicList inputQueue; // input pictures in order received
>> PicList outputQueue; // pictures to be encoded, in encode order
>>
>> - TEncCfg *cfg;
>> + Encoder *cfg;
>> Lowres *lastNonB;
>> int *scratch; // temp buffer
>>
>> diff -r 6662df480e39 -r 56fa912d6e7c source/x265.cpp
>> --- a/source/x265.cpp Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/x265.cpp Mon Mar 03 14:24:34 2014 -0800
>> @@ -170,7 +170,8 @@
>> { "no-framefieldinfo", no_argument, NULL, 0 },
>> { "crop-rect", required_argument, NULL, 0 },
>> { "timinginfo", no_argument, NULL, 0 },
>> - { "nal-hrd", no_argument, NULL, 0 },
>> + { "hrd", no_argument, NULL, 0 },
>> + { "nal-hrd", required_argument, NULL, 0 },
>> { "bitstreamrestriction", no_argument, NULL, 0 },
>> { "subpichrd", no_argument, NULL, 0 },
>> { 0, 0, 0, 0 }
>> @@ -394,7 +395,8 @@
>> H0(" --[no-]framefieldinfo Specify that a pic-struct will be added to the SEI timing message. Default %s\n", OPT(param->bEnableFrameFieldInfoPresentFlag));
>> H0(" --crop-rect <string> Add 'left,top,right,bottom' to the bitstream-level cropping rectangle\n");
>> H0(" --timinginfo Add timing information to the VUI. Defaut %s\n", OPT(param->bEnableVuiTimingInfoPresentFlag));
>> - H0(" --nal-hrd Signal HRD information. Default %s\n", OPT(param->bEnableVuiHrdParametersPresentFlag));
>> + H0(" --hrd Signal HRD information. Default %s\n", OPT(param->bEnableVuiHrdParametersPresentFlag));
>> + H0(" --nal-hrd <string> Signal NAL HRD information (requires vbv-buffer size) Choose from none, vbr or cbr.Default none\n");
>> H0(" --bitstreamrestriction Add bit stream restriction fields to the VUI. Default %s\n", OPT(param->bEnableBitstreamRestrictionFlag));
>> H0(" --subpichrd Add sub picture HRD parameters to the HRD. Default %s\n", OPT(param->bEnableSubPicHrdParamsPresentFlag));
>> #undef OPT
>> diff -r 6662df480e39 -r 56fa912d6e7c source/x265.h
>> --- a/source/x265.h Mon Mar 03 11:28:22 2014 +0530
>> +++ b/source/x265.h Mon Mar 03 14:24:34 2014 -0800
>> @@ -290,6 +290,7 @@
>> "YCgCo", "bt2020nc", "bt2020c", 0 };
>> static const char * const x265_sar_names[] = { "undef", "1:1", "12:11", "10:11", "16:11", "40:33", "24:11", "20:11",
>> "32:11", "80:33", "18:11", "15:11", "64:33", "160:99", "4:3", "3:2", "2:1", 0 };
>> +static const char * const x265_nal_hrd_names[] = { "none", "vbr", "cbr", 0 };
>>
>> /* x265 input parameters
>> *
>> @@ -479,6 +480,10 @@
>>
>> /*== Hypothetical Reference Decoder Parameters ==*/
>>
>> + /* NAL HRD parameters present flag determines if NAL HRD parameters related
>> + * to Type II bitstream are added to the VUI. The default is false. */
>> + int bEnableNalHrdParametersPresentFlag;
> this is the kicker, it changes the public API so it will require a
> bump to the build number so I'll need to hold off pushing it for a day
> or two so I can get all the other queued API changes in all at once.
>
>> +
>> /* Sub pic HRD params present flag determines if tic_divisor_minus2,
>> * du_cpb_removal_delay_increment_length_minus1,
>> * sub_pic_cpb_params_in_pic_timing_sei_flag,
>> _______________________________________________
>> x265-devel mailing list
>> x265-devel at videolan.org
>> https://mailman.videolan.org/listinfo/x265-devel
>
>
At first I thought replacing the copy of x265_param in TEncCfg with a
pointer to the original made perfect sense but after contemplating
replacing the other HM classes and code, I might bring the copy back.
It depends on how to best fit everything together and I am still
thinking about it.
More information about the x265-devel
mailing list