| ;// |
| ;// Copyright (C) 2007-2008 ARM Limited |
| ;// |
| ;// Licensed under the Apache License, Version 2.0 (the "License"); |
| ;// you may not use this file except in compliance with the License. |
| ;// You may obtain a copy of the License at |
| ;// |
| ;// http://www.apache.org/licenses/LICENSE-2.0 |
| ;// |
| ;// Unless required by applicable law or agreed to in writing, software |
| ;// distributed under the License is distributed on an "AS IS" BASIS, |
| ;// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| ;// See the License for the specific language governing permissions and |
| ;// limitations under the License. |
| ;// |
| ;// |
| ;// |
| ;// File Name: armCOMM_BitDec_s.h |
| ;// OpenMAX DL: v1.0.2 |
| ;// Revision: 12290 |
| ;// Date: Wednesday, April 9, 2008 |
| ;// |
| ;// |
| ;// |
| ;// |
| ;// OpenMAX optimized bitstream decode module |
| ;// |
| ;// You must include armCOMM_s.h before including this file |
| ;// |
| ;// This module provides macros to perform assembly optimized fixed and |
| ;// variable length decoding from a read-only bitstream. The variable |
| ;// length decode modules take as input a pointer to a table of 16-bit |
| ;// entries of the following format. |
| ;// |
| ;// VLD Table Entry format |
| ;// |
| ;// 15 14 13 12 11 10 09 08 07 06 05 04 03 02 01 00 |
| ;// +------------------------------------------------+ |
| ;// | Len | Symbol | 1 | |
| ;// +------------------------------------------------+ |
| ;// | Offset | 0 | |
| ;// +------------------------------------------------+ |
| ;// |
| ;// If the table entry is a leaf entry then bit 0 set: |
| ;// Len = Number of bits overread (0 to 7) |
| ;// Symbol = Symbol payload (unsigned 12 bits) |
| ;// |
| ;// If the table entry is an internal node then bit 0 is clear: |
| ;// Offset = Number of (16-bit) half words from the table |
| ;// start to the next table node |
| ;// |
| ;// The table is accessed by successive lookup up on the |
| ;// next Step bits of the input bitstream until a leaf node |
| ;// is obtained. The Step sizes are supplied to the VLD macro. |
| ;// |
| ;// USAGE: |
| ;// |
| ;// To use any of the macros in this package, first call: |
| ;// |
| ;// M_BD_INIT ppBitStream, pBitOffset, pBitStream, RBitBuffer, RBitCount, Tmp |
| ;// |
| ;// This caches the current bitstream position and next available |
| ;// bits in registers pBitStream, RBitBuffer, RBitCount. These registers |
| ;// are reserved for use by the bitstream decode package until you |
| ;// call M_BD_FINI. |
| ;// |
| ;// Next call the following macro(s) as many times as you need: |
| ;// |
| ;// M_BD_LOOK8 - Look ahead constant 1<=N<=8 bits into the bitstream |
| ;// M_BD_LOOK16 - Look ahead constant 1<=N<=16 bits into the bitstream |
| ;// M_BD_READ8 - Read constant 1<=N<=8 bits from the bitstream |
| ;// M_BD_READ16 - Read constant 1<=N<=16 bits from the bitstream |
| ;// M_BD_VREAD8 - Read variable 1<=N<=8 bits from the bitstream |
| ;// M_BD_VREAD16 - Read variable 1<=N<=16 bits from the bitstream |
| ;// M_BD_VLD - Perform variable length decode using lookup table |
| ;// |
| ;// Finally call the macro: |
| ;// |
| ;// M_BD_FINI ppBitStream, pBitOffset |
| ;// |
| ;// This writes the bitstream state back to memory. |
| ;// |
| ;// The three bitstream cache register names are assigned to the following global |
| ;// variables: |
| ;// |
| |
| GBLS pBitStream ;// Register name for pBitStream |
| GBLS BitBuffer ;// Register name for BitBuffer |
| GBLS BitCount ;// Register name for BitCount |
| |
| ;// |
| ;// These register variables must have a certain defined state on entry to every bitstream |
| ;// macro (except M_BD_INIT) and on exit from every bitstream macro (except M_BD_FINI). |
| ;// The state may depend on implementation. |
| ;// |
| ;// For the default (ARM11) implementation the following hold: |
| ;// pBitStream - points to the first byte not held in the BitBuffer |
| ;// BitBuffer - is a cache of (4 bytes) 32 bits, bit 31 the first bit |
| ;// BitCount - is offset (from the top bit) to the next unused bitstream bit |
| ;// 0<=BitCount<=15 (so BitBuffer holds at least 17 unused bits) |
| ;// |
| ;// |
| |
| ;// Bitstream Decode initialise |
| ;// |
| ;// Initialises the bitstream decode global registers from |
| ;// bitstream pointers. This macro is split into 3 parts to enable |
| ;// scheduling. |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $ppBitStream - pointer to pointer to the next bitstream byte |
| ;// $pBitOffset - pointer to the number of bits used in the current byte (0..7) |
| ;// $RBitStream - register to use for pBitStream (can be $ppBitStream) |
| ;// $RBitBuffer - register to use for BitBuffer |
| ;// $RBitCount - register to use for BitCount (can be $pBitOffset) |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $T1,$T2,$T3 - registers that must be preserved between calls to |
| ;// M_BD_INIT1 and M_BD_INIT2 |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_INIT0 $ppBitStream, $pBitOffset, $RBitStream, $RBitBuffer, $RBitCount |
| |
| pBitStream SETS "$RBitStream" |
| BitBuffer SETS "$RBitBuffer" |
| BitCount SETS "$RBitCount" |
| |
| ;// load inputs |
| LDR $pBitStream, [$ppBitStream] |
| LDR $BitCount, [$pBitOffset] |
| MEND |
| |
| MACRO |
| M_BD_INIT1 $T1, $T2, $T3 |
| LDRB $T2, [$pBitStream, #2] |
| LDRB $T1, [$pBitStream, #1] |
| LDRB $BitBuffer, [$pBitStream], #3 |
| ADD $BitCount, $BitCount, #8 |
| MEND |
| |
| MACRO |
| M_BD_INIT2 $T1, $T2, $T3 |
| ORR $T2, $T2, $T1, LSL #8 |
| ORR $BitBuffer, $T2, $BitBuffer, LSL #16 |
| MEND |
| |
| ;// |
| ;// Look ahead fixed 1<=N<=8 bits without consuming any bits |
| ;// The next bits will be placed at bit 31..24 of destination register |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $N - number of bits to look |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $Symbol - the next N bits of the bitstream |
| ;// $T1 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_LOOK8 $Symbol, $N |
| ASSERT ($N>=1):LAND:($N<=8) |
| MOV $Symbol, $BitBuffer, LSL $BitCount |
| MEND |
| |
| ;// |
| ;// Look ahead fixed 1<=N<=16 bits without consuming any bits |
| ;// The next bits will be placed at bit 31..16 of destination register |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $N - number of bits to look |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $Symbol - the next N bits of the bitstream |
| ;// $T1 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_LOOK16 $Symbol, $N, $T1 |
| ASSERT ($N >= 1):LAND:($N <= 16) |
| MOV $Symbol, $BitBuffer, LSL $BitCount |
| MEND |
| |
| ;// |
| ;// Skips fixed 1<=N<=8 bits from the bitstream, advancing the bitstream pointer |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $N - number of bits |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $T1 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_SKIP8 $N, $T1 |
| ASSERT ($N>=1):LAND:($N<=8) |
| SUBS $BitCount, $BitCount, #(8-$N) |
| LDRCSB $T1, [$pBitStream], #1 |
| ADDCC $BitCount, $BitCount, #8 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| MEND |
| |
| |
| ;// |
| ;// Read fixed 1<=N<=8 bits from the bitstream, advancing the bitstream pointer |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $N - number of bits to read |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $Symbol - the next N bits of the bitstream |
| ;// $T1 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_READ8 $Symbol, $N, $T1 |
| ASSERT ($N>=1):LAND:($N<=8) |
| MOVS $Symbol, $BitBuffer, LSL $BitCount |
| SUBS $BitCount, $BitCount, #(8-$N) |
| LDRCSB $T1, [$pBitStream], #1 |
| ADDCC $BitCount, $BitCount, #8 |
| MOV $Symbol, $Symbol, LSR #(32-$N) |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| MEND |
| |
| ;// |
| ;// Read fixed 1<=N<=16 bits from the bitstream, advancing the bitstream pointer |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $N - number of bits to read |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $Symbol - the next N bits of the bitstream |
| ;// $T1 - corrupted temp/scratch register |
| ;// $T2 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_READ16 $Symbol, $N, $T1, $T2 |
| ASSERT ($N>=1):LAND:($N<=16) |
| ASSERT $Symbol<>$T1 |
| IF ($N<=8) |
| M_BD_READ8 $Symbol, $N, $T1 |
| ELSE |
| ;// N>8 so we will be able to refill at least one byte |
| LDRB $T1, [$pBitStream], #1 |
| MOVS $Symbol, $BitBuffer, LSL $BitCount |
| ORR $BitBuffer, $T1, $BitBuffer, LSL #8 |
| SUBS $BitCount, $BitCount, #(16-$N) |
| LDRCSB $T1, [$pBitStream], #1 |
| MOV $Symbol, $Symbol, LSR #(32-$N) |
| ADDCC $BitCount, $BitCount, #8 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| ENDIF |
| MEND |
| |
| ;// |
| ;// Skip variable 1<=N<=8 bits from the bitstream, advancing the bitstream pointer. |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $N - number of bits. 1<=N<=8 |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $T1 - corrupted temp/scratch register |
| ;// $T2 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_VSKIP8 $N, $T1 |
| ADD $BitCount, $BitCount, $N |
| SUBS $BitCount, $BitCount, #8 |
| LDRCSB $T1, [$pBitStream], #1 |
| ADDCC $BitCount, $BitCount, #8 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| MEND |
| |
| ;// |
| ;// Skip variable 1<=N<=16 bits from the bitstream, advancing the bitstream pointer. |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $N - number of bits. 1<=N<=16 |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $T1 - corrupted temp/scratch register |
| ;// $T2 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_VSKIP16 $N, $T1, $T2 |
| ADD $BitCount, $BitCount, $N |
| SUBS $BitCount, $BitCount, #8 |
| LDRCSB $T1, [$pBitStream], #1 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| SUBCSS $BitCount, $BitCount, #8 |
| LDRCSB $T1, [$pBitStream], #1 |
| ADDCC $BitCount, $BitCount, #8 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| MEND |
| |
| ;// |
| ;// Read variable 1<=N<=8 bits from the bitstream, advancing the bitstream pointer. |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $N - number of bits to read. 1<=N<=8 |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $Symbol - the next N bits of the bitstream |
| ;// $T1 - corrupted temp/scratch register |
| ;// $T2 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_VREAD8 $Symbol, $N, $T1, $T2 |
| MOV $Symbol, $BitBuffer, LSL $BitCount |
| ADD $BitCount, $BitCount, $N |
| SUBS $BitCount, $BitCount, #8 |
| LDRCSB $T1, [$pBitStream], #1 |
| RSB $T2, $N, #32 |
| ADDCC $BitCount, $BitCount, #8 |
| MOV $Symbol, $Symbol, LSR $T2 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| MEND |
| |
| |
| ;// |
| ;// Read variable 1<=N<=16 bits from the bitstream, advancing the bitstream pointer. |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $N - number of bits to read. 1<=N<=16 |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $Symbol - the next N bits of the bitstream |
| ;// $T1 - corrupted temp/scratch register |
| ;// $T2 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_VREAD16 $Symbol, $N, $T1, $T2 |
| MOV $Symbol, $BitBuffer, LSL $BitCount |
| ADD $BitCount, $BitCount, $N |
| SUBS $BitCount, $BitCount, #8 |
| LDRCSB $T1, [$pBitStream], #1 |
| RSB $T2, $N, #32 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| SUBCSS $BitCount, $BitCount, #8 |
| LDRCSB $T1, [$pBitStream], #1 |
| ADDCC $BitCount, $BitCount, #8 |
| MOV $Symbol, $Symbol, LSR $T2 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| MEND |
| |
| |
| ;// |
| ;// Decode a code of the form 0000...001 where there |
| ;// are N zeros before the 1 and N<=15 (code length<=16) |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $Symbol - the number of zeros before the next 1 |
| ;// >=16 is an illegal code |
| ;// $T1 - corrupted temp/scratch register |
| ;// $T2 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_CLZ16 $Symbol, $T1, $T2 |
| MOVS $Symbol, $BitBuffer, LSL $BitCount |
| CLZ $Symbol, $Symbol |
| ADD $BitCount, $BitCount, $Symbol |
| SUBS $BitCount, $BitCount, #7 ;// length is Symbol+1 |
| LDRCSB $T1, [$pBitStream], #1 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| SUBCSS $BitCount, $BitCount, #8 |
| LDRCSB $T1, [$pBitStream], #1 |
| ADDCC $BitCount, $BitCount, #8 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| MEND |
| |
| ;// |
| ;// Decode a code of the form 1111...110 where there |
| ;// are N ones before the 0 and N<=15 (code length<=16) |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $Symbol - the number of zeros before the next 1 |
| ;// >=16 is an illegal code |
| ;// $T1 - corrupted temp/scratch register |
| ;// $T2 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_CLO16 $Symbol, $T1, $T2 |
| MOV $Symbol, $BitBuffer, LSL $BitCount |
| MVN $Symbol, $Symbol |
| CLZ $Symbol, $Symbol |
| ADD $BitCount, $BitCount, $Symbol |
| SUBS $BitCount, $BitCount, #7 ;// length is Symbol+1 |
| LDRCSB $T1, [$pBitStream], #1 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| SUBCSS $BitCount, $BitCount, #8 |
| LDRCSB $T1, [$pBitStream], #1 |
| ADDCC $BitCount, $BitCount, #8 |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 |
| MEND |
| |
| |
| ;// |
| ;// Variable Length Decode module |
| ;// |
| ;// Decodes one VLD Symbol from a bitstream and refill the bitstream |
| ;// buffer. |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $pVLDTable - pointer to VLD decode table of 16-bit entries. |
| ;// The format is described above at the start of |
| ;// this file. |
| ;// $S0 - The number of bits to look up for the first step |
| ;// 1<=$S0<=8 |
| ;// $S1 - The number of bits to look up for each subsequent |
| ;// step 1<=$S1<=$S0. |
| ;// |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $Symbol - decoded VLD symbol value |
| ;// $T1 - corrupted temp/scratch register |
| ;// $T2 - corrupted temp/scratch register |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_VLD $Symbol, $T1, $T2, $pVLDTable, $S0, $S1 |
| ASSERT (1<=$S0):LAND:($S0<=8) |
| ASSERT (1<=$S1):LAND:($S1<=$S0) |
| |
| ;// Note 0<=BitCount<=15 on entry and exit |
| |
| MOVS $T1, $BitBuffer, LSL $BitCount ;// left align next bits |
| MOVS $Symbol, #(2<<$S0)-2 ;// create mask |
| AND $Symbol, $Symbol, $T1, LSR #(31-$S0) ;// 2*(next $S0 bits) |
| SUBS $BitCount, $BitCount, #8 ;// CS if buffer can be filled |
| 01 |
| LDRCSB $T1, [$pBitStream], #1 ;// load refill byte |
| LDRH $Symbol, [$pVLDTable, $Symbol] ;// load table entry |
| ADDCC $BitCount, $BitCount, #8 ;// refill not possible |
| ADD $BitCount, $BitCount, #$S0 ;// assume $S0 bits used |
| ORRCS $BitBuffer, $T1, $BitBuffer, LSL #8 ;// merge in refill byte |
| MOVS $T1, $Symbol, LSR #1 ;// CS=leaf entry |
| BCS %FT02 |
| |
| MOVS $T1, $BitBuffer, LSL $BitCount ;// left align next bit |
| IF (2*$S0-$S1<=8) |
| ;// Can combine refill check and -S0+S1 and keep $BitCount<=15 |
| SUBS $BitCount, $BitCount, #8+($S0-$S1) |
| ELSE |
| ;// Separate refill check and -S0+S1 offset |
| SUBS $BitCount, $BitCount, #8 |
| SUB $BitCount, $BitCount, #($S0-$S1) |
| ENDIF |
| ADD $Symbol, $Symbol, $T1, LSR #(31-$S1) ;// add 2*(next $S1 bits) to |
| BIC $Symbol, $Symbol, #1 ;// table offset |
| B %BT01 ;// load next table entry |
| 02 |
| ;// BitCount range now depend on the route here |
| ;// if (first step) S0 <= BitCount <= 7+S0 <=15 |
| ;// else if (2*S0-S1<=8) S0 <= BitCount <= 7+(2*S0-S1) <=15 |
| ;// else S1 <= BitCount <= 7+S1 <=15 |
| |
| SUB $BitCount, $BitCount, $Symbol, LSR#13 |
| BIC $Symbol, $T1, #0xF000 |
| MEND |
| |
| |
| ;// Add an offset number of bits |
| ;// |
| ;// Outputs destination byte and bit index values which corresponds to an offset number of bits |
| ;// from the current location. This is used to compare bitstream positions using. M_BD_CMP. |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $Offset - Offset to be added in bits. |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $ByteIndex - Destination pBitStream pointer after adding the Offset. |
| ;// This value will be 4 byte ahead and needs to subtract by 4 to get exact |
| ;// pointer (as in M_BD_FINI). But for using with M_BD_CMP subtract is not needed. |
| ;// $BitIndex - Destination BitCount after the addition of Offset number of bits |
| ;// |
| MACRO |
| M_BD_ADD $ByteIndex, $BitIndex, $Offset |
| |
| ;// ($ByteIndex,$BitIndex) = Current position + $Offset bits |
| ADD $Offset, $Offset, $BitCount |
| AND $BitIndex, $Offset, #7 |
| ADD $ByteIndex, $pBitStream, $Offset, ASR #3 |
| MEND |
| |
| ;// Move bitstream pointers to the location given |
| ;// |
| ;// Outputs destination byte and bit index values which corresponds to |
| ;// the current location given (calculated using M_BD_ADD). |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// $ByteIndex - Destination pBitStream pointer after move. |
| ;// This value will be 4 byte ahead and needs to subtract by 4 to get exact |
| ;// pointer (as in M_BD_FINI). |
| ;// $BitIndex - Destination BitCount after the move |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $pBitStream \ |
| ;// } See description above. |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_MOV $ByteIndex, $BitIndex |
| |
| ;// ($pBitStream, $Offset) = ($ByteIndex,$BitIndex) |
| MOV $BitCount, $BitIndex |
| MOV $pBitStream, $ByteIndex |
| MEND |
| |
| ;// Bitstream Compare |
| ;// |
| ;// Compares bitstream position with that of a destination position. Destination position |
| ;// is held in two input registers which are calculated using M_BD_ADD macro |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $ByteIndex - Destination pBitStream pointer, (4 byte ahead as described in M_BD_ADD) |
| ;// $BitIndex - Destination BitCount |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// FLAGS - GE if destination is reached, LT = is destination is ahead |
| ;// $T1 - corrupted temp/scratch register |
| ;// |
| MACRO |
| M_BD_CMP $ByteIndex, $BitIndex, $T1 |
| |
| ;// Return flags set by (current positon)-($ByteIndex,$BitIndex) |
| ;// so GE means that we have reached the indicated position |
| |
| ADD $T1, $pBitStream, $BitCount, LSR #3 |
| CMP $T1, $ByteIndex |
| AND $T1, $BitCount, #7 |
| CMPEQ $T1, $BitIndex |
| MEND |
| |
| |
| ;// Bitstream Decode finalise |
| ;// |
| ;// Writes back the bitstream state to the bitstream pointers |
| ;// |
| ;// Input Registers: |
| ;// |
| ;// $pBitStream \ |
| ;// $BitBuffer } See description above. |
| ;// $BitCount / |
| ;// |
| ;// Output Registers: |
| ;// |
| ;// $ppBitStream - pointer to pointer to the next bitstream byte |
| ;// $pBitOffset - pointer to the number of bits used in the current byte (0..7) |
| ;// $pBitStream \ |
| ;// $BitBuffer } these register are corrupted |
| ;// $BitCount / |
| ;// |
| MACRO |
| M_BD_FINI $ppBitStream, $pBitOffset |
| |
| ;// Advance pointer by the number of free bits in the buffer |
| ADD $pBitStream, $pBitStream, $BitCount, LSR#3 |
| AND $BitCount, $BitCount, #7 |
| |
| ;// Now move back 32 bits to reach the first usued bit |
| SUB $pBitStream, $pBitStream, #4 |
| |
| ;// Store out bitstream state |
| STR $BitCount, [$pBitOffset] |
| STR $pBitStream, [$ppBitStream] |
| MEND |
| |
| END |
| |
