ovr_sdk: f12a8f74fe1f LibOVR/Src/Net/OVR

428 if ( numberOfBitsToWrite < 8 && rightAlignedBits ) // rightAlignedBits means in the case of a partial byte, the bits are aligned from the right (bit 0) rather than the left (as in the normal internal representation)

429 dataByte <<= 8 - numberOfBitsToWrite; // shift left to get the bits on the left, as in our internal representation

430

431 // Writing to a new byte each time

432 if ( numberOfBitsUsedMod8 == 0 )

433 * ( data + ( numberOfBitsUsed >> 3 ) ) = dataByte;

434 else

435 {

436 // Copy over the new data.

437 *( data + ( numberOfBitsUsed >> 3 ) ) |= dataByte >> ( numberOfBitsUsedMod8 ); // First half

438

439 if ( 8 - ( numberOfBitsUsedMod8 ) < 8 && 8 - ( numberOfBitsUsedMod8 ) < numberOfBitsToWrite ) // If we didn't write it all out in the first half (8 - (numberOfBitsUsed%8) is the number we wrote in the first half)

440 {

441 *( data + ( numberOfBitsUsed >> 3 ) + 1 ) = (unsigned char) ( dataByte << ( 8 - ( numberOfBitsUsedMod8 ) ) ); // Second half (overlaps byte boundary)

442 }

443 }

444

445 if ( numberOfBitsToWrite >= 8 )

446 {

447 numberOfBitsUsed += 8;

448 numberOfBitsToWrite -= 8;

449 }

450 else

451 {

452 numberOfBitsUsed += numberOfBitsToWrite;

453 numberOfBitsToWrite=0;

454 }

455 }

456 // } while(numberOfBitsToWrite>0);

457 }

458

459 // Set the stream to some initial data. For internal use

460 void BitStream::SetData( unsigned char *inByteArray )

461 {

462 data=inByteArray;

463 copyData=false;

464 }

465

466 // Assume the input source points to a native type, compress and write it

467 void BitStream::WriteCompressed( const unsigned char* inByteArray,

468 const unsigned int size, const bool unsignedData )

469 {

470 BitSize_t currentByte = ( size >> 3 ) - 1; // PCs

471

472 unsigned char byteMatch;

473

474 if ( unsignedData )

475 {

476 byteMatch = 0;

477 }

478

479 else

480 {

481 byteMatch = 0xFF;

482 }

483

484 // Write upper bytes with a single 1

485 // From high byte to low byte, if high byte is a byteMatch then write a 1 bit. Otherwise write a 0 bit and then write the remaining bytes

486 while ( currentByte > 0 )

487 {

488 if ( inByteArray[ currentByte ] == byteMatch ) // If high byte is byteMatch (0 of 0xff) then it would have the same value shifted

489 {

490 bool b = true;

491 Write( b );

492 }

493 else

494 {

495 // Write the remainder of the data after writing 0

496 bool b = false;

497 Write( b );

498

499 WriteBits( inByteArray, ( currentByte + 1 ) << 3, true );

500 // currentByte--;

501

502

503 return ;

504 }

505

506 currentByte--;

507 }

508

509 // If the upper half of the last byte is a 0 (positive) or 16 (negative) then write a 1 and the remaining 4 bits. Otherwise write a 0 and the 8 bites.

510 if ( ( unsignedData && ( ( *( inByteArray + currentByte ) ) & 0xF0 ) == 0x00 ) ||

511 ( unsignedData == false && ( ( *( inByteArray + currentByte ) ) & 0xF0 ) == 0xF0 ) )

512 {

513 bool b = true;

514 Write( b );

515 WriteBits( inByteArray + currentByte, 4, true );

516 }

517

518 else

519 {

520 bool b = false;

521 Write( b );

522 WriteBits( inByteArray + currentByte, 8, true );

523 }

524 }

525

526 // Read numberOfBitsToRead bits to the output source

527 // alignBitsToRight should be set to true to convert internal bitstream data to userdata

528 // It should be false if you used WriteBits with rightAlignedBits false

529 bool BitStream::ReadBits( unsigned char *inOutByteArray, BitSize_t numberOfBitsToRead, const bool alignBitsToRight )

530 {

531 #ifdef _DEBUG

532 // OVR_ASSERT( numberOfBitsToRead > 0 );

533 #endif

534 if (numberOfBitsToRead<=0)

535 return false;

536

537 if ( readOffset + numberOfBitsToRead > numberOfBitsUsed )

538 return false;

539

540

541 const BitSize_t readOffsetMod8 = readOffset & 7;

542

543 // If currently aligned and numberOfBits is a multiple of 8, just memcpy for speed

544 if (readOffsetMod8==0 && (numberOfBitsToRead&7)==0)

545 {

546 memcpy( inOutByteArray, data + ( readOffset >> 3 ), numberOfBitsToRead>>3);

547 readOffset+=numberOfBitsToRead;

548 return true;

549 }

550

551

552

553 BitSize_t offset = 0;

554

555 memset( inOutByteArray, 0, (size_t) BITS_TO_BYTES( numberOfBitsToRead ) );

556

557 while ( numberOfBitsToRead > 0 )

558 {

559 *( inOutByteArray + offset ) |= *( data + ( readOffset >> 3 ) ) << ( readOffsetMod8 ); // First half

560

561 if ( readOffsetMod8 > 0 && numberOfBitsToRead > 8 - ( readOffsetMod8 ) ) // If we have a second half, we didn't read enough bytes in the first half

562 *( inOutByteArray + offset ) |= *( data + ( readOffset >> 3 ) + 1 ) >> ( 8 - ( readOffsetMod8 ) ); // Second half (overlaps byte boundary)

563

564 if (numberOfBitsToRead>=8)

565 {

566 numberOfBitsToRead -= 8;

567 readOffset += 8;

568 offset++;

569 }

570 else

571 {

572 int neg = (int) numberOfBitsToRead - 8;

573

574 if ( neg < 0 ) // Reading a partial byte for the last byte, shift right so the data is aligned on the right

575 {

576

577 if ( alignBitsToRight )

578 * ( inOutByteArray + offset ) >>= -neg;

579

580 readOffset += 8 + neg;

581 }

582 else

583 readOffset += 8;

584

585 offset++;

586

587 numberOfBitsToRead=0;

588 }

589 }

590

591 return true;

592 }

593

594 // Assume the input source points to a compressed native type. Decompress and read it

595 bool BitStream::ReadCompressed( unsigned char* inOutByteArray,

596 const unsigned int size, const bool unsignedData )

597 {

598 unsigned int currentByte = ( size >> 3 ) - 1;

599

600

601 unsigned char byteMatch, halfByteMatch;

602

603 if ( unsignedData )

604 {

605 byteMatch = 0;

606 halfByteMatch = 0;

607 }

608

609 else

610 {

611 byteMatch = 0xFF;

612 halfByteMatch = 0xF0;

613 }

614

615 // Upper bytes are specified with a single 1 if they match byteMatch

616 // From high byte to low byte, if high byte is a byteMatch then write a 1 bit. Otherwise write a 0 bit and then write the remaining bytes

617 while ( currentByte > 0 )

618 {

619 // If we read a 1 then the data is byteMatch.

620

621 bool b;

622

623 if ( Read( b ) == false )

624 return false;

625

626 if ( b ) // Check that bit

627 {

628 inOutByteArray[ currentByte ] = byteMatch;

629 currentByte--;

630 }

631 else

632 {

633 // Read the rest of the bytes

634

635 if ( ReadBits( inOutByteArray, ( currentByte + 1 ) << 3 ) == false )

636 return false;

637

638 return true;

639 }

640 }

641

642 // All but the first bytes are byteMatch. If the upper half of the last byte is a 0 (positive) or 16 (negative) then what we read will be a 1 and the remaining 4 bits.

643 // Otherwise we read a 0 and the 8 bytes

644 //OVR_ASSERT(readOffset+1 <=numberOfBitsUsed); // If this assert is hit the stream wasn't long enough to read from

645 if ( readOffset + 1 > numberOfBitsUsed )

646 return false;

647

648 bool b=false;

649

650 if ( Read( b ) == false )

651 return false;

652

653 if ( b ) // Check that bit

654 {

655

656 if ( ReadBits( inOutByteArray + currentByte, 4 ) == false )

657 return false;

658

659 inOutByteArray[ currentByte ] |= halfByteMatch; // We have to set the high 4 bits since these are set to 0 by ReadBits

660 }

661 else

662 {

663 if ( ReadBits( inOutByteArray + currentByte, 8 ) == false )

664 return false;

665 }

666

667 return true;

668 }

669

670 // Reallocates (if necessary) in preparation of writing numberOfBitsToWrite

671 void BitStream::AddBitsAndReallocate( const BitSize_t numberOfBitsToWrite )

672 {

673 BitSize_t newNumberOfBitsAllocated = numberOfBitsToWrite + numberOfBitsUsed;

674

675 if ( numberOfBitsToWrite + numberOfBitsUsed > 0 && ( ( numberOfBitsAllocated - 1 ) >> 3 ) < ( ( newNumberOfBitsAllocated - 1 ) >> 3 ) ) // If we need to allocate 1 or more new bytes

676 {

677 #ifdef _DEBUG

678 // If this assert hits then we need to specify true for the third parameter in the constructor

679 // It needs to reallocate to hold all the data and can't do it unless we allocated to begin with

680 // Often hits if you call Write or Serialize on a read-only bitstream

681 OVR_ASSERT( copyData == true );

682 #endif

683

684 // Less memory efficient but saves on news and deletes

685 /// Cap to 1 meg buffer to save on huge allocations

686 newNumberOfBitsAllocated = ( numberOfBitsToWrite + numberOfBitsUsed ) * 2;

687 if (newNumberOfBitsAllocated - ( numberOfBitsToWrite + numberOfBitsUsed ) > 1048576 )