You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
329 lines
10 KiB
329 lines
10 KiB
/* *************************************************************************
|
|
** INTEL Corporation Proprietary Information
|
|
**
|
|
** This listing is supplied under the terms of a license
|
|
** agreement with INTEL Corporation and may not be copied
|
|
** nor disclosed except in accordance with the terms of
|
|
** that agreement.
|
|
**
|
|
** Copyright (c) 1995 Intel Corporation.
|
|
** All Rights Reserved.
|
|
**
|
|
** *************************************************************************
|
|
*/
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* e1stat.cpp
|
|
*
|
|
* DESCRIPTION:
|
|
* Encoder statistics functions
|
|
*
|
|
* Routines: Prototypes in:
|
|
* OutputEncodeTimingStatistics e1stat.h
|
|
*/
|
|
|
|
// $Header: R:\h26x\h26x\src\enc\e1stat.cpv 1.2 20 Mar 1996 14:20:58 Sylvia_C_Day $
|
|
// $Log: R:\h26x\h26x\src\enc\e1stat.cpv $
|
|
//
|
|
// Rev 1.2 20 Mar 1996 14:20:58 Sylvia_C_Day
|
|
// Added lower level timing stats for SLF_UV
|
|
//
|
|
// Rev 1.1 29 Dec 1995 18:08:56 DBRUCKS
|
|
// add average quant used and coded
|
|
//
|
|
// Rev 1.0 26 Dec 1995 17:46:16 DBRUCKS
|
|
// Initial revision.
|
|
|
|
#include "precomp.h"
|
|
|
|
#ifdef ENCODE_STATS
|
|
|
|
static void OutputEncTimingDetail(FILE * pFile, ENC_TIMING_INFO * pEncTimingInfo);
|
|
|
|
/************************************************************************
|
|
*
|
|
* OutputEncodeBitStreamStatistics
|
|
*/
|
|
extern void OutputEncodeBitStreamStatistics(
|
|
char * szFileName,
|
|
ENC_BITSTREAM_INFO * pBSInfo,
|
|
int bCIF)
|
|
{
|
|
FILE * pFile;
|
|
U32 uTotalMBs;
|
|
U32 uProcessedMBs;
|
|
U32 uCOEFFBlocks;
|
|
U32 uSkippedMBs;
|
|
U32 uTotalQuantUsed;
|
|
U32 uTotalQuantCoded;
|
|
int i;
|
|
|
|
pFile = fopen(szFileName, "a");
|
|
if (pFile == NULL)
|
|
{
|
|
DBOUT("Error opening encode stat file");
|
|
goto done;
|
|
}
|
|
|
|
/* Update the statistics
|
|
*/
|
|
if (bCIF)
|
|
{
|
|
uTotalMBs = (pBSInfo->uKeyFrameCount + pBSInfo->uDeltaFrameCount) * 33 * 12;
|
|
}
|
|
else
|
|
{
|
|
uTotalMBs = (pBSInfo->uKeyFrameCount + pBSInfo->uDeltaFrameCount) * 33 * 3;
|
|
}
|
|
|
|
if (uTotalMBs == 0)
|
|
{
|
|
fprintf(pFile,"No Macro Blocks processed - skipping frame statistics\n");
|
|
goto done;
|
|
}
|
|
|
|
uProcessedMBs = 0;
|
|
uCOEFFBlocks = 0;
|
|
for (i = 0 ; i < 10 ; i++)
|
|
{
|
|
uProcessedMBs += pBSInfo->uMTypeCount[i];
|
|
uCOEFFBlocks += pBSInfo->uBlockCount[i];
|
|
}
|
|
uSkippedMBs = uTotalMBs - uProcessedMBs;
|
|
|
|
fprintf(pFile,"Total Key Frames=%ld Delta Frames=%ld\n",
|
|
pBSInfo->uKeyFrameCount, pBSInfo->uDeltaFrameCount);
|
|
fprintf(pFile,"Total Total MBs=%ld\n", uTotalMBs);
|
|
fprintf(pFile,"Total Coded MBs=%ld (%ld%%)\n", uProcessedMBs, ((uProcessedMBs*100)+(uTotalMBs/2))/uTotalMBs);
|
|
fprintf(pFile,"Total Coded Blocks=%ld (%ld%%)\n", uCOEFFBlocks, ((uCOEFFBlocks*100)+(uTotalMBs/2))/(uTotalMBs*6));
|
|
|
|
for (i = 0; i < 10 ; i++)
|
|
{
|
|
if (pBSInfo->uMTypeCount[i])
|
|
{
|
|
fprintf(pFile,"Total Coded MBType[%d]=%ld (%ld%%) blocks=%ld (%ld%%)\n",
|
|
i,
|
|
pBSInfo->uMTypeCount[i],
|
|
((pBSInfo->uMTypeCount[i]*100)+(uProcessedMBs/2))/uProcessedMBs,
|
|
pBSInfo->uBlockCount[i],
|
|
((pBSInfo->uBlockCount[i]*100)+(uCOEFFBlocks/2))/uCOEFFBlocks);
|
|
}
|
|
}
|
|
|
|
if (pBSInfo->uKeyFrameCount)
|
|
{
|
|
fprintf(pFile,"Total Key Frame Bytes=%ld Average Per Key Frame=%ld\n",
|
|
pBSInfo->uTotalKeyBytes,
|
|
(pBSInfo->uTotalKeyBytes + (pBSInfo->uKeyFrameCount/2)) / pBSInfo->uKeyFrameCount);
|
|
}
|
|
if (pBSInfo->uDeltaFrameCount)
|
|
{
|
|
fprintf(pFile,"Total Delta Frame Bytes=%ld Average Per Delta Frame=%ld\n",
|
|
pBSInfo->uTotalDeltaBytes,
|
|
(pBSInfo->uTotalDeltaBytes + (pBSInfo->uDeltaFrameCount/2)) / pBSInfo->uDeltaFrameCount);
|
|
}
|
|
if (pBSInfo->uKeyFrameCount || pBSInfo->uDeltaFrameCount)
|
|
{
|
|
fprintf(pFile,"Total Bytes=%ld Average Per Frame=%ld\n",
|
|
pBSInfo->uTotalKeyBytes + pBSInfo->uTotalDeltaBytes,
|
|
((pBSInfo->uTotalKeyBytes + pBSInfo->uTotalDeltaBytes) + ((pBSInfo->uKeyFrameCount + pBSInfo->uDeltaFrameCount) / 2)) /
|
|
(pBSInfo->uKeyFrameCount + pBSInfo->uDeltaFrameCount));
|
|
}
|
|
|
|
/* Quantization Information
|
|
*/
|
|
uTotalQuantUsed = 0;
|
|
uTotalQuantCoded = 0;
|
|
for (i = 0; i <= 31; i++)
|
|
{
|
|
if (pBSInfo->uQuantsUsedOnBlocks[i])
|
|
{
|
|
fprintf(pFile,"QuantValue %2ld",i);
|
|
fprintf(pFile," Used %7ld (%2ld%%)", pBSInfo->uQuantsUsedOnBlocks[i],
|
|
((pBSInfo->uQuantsUsedOnBlocks[i] * 100) + ((uTotalMBs*6)/2))/(uTotalMBs*6));
|
|
fprintf(pFile," Coded %7ld (%2ld%%)\n", pBSInfo->uQuantsTransmittedOnBlocks[i],
|
|
((pBSInfo->uQuantsTransmittedOnBlocks[i] * 100) + ((uTotalMBs*6)/2))/(uTotalMBs*6));
|
|
uTotalQuantUsed += pBSInfo->uQuantsUsedOnBlocks[i] * i;
|
|
uTotalQuantCoded += pBSInfo->uQuantsTransmittedOnBlocks[i] * i;
|
|
}
|
|
if (pBSInfo->uQuantsTransmittedOnBlocks[i])
|
|
ASSERT(pBSInfo->uQuantsUsedOnBlocks[i]);
|
|
}
|
|
if ((uTotalMBs > 0) && (uCOEFFBlocks > 0))
|
|
{
|
|
fprintf(pFile,"Average Used %f Average Coded %f",
|
|
(float) uTotalQuantUsed / (float)(uTotalMBs*6),
|
|
(float) uTotalQuantCoded / (float) uCOEFFBlocks);
|
|
}
|
|
#ifdef _DEBUG
|
|
{
|
|
U32 uUsedTotal = 0;
|
|
U32 uCodedTotal = 0;
|
|
for (i = 0; i <= 31; i++)
|
|
{
|
|
uUsedTotal += pBSInfo->uQuantsUsedOnBlocks[i];
|
|
uCodedTotal += pBSInfo->uQuantsTransmittedOnBlocks[i];
|
|
}
|
|
ASSERT(uUsedTotal == (uTotalMBs*6));
|
|
ASSERT(uCodedTotal == uCOEFFBlocks);
|
|
}
|
|
#endif
|
|
|
|
done:
|
|
|
|
return;
|
|
} /* end OutputEncodeBitStreamStatistics() */
|
|
|
|
|
|
/************************************************************************
|
|
*
|
|
* OutputEncodeTimingStatistics
|
|
*/
|
|
extern void OutputEncodeTimingStatistics(
|
|
char * szFileName,
|
|
ENC_TIMING_INFO * pEncTimingInfo)
|
|
{
|
|
FILE * pFile;
|
|
ENC_TIMING_INFO * pTempEncTimingInfo;
|
|
ENC_TIMING_INFO etiTemp;
|
|
int i;
|
|
int iCount;
|
|
|
|
pFile = fopen(szFileName, "a");
|
|
if (pFile == NULL)
|
|
{
|
|
DBOUT("Error opening encode stat file");
|
|
goto done;
|
|
}
|
|
|
|
#ifdef DETAIL_ENCODE_STATS
|
|
/* Output the detail information
|
|
*/
|
|
fprintf(pFile,"\nDetail Timing Information\n");
|
|
for ( i = 0, pTempEncTimingInfo = pEncTimingInfo ;
|
|
i < ENC_TIMING_INFO_FRAME_COUNT ;
|
|
i++, pTempEncTimingInfo++ )
|
|
{
|
|
if (pTempEncTimingInfo->uDecodeFrame != 0)
|
|
{
|
|
fprintf(pFile, "Frame %d Detail Timing Information\n", i);
|
|
OutputEncTimingDetail(pFile, pTempEncTimingInfo);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
/* Compute the total information
|
|
*/
|
|
memset(&etiTemp, 0, sizeof(ENC_TIMING_INFO));
|
|
iCount = 0;
|
|
|
|
for ( i = 0, pTempEncTimingInfo = pEncTimingInfo ;
|
|
i < ENC_TIMING_INFO_FRAME_COUNT ;
|
|
i++, pTempEncTimingInfo++ )
|
|
{
|
|
if (pTempEncTimingInfo->uDecodeFrame != 0)
|
|
{
|
|
iCount++;
|
|
|
|
etiTemp.uEncodeFrame += pTempEncTimingInfo->uEncodeFrame;
|
|
etiTemp.uInputCC += pTempEncTimingInfo->uInputCC;
|
|
etiTemp.uMotionEstimation += pTempEncTimingInfo->uMotionEstimation;
|
|
etiTemp.uFDCT += pTempEncTimingInfo->uFDCT;
|
|
etiTemp.uQRLE += pTempEncTimingInfo->uQRLE;
|
|
etiTemp.uDecodeFrame += pTempEncTimingInfo->uDecodeFrame;
|
|
etiTemp.uZeroingBuffer += pTempEncTimingInfo->uZeroingBuffer;
|
|
etiTemp.uSLF_UV += pTempEncTimingInfo->uSLF_UV;
|
|
}
|
|
}
|
|
|
|
if (iCount > 0)
|
|
{
|
|
#ifdef DETAIL_ENCODE_STATS
|
|
/* Output the total information
|
|
*/
|
|
fprintf(pFile,"Total for %d frames\n", iCount);
|
|
OutputEncTimingDetail(pFile, &etiTemp);
|
|
#endif
|
|
|
|
/* Compute the average
|
|
*/
|
|
etiTemp.uEncodeFrame = (etiTemp.uEncodeFrame + (iCount / 2)) / iCount;
|
|
etiTemp.uInputCC = (etiTemp.uInputCC + (iCount / 2)) / iCount;
|
|
etiTemp.uMotionEstimation = (etiTemp.uMotionEstimation + (iCount / 2)) / iCount;
|
|
etiTemp.uFDCT = (etiTemp.uFDCT + (iCount / 2)) / iCount;
|
|
etiTemp.uQRLE = (etiTemp.uQRLE + (iCount / 2)) / iCount;
|
|
etiTemp.uDecodeFrame = (etiTemp.uDecodeFrame + (iCount / 2)) / iCount;
|
|
etiTemp.uZeroingBuffer = (etiTemp.uZeroingBuffer + (iCount / 2)) / iCount;
|
|
etiTemp.uSLF_UV = (etiTemp.uSLF_UV + (iCount / 2)) / iCount;
|
|
|
|
/* Output the average information
|
|
*/
|
|
fprintf(pFile,"Average over %d frames\n", iCount);
|
|
OutputEncTimingDetail(pFile, &etiTemp);
|
|
}
|
|
|
|
fclose(pFile);
|
|
done:
|
|
|
|
return;
|
|
} /* OutputEncodeTimingStatistics() */
|
|
|
|
/************************************************************************
|
|
*
|
|
* OutputEncTimingDetail
|
|
*/
|
|
static void OutputEncTimingDetail(
|
|
FILE * pFile,
|
|
ENC_TIMING_INFO * pEncTimingInfo)
|
|
{
|
|
U32 uOther;
|
|
U32 uRoundUp;
|
|
U32 uDivisor;
|
|
|
|
fprintf(pFile, "\tEncode Frame = %10d (%d milliseconds at 90Mhz)\n", pEncTimingInfo->uEncodeFrame,
|
|
(pEncTimingInfo->uEncodeFrame + 45000) / 90000);
|
|
uOther = pEncTimingInfo->uEncodeFrame;
|
|
|
|
/* This is needed because of the integer truncation.
|
|
*/
|
|
uDivisor = pEncTimingInfo->uEncodeFrame / 100; // to yield a percent
|
|
uRoundUp = uDivisor / 2;
|
|
|
|
fprintf(pFile, "\tInputCC = %10d (%2d%%)\n", pEncTimingInfo->uInputCC,
|
|
(pEncTimingInfo->uInputCC + uRoundUp) / uDivisor);
|
|
uOther -= pEncTimingInfo->uInputCC;
|
|
|
|
fprintf(pFile, "\tMotionEstimation = %10d (%2d%%)\n", pEncTimingInfo->uMotionEstimation,
|
|
(pEncTimingInfo->uMotionEstimation + uRoundUp) / uDivisor);
|
|
uOther -= pEncTimingInfo->uMotionEstimation;
|
|
|
|
fprintf(pFile, "\tFDCT = %10d (%2d%%)\n", pEncTimingInfo->uFDCT,
|
|
(pEncTimingInfo->uFDCT + uRoundUp) / uDivisor);
|
|
uOther -= pEncTimingInfo->uFDCT;
|
|
|
|
fprintf(pFile, "\tQRLE = %10d (%2d%%)\n", pEncTimingInfo->uQRLE,
|
|
(pEncTimingInfo->uQRLE + uRoundUp) / uDivisor);
|
|
uOther -= pEncTimingInfo->uQRLE;
|
|
|
|
fprintf(pFile, "\tDecodeFrame = %10d (%2d%%)\n", pEncTimingInfo->uDecodeFrame,
|
|
(pEncTimingInfo->uDecodeFrame + uRoundUp) / uDivisor);
|
|
uOther -= pEncTimingInfo->uDecodeFrame;
|
|
|
|
fprintf(pFile, "\tZeroingBuffer = %10d (%2d%%)\n", pEncTimingInfo->uZeroingBuffer,
|
|
(pEncTimingInfo->uZeroingBuffer + uRoundUp) / uDivisor);
|
|
uOther -= pEncTimingInfo->uZeroingBuffer;
|
|
|
|
fprintf(pFile, "\tSLF_UV = %10d (%2d%%)\n", pEncTimingInfo->uSLF_UV,
|
|
(pEncTimingInfo->uSLF_UV + uRoundUp) / uDivisor);
|
|
uOther -= pEncTimingInfo->uSLF_UV;
|
|
|
|
fprintf(pFile, "\tOther = %10d (%2d%%)\n", uOther,
|
|
(uOther + uRoundUp) / uDivisor);
|
|
|
|
|
|
} /* end OutputEncTimingDetail() */
|
|
|
|
#endif /* ENCODE_STATS */
|
|
|
|
|