| /* |
| * 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 "test_util.h" |
| #include "rtp_dump.h" |
| #include <cmath> |
| |
| using namespace webrtc; |
| |
| /****************************** |
| * VCMEncodeCompleteCallback |
| *****************************/ |
| // Basic callback implementation |
| // passes the encoded frame directly to the encoder |
| // Packetization callback implmentation |
| VCMEncodeCompleteCallback::VCMEncodeCompleteCallback(FILE* encodedFile): |
| _seqNo(0), |
| _encodedFile(encodedFile), |
| _encodedBytes(0), |
| _VCMReceiver(NULL), |
| _encodeComplete(false), |
| _width(0), |
| _height(0), |
| _codecType(kRTPVideoNoVideo), |
| _layerPacketId(1) |
| { |
| // |
| } |
| VCMEncodeCompleteCallback::~VCMEncodeCompleteCallback() |
| { |
| } |
| |
| void |
| VCMEncodeCompleteCallback::RegisterTransportCallback(VCMPacketizationCallback* transport) |
| { |
| } |
| |
| WebRtc_Word32 |
| VCMEncodeCompleteCallback::SendData(const FrameType frameType, |
| const WebRtc_UWord8 payloadType, |
| const WebRtc_UWord32 timeStamp, |
| const WebRtc_UWord8* payloadData, |
| const WebRtc_UWord32 payloadSize, |
| const RTPFragmentationHeader& fragmentationHeader) |
| { |
| // will call the VCMReceiver input packet |
| _frameType = frameType; |
| // writing encodedData into file |
| fwrite(payloadData, 1, payloadSize, _encodedFile); |
| WebRtcRTPHeader rtpInfo; |
| rtpInfo.header.markerBit = true; // end of frame |
| rtpInfo.type.Video.isFirstPacket = true; |
| rtpInfo.type.Video.codec = _codecType; |
| switch (_codecType) |
| { |
| case webrtc::kRTPVideoH263: |
| rtpInfo.type.Video.codecHeader.H263.bits = false; |
| rtpInfo.type.Video.codecHeader.H263.independentlyDecodable = false; |
| rtpInfo.type.Video.height = (WebRtc_UWord16)_height; |
| rtpInfo.type.Video.width = (WebRtc_UWord16)_width; |
| break; |
| } |
| |
| rtpInfo.header.payloadType = payloadType; |
| rtpInfo.header.sequenceNumber = _seqNo++; |
| rtpInfo.header.ssrc = 0; |
| rtpInfo.header.timestamp = timeStamp; |
| rtpInfo.frameType = frameType; |
| // Size should also be received from that table, since the payload type |
| // defines the size. |
| |
| _encodedBytes += payloadSize; |
| // directly to receiver |
| _VCMReceiver->IncomingPacket(payloadData, payloadSize, rtpInfo); |
| _encodeComplete = true; |
| |
| return 0; |
| } |
| |
| float |
| VCMEncodeCompleteCallback::EncodedBytes() |
| { |
| return _encodedBytes; |
| } |
| |
| bool |
| VCMEncodeCompleteCallback::EncodeComplete() |
| { |
| if (_encodeComplete) |
| { |
| _encodeComplete = false; |
| return true; |
| } |
| return false; |
| } |
| |
| void |
| VCMEncodeCompleteCallback::Initialize() |
| { |
| _encodeComplete = false; |
| _encodedBytes = 0; |
| _seqNo = 0; |
| return; |
| } |
| |
| void |
| VCMEncodeCompleteCallback::ResetByteCount() |
| { |
| _encodedBytes = 0; |
| } |
| |
| /**********************************/ |
| /* VCMRTPEncodeCompleteCallback / |
| /********************************/ |
| // Encode Complete callback implementation |
| // passes the encoded frame via the RTP module to the decoder |
| // Packetization callback implmentation |
| |
| WebRtc_Word32 |
| VCMRTPEncodeCompleteCallback::SendData(const FrameType frameType, |
| const WebRtc_UWord8 payloadType, |
| const WebRtc_UWord32 timeStamp, |
| const WebRtc_UWord8* payloadData, |
| const WebRtc_UWord32 payloadSize, |
| const RTPFragmentationHeader& fragmentationHeader) |
| { |
| _frameType = frameType; |
| _encodedBytes+= payloadSize; |
| _encodeComplete = true; |
| //printf("encoded = %d Bytes\n", payloadSize); |
| return _RTPModule->SendOutgoingData(frameType, payloadType, timeStamp, payloadData, payloadSize, &fragmentationHeader); |
| } |
| |
| float |
| VCMRTPEncodeCompleteCallback::EncodedBytes() |
| { |
| // only good for one call - after which will reset value; |
| float tmp = _encodedBytes; |
| _encodedBytes = 0; |
| return tmp; |
| } |
| |
| bool |
| VCMRTPEncodeCompleteCallback::EncodeComplete() |
| { |
| if (_encodeComplete) |
| { |
| _encodeComplete = false; |
| return true; |
| } |
| return false; |
| } |
| |
| // Decoded Frame Callback Implmentation |
| |
| WebRtc_Word32 |
| VCMDecodeCompleteCallback::FrameToRender(VideoFrame& videoFrame) |
| { |
| fwrite(videoFrame.Buffer(), 1, videoFrame.Length(), _decodedFile); |
| _decodedBytes+= videoFrame.Length(); |
| // keeping last decoded frame |
| _lastDecodedFrame.VerifyAndAllocate(videoFrame.Size()); |
| _lastDecodedFrame.CopyFrame(videoFrame.Size(), videoFrame.Buffer()); |
| _lastDecodedFrame.SetHeight(videoFrame.Height()); |
| _lastDecodedFrame.SetWidth(videoFrame.Width()); |
| _lastDecodedFrame.SetTimeStamp(videoFrame.TimeStamp()); |
| |
| return VCM_OK; |
| } |
| |
| int |
| VCMDecodeCompleteCallback::PSNRLastFrame(const VideoFrame& sourceFrame, double *YPSNRptr) |
| { |
| double mse = 0.0; |
| double mseLogSum = 0.0; |
| |
| WebRtc_Word32 frameBytes = sourceFrame.Height() * sourceFrame.Width(); // only Y |
| WebRtc_UWord8 *ref = sourceFrame.Buffer(); |
| if (_lastDecodedFrame.Height() == 0) |
| { |
| *YPSNRptr = 0; |
| return 0; // no new decoded frames |
| } |
| WebRtc_UWord8 *test = _lastDecodedFrame.Buffer(); |
| for( int k = 0; k < frameBytes; k++ ) |
| { |
| mse += (test[k] - ref[k]) * (test[k] - ref[k]); |
| } |
| |
| // divide by number of pixels |
| mse /= (double) (frameBytes); |
| |
| // accumulate for total average |
| mseLogSum += std::log10( mse ); |
| |
| *YPSNRptr = 20.0 * std::log10(255.0) - 10.0 * mseLogSum; // for only 1 frame |
| |
| _lastDecodedFrame.Free(); |
| _lastDecodedFrame.SetHeight(0); |
| return 0; |
| } |
| |
| WebRtc_Word32 |
| VCMDecodeCompleteCallback::DecodedBytes() |
| { |
| return _decodedBytes; |
| } |
| |
| RTPSendCompleteCallback::RTPSendCompleteCallback(RtpRtcp* rtp, const char* filename): |
| _rtp(rtp), |
| _sendCount(0), |
| _lossPct(0), |
| _rtpDump(NULL) |
| { |
| if (filename != NULL) |
| { |
| _rtpDump = RtpDump::CreateRtpDump(); |
| _rtpDump->Start(filename); |
| } |
| } |
| RTPSendCompleteCallback::~RTPSendCompleteCallback() |
| { |
| if (_rtpDump != NULL) |
| { |
| _rtpDump->Stop(); |
| RtpDump::DestroyRtpDump(_rtpDump); |
| } |
| } |
| int |
| RTPSendCompleteCallback::SendPacket(int channel, const void *data, int len) |
| { |
| _sendCount++; |
| // Packet Loss - randomly drop %loss packets |
| // don't drop I-frame packets |
| if(PacketLoss(_lossPct) && (_sendCount > 12)) |
| { |
| // drop |
| //printf("\tDrop packet, sendCount = %d\n", _sendCount); |
| return len; |
| } |
| if (_rtpDump != NULL) |
| { |
| if (_rtpDump->DumpPacket((const WebRtc_UWord8*)data, len) != 0) |
| { |
| return -1; |
| } |
| } |
| if(_rtp->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) |
| { |
| return len; |
| } |
| return -1; |
| } |
| |
| int |
| RTPSendCompleteCallback::SendRTCPPacket(int channel, const void *data, int len) |
| { |
| if(_rtp->IncomingPacket((const WebRtc_UWord8*)data, len) == 0) |
| { |
| return len; |
| } |
| return -1; |
| } |
| |
| void |
| RTPSendCompleteCallback::SetLossPct(double lossPct) |
| { |
| _lossPct = lossPct; |
| return; |
| } |
| |
| bool |
| RTPSendCompleteCallback::PacketLoss(double lossPct) |
| { |
| double randVal = (std::rand() + 1.0)/(RAND_MAX + 1.0); |
| return randVal < lossPct/100; |
| } |
| |
| WebRtc_Word32 |
| PacketRequester::ResendPackets(const WebRtc_UWord16* sequenceNumbers, WebRtc_UWord16 length) |
| { |
| return _rtp.SendNACK(sequenceNumbers, length); |
| } |
| |
| WebRtc_Word32 |
| PSNRfromFiles(const WebRtc_Word8 *refFileName, const WebRtc_Word8 *testFileName, WebRtc_Word32 width, WebRtc_Word32 height, double *YPSNRptr) |
| { |
| FILE *refFp = fopen(refFileName, "rb"); |
| if( refFp == NULL ) { |
| // cannot open reference file |
| fprintf(stderr, "Cannot open file %s\n", refFileName); |
| return -1; |
| } |
| |
| FILE *testFp = fopen(testFileName, "rb"); |
| if( testFp == NULL ) { |
| // cannot open test file |
| fprintf(stderr, "Cannot open file %s\n", testFileName); |
| return -2; |
| } |
| |
| double mse = 0.0; |
| double mseLogSum = 0.0; |
| WebRtc_Word32 frames = 0; |
| |
| WebRtc_Word32 frameBytes = 3*width*height/2; // bytes in one frame I420 |
| WebRtc_UWord8 *ref = new WebRtc_UWord8[frameBytes]; // space for one frame I420 |
| WebRtc_UWord8 *test = new WebRtc_UWord8[frameBytes]; // space for one frame I420 |
| |
| WebRtc_Word32 refBytes = (WebRtc_Word32) fread(ref, 1, frameBytes, refFp); |
| WebRtc_Word32 testBytes = (WebRtc_Word32) fread(test, 1, frameBytes, testFp); |
| |
| while( refBytes == frameBytes && testBytes == frameBytes ) |
| { |
| mse = 0.0; |
| |
| int sh = 8;//boundary offset |
| for( int k2 = sh; k2 < height-sh;k2++) |
| for( int k = sh; k < width-sh;k++) |
| { |
| int kk = k2*width + k; |
| mse += (test[kk] - ref[kk]) * (test[kk] - ref[kk]); |
| } |
| |
| // divide by number of pixels |
| mse /= (double) (width * height); |
| |
| // accumulate for total average |
| mseLogSum += std::log10( mse ); |
| frames++; |
| |
| refBytes = (int) fread(ref, 1, frameBytes, refFp); |
| testBytes = (int) fread(test, 1, frameBytes, testFp); |
| } |
| // for identical reproduction: |
| if (mse == 0) |
| { |
| *YPSNRptr = 48; |
| } |
| else |
| { |
| *YPSNRptr = 20.0 * std::log10(255.0) - 10.0 * mseLogSum / frames; |
| } |
| |
| |
| delete [] ref; |
| delete [] test; |
| |
| fclose(refFp); |
| fclose(testFp); |
| |
| return 0; |
| } |
| |
| WebRtc_Word32 |
| SSIMfromFiles(const WebRtc_Word8 *refFileName, const WebRtc_Word8 *testFileName, WebRtc_Word32 width, WebRtc_Word32 height, double *SSIMptr) |
| { |
| FILE *refFp = fopen(refFileName, "rb"); |
| if( refFp == NULL ) { |
| // cannot open reference file |
| fprintf(stderr, "Cannot open file %s\n", refFileName); |
| return -1; |
| } |
| |
| FILE *testFp = fopen(testFileName, "rb"); |
| if( testFp == NULL ) { |
| // cannot open test file |
| fprintf(stderr, "Cannot open file %s\n", testFileName); |
| return -2; |
| } |
| |
| int frames = 0; |
| |
| int frameBytes = 3*width*height/2; // bytes in one frame I420 |
| unsigned char *ref = new unsigned char[frameBytes]; // space for one frame I420 |
| unsigned char *test = new unsigned char[frameBytes]; // space for one frame I420 |
| |
| int refBytes = (int) fread(ref, 1, frameBytes, refFp); |
| int testBytes = (int) fread(test, 1, frameBytes, testFp); |
| |
| float *righMostColumnAvgTest = new float[width]; |
| float *righMostColumnAvgRef = new float[width]; |
| float *righMostColumnContrastTest = new float[width]; |
| float *righMostColumnContrastRef = new float[width]; |
| float *righMostColumnCrossCorr = new float[width]; |
| |
| float term1,term2,term3,term4,term5; |
| |
| // |
| // SSIM: variable definition, window function, initialization |
| int window = 10; |
| // |
| int flag_window = 0; //0 and 1 for uniform window filter, 2 for gaussian window |
| // |
| float variance_window = 2.0; //variance for window function |
| float ssimFilter[121]; //2d window filter: typically 11x11 = (window+1)*(window+1) |
| //statistics per column of window (#columns = window+1), 0 element for avg over all columns |
| float avgTest[12]; |
| float avgRef[12]; |
| float contrastTest[12]; |
| float contrastRef[12]; |
| float crossCorr[12]; |
| // |
| //offsets for stability |
| float offset1 = 1.0f; //0.1 |
| float offset2 = 1.0f; //0.1 |
| //for Guassian window: settings from paper: |
| //float offset1 = 6.0f; // ~ (K1*L)^2 , K1 = 0.01 |
| //float offset2 = 58.0f; // ~ (K1*L)^2 , K2 = 0.03 |
| |
| |
| float offset3 = offset2/2; |
| // |
| //define window for SSIM: take uniform filter for now |
| float sumfil = 0.0; |
| int nn=-1; |
| for(int j=-window/2;j<=window/2;j++) |
| for(int i=-window/2;i<=window/2;i++) |
| { |
| nn+=1; |
| if (flag_window != 2) |
| ssimFilter[nn] = 1.0; |
| else |
| { |
| float dist = (float)(i*i) + (float)(j*j); |
| float tmp = 0.5f*dist/variance_window; |
| ssimFilter[nn] = exp(-tmp); |
| } |
| sumfil +=ssimFilter[nn]; |
| } |
| //normalize window |
| nn=-1; |
| for(int j=-window/2;j<=window/2;j++) |
| for(int i=-window/2;i<=window/2;i++) |
| { |
| nn+=1; |
| ssimFilter[nn] = ssimFilter[nn]/((float)sumfil); |
| } |
| // |
| float ssimScene = 0.0; //avgerage SSIM for sequence |
| // |
| //SSIM: done with variables and defintion |
| // |
| |
| int sh = 8; //boundary offset |
| |
| while( refBytes == frameBytes && testBytes == frameBytes ) |
| { |
| float ssimFrame = 0.0; |
| |
| int numPixels = 0; |
| |
| //skip over pixels vertically and horizontally |
| //for window cases 1 and 2 |
| int skipH = 2; |
| int skipV = 2; |
| |
| //uniform window case, with window computation updated for each pixel horiz and vert: can't skip pixels for this case |
| if (flag_window == 0) |
| { |
| skipH = 1; |
| skipV = 1; |
| } |
| for(int i=sh;i<height-sh;i+=skipV) |
| for(int j=sh;j<width-sh;j+=skipH) |
| { |
| avgTest[0] = 0.0; |
| avgRef[0] = 0.0; |
| contrastTest[0] = 0.0; |
| contrastRef[0] = 0.0; |
| crossCorr[0] = 0.0; |
| |
| numPixels +=1; |
| |
| if (flag_window > 0 ) |
| { |
| //initialize statistics |
| avgTest[0] = 0.0; |
| avgRef[0] = 0.0; |
| contrastTest[0] = 0.0; |
| contrastRef[0] = 0.0; |
| crossCorr[0] = 0.0; |
| |
| int nn=-1; |
| //compute contrast and correlation |
| //windows are symmetrics |
| for(int jj=-window/2;jj<=window/2;jj++) |
| for(int ii=-window/2;ii<=window/2;ii++) |
| { |
| nn+=1; |
| int i2 = i+ii; |
| int j2 = j+jj; |
| float tmp1 = (float)test[i2*width+j2]; |
| float tmp2 = (float)ref[i2*width+j2]; |
| |
| term1 = tmp1; |
| term2 = tmp2; |
| term3 = tmp1*tmp1; |
| term4 = tmp2*tmp2; |
| term5 = tmp1*tmp2; |
| |
| //local average of each signal |
| avgTest[0] += ssimFilter[nn]*term1; |
| avgRef[0] += ssimFilter[nn]*term2; |
| //local correlation/contrast of each signal |
| contrastTest[0] += ssimFilter[nn]*term3; |
| contrastRef[0] += ssimFilter[nn]*term4; |
| //local cross correlation |
| crossCorr[0] += ssimFilter[nn]*term5; |
| |
| } |
| |
| } |
| |
| else |
| { |
| //for uniform window case == 0: only need to loop over whole window for first row and column, and then shift/update |
| if (j == sh || i == sh) |
| { |
| //initialize statistics |
| for(int k=0;k<window+2;k++) |
| { |
| avgTest[k] = 0.0; |
| avgRef[k] = 0.0; |
| contrastTest[k] = 0.0; |
| contrastRef[k] = 0.0; |
| crossCorr[k] = 0.0; |
| } |
| |
| int nn=-1; |
| //compute contrast and correlation |
| //windows are symmetrics |
| for(int jj=-window/2;jj<=window/2;jj++) |
| for(int ii=-window/2;ii<=window/2;ii++) |
| { |
| nn+=1; |
| int i2 = i+ii; |
| int j2 = j+jj; |
| float tmp1 = (float)test[i2*width+j2]; |
| float tmp2 = (float)ref[i2*width+j2]; |
| |
| term1 = tmp1; |
| term2 = tmp2; |
| term3 = tmp1*tmp1; |
| term4 = tmp2*tmp2; |
| term5 = tmp1*tmp2; |
| |
| //local average of each signal |
| avgTest[jj+window/2+1] += term1; |
| avgRef[jj+window/2+1] += term2; |
| //local correlation/contrast of each signal |
| contrastTest[jj+window/2+1] += term3; |
| contrastRef[jj+window/2+1] += term4; |
| //local cross correlation |
| crossCorr[jj+window/2+1] += term5; |
| |
| } |
| |
| //normalize |
| for(int k=1;k<window+2;k++) |
| { |
| avgTest[k] = ssimFilter[0]*avgTest[k]; |
| avgRef[k] = ssimFilter[0]*avgRef[k]; |
| contrastTest[k] = ssimFilter[0]*contrastTest[k]; |
| contrastRef[k] = ssimFilter[0]*contrastRef[k]; |
| crossCorr[k] = ssimFilter[0]*crossCorr[k]; |
| } |
| |
| } |
| //for all other pixels, update window filter computation |
| else |
| { |
| //shift statistics horiz. |
| for(int k=1;k<window+1;k++) |
| { |
| avgTest[k]=avgTest[k+1]; |
| avgRef[k]=avgRef[k+1]; |
| contrastTest[k] = contrastTest[k+1]; |
| contrastRef[k] = contrastRef[k+1]; |
| crossCorr[k] = crossCorr[k+1]; |
| } |
| |
| //compute statistics for last column |
| //update right-most column, by updating with bottom pixel contribution |
| int j2 = j + window/2; //last column of window |
| int i2 = i + window/2; //last window pixel of column |
| int ix = i - window/2 - 1; //last window pixel of top neighboring pixel |
| float tmp1 = (float)test[i2*width+j2]; |
| float tmp2 = (float)ref[i2*width+j2]; |
| float tmp1x = (float)test[ix*width+j2]; |
| float tmp2x = (float)ref[ix*width+j2]; |
| |
| avgTest[window+1] = righMostColumnAvgTest[j] + ssimFilter[0]*(tmp1 - tmp1x); |
| avgRef[window+1] = righMostColumnAvgRef[j] + ssimFilter[0]*(tmp2 - tmp2x); |
| contrastTest[window+1] = righMostColumnContrastTest[j] + ssimFilter[0]*(tmp1*tmp1 - tmp1x*tmp1x); |
| contrastRef[window+1] = righMostColumnContrastRef[j] + ssimFilter[0]*(tmp2*tmp2 - tmp2x*tmp2x); |
| crossCorr[window+1] = righMostColumnCrossCorr[j] + ssimFilter[0]*(tmp1*tmp2 - tmp1x*tmp2x); |
| } |
| |
| //sum over all columns |
| for(int k=1;k<window+2;k++) |
| { |
| avgTest[0] += avgTest[k]; |
| avgRef[0] += avgRef[k]; |
| contrastTest[0] += contrastTest[k]; |
| contrastRef[0] += contrastRef[k]; |
| crossCorr[0] += crossCorr[k]; |
| } |
| |
| // |
| righMostColumnAvgTest[j] = avgTest[window+1]; |
| righMostColumnAvgRef[j] = avgRef[window+1]; |
| righMostColumnContrastTest[j] = contrastTest[window+1]; |
| righMostColumnContrastRef[j] = contrastRef[window+1]; |
| righMostColumnCrossCorr[j] = crossCorr[window+1]; |
| // |
| |
| } //end of window = 0 case |
| |
| float tmp1 = (contrastTest[0] - avgTest[0]*avgTest[0]); |
| if (tmp1 < 0.0) tmp1 = 0.0; |
| contrastTest[0] = sqrt(tmp1); |
| float tmp2 = (contrastRef[0] - avgRef[0]*avgRef[0]); |
| if (tmp2 < 0.0) tmp2 = 0.0; |
| contrastRef[0] = sqrt(tmp2); |
| crossCorr[0] = crossCorr[0] - avgTest[0]*avgRef[0]; |
| |
| float ssimCorrCoeff = (crossCorr[0]+offset3)/(contrastTest[0]*contrastRef[0] + offset3); |
| float ssimLuminance = (2*avgTest[0]*avgRef[0]+offset1)/(avgTest[0]*avgTest[0] + avgRef[0]*avgRef[0] + offset1); |
| float ssimContrast = (2*contrastTest[0]*contrastRef[0]+offset2)/(contrastTest[0]*contrastTest[0] + contrastRef[0]*contrastRef[0] + offset2); |
| |
| float ssimPixel = ssimCorrCoeff * ssimLuminance * ssimContrast; |
| ssimFrame += ssimPixel; |
| |
| } //done with ssim computation |
| |
| ssimFrame = ssimFrame / (numPixels); |
| //printf("***SSIM for frame ***%f \n",ssimFrame); |
| ssimScene += ssimFrame; |
| // |
| //SSIM: done with SSIM computation |
| // |
| |
| frames++; |
| |
| refBytes = (int) fread(ref, 1, frameBytes, refFp); |
| testBytes = (int) fread(test, 1, frameBytes, testFp); |
| |
| } |
| |
| //SSIM: normalize/average for sequence |
| ssimScene = ssimScene / frames; |
| *SSIMptr = ssimScene; |
| |
| |
| delete [] ref; |
| delete [] test; |
| |
| delete [] righMostColumnAvgTest; |
| delete [] righMostColumnAvgRef; |
| delete [] righMostColumnContrastTest; |
| delete [] righMostColumnContrastRef; |
| delete [] righMostColumnCrossCorr; |
| |
| |
| fclose(refFp); |
| fclose(testFp); |
| |
| return 0; |
| |
| } |
| |
| |
| RTPVideoCodecTypes |
| ConvertCodecType(const char* plname) |
| { |
| if (strncmp(plname,"VP8" , 3) == 0) |
| { |
| return kRTPVideoVP8; |
| }else if (strncmp(plname,"H263" , 5) == 0) |
| { |
| return kRTPVideoH263; |
| }else if (strncmp(plname, "H263-1998",10) == 0) |
| { |
| return kRTPVideoH263; |
| }else if (strncmp(plname,"I420" , 5) == 0) |
| { |
| return kRTPVideoI420; |
| }else |
| { |
| return kRTPVideoNoVideo; // defualt value |
| } |
| |
| } |
| |
| WebRtc_Word32 |
| SendStatsTest::SendStatistics(const WebRtc_UWord32 bitRate, const WebRtc_UWord32 frameRate) |
| { |
| TEST(frameRate <= _frameRate); |
| TEST(bitRate > 0 && bitRate < 100000); |
| printf("VCM 1 sec: Bit rate: %u\tFrame rate: %u\n", bitRate, frameRate); |
| return 0; |
| } |
| |
| WebRtc_Word32 |
| KeyFrameReqTest::FrameTypeRequest(const FrameType frameType) |
| { |
| TEST(frameType == kVideoFrameKey); |
| if (frameType == kVideoFrameKey) |
| { |
| printf("Key frame requested\n"); |
| } |
| else |
| { |
| printf("Non-key frame requested: %d\n", frameType); |
| } |
| return 0; |
| } |
