539 lines
18 KiB
C++
539 lines
18 KiB
C++
/*
|
|
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
|
|
*
|
|
* Use of this source code is governed by a BSD-style license
|
|
* that can be found in the LICENSE file in the root of the source
|
|
* tree. An additional intellectual property rights grant can be found
|
|
* in the file PATENTS. All contributing project authors may
|
|
* be found in the AUTHORS file in the root of the source tree.
|
|
*/
|
|
|
|
#include "../../source/BitstreamBuilder.h"
|
|
#include "../../source/BitstreamParser.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
#include <tchar.h>
|
|
#include <windows.h>
|
|
|
|
WebRtc_UWord32 BitRateBPS(WebRtc_UWord16 x )
|
|
{
|
|
return (x & 0x3fff) * WebRtc_UWord32(pow(10.0f,(2 + (x >> 14))));
|
|
}
|
|
|
|
WebRtc_UWord16 BitRateBPSInv(WebRtc_UWord32 x )
|
|
{
|
|
// 16383 0x3fff
|
|
// 1 638 300 exp 0
|
|
// 16 383 000 exp 1
|
|
// 163 830 000 exp 2
|
|
// 1 638 300 000 exp 3
|
|
const float exp = log10(float(x>>14)) - 2;
|
|
if(exp < 0.0)
|
|
{
|
|
return WebRtc_UWord16(x /100);
|
|
}else if(exp < 1.0)
|
|
{
|
|
return 0x4000 + WebRtc_UWord16(x /1000);
|
|
}else if(exp < 2.0)
|
|
{
|
|
return 0x8000 + WebRtc_UWord16(x /10000);
|
|
}else if(exp < 3.0)
|
|
{
|
|
return 0xC000 + WebRtc_UWord16(x /100000);
|
|
} else
|
|
{
|
|
assert(false);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
|
|
int _tmain(int argc, _TCHAR* argv[])
|
|
{
|
|
WebRtc_UWord8 dataBuffer[128];
|
|
BitstreamBuilder builder(dataBuffer, sizeof(dataBuffer));
|
|
|
|
// test 1 to 4 bits
|
|
builder.Add1Bit(1);
|
|
builder.Add1Bit(0);
|
|
builder.Add1Bit(1);
|
|
|
|
builder.Add2Bits(1);
|
|
builder.Add2Bits(2);
|
|
builder.Add2Bits(3);
|
|
|
|
builder.Add3Bits(1);
|
|
builder.Add3Bits(3);
|
|
builder.Add3Bits(7);
|
|
|
|
builder.Add4Bits(1);
|
|
builder.Add4Bits(5);
|
|
builder.Add4Bits(15);
|
|
|
|
assert(4 == builder.Length());
|
|
|
|
BitstreamParser parser(dataBuffer, sizeof(dataBuffer));
|
|
|
|
assert(1 == parser.Get1Bit());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(1 == parser.Get1Bit());
|
|
|
|
assert(1 == parser.Get2Bits());
|
|
assert(2 == parser.Get2Bits());
|
|
assert(3 == parser.Get2Bits());
|
|
|
|
assert(1 == parser.Get3Bits());
|
|
assert(3 == parser.Get3Bits());
|
|
assert(7 == parser.Get3Bits());
|
|
|
|
assert(1 == parser.Get4Bits());
|
|
assert(5 == parser.Get4Bits());
|
|
assert(15 == parser.Get4Bits());
|
|
|
|
printf("Test of 1 to 4 bits done\n");
|
|
|
|
// test 5 to 7 bits
|
|
builder.Add5Bits(1);
|
|
builder.Add5Bits(15);
|
|
builder.Add5Bits(30);
|
|
|
|
builder.Add6Bits(1);
|
|
builder.Add6Bits(30);
|
|
builder.Add6Bits(60);
|
|
|
|
builder.Add7Bits(1);
|
|
builder.Add7Bits(60);
|
|
builder.Add7Bits(120);
|
|
|
|
assert(1 == parser.Get5Bits());
|
|
assert(15 == parser.Get5Bits());
|
|
assert(30 == parser.Get5Bits());
|
|
|
|
assert(1 == parser.Get6Bits());
|
|
assert(30 == parser.Get6Bits());
|
|
assert(60 == parser.Get6Bits());
|
|
|
|
assert(1 == parser.Get7Bits());
|
|
assert(60 == parser.Get7Bits());
|
|
assert(120 == parser.Get7Bits());
|
|
|
|
printf("Test of 5 to 7 bits done\n");
|
|
|
|
builder.Add8Bits(1);
|
|
builder.Add1Bit(1);
|
|
builder.Add8Bits(255);
|
|
builder.Add1Bit(0);
|
|
builder.Add8Bits(127);
|
|
builder.Add1Bit(1);
|
|
builder.Add8Bits(60);
|
|
builder.Add1Bit(0);
|
|
builder.Add8Bits(30);
|
|
builder.Add1Bit(1);
|
|
builder.Add8Bits(120);
|
|
builder.Add1Bit(0);
|
|
builder.Add8Bits(160);
|
|
builder.Add1Bit(1);
|
|
builder.Add8Bits(180);
|
|
|
|
assert(1 == parser.Get8Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(255 == parser.Get8Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(127 == parser.Get8Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(60 == parser.Get8Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(30 == parser.Get8Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(120 == parser.Get8Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(160 == parser.Get8Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(180 == parser.Get8Bits());
|
|
|
|
printf("Test of 8 bits done\n");
|
|
|
|
builder.Add16Bits(1);
|
|
builder.Add1Bit(1);
|
|
builder.Add16Bits(255);
|
|
builder.Add1Bit(0);
|
|
builder.Add16Bits(12756);
|
|
builder.Add1Bit(1);
|
|
builder.Add16Bits(60);
|
|
builder.Add1Bit(0);
|
|
builder.Add16Bits(30);
|
|
builder.Add1Bit(1);
|
|
builder.Add16Bits(30120);
|
|
builder.Add1Bit(0);
|
|
builder.Add16Bits(160);
|
|
builder.Add1Bit(1);
|
|
builder.Add16Bits(180);
|
|
|
|
assert(1 == parser.Get16Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(255 == parser.Get16Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(12756 == parser.Get16Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(60 == parser.Get16Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(30 == parser.Get16Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(30120 == parser.Get16Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(160 == parser.Get16Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(180 == parser.Get16Bits());
|
|
|
|
printf("Test of 16 bits done\n");
|
|
|
|
builder.Add24Bits(1);
|
|
builder.Add1Bit(1);
|
|
builder.Add24Bits(255);
|
|
builder.Add1Bit(0);
|
|
builder.Add24Bits(12756);
|
|
builder.Add1Bit(1);
|
|
builder.Add24Bits(60);
|
|
builder.Add1Bit(0);
|
|
builder.Add24Bits(303333);
|
|
builder.Add1Bit(1);
|
|
builder.Add24Bits(30120);
|
|
builder.Add1Bit(0);
|
|
builder.Add24Bits(160);
|
|
builder.Add1Bit(1);
|
|
builder.Add24Bits(8018018);
|
|
|
|
assert(1 == parser.Get24Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(255 == parser.Get24Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(12756 == parser.Get24Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(60 == parser.Get24Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(303333 == parser.Get24Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(30120 == parser.Get24Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(160 == parser.Get24Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(8018018 == parser.Get24Bits());
|
|
|
|
printf("Test of 24 bits done\n");
|
|
|
|
builder.Add32Bits(1);
|
|
builder.Add1Bit(1);
|
|
builder.Add32Bits(255);
|
|
builder.Add1Bit(0);
|
|
builder.Add32Bits(12756);
|
|
builder.Add1Bit(1);
|
|
builder.Add32Bits(60);
|
|
builder.Add1Bit(0);
|
|
builder.Add32Bits(303333);
|
|
builder.Add1Bit(1);
|
|
builder.Add32Bits(3012000012);
|
|
builder.Add1Bit(0);
|
|
builder.Add32Bits(1601601601);
|
|
builder.Add1Bit(1);
|
|
builder.Add32Bits(8018018);
|
|
|
|
assert(1 == parser.Get32Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(255 == parser.Get32Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(12756 == parser.Get32Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(60 == parser.Get32Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(303333 == parser.Get32Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(3012000012 == parser.Get32Bits());
|
|
assert(0 == parser.Get1Bit());
|
|
assert(1601601601 == parser.Get32Bits());
|
|
assert(1 == parser.Get1Bit());
|
|
assert(8018018 == parser.Get32Bits());
|
|
|
|
printf("Test of 32 bits done\n");
|
|
|
|
builder.AddUE(1);
|
|
builder.AddUE(4);
|
|
builder.AddUE(9809706);
|
|
builder.AddUE(2);
|
|
builder.AddUE(15);
|
|
builder.AddUE(16998);
|
|
|
|
assert( 106 == builder.Length());
|
|
|
|
assert(1 == parser.GetUE());
|
|
assert(4 == parser.GetUE());
|
|
assert(9809706 == parser.GetUE());
|
|
assert(2 == parser.GetUE());
|
|
assert(15 == parser.GetUE());
|
|
assert(16998 == parser.GetUE());
|
|
|
|
printf("Test UE bits done\n");
|
|
|
|
BitstreamBuilder builderScalabilityInfo(dataBuffer, sizeof(dataBuffer));
|
|
BitstreamParser parserScalabilityInfo(dataBuffer, sizeof(dataBuffer));
|
|
|
|
const WebRtc_UWord8 numberOfLayers = 4;
|
|
const WebRtc_UWord8 layerId[numberOfLayers] = {0,1,2,3};
|
|
const WebRtc_UWord8 priorityId[numberOfLayers] = {0,1,2,3};
|
|
const WebRtc_UWord8 discardableId[numberOfLayers] = {0,1,1,1};
|
|
|
|
const WebRtc_UWord8 dependencyId[numberOfLayers]= {0,1,1,1};
|
|
const WebRtc_UWord8 qualityId[numberOfLayers]= {0,0,0,1};
|
|
const WebRtc_UWord8 temporalId[numberOfLayers]= {0,0,1,1};
|
|
|
|
const WebRtc_UWord16 avgBitrate[numberOfLayers]= {BitRateBPSInv(100000),
|
|
BitRateBPSInv(200000),
|
|
BitRateBPSInv(400000),
|
|
BitRateBPSInv(800000)};
|
|
|
|
// todo which one is the sum?
|
|
const WebRtc_UWord16 maxBitrateLayer[numberOfLayers]= {BitRateBPSInv(150000),
|
|
BitRateBPSInv(300000),
|
|
BitRateBPSInv(500000),
|
|
BitRateBPSInv(900000)};
|
|
|
|
const WebRtc_UWord16 maxBitrateLayerRepresentation[numberOfLayers] = {BitRateBPSInv(150000),
|
|
BitRateBPSInv(450000),
|
|
BitRateBPSInv(950000),
|
|
BitRateBPSInv(1850000)};
|
|
|
|
assert( 16300 == BitRateBPS(BitRateBPSInv(16383)));
|
|
assert( 163800 == BitRateBPS(BitRateBPSInv(163830)));
|
|
assert( 1638300 == BitRateBPS(BitRateBPSInv(1638300)));
|
|
assert( 1638000 == BitRateBPS(BitRateBPSInv(1638400)));
|
|
|
|
assert( 18500 == BitRateBPS(BitRateBPSInv(18500)));
|
|
assert( 185000 == BitRateBPS(BitRateBPSInv(185000)));
|
|
assert( 1850000 == BitRateBPS(BitRateBPSInv(1850000)));
|
|
assert( 18500000 == BitRateBPS(BitRateBPSInv(18500000)));
|
|
assert( 185000000 == BitRateBPS(BitRateBPSInv(185000000)));
|
|
|
|
const WebRtc_UWord16 maxBitrareCalcWindow[numberOfLayers] = {200, 200,200,200};// in 1/100 of second
|
|
|
|
builderScalabilityInfo.Add1Bit(0); // temporal_id_nesting_flag
|
|
builderScalabilityInfo.Add1Bit(0); // priority_layer_info_present_flag
|
|
builderScalabilityInfo.Add1Bit(0); // priority_id_setting_flag
|
|
|
|
builderScalabilityInfo.AddUE(numberOfLayers-1);
|
|
|
|
for(int i = 0; i<= numberOfLayers-1; i++)
|
|
{
|
|
builderScalabilityInfo.AddUE(layerId[i]);
|
|
builderScalabilityInfo.Add6Bits(priorityId[i]);
|
|
builderScalabilityInfo.Add1Bit(discardableId[i]);
|
|
builderScalabilityInfo.Add3Bits(dependencyId[i]);
|
|
builderScalabilityInfo.Add4Bits(qualityId[i]);
|
|
builderScalabilityInfo.Add3Bits(temporalId[i]);
|
|
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
|
|
builderScalabilityInfo.Add1Bit(1); // bitrate_info_present_flag
|
|
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
builderScalabilityInfo.Add1Bit(0);
|
|
|
|
builderScalabilityInfo.Add16Bits(avgBitrate[i]);
|
|
builderScalabilityInfo.Add16Bits(maxBitrateLayer[i]);
|
|
builderScalabilityInfo.Add16Bits(maxBitrateLayerRepresentation[i]);
|
|
builderScalabilityInfo.Add16Bits(maxBitrareCalcWindow[i]);
|
|
|
|
builderScalabilityInfo.AddUE(0); // layer_dependency_info_src_layer_id_delta
|
|
builderScalabilityInfo.AddUE(0); // parameter_sets_info_src_layer_id_delta
|
|
}
|
|
|
|
printf("Test builderScalabilityInfo done\n");
|
|
|
|
// Scalability Info parser
|
|
parserScalabilityInfo.Get1Bit(); // not used in futher parsing
|
|
const WebRtc_UWord8 priority_layer_info_present = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 priority_id_setting_flag = parserScalabilityInfo.Get1Bit();
|
|
|
|
WebRtc_UWord32 numberOfLayersMinusOne = parserScalabilityInfo.GetUE();
|
|
for(WebRtc_UWord32 j = 0; j<= numberOfLayersMinusOne; j++)
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
parserScalabilityInfo.Get6Bits();
|
|
parserScalabilityInfo.Get1Bit();
|
|
parserScalabilityInfo.Get3Bits();
|
|
parserScalabilityInfo.Get4Bits();
|
|
parserScalabilityInfo.Get3Bits();
|
|
|
|
const WebRtc_UWord8 sub_pic_layer_flag = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 sub_region_layer_flag = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 iroi_division_info_present_flag = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 profile_level_info_present_flag = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 bitrate_info_present_flag = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 frm_rate_info_present_flag = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 frm_size_info_present_flag = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 layer_dependency_info_present_flag = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 parameter_sets_info_present_flag = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 bitstream_restriction_info_present_flag = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 exact_inter_layer_pred_flag = parserScalabilityInfo.Get1Bit(); // not used in futher parsing
|
|
|
|
if(sub_pic_layer_flag || iroi_division_info_present_flag)
|
|
{
|
|
parserScalabilityInfo.Get1Bit();
|
|
}
|
|
const WebRtc_UWord8 layer_conversion_flag = parserScalabilityInfo.Get1Bit();
|
|
const WebRtc_UWord8 layer_output_flag = parserScalabilityInfo.Get1Bit(); // not used in futher parsing
|
|
|
|
if(profile_level_info_present_flag)
|
|
{
|
|
parserScalabilityInfo.Get24Bits();
|
|
}
|
|
if(bitrate_info_present_flag)
|
|
{
|
|
// this is what we want
|
|
assert(avgBitrate[j] == parserScalabilityInfo.Get16Bits());
|
|
assert(maxBitrateLayer[j] == parserScalabilityInfo.Get16Bits());
|
|
assert(maxBitrateLayerRepresentation[j] == parserScalabilityInfo.Get16Bits());
|
|
assert(maxBitrareCalcWindow[j] == parserScalabilityInfo.Get16Bits());
|
|
}else
|
|
{
|
|
assert(false);
|
|
}
|
|
if(frm_rate_info_present_flag)
|
|
{
|
|
parserScalabilityInfo.Get2Bits();
|
|
parserScalabilityInfo.Get16Bits();
|
|
}
|
|
if(frm_size_info_present_flag || iroi_division_info_present_flag)
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
parserScalabilityInfo.GetUE();
|
|
}
|
|
if(sub_region_layer_flag)
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
if(parserScalabilityInfo.Get1Bit())
|
|
{
|
|
parserScalabilityInfo.Get16Bits();
|
|
parserScalabilityInfo.Get16Bits();
|
|
parserScalabilityInfo.Get16Bits();
|
|
parserScalabilityInfo.Get16Bits();
|
|
}
|
|
}
|
|
if(sub_pic_layer_flag)
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
}
|
|
if(iroi_division_info_present_flag)
|
|
{
|
|
if(parserScalabilityInfo.Get1Bit())
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
parserScalabilityInfo.GetUE();
|
|
}else
|
|
{
|
|
const WebRtc_UWord32 numRoisMinusOne = parserScalabilityInfo.GetUE();
|
|
for(WebRtc_UWord32 k = 0; k <= numRoisMinusOne; k++)
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
parserScalabilityInfo.GetUE();
|
|
parserScalabilityInfo.GetUE();
|
|
}
|
|
}
|
|
}
|
|
if(layer_dependency_info_present_flag)
|
|
{
|
|
const WebRtc_UWord32 numDirectlyDependentLayers = parserScalabilityInfo.GetUE();
|
|
for(WebRtc_UWord32 k = 0; k < numDirectlyDependentLayers; k++)
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
}
|
|
} else
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
}
|
|
if(parameter_sets_info_present_flag)
|
|
{
|
|
const WebRtc_UWord32 numSeqParameterSetMinusOne = parserScalabilityInfo.GetUE();
|
|
for(WebRtc_UWord32 k = 0; k <= numSeqParameterSetMinusOne; k++)
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
}
|
|
const WebRtc_UWord32 numSubsetSeqParameterSetMinusOne = parserScalabilityInfo.GetUE();
|
|
for(WebRtc_UWord32 l = 0; l <= numSubsetSeqParameterSetMinusOne; l++)
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
}
|
|
const WebRtc_UWord32 numPicParameterSetMinusOne = parserScalabilityInfo.GetUE();
|
|
for(WebRtc_UWord32 m = 0; m <= numPicParameterSetMinusOne; m++)
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
}
|
|
}else
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
}
|
|
if(bitstream_restriction_info_present_flag)
|
|
{
|
|
parserScalabilityInfo.Get1Bit();
|
|
parserScalabilityInfo.GetUE();
|
|
parserScalabilityInfo.GetUE();
|
|
parserScalabilityInfo.GetUE();
|
|
parserScalabilityInfo.GetUE();
|
|
parserScalabilityInfo.GetUE();
|
|
parserScalabilityInfo.GetUE();
|
|
}
|
|
if(layer_conversion_flag)
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
for(WebRtc_UWord32 k = 0; k <2;k++)
|
|
{
|
|
if(parserScalabilityInfo.Get1Bit())
|
|
{
|
|
parserScalabilityInfo.Get24Bits();
|
|
parserScalabilityInfo.Get16Bits();
|
|
parserScalabilityInfo.Get16Bits();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if(priority_layer_info_present)
|
|
{
|
|
const WebRtc_UWord32 prNumDidMinusOne = parserScalabilityInfo.GetUE();
|
|
for(WebRtc_UWord32 k = 0; k <= prNumDidMinusOne;k++)
|
|
{
|
|
parserScalabilityInfo.Get3Bits();
|
|
const WebRtc_UWord32 prNumMinusOne = parserScalabilityInfo.GetUE();
|
|
for(WebRtc_UWord32 l = 0; l <= prNumMinusOne; l++)
|
|
{
|
|
parserScalabilityInfo.GetUE();
|
|
parserScalabilityInfo.Get24Bits();
|
|
parserScalabilityInfo.Get16Bits();
|
|
parserScalabilityInfo.Get16Bits();
|
|
}
|
|
}
|
|
}
|
|
if(priority_id_setting_flag)
|
|
{
|
|
WebRtc_UWord8 priorityIdSettingUri;
|
|
WebRtc_UWord32 priorityIdSettingUriIdx = 0;
|
|
do
|
|
{
|
|
priorityIdSettingUri = parserScalabilityInfo.Get8Bits();
|
|
} while (priorityIdSettingUri != 0);
|
|
}
|
|
printf("Test parserScalabilityInfo done\n");
|
|
|
|
printf("\nAPI test of parser for ScalabilityInfo done\n");
|
|
|
|
::Sleep(5000);
|
|
}
|