generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Put some table size information in one place.

Browse Source 
Motivated by fixing an unused variable warning in release mode.
Review URL: http://webrtc-codereview.appspot.com/132007

git-svn-id: http://webrtc.googlecode.com/svn/trunk@523 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
andrew@webrtc.org 2011-09-02 22:03:56 +00:00
parent d7a41774ce
commit 413b993166
3 changed files with 61 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
src/modules/video_coding/main/source/er_tables_xor.h
View File

@ -11,15 +11,29 @@
#ifndef WEBRTC_MODULES_VIDEO_CODING_SOURCE_ER_TABLES_XOR_H_ #ifndef WEBRTC_MODULES_VIDEO_CODING_SOURCE_ER_TABLES_XOR_H_
#define WEBRTC_MODULES_VIDEO_CODING_SOURCE_ER_TABLES_XOR_H_ #define WEBRTC_MODULES_VIDEO_CODING_SOURCE_ER_TABLES_XOR_H_
namespace webrtc // This is a private header for media_opt_util.cc.
{ // It should not be included by other files.
namespace webrtc {
// Table for average FEC recovery from packet loss, for XOR code. // Table for average FEC recovery from packet loss, for XOR code.
// From RPL model of random loss. // From RPL model of random loss.
// Input is the received packet loss (up to 50%), and FEC code parameters (up to 24x24): // Input is the received packet loss (up to 50%), and FEC code parameters
// i.e., averageFECRecoveryRS[k] where k= code_i*129 + loss_j; // (up to 24x24):
// code_i=1x1,2x1,2x2,..24x24, loss_j=0,1,..128. // i.e., kAvgFECRecoveryXOR[k] where k = code_i*129 + loss_j;
const unsigned char VCMAvgFECRecoveryXOR[38700] = { // code_i=1x1,2x1,2x2,..24x24, loss_j = 0,1,..128.
// Maximum number of source packets in off-line model
static const int kMaxNumPackets = 24;
// Max value of loss rates in off-line model
static const int kPacketLossMax = 129;
// Table size for model is: kPacketLossMax * numberOfFecCodes = 38700
// numberOfFecCodes is determined as:
// {(1,1), (2,1), (2,2),...(n,1),..(n,n-1), (n,n)} = n*(n+1)/2
// for n = kMaxNumPackets.
static const int kSizeAvgFECRecoveryXOR = 38700;
static const unsigned char kAvgFECRecoveryXOR[kSizeAvgFECRecoveryXOR] = {
0, 0,
0, 0,
1, 1,

13
src/modules/video_coding/main/source/fec_tables_xor.h
View File

@ -11,14 +11,17 @@
#ifndef WEBRTC_MODULES_VIDEO_CODING_SOURCE_FEC_TABLES_XOR_H_ #ifndef WEBRTC_MODULES_VIDEO_CODING_SOURCE_FEC_TABLES_XOR_H_
#define WEBRTC_MODULES_VIDEO_CODING_SOURCE_FEC_TABLES_XOR_H_ #define WEBRTC_MODULES_VIDEO_CODING_SOURCE_FEC_TABLES_XOR_H_
namespace webrtc // This is a private header for media_opt_util.cc.
{ // It should not be included by other files.
namespace webrtc {
// Table for Protection factor (code rate) of delta frames, for the XOR FEC. // Table for Protection factor (code rate) of delta frames, for the XOR FEC.
// Input is the packet loss and an effective rate (bits/frame). // Input is the packet loss and an effective rate (bits/frame).
// Output is array codeRateXORTable[k], where k = rate_i*129 + loss_j; // Output is array kCodeRateXORTable[k], where k = rate_i*129 + loss_j;
// loss_j=0,1,..128, and rate_i varies over some range. // loss_j = 0,1,..128, and rate_i varies over some range.
const unsigned char VCMCodeRateXORTable[6450] = { static const int kSizeCodeRateXORTable = 6450;
static const unsigned char kCodeRateXORTable[kSizeCodeRateXORTable] = {
0, 0,
0, 0,
0, 0,

81
src/modules/video_coding/main/source/media_opt_util.cc
View File

@ -225,17 +225,6 @@ VCMFecMethod::AvgRecoveryFEC(const VCMProtectionParameters* parameters) const
(static_cast<float> (bitRatePerFrame * 1000.0) / (static_cast<float> (bitRatePerFrame * 1000.0) /
static_cast<float> (8.0 * _maxPayloadSize) + 0.5); static_cast<float> (8.0 * _maxPayloadSize) + 0.5);
// Parameters for tables
// Maximum number of source packets in off-line model
const WebRtc_UWord8 maxNumPackets = 24;
// Max value of loss rates in off-line model
const WebRtc_UWord8 plossMax = 129;
// Table size for model is: plossMax * numberOfFecCodes = 38700
// numberOfFecCodes is determined as:
// {(1,1), (2,1), (2,2),...(n,1),..(n,n-1), (n,n)} = n*(n+1)/2; for n=24.
const WebRtc_UWord16 maxErTableSize = 38700;
const float protectionFactor = static_cast<float>(_protectionFactorD) / const float protectionFactor = static_cast<float>(_protectionFactorD) /
255.0; 255.0;
@ -250,26 +239,26 @@ VCMFecMethod::AvgRecoveryFEC(const VCMProtectionParameters* parameters) const
return 0.0; return 0.0;
} }
// Table defined up to maxNumPackets // Table defined up to kMaxNumPackets
if (sourcePacketsPerFrame > maxNumPackets) if (sourcePacketsPerFrame > kMaxNumPackets)
{ {
sourcePacketsPerFrame = maxNumPackets; sourcePacketsPerFrame = kMaxNumPackets;
} }
// Table defined up to maxNumPackets // Table defined up to kMaxNumPackets
if (fecPacketsPerFrame > maxNumPackets) if (fecPacketsPerFrame > kMaxNumPackets)
{ {
fecPacketsPerFrame = maxNumPackets; fecPacketsPerFrame = kMaxNumPackets;
} }
// Code index for tables: up to (maxNumPackets * maxNumPackets) // Code index for tables: up to (kMaxNumPackets * kMaxNumPackets)
WebRtc_UWord16 codeIndexTable[maxNumPackets * maxNumPackets]; WebRtc_UWord16 codeIndexTable[kMaxNumPackets * kMaxNumPackets];
WebRtc_UWord16 k = 0; WebRtc_UWord16 k = 0;
for (WebRtc_UWord8 i = 1; i <= maxNumPackets; i++) for (WebRtc_UWord8 i = 1; i <= kMaxNumPackets; i++)
{ {
for (WebRtc_UWord8 j = 1; j <= i; j++) for (WebRtc_UWord8 j = 1; j <= i; j++)
{ {
codeIndexTable[(j - 1) * maxNumPackets + i - 1] = k; codeIndexTable[(j - 1) * kMaxNumPackets + i - 1] = k;
k += 1; k += 1;
} }
} }
@ -278,21 +267,20 @@ VCMFecMethod::AvgRecoveryFEC(const VCMProtectionParameters* parameters) const
parameters->lossPr + 0.5f); parameters->lossPr + 0.5f);
// Constrain lossRate to 50%: tables defined up to 50% // Constrain lossRate to 50%: tables defined up to 50%
if (lossRate >= plossMax) if (lossRate >= kPacketLossMax)
{ {
lossRate = plossMax - 1; lossRate = kPacketLossMax - 1;
} }
const WebRtc_UWord16 codeIndex = (fecPacketsPerFrame - 1) * maxNumPackets + const WebRtc_UWord16 codeIndex = (fecPacketsPerFrame - 1) * kMaxNumPackets +
(sourcePacketsPerFrame - 1); (sourcePacketsPerFrame - 1);
const WebRtc_UWord16 indexTable = codeIndexTable[codeIndex] * plossMax + const WebRtc_UWord16 indexTable = codeIndexTable[codeIndex] * kPacketLossMax +
lossRate; lossRate;
// Check on table index // Check on table index
assert (indexTable < maxErTableSize); assert(indexTable < kSizeAvgFECRecoveryXOR);
float avgFecRecov = static_cast<float>(kAvgFECRecoveryXOR[indexTable]);
float avgFecRecov = static_cast<float> (VCMAvgFECRecoveryXOR[indexTable]);
return avgFecRecov; return avgFecRecov;
} }
@ -322,12 +310,9 @@ VCMFecMethod::ProtectionFactor(const VCMProtectionParameters* parameters)
WebRtc_UWord8 lossThr = 0; WebRtc_UWord8 lossThr = 0;
WebRtc_UWord8 packetNumThr = 1; WebRtc_UWord8 packetNumThr = 1;
// Size of table // Parameters for range of rate index of table.
const WebRtc_UWord16 maxFecTableSize = 6450;
// Parameters for range of rate and packet loss for tables
const WebRtc_UWord8 ratePar1 = 5; const WebRtc_UWord8 ratePar1 = 5;
const WebRtc_UWord8 ratePar2 = 49; const WebRtc_UWord8 ratePar2 = 49;
const WebRtc_UWord8 plossMax = 129;
// Spatial resolution size, relative to a reference size. // Spatial resolution size, relative to a reference size.
float spatialSizeToRef = static_cast<float> float spatialSizeToRef = static_cast<float>
@ -365,17 +350,17 @@ VCMFecMethod::ProtectionFactor(const VCMProtectionParameters* parameters)
// Restrict packet loss range to 50: // Restrict packet loss range to 50:
// current tables defined only up to 50% // current tables defined only up to 50%
if (packetLoss >= plossMax) if (packetLoss >= kPacketLossMax)
{ {
packetLoss = plossMax - 1; packetLoss = kPacketLossMax - 1;
} }
WebRtc_UWord16 indexTable = rateIndexTable * plossMax + packetLoss; WebRtc_UWord16 indexTable = rateIndexTable * kPacketLossMax + packetLoss;
// Check on table index // Check on table index
assert(indexTable < maxFecTableSize); assert(indexTable < kSizeCodeRateXORTable);
// Protection factor for P frame // Protection factor for P frame
codeRateDelta = VCMCodeRateXORTable[indexTable]; codeRateDelta = kCodeRateXORTable[indexTable];
if (packetLoss > lossThr && avgTotPackets > packetNumThr) if (packetLoss > lossThr && avgTotPackets > packetNumThr)
{ {
@ -387,9 +372,9 @@ VCMFecMethod::ProtectionFactor(const VCMProtectionParameters* parameters)
} }
// Check limit on amount of protection for P frame; 50% is max. // Check limit on amount of protection for P frame; 50% is max.
if (codeRateDelta >= plossMax) if (codeRateDelta >= kPacketLossMax)
{ {
codeRateDelta = plossMax - 1; codeRateDelta = kPacketLossMax - 1;
} }
float adjustFec = _qmRobustness->AdjustFecFactor(codeRateDelta, float adjustFec = _qmRobustness->AdjustFecFactor(codeRateDelta,
@ -414,21 +399,21 @@ VCMFecMethod::ProtectionFactor(const VCMProtectionParameters* parameters)
rateIndexTable = (WebRtc_UWord8) VCM_MAX(VCM_MIN( rateIndexTable = (WebRtc_UWord8) VCM_MAX(VCM_MIN(
1 + (boostKey * effRateFecTable - ratePar1) / 1 + (boostKey * effRateFecTable - ratePar1) /
ratePar1,ratePar2),0); ratePar1,ratePar2),0);
WebRtc_UWord16 indexTableKey = rateIndexTable * plossMax + packetLoss; WebRtc_UWord16 indexTableKey = rateIndexTable * kPacketLossMax + packetLoss;
indexTableKey = VCM_MIN(indexTableKey, maxFecTableSize); indexTableKey = VCM_MIN(indexTableKey, kSizeCodeRateXORTable);
// Check on table index // Check on table index
assert(indexTableKey < maxFecTableSize); assert(indexTableKey < kSizeCodeRateXORTable);
// Protection factor for I frame // Protection factor for I frame
codeRateKey = VCMCodeRateXORTable[indexTableKey]; codeRateKey = kCodeRateXORTable[indexTableKey];
// Boosting for Key frame. // Boosting for Key frame.
WebRtc_UWord32 boostKeyProt = _scaleProtKey * codeRateDelta; int boostKeyProt = _scaleProtKey * codeRateDelta;
if ( boostKeyProt >= plossMax) if (boostKeyProt >= kPacketLossMax)
{ {
boostKeyProt = plossMax - 1; boostKeyProt = kPacketLossMax - 1;
} }
// Make sure I frame protection is at least larger than P frame protection, // Make sure I frame protection is at least larger than P frame protection,
@ -437,9 +422,9 @@ VCMFecMethod::ProtectionFactor(const VCMProtectionParameters* parameters)
VCM_MAX(boostKeyProt, codeRateKey))); VCM_MAX(boostKeyProt, codeRateKey)));
// Check limit on amount of protection for I frame: 50% is max. // Check limit on amount of protection for I frame: 50% is max.
if (codeRateKey >= plossMax) if (codeRateKey >= kPacketLossMax)
{ {
codeRateKey = plossMax - 1; codeRateKey = kPacketLossMax - 1;
} }
_protectionFactorK = codeRateKey; _protectionFactorK = codeRateKey;