Странная ошибка прямого объявления, о которой сообщает llvm-gcc-4.2
Когда я использую llvm-gcc-4.2 в Xcode4.6.3 для компиляции источников "x265", он сообщал о странной ошибке: ./source/encoder/reference.h:38:error: прямое объявление "class x265::MotionReference". Однако объявление класса x265:: MotionReference завершено в файле reference.h:
#ifndef X265_REFERENCE_H
#define X265_REFERENCE_H
#include "primitives.h"
#include "picyuv.h"
#include "lowres.h"
#include "mv.h"
namespace X265_NS {
// private x265 namespace
struct WeightParam;
class MotionReference : public ReferencePlanes
{
public:
MotionReference();
~MotionReference();
int init(PicYuv*, WeightParam* wp, const x265_param& p);
void applyWeight(int rows, int numRows);
pixel* weightBuffer[3];
int numInterpPlanes;
int numWeightedRows;
protected:
MotionReference& operator =(const MotionReference&);
};
}
и его родительский класс определен в заголовочном файле 'lowres.h':
#ifndef X265_LOWRES_H
#define X265_LOWRES_H
#include "primitives.h"
#include "common.h"
#include "picyuv.h"
#include "mv.h"
namespace X265_NS {
// private namespace
struct ReferencePlanes
{
ReferencePlanes() { memset(this, 0, sizeof(ReferencePlanes)); }
pixel* fpelPlane[3];
pixel* lowresPlane[4];
PicYuv* reconPic;
bool isWeighted;
bool isLowres;
intptr_t lumaStride;
intptr_t chromaStride;
struct {
int weight;
int offset;
int shift;
int round;
} w[3];
pixel* getLumaAddr(uint32_t ctuAddr, uint32_t absPartIdx) { return fpelPlane[0] + reconPic->m_cuOffsetY[ctuAddr] + reconPic->m_buOffsetY[absPartIdx]; }
pixel* getCbAddr(uint32_t ctuAddr, uint32_t absPartIdx) { return fpelPlane[1] + reconPic->m_cuOffsetC[ctuAddr] + reconPic->m_buOffsetC[absPartIdx]; }
pixel* getCrAddr(uint32_t ctuAddr, uint32_t absPartIdx) { return fpelPlane[2] + reconPic->m_cuOffsetC[ctuAddr] + reconPic->m_buOffsetC[absPartIdx]; }
/* lowres motion compensation, you must provide a buffer and stride for QPEL averaged pixels
* in case QPEL is required. Else it returns a pointer to the HPEL pixels */
inline pixel *lowresMC(intptr_t blockOffset, const MV& qmv, pixel *buf, intptr_t& outstride)
{
if ((qmv.x | qmv.y) & 1)
{
int hpelA = (qmv.y & 2) | ((qmv.x & 2) >> 1);
pixel *frefA = lowresPlane[hpelA] + blockOffset + (qmv.x >> 2) + (qmv.y >> 2) * lumaStride;
int qmvx = qmv.x + (qmv.x & 1);
int qmvy = qmv.y + (qmv.y & 1);
int hpelB = (qmvy & 2) | ((qmvx & 2) >> 1);
pixel *frefB = lowresPlane[hpelB] + blockOffset + (qmvx >> 2) + (qmvy >> 2) * lumaStride;
primitives.pu[LUMA_8x8].pixelavg_pp(buf, outstride, frefA, lumaStride, frefB, lumaStride, 32);
return buf;
}
else
{
outstride = lumaStride;
int hpel = (qmv.y & 2) | ((qmv.x & 2) >> 1);
return lowresPlane[hpel] + blockOffset + (qmv.x >> 2) + (qmv.y >> 2) * lumaStride;
}
}
inline int lowresQPelCost(pixel *fenc, intptr_t blockOffset, const MV& qmv, pixelcmp_t comp)
{
if ((qmv.x | qmv.y) & 1)
{
ALIGN_VAR_16(pixel, subpelbuf[8 * 8]);
int hpelA = (qmv.y & 2) | ((qmv.x & 2) >> 1);
pixel *frefA = lowresPlane[hpelA] + blockOffset + (qmv.x >> 2) + (qmv.y >> 2) * lumaStride;
int qmvx = qmv.x + (qmv.x & 1);
int qmvy = qmv.y + (qmv.y & 1);
int hpelB = (qmvy & 2) | ((qmvx & 2) >> 1);
pixel *frefB = lowresPlane[hpelB] + blockOffset + (qmvx >> 2) + (qmvy >> 2) * lumaStride;
primitives.pu[LUMA_8x8].pixelavg_pp(subpelbuf, 8, frefA, lumaStride, frefB, lumaStride, 32);
return comp(fenc, FENC_STRIDE, subpelbuf, 8);
}
else
{
int hpel = (qmv.y & 2) | ((qmv.x & 2) >> 1);
pixel *fref = lowresPlane[hpel] + blockOffset + (qmv.x >> 2) + (qmv.y >> 2) * lumaStride;
return comp(fenc, FENC_STRIDE, fref, lumaStride);
}
}
};
/* lowres buffers, sizes and strides */
struct Lowres : public ReferencePlanes
{
pixel *buffer[4];
int frameNum; // Presentation frame number
int sliceType; // Slice type decided by lookahead
int width; // width of lowres frame in pixels
int lines; // height of lowres frame in pixel lines
int leadingBframes; // number of leading B frames for P or I
bool bScenecut; // Set to false if the frame cannot possibly be part of a real scenecut.
bool bKeyframe;
bool bLastMiniGopBFrame;
/* lookahead output data */
int64_t costEst[X265_BFRAME_MAX + 2][X265_BFRAME_MAX + 2];
int64_t costEstAq[X265_BFRAME_MAX + 2][X265_BFRAME_MAX + 2];
int32_t* rowSatds[X265_BFRAME_MAX + 2][X265_BFRAME_MAX + 2];
int intraMbs[X265_BFRAME_MAX + 2];
int32_t* intraCost;
uint8_t* intraMode;
int64_t satdCost;
uint16_t* lowresCostForRc;
uint16_t(*lowresCosts[X265_BFRAME_MAX + 2][X265_BFRAME_MAX + 2]);
int32_t* lowresMvCosts[2][X265_BFRAME_MAX + 1];
MV* lowresMvs[2][X265_BFRAME_MAX + 1];
uint32_t maxBlocksInRow;
uint32_t maxBlocksInCol;
/* used for vbvLookahead */
int plannedType[X265_LOOKAHEAD_MAX + 1];
int64_t plannedSatd[X265_LOOKAHEAD_MAX + 1];
int indB;
int bframes;
/* rate control / adaptive quant data */
double* qpAqOffset; // AQ QP offset values for each 16x16 CU
double* qpCuTreeOffset; // cuTree QP offset values for each 16x16 CU
int* invQscaleFactor; // qScale values for qp Aq Offsets
uint32_t* blockVariance;
uint64_t wp_ssd[3]; // This is different than SSDY, this is sum(pixel^2) - sum(pixel)^2 for entire frame
uint64_t wp_sum[3];
uint64_t frameVariance;
/* cutree intermediate data */
uint16_t* propagateCost;
double weightedCostDelta[X265_BFRAME_MAX + 2];
ReferencePlanes weightedRef[X265_BFRAME_MAX + 2];
bool create(PicYuv *origPic, int _bframes, bool bAqEnabled);
void destroy();
void init(PicYuv *origPic, int poc);
};
}
Кто-нибудь знает почему? Любая подсказка будет оценена! Заранее спасибо!
1 ответ
Причиной проблемы является не этот файл, а другой файл... Существует еще один файл 'sllice.h', использующий предварительное объявление как:
#ifndef X265_SLICE_H
#define X265_SLICE_H
#include "common.h"
namespace X265_NS {
// private namespace
class Frame;
class PicList;
class PicYuv;
class MotionReference;
enum SliceType
{
B_SLICE,
P_SLICE,
I_SLICE
};
struct RPS
{
int numberOfPictures;
int numberOfNegativePictures;
int numberOfPositivePictures;
int poc[MAX_NUM_REF_PICS];
int deltaPOC[MAX_NUM_REF_PICS];
bool bUsed[MAX_NUM_REF_PICS];
RPS()
: numberOfPictures(0)
, numberOfNegativePictures(0)
, numberOfPositivePictures(0)
{
memset(deltaPOC, 0, sizeof(deltaPOC));
memset(poc, 0, sizeof(poc));
memset(bUsed, 0, sizeof(bUsed));
}
void sortDeltaPOC();
};
namespace Profile {
enum Name
{
NONE = 0,
MAIN = 1,
MAIN10 = 2,
MAINSTILLPICTURE = 3,
MAINREXT = 4,
HIGHTHROUGHPUTREXT = 5
};
}
namespace Level {
enum Tier
{
MAIN = 0,
HIGH = 1,
};
enum Name
{
NONE = 0,
LEVEL1 = 30,
LEVEL2 = 60,
LEVEL2_1 = 63,
LEVEL3 = 90,
LEVEL3_1 = 93,
LEVEL4 = 120,
LEVEL4_1 = 123,
LEVEL5 = 150,
LEVEL5_1 = 153,
LEVEL5_2 = 156,
LEVEL6 = 180,
LEVEL6_1 = 183,
LEVEL6_2 = 186,
LEVEL8_5 = 255,
};
}
struct ProfileTierLevel
{
int profileIdc;
int levelIdc;
uint32_t minCrForLevel;
uint32_t maxLumaSrForLevel;
uint32_t bitDepthConstraint;
int chromaFormatConstraint;
bool tierFlag;
bool progressiveSourceFlag;
bool interlacedSourceFlag;
bool nonPackedConstraintFlag;
bool frameOnlyConstraintFlag;
bool profileCompatibilityFlag[32];
bool intraConstraintFlag;
bool onePictureOnlyConstraintFlag;
bool lowerBitRateConstraintFlag;
};
struct HRDInfo
{
uint32_t bitRateScale;
uint32_t cpbSizeScale;
uint32_t initialCpbRemovalDelayLength;
uint32_t cpbRemovalDelayLength;
uint32_t dpbOutputDelayLength;
uint32_t bitRateValue;
uint32_t cpbSizeValue;
bool cbrFlag;
HRDInfo()
: bitRateScale(0)
, cpbSizeScale(0)
, initialCpbRemovalDelayLength(1)
, cpbRemovalDelayLength(1)
, dpbOutputDelayLength(1)
, cbrFlag(false)
{
}
};
struct TimingInfo
{
uint32_t numUnitsInTick;
uint32_t timeScale;
};
struct VPS
{
HRDInfo hrdParameters;
ProfileTierLevel ptl;
uint32_t maxTempSubLayers;
uint32_t numReorderPics;
uint32_t maxDecPicBuffering;
uint32_t maxLatencyIncrease;
};
struct Window
{
int leftOffset;
int rightOffset;
int topOffset;
int bottomOffset;
bool bEnabled;
Window()
{
bEnabled = false;
}
};
struct VUI
{
int aspectRatioIdc;
int sarWidth;
int sarHeight;
int videoFormat;
int colourPrimaries;
int transferCharacteristics;
int matrixCoefficients;
int chromaSampleLocTypeTopField;
int chromaSampleLocTypeBottomField;
bool aspectRatioInfoPresentFlag;
bool overscanInfoPresentFlag;
bool overscanAppropriateFlag;
bool videoSignalTypePresentFlag;
bool videoFullRangeFlag;
bool colourDescriptionPresentFlag;
bool chromaLocInfoPresentFlag;
bool frameFieldInfoPresentFlag;
bool fieldSeqFlag;
bool hrdParametersPresentFlag;
HRDInfo hrdParameters;
Window defaultDisplayWindow;
TimingInfo timingInfo;
};
struct SPS
{
/* cached PicYuv offset arrays, shared by all instances of
* PicYuv created by this encoder */
intptr_t* cuOffsetY;
intptr_t* cuOffsetC;
intptr_t* buOffsetY;
intptr_t* buOffsetC;
int chromaFormatIdc; // use param
uint32_t picWidthInLumaSamples; // use param
uint32_t picHeightInLumaSamples; // use param
uint32_t numCuInWidth;
uint32_t numCuInHeight;
uint32_t numCUsInFrame;
uint32_t numPartitions;
uint32_t numPartInCUSize;
int log2MinCodingBlockSize;
int log2DiffMaxMinCodingBlockSize;
uint32_t quadtreeTULog2MaxSize;
uint32_t quadtreeTULog2MinSize;
uint32_t quadtreeTUMaxDepthInter; // use param
uint32_t quadtreeTUMaxDepthIntra; // use param
uint32_t maxAMPDepth;
uint32_t maxTempSubLayers; // max number of Temporal Sub layers
uint32_t maxDecPicBuffering; // these are dups of VPS values
uint32_t maxLatencyIncrease;
int numReorderPics;
bool bUseSAO; // use param
bool bUseAMP; // use param
bool bUseStrongIntraSmoothing; // use param
bool bTemporalMVPEnabled;
Window conformanceWindow;
VUI vuiParameters;
SPS()
{
memset(this, 0, sizeof(*this));
}
~SPS()
{
X265_FREE(cuOffsetY);
X265_FREE(cuOffsetC);
X265_FREE(buOffsetY);
X265_FREE(buOffsetC);
}
};
struct PPS
{
uint32_t maxCuDQPDepth;
int chromaQpOffset[2]; // use param
int deblockingFilterBetaOffsetDiv2;
int deblockingFilterTcOffsetDiv2;
bool bUseWeightPred; // use param
bool bUseWeightedBiPred; // use param
bool bUseDQP;
bool bConstrainedIntraPred; // use param
bool bTransquantBypassEnabled; // Indicates presence of cu_transquant_bypass_flag in CUs.
bool bTransformSkipEnabled; // use param
bool bEntropyCodingSyncEnabled; // use param
bool bSignHideEnabled; // use param
bool bDeblockingFilterControlPresent;
bool bPicDisableDeblockingFilter;
};
struct WeightParam
{
// Explicit weighted prediction parameters parsed in slice header,
uint32_t log2WeightDenom;
int inputWeight;
int inputOffset;
bool bPresentFlag;
/* makes a non-h265 weight (i.e. fix7), into an h265 weight */
void setFromWeightAndOffset(int w, int o, int denom, bool bNormalize)
{
inputOffset = o;
log2WeightDenom = denom;
inputWeight = w;
while (bNormalize && log2WeightDenom > 0 && (inputWeight > 127))
{
log2WeightDenom--;
inputWeight >>= 1;
}
inputWeight = X265_MIN(inputWeight, 127);
}
};
#define SET_WEIGHT(w, b, s, d, o) \
{ \
(w).inputWeight = (s); \
(w).log2WeightDenom = (d); \
(w).inputOffset = (o); \
(w).bPresentFlag = (b); \
}
class Slice
{
public:
const SPS* m_sps;
const PPS* m_pps;
Frame* m_refFrameList[2][MAX_NUM_REF + 1];
PicYuv* m_refReconPicList[2][MAX_NUM_REF + 1];
WeightParam m_weightPredTable[2][MAX_NUM_REF][3]; //
[list][refIdx][0:Y, 1:U, 2:V]
MotionReference (*m_mref)[MAX_NUM_REF + 1];
RPS m_rps;
NalUnitType m_nalUnitType;
SliceType m_sliceType;
int m_sliceQp;
int m_poc;
int m_lastIDR;
uint32_t m_colRefIdx; // never modified
int m_numRefIdx[2];
int m_refPOCList[2][MAX_NUM_REF + 1];
uint32_t m_maxNumMergeCand; // use param
uint32_t m_endCUAddr;
bool m_bCheckLDC; // TODO: is this necessary?
bool m_sLFaseFlag; // loop filter boundary flag
bool m_colFromL0Flag; // collocated picture from List0 or List1 flag
Slice()
{
m_lastIDR = 0;
m_sLFaseFlag = true;
m_numRefIdx[0] = m_numRefIdx[1] = 0;
memset(m_refFrameList, 0, sizeof(m_refFrameList));
memset(m_refReconPicList, 0, sizeof(m_refReconPicList));
memset(m_refPOCList, 0, sizeof(m_refPOCList));
disableWeights();
}
void disableWeights();
void setRefPicList(PicList& picList);
bool getRapPicFlag() const
{
return m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL
|| m_nalUnitType == NAL_UNIT_CODED_SLICE_CRA;
}
bool getIdrPicFlag() const
{
return m_nalUnitType == NAL_UNIT_CODED_SLICE_IDR_W_RADL;
}
bool isIRAP() const { return m_nalUnitType >= 16 && m_nalUnitType <= 23; }
bool isIntra() const { return m_sliceType == I_SLICE; }
bool isInterB() const { return m_sliceType == B_SLICE; }
bool isInterP() const { return m_sliceType == P_SLICE; }
uint32_t realEndAddress(uint32_t endCUAddr) const;
};
}
#endif // ifndef X265_SLICE_H
Если я изменю предварительное объявление на включение соответствующего заголовка, ошибки не будет!