1 /* 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. 3 * 4 * Use of this source code is governed by a BSD-style license 5 * that can be found in the LICENSE file in the root of the source 6 * tree. An additional intellectual property rights grant can be found 7 * in the file PATENTS. All contributing project authors may 8 * be found in the AUTHORS file in the root of the source tree. 9 */ 10 11 #include "NETEQTEST_RTPpacket.h" 12 13 #include <assert.h> 14 #include <stdlib.h> // rand 15 #include <string.h> 16 17 #ifdef WIN32 18 #include <winsock2.h> 19 #else 20 #include <netinet/in.h> // for htons, htonl, etc 21 #endif 22 23 const int NETEQTEST_RTPpacket::_kRDHeaderLen = 8; 24 const int NETEQTEST_RTPpacket::_kBasicHeaderLen = 12; 25 26 NETEQTEST_RTPpacket::NETEQTEST_RTPpacket() 27 : 28 _datagram(NULL), 29 _payloadPtr(NULL), 30 _memSize(0), 31 _datagramLen(-1), 32 _payloadLen(0), 33 _rtpParsed(false), 34 _receiveTime(0), 35 _lost(false) 36 { 37 memset(&_rtpInfo, 0, sizeof(_rtpInfo)); 38 _blockList.clear(); 39 } 40 41 NETEQTEST_RTPpacket::~NETEQTEST_RTPpacket() 42 { 43 if(_datagram) 44 { 45 delete [] _datagram; 46 } 47 } 48 49 void NETEQTEST_RTPpacket::reset() 50 { 51 if(_datagram) { 52 delete [] _datagram; 53 } 54 _datagram = NULL; 55 _memSize = 0; 56 _datagramLen = -1; 57 _payloadLen = 0; 58 _payloadPtr = NULL; 59 _receiveTime = 0; 60 memset(&_rtpInfo, 0, sizeof(_rtpInfo)); 61 _rtpParsed = false; 62 63 } 64 65 int NETEQTEST_RTPpacket::skipFileHeader(FILE *fp) 66 { 67 if (!fp) { 68 return -1; 69 } 70 71 const int kFirstLineLength = 40; 72 char firstline[kFirstLineLength]; 73 if (fgets(firstline, kFirstLineLength, fp) == NULL) { 74 return -1; 75 } 76 if (strncmp(firstline, "#!rtpplay", 9) == 0) { 77 if (strncmp(firstline, "#!rtpplay1.0", 12) != 0) { 78 return -1; 79 } 80 } 81 else if (strncmp(firstline, "#!RTPencode", 11) == 0) { 82 if (strncmp(firstline, "#!RTPencode1.0", 14) != 0) { 83 return -1; 84 } 85 } 86 else 87 { 88 return -1; 89 } 90 91 const int kRtpDumpHeaderSize = 4 + 4 + 4 + 2 + 2; 92 if (fseek(fp, kRtpDumpHeaderSize, SEEK_CUR) != 0) 93 { 94 return -1; 95 } 96 return 0; 97 } 98 99 int NETEQTEST_RTPpacket::readFromFile(FILE *fp) 100 { 101 if(!fp) 102 { 103 return(-1); 104 } 105 106 uint16_t length, plen; 107 uint32_t offset; 108 int packetLen; 109 110 bool readNextPacket = true; 111 while (readNextPacket) { 112 readNextPacket = false; 113 if (fread(&length,2,1,fp)==0) 114 { 115 reset(); 116 return(-2); 117 } 118 length = ntohs(length); 119 120 if (fread(&plen,2,1,fp)==0) 121 { 122 reset(); 123 return(-1); 124 } 125 packetLen = ntohs(plen); 126 127 if (fread(&offset,4,1,fp)==0) 128 { 129 reset(); 130 return(-1); 131 } 132 // store in local variable until we have passed the reset below 133 uint32_t receiveTime = ntohl(offset); 134 135 // Use length here because a plen of 0 specifies rtcp 136 length = (uint16_t) (length - _kRDHeaderLen); 137 138 // check buffer size 139 if (_datagram && _memSize < length) 140 { 141 reset(); 142 } 143 144 if (!_datagram) 145 { 146 _datagram = new uint8_t[length]; 147 _memSize = length; 148 } 149 150 if (fread((unsigned short *) _datagram,1,length,fp) != length) 151 { 152 reset(); 153 return(-1); 154 } 155 156 _datagramLen = length; 157 _receiveTime = receiveTime; 158 159 if (!_blockList.empty() && _blockList.count(payloadType()) > 0) 160 { 161 readNextPacket = true; 162 } 163 } 164 165 _rtpParsed = false; 166 return(packetLen); 167 168 } 169 170 171 int NETEQTEST_RTPpacket::readFixedFromFile(FILE *fp, size_t length) 172 { 173 if (!fp) 174 { 175 return -1; 176 } 177 178 // check buffer size 179 if (_datagram && _memSize < static_cast<int>(length)) 180 { 181 reset(); 182 } 183 184 if (!_datagram) 185 { 186 _datagram = new uint8_t[length]; 187 _memSize = length; 188 } 189 190 if (fread(_datagram, 1, length, fp) != length) 191 { 192 reset(); 193 return -1; 194 } 195 196 _datagramLen = length; 197 _receiveTime = 0; 198 199 if (!_blockList.empty() && _blockList.count(payloadType()) > 0) 200 { 201 // discard this payload 202 return readFromFile(fp); 203 } 204 205 _rtpParsed = false; 206 return length; 207 208 } 209 210 211 int NETEQTEST_RTPpacket::writeToFile(FILE *fp) 212 { 213 if (!fp) 214 { 215 return -1; 216 } 217 218 uint16_t length, plen; 219 uint32_t offset; 220 221 // length including RTPplay header 222 length = htons(_datagramLen + _kRDHeaderLen); 223 if (fwrite(&length, 2, 1, fp) != 1) 224 { 225 return -1; 226 } 227 228 // payload length 229 plen = htons(_datagramLen); 230 if (fwrite(&plen, 2, 1, fp) != 1) 231 { 232 return -1; 233 } 234 235 // offset (=receive time) 236 offset = htonl(_receiveTime); 237 if (fwrite(&offset, 4, 1, fp) != 1) 238 { 239 return -1; 240 } 241 242 243 // write packet data 244 if (fwrite(_datagram, 1, _datagramLen, fp) != 245 static_cast<size_t>(_datagramLen)) 246 { 247 return -1; 248 } 249 250 return _datagramLen + _kRDHeaderLen; // total number of bytes written 251 252 } 253 254 255 void NETEQTEST_RTPpacket::blockPT(uint8_t pt) 256 { 257 _blockList[pt] = true; 258 } 259 260 261 void NETEQTEST_RTPpacket::parseHeader() 262 { 263 if (_rtpParsed) 264 { 265 // nothing to do 266 return; 267 } 268 269 if (_datagramLen < _kBasicHeaderLen) 270 { 271 // corrupt packet? 272 return; 273 } 274 275 _payloadLen = parseRTPheader(&_payloadPtr); 276 277 _rtpParsed = true; 278 279 return; 280 281 } 282 283 void NETEQTEST_RTPpacket::parseHeader(webrtc::WebRtcRTPHeader* rtp_header) { 284 if (!_rtpParsed) { 285 parseHeader(); 286 } 287 if (rtp_header) { 288 rtp_header->header.markerBit = _rtpInfo.header.markerBit; 289 rtp_header->header.payloadType = _rtpInfo.header.payloadType; 290 rtp_header->header.sequenceNumber = _rtpInfo.header.sequenceNumber; 291 rtp_header->header.timestamp = _rtpInfo.header.timestamp; 292 rtp_header->header.ssrc = _rtpInfo.header.ssrc; 293 } 294 } 295 296 const webrtc::WebRtcRTPHeader* NETEQTEST_RTPpacket::RTPinfo() const 297 { 298 if (_rtpParsed) 299 { 300 return &_rtpInfo; 301 } 302 else 303 { 304 return NULL; 305 } 306 } 307 308 uint8_t * NETEQTEST_RTPpacket::datagram() const 309 { 310 if (_datagramLen > 0) 311 { 312 return _datagram; 313 } 314 else 315 { 316 return NULL; 317 } 318 } 319 320 uint8_t * NETEQTEST_RTPpacket::payload() const 321 { 322 if (_payloadLen > 0) 323 { 324 return _payloadPtr; 325 } 326 else 327 { 328 return NULL; 329 } 330 } 331 332 int16_t NETEQTEST_RTPpacket::payloadLen() 333 { 334 parseHeader(); 335 return _payloadLen; 336 } 337 338 int16_t NETEQTEST_RTPpacket::dataLen() const 339 { 340 return _datagramLen; 341 } 342 343 bool NETEQTEST_RTPpacket::isParsed() const 344 { 345 return _rtpParsed; 346 } 347 348 bool NETEQTEST_RTPpacket::isLost() const 349 { 350 return _lost; 351 } 352 353 uint8_t NETEQTEST_RTPpacket::payloadType() const 354 { 355 webrtc::WebRtcRTPHeader tempRTPinfo; 356 357 if(_datagram && _datagramLen >= _kBasicHeaderLen) 358 { 359 parseRTPheader(&tempRTPinfo); 360 } 361 else 362 { 363 return 0; 364 } 365 366 return tempRTPinfo.header.payloadType; 367 } 368 369 uint16_t NETEQTEST_RTPpacket::sequenceNumber() const 370 { 371 webrtc::WebRtcRTPHeader tempRTPinfo; 372 373 if(_datagram && _datagramLen >= _kBasicHeaderLen) 374 { 375 parseRTPheader(&tempRTPinfo); 376 } 377 else 378 { 379 return 0; 380 } 381 382 return tempRTPinfo.header.sequenceNumber; 383 } 384 385 uint32_t NETEQTEST_RTPpacket::timeStamp() const 386 { 387 webrtc::WebRtcRTPHeader tempRTPinfo; 388 389 if(_datagram && _datagramLen >= _kBasicHeaderLen) 390 { 391 parseRTPheader(&tempRTPinfo); 392 } 393 else 394 { 395 return 0; 396 } 397 398 return tempRTPinfo.header.timestamp; 399 } 400 401 uint32_t NETEQTEST_RTPpacket::SSRC() const 402 { 403 webrtc::WebRtcRTPHeader tempRTPinfo; 404 405 if(_datagram && _datagramLen >= _kBasicHeaderLen) 406 { 407 parseRTPheader(&tempRTPinfo); 408 } 409 else 410 { 411 return 0; 412 } 413 414 return tempRTPinfo.header.ssrc; 415 } 416 417 uint8_t NETEQTEST_RTPpacket::markerBit() const 418 { 419 webrtc::WebRtcRTPHeader tempRTPinfo; 420 421 if(_datagram && _datagramLen >= _kBasicHeaderLen) 422 { 423 parseRTPheader(&tempRTPinfo); 424 } 425 else 426 { 427 return 0; 428 } 429 430 return tempRTPinfo.header.markerBit; 431 } 432 433 434 435 int NETEQTEST_RTPpacket::setPayloadType(uint8_t pt) 436 { 437 438 if (_datagramLen < 12) 439 { 440 return -1; 441 } 442 443 if (!_rtpParsed) 444 { 445 _rtpInfo.header.payloadType = pt; 446 } 447 448 _datagram[1]=(unsigned char)(pt & 0xFF); 449 450 return 0; 451 452 } 453 454 int NETEQTEST_RTPpacket::setSequenceNumber(uint16_t sn) 455 { 456 457 if (_datagramLen < 12) 458 { 459 return -1; 460 } 461 462 if (!_rtpParsed) 463 { 464 _rtpInfo.header.sequenceNumber = sn; 465 } 466 467 _datagram[2]=(unsigned char)((sn>>8)&0xFF); 468 _datagram[3]=(unsigned char)((sn)&0xFF); 469 470 return 0; 471 472 } 473 474 int NETEQTEST_RTPpacket::setTimeStamp(uint32_t ts) 475 { 476 477 if (_datagramLen < 12) 478 { 479 return -1; 480 } 481 482 if (!_rtpParsed) 483 { 484 _rtpInfo.header.timestamp = ts; 485 } 486 487 _datagram[4]=(unsigned char)((ts>>24)&0xFF); 488 _datagram[5]=(unsigned char)((ts>>16)&0xFF); 489 _datagram[6]=(unsigned char)((ts>>8)&0xFF); 490 _datagram[7]=(unsigned char)(ts & 0xFF); 491 492 return 0; 493 494 } 495 496 int NETEQTEST_RTPpacket::setSSRC(uint32_t ssrc) 497 { 498 499 if (_datagramLen < 12) 500 { 501 return -1; 502 } 503 504 if (!_rtpParsed) 505 { 506 _rtpInfo.header.ssrc = ssrc; 507 } 508 509 _datagram[8]=(unsigned char)((ssrc>>24)&0xFF); 510 _datagram[9]=(unsigned char)((ssrc>>16)&0xFF); 511 _datagram[10]=(unsigned char)((ssrc>>8)&0xFF); 512 _datagram[11]=(unsigned char)(ssrc & 0xFF); 513 514 return 0; 515 516 } 517 518 int NETEQTEST_RTPpacket::setMarkerBit(uint8_t mb) 519 { 520 521 if (_datagramLen < 12) 522 { 523 return -1; 524 } 525 526 if (_rtpParsed) 527 { 528 _rtpInfo.header.markerBit = mb; 529 } 530 531 if (mb) 532 { 533 _datagram[0] |= 0x01; 534 } 535 else 536 { 537 _datagram[0] &= 0xFE; 538 } 539 540 return 0; 541 542 } 543 544 int NETEQTEST_RTPpacket::setRTPheader(const webrtc::WebRtcRTPHeader* RTPinfo) 545 { 546 if (_datagramLen < 12) 547 { 548 // this packet is not ok 549 return -1; 550 } 551 552 makeRTPheader(_datagram, 553 RTPinfo->header.payloadType, 554 RTPinfo->header.sequenceNumber, 555 RTPinfo->header.timestamp, 556 RTPinfo->header.ssrc, 557 RTPinfo->header.markerBit); 558 559 return 0; 560 } 561 562 563 int NETEQTEST_RTPpacket::splitStereo(NETEQTEST_RTPpacket* slaveRtp, 564 enum stereoModes mode) 565 { 566 // if mono, do nothing 567 if (mode == stereoModeMono) 568 { 569 return 0; 570 } 571 572 // check that the RTP header info is parsed 573 parseHeader(); 574 575 // start by copying the main rtp packet 576 *slaveRtp = *this; 577 578 if(_payloadLen == 0) 579 { 580 // do no more 581 return 0; 582 } 583 584 if(_payloadLen%2 != 0) 585 { 586 // length must be a factor of 2 587 return -1; 588 } 589 590 switch(mode) 591 { 592 case stereoModeSample1: 593 { 594 // sample based codec with 1-byte samples 595 splitStereoSample(slaveRtp, 1 /* 1 byte/sample */); 596 break; 597 } 598 case stereoModeSample2: 599 { 600 // sample based codec with 2-byte samples 601 splitStereoSample(slaveRtp, 2 /* 2 bytes/sample */); 602 break; 603 } 604 case stereoModeFrame: 605 { 606 // frame based codec 607 splitStereoFrame(slaveRtp); 608 break; 609 } 610 case stereoModeDuplicate: 611 { 612 // frame based codec, send the whole packet to both master and slave 613 splitStereoDouble(slaveRtp); 614 break; 615 } 616 case stereoModeMono: 617 { 618 assert(false); 619 return -1; 620 } 621 } 622 623 return 0; 624 } 625 626 627 void NETEQTEST_RTPpacket::makeRTPheader(unsigned char* rtp_data, uint8_t payloadType, uint16_t seqNo, uint32_t timestamp, uint32_t ssrc, uint8_t markerBit) const 628 { 629 rtp_data[0]=(unsigned char)0x80; 630 if (markerBit) 631 { 632 rtp_data[0] |= 0x01; 633 } 634 else 635 { 636 rtp_data[0] &= 0xFE; 637 } 638 rtp_data[1]=(unsigned char)(payloadType & 0xFF); 639 rtp_data[2]=(unsigned char)((seqNo>>8)&0xFF); 640 rtp_data[3]=(unsigned char)((seqNo)&0xFF); 641 rtp_data[4]=(unsigned char)((timestamp>>24)&0xFF); 642 rtp_data[5]=(unsigned char)((timestamp>>16)&0xFF); 643 644 rtp_data[6]=(unsigned char)((timestamp>>8)&0xFF); 645 rtp_data[7]=(unsigned char)(timestamp & 0xFF); 646 647 rtp_data[8]=(unsigned char)((ssrc>>24)&0xFF); 648 rtp_data[9]=(unsigned char)((ssrc>>16)&0xFF); 649 650 rtp_data[10]=(unsigned char)((ssrc>>8)&0xFF); 651 rtp_data[11]=(unsigned char)(ssrc & 0xFF); 652 } 653 654 uint16_t 655 NETEQTEST_RTPpacket::parseRTPheader(webrtc::WebRtcRTPHeader* RTPinfo, 656 uint8_t **payloadPtr) const 657 { 658 int16_t *rtp_data = (int16_t *) _datagram; 659 int i_P, i_X, i_CC; 660 661 assert(_datagramLen >= 12); 662 parseBasicHeader(RTPinfo, &i_P, &i_X, &i_CC); 663 664 int i_startPosition = calcHeaderLength(i_X, i_CC); 665 666 int i_padlength = calcPadLength(i_P); 667 668 if (payloadPtr) 669 { 670 *payloadPtr = (uint8_t*) &rtp_data[i_startPosition >> 1]; 671 } 672 673 return (uint16_t) (_datagramLen - i_startPosition - i_padlength); 674 } 675 676 677 void NETEQTEST_RTPpacket::parseBasicHeader(webrtc::WebRtcRTPHeader* RTPinfo, 678 int *i_P, int *i_X, int *i_CC) const 679 { 680 int16_t *rtp_data = (int16_t *) _datagram; 681 if (_datagramLen < 12) 682 { 683 assert(false); 684 return; 685 } 686 687 *i_P=(((uint16_t)(rtp_data[0] & 0x20))>>5); /* Extract the P bit */ 688 *i_X=(((uint16_t)(rtp_data[0] & 0x10))>>4); /* Extract the X bit */ 689 *i_CC=(uint16_t)(rtp_data[0] & 0xF); /* Get the CC number */ 690 /* Get the marker bit */ 691 RTPinfo->header.markerBit = (uint8_t) ((rtp_data[0] >> 15) & 0x01); 692 /* Get the coder type */ 693 RTPinfo->header.payloadType = (uint8_t) ((rtp_data[0] >> 8) & 0x7F); 694 /* Get the packet number */ 695 RTPinfo->header.sequenceNumber = 696 ((( ((uint16_t)rtp_data[1]) >> 8) & 0xFF) | 697 ( ((uint16_t)(rtp_data[1] & 0xFF)) << 8)); 698 /* Get timestamp */ 699 RTPinfo->header.timestamp = ((((uint16_t)rtp_data[2]) & 0xFF) << 24) | 700 ((((uint16_t)rtp_data[2]) & 0xFF00) << 8) | 701 ((((uint16_t)rtp_data[3]) >> 8) & 0xFF) | 702 ((((uint16_t)rtp_data[3]) & 0xFF) << 8); 703 /* Get the SSRC */ 704 RTPinfo->header.ssrc = ((((uint16_t)rtp_data[4]) & 0xFF) << 24) | 705 ((((uint16_t)rtp_data[4]) & 0xFF00) << 8) | 706 ((((uint16_t)rtp_data[5]) >> 8) & 0xFF) | 707 ((((uint16_t)rtp_data[5]) & 0xFF) << 8); 708 } 709 710 int NETEQTEST_RTPpacket::calcHeaderLength(int i_X, int i_CC) const 711 { 712 int i_extlength = 0; 713 int16_t *rtp_data = (int16_t *) _datagram; 714 715 if (i_X == 1) 716 { 717 // Extension header exists. 718 // Find out how many int32_t it consists of. 719 assert(_datagramLen > 2 * (7 + 2 * i_CC)); 720 if (_datagramLen > 2 * (7 + 2 * i_CC)) 721 { 722 i_extlength = (((((uint16_t) rtp_data[7 + 2 * i_CC]) >> 8) 723 & 0xFF) | (((uint16_t) (rtp_data[7 + 2 * i_CC] & 0xFF)) 724 << 8)) + 1; 725 } 726 } 727 728 return 12 + 4 * i_extlength + 4 * i_CC; 729 } 730 731 int NETEQTEST_RTPpacket::calcPadLength(int i_P) const 732 { 733 int16_t *rtp_data = (int16_t *) _datagram; 734 if (i_P == 1) 735 { 736 /* Padding exists. Find out how many bytes the padding consists of. */ 737 if (_datagramLen & 0x1) 738 { 739 /* odd number of bytes => last byte in higher byte */ 740 return rtp_data[_datagramLen >> 1] & 0xFF; 741 } 742 else 743 { 744 /* even number of bytes => last byte in lower byte */ 745 return ((uint16_t) rtp_data[(_datagramLen >> 1) - 1]) >> 8; 746 } 747 } 748 return 0; 749 } 750 751 void NETEQTEST_RTPpacket::splitStereoSample(NETEQTEST_RTPpacket* slaveRtp, 752 int stride) 753 { 754 if(!_payloadPtr || !slaveRtp || !slaveRtp->_payloadPtr 755 || _payloadLen <= 0 || slaveRtp->_memSize < _memSize) 756 { 757 return; 758 } 759 760 uint8_t *readDataPtr = _payloadPtr; 761 uint8_t *writeDataPtr = _payloadPtr; 762 uint8_t *slaveData = slaveRtp->_payloadPtr; 763 764 while (readDataPtr - _payloadPtr < _payloadLen) 765 { 766 // master data 767 for (int ix = 0; ix < stride; ix++) { 768 *writeDataPtr = *readDataPtr; 769 writeDataPtr++; 770 readDataPtr++; 771 } 772 773 // slave data 774 for (int ix = 0; ix < stride; ix++) { 775 *slaveData = *readDataPtr; 776 slaveData++; 777 readDataPtr++; 778 } 779 } 780 781 _payloadLen /= 2; 782 slaveRtp->_payloadLen = _payloadLen; 783 } 784 785 786 void NETEQTEST_RTPpacket::splitStereoFrame(NETEQTEST_RTPpacket* slaveRtp) 787 { 788 if(!_payloadPtr || !slaveRtp || !slaveRtp->_payloadPtr 789 || _payloadLen <= 0 || slaveRtp->_memSize < _memSize) 790 { 791 return; 792 } 793 794 memmove(slaveRtp->_payloadPtr, _payloadPtr + _payloadLen/2, _payloadLen/2); 795 796 _payloadLen /= 2; 797 slaveRtp->_payloadLen = _payloadLen; 798 } 799 void NETEQTEST_RTPpacket::splitStereoDouble(NETEQTEST_RTPpacket* slaveRtp) 800 { 801 if(!_payloadPtr || !slaveRtp || !slaveRtp->_payloadPtr 802 || _payloadLen <= 0 || slaveRtp->_memSize < _memSize) 803 { 804 return; 805 } 806 807 memcpy(slaveRtp->_payloadPtr, _payloadPtr, _payloadLen); 808 slaveRtp->_payloadLen = _payloadLen; 809 } 810 811 // Get the RTP header for the RED payload indicated by argument index. 812 // The first RED payload is index = 0. 813 int NETEQTEST_RTPpacket::extractRED(int index, webrtc::WebRtcRTPHeader& red) 814 { 815 // 816 // 0 1 2 3 817 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 818 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 819 // |1| block PT | timestamp offset | block length | 820 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 821 // |1| ... | 822 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 823 // |0| block PT | 824 // +-+-+-+-+-+-+-+-+ 825 // 826 827 parseHeader(); 828 829 uint8_t* ptr = payload(); 830 uint8_t* payloadEndPtr = ptr + payloadLen(); 831 int num_encodings = 0; 832 int total_len = 0; 833 834 while ((ptr < payloadEndPtr) && (*ptr & 0x80)) 835 { 836 int len = ((ptr[2] & 0x03) << 8) + ptr[3]; 837 if (num_encodings == index) 838 { 839 // Header found. 840 red.header.payloadType = ptr[0] & 0x7F; 841 uint32_t offset = (ptr[1] << 6) + ((ptr[2] & 0xFC) >> 2); 842 red.header.sequenceNumber = sequenceNumber(); 843 red.header.timestamp = timeStamp() - offset; 844 red.header.markerBit = markerBit(); 845 red.header.ssrc = SSRC(); 846 return len; 847 } 848 ++num_encodings; 849 total_len += len; 850 ptr += 4; 851 } 852 if ((ptr < payloadEndPtr) && (num_encodings == index)) 853 { 854 // Last header. 855 red.header.payloadType = ptr[0] & 0x7F; 856 red.header.sequenceNumber = sequenceNumber(); 857 red.header.timestamp = timeStamp(); 858 red.header.markerBit = markerBit(); 859 red.header.ssrc = SSRC(); 860 ++ptr; 861 return payloadLen() - (ptr - payload()) - total_len; 862 } 863 return -1; 864 } 865 866 // Randomize the payload, not the RTP header. 867 void NETEQTEST_RTPpacket::scramblePayload(void) 868 { 869 parseHeader(); 870 871 for (int i = 0; i < _payloadLen; ++i) 872 { 873 _payloadPtr[i] = static_cast<uint8_t>(rand()); 874 } 875 } 876
