@ Tremolo library
@-----------------------------------------------------------------------
@ Copyright (C) 2002-2009, Xiph.org Foundation
@ Copyright (C) 2010, Robin Watts for Pinknoise Productions Ltd
@ All rights reserved.
@ Redistribution and use in source and binary forms, with or without
@ modification, are permitted provided that the following conditions
@ are met:
@ * Redistributions of source code must retain the above copyright
@ notice, this list of conditions and the following disclaimer.
@ * Redistributions in binary form must reproduce the above
@ copyright notice, this list of conditions and the following disclaimer
@ in the documentation and/or other materials provided with the
@ distribution.
@ * Neither the names of the Xiph.org Foundation nor Pinknoise
@ Productions Ltd nor the names of its contributors may be used to
@ endorse or promote products derived from this software without
@ specific prior written permission.
@
@ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
@ "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
@ LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
@ A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
@ OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
@ SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
@ LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
@ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
@ ----------------------------------------------------------------------
.text
.global oggpack_look
.global oggpack_adv
.global oggpack_readinit
.global oggpack_read
oggpack_look:
@ r0 = oggpack_buffer *b
@ r1 = int bits
STMFD r13!,{r10,r11,r14}
LDMIA r0,{r2,r3,r12}
@ r2 = bitsLeftInSegment
@ r3 = ptr
@ r12= bitsLeftInWord
SUBS r2,r2,r1 @ bitsLeftinSegment -= bits
BLT look_slow @ Not enough bits in this segment for
@ this request. Do it slowly.
LDR r10,[r3] @ r10= ptr[0]
RSB r14,r12,#32 @ r14= 32-bitsLeftInWord
SUBS r12,r12,r1 @ r12= bitsLeftInWord -= bits
LDRLT r11,[r3,#4]! @ r11= ptr[1]
MOV r10,r10,LSR r14 @ r10= ptr[0]>>(32-bitsLeftInWord)
ADDLE r12,r12,#32 @ r12= bitsLeftInWord += 32
RSB r14,r14,#32 @ r14= 32-bitsLeftInWord
ORRLT r10,r10,r11,LSL r14 @ r10= Next 32 bits.
MOV r14,#1
RSB r14,r14,r14,LSL r1
AND r0,r10,r14
LDMFD r13!,{r10,r11,PC}
look_slow:
STMFD r13!,{r5,r6}
ADDS r10,r2,r1 @ r10= bitsLeftInSegment + bits (i.e.
@ the initial value of bitsLeftInSeg)
@ r10 = bitsLeftInSegment (initial)
@ r12 = bitsLeftInWord
RSB r14,r12,#32 @ r14= 32-bitsLeftInWord
MOV r5,r10 @ r5 = bitsLeftInSegment (initial)
BLT look_overrun
BEQ look_next_segment @ r10= r12 = 0, if we branch
CMP r12,r10 @ If bitsLeftInWord < bitsLeftInSeg
@ there must be more in the next word
LDR r10,[r3],#4 @ r10= ptr[0]
LDRLT r6,[r3] @ r6 = ptr[1]
MOV r11,#1
MOV r10,r10,LSR r14 @ r10= first bitsLeftInWord bits
ORRLT r10,r10,r6,LSL r12 @ r10= first bitsLeftInSeg bits+crap
RSB r11,r11,r11,LSL r5 @ r11= mask
AND r10,r10,r11 @ r10= first r5 bits
@ Load the next segments data
look_next_segment:
@ At this point, r10 contains the first r5 bits of the result
LDR r11,[r0,#12] @ r11= head = b->head
@ Stall
@ Stall
look_next_segment_2:
LDR r11,[r11,#12] @ r11= head = head->next
@ Stall
@ Stall
CMP r11,#0
BEQ look_out_of_data
LDMIA r11,{r6,r12,r14} @ r6 = buffer
@ r12= begin
@ r14= length
LDR r6,[r6] @ r6 = buffer->data
CMP r14,#0
BEQ look_next_segment_2
ADD r6,r6,r12 @ r6 = buffer->data+begin
look_slow_loop:
LDRB r12,[r6],#1 @ r12= *buffer
SUBS r14,r14,#1 @ r14= length
@ Stall
ORR r10,r10,r12,LSL r5 @ r10= first r5+8 bits
ADD r5,r5,#8
BLE look_really_slow
CMP r5,r1
BLT look_slow_loop
MOV r14,#1
RSB r14,r14,r14,LSL r1
AND r0,r10,r14
LDMFD r13!,{r5,r6,r10,r11,PC}
look_really_slow:
CMP r5,r1
BLT look_next_segment_2
MOV r14,#1
RSB r14,r14,r14,LSL r1
AND r0,r10,r14
LDMFD r13!,{r5,r6,r10,r11,PC}
look_out_of_data:
@MVN r0,#0 ; return -1
MOV r0,#0
LDMFD r13!,{r5,r6,r10,r11,PC}
look_overrun:
@ We had overrun when we started, so we need to skip -r10 bits.
LDR r11,[r0,#12] @ r11 = head = b->head
@ stall
@ stall
look_overrun_next_segment:
LDR r11,[r11,#12] @ r11 = head->next
@ stall
@ stall
CMP r11,#0
BEQ look_out_of_data
LDMIA r11,{r6,r7,r14} @ r6 = buffer
@ r7 = begin
@ r14= length
LDR r6,[r6] @ r6 = buffer->data
@ stall
@ stall
ADD r6,r6,r7 @ r6 = buffer->data+begin
MOV r14,r14,LSL #3 @ r14= length in bits
ADDS r14,r14,r10 @ r14= length in bits-bits to skip
MOVLE r10,r14
BLE look_overrun_next_segment
RSB r10,r10,#0 @ r10= bits to skip
ADD r6,r10,r10,LSR #3 @ r6 = pointer to data
MOV r10,#0
B look_slow_loop
oggpack_adv:
@ r0 = oggpack_buffer *b
@ r1 = bits
LDMIA r0,{r2,r3,r12}
@ r2 = bitsLeftInSegment
@ r3 = ptr
@ r12= bitsLeftInWord
SUBS r2,r2,r1 @ Does this run us out of bits in the
BLE adv_slow @ segment? If so, do it slowly
SUBS r12,r12,r1
ADDLE r12,r12,#32
ADDLE r3,r3,#4
STMIA r0,{r2,r3,r12}
BX LR
adv_slow:
STMFD r13!,{r10,r14}
LDR r14,[r0,#12] @ r14= head
@ stall
adv_slow_loop:
LDR r1,[r0,#20] @ r1 = count
LDR r10,[r14,#8] @ r10= head->length
LDR r14,[r14,#12] @ r14= head->next
@ stall
ADD r1,r1,r10 @ r1 = count += head->length
CMP r14,#0
BEQ adv_end
STR r1,[r0,#20] @ b->count = count
STR r14,[r0,#12] @ b->head = head
LDMIA r14,{r3,r10,r12} @ r3 = buffer
@ r10= begin
@ r12= length
LDR r3,[r3] @ r3 = buffer->data
ADD r3,r3,r10 @ r3 = Pointer to start (byte)
AND r10,r3,#3 @ r10= bytes to backtrk to word align
MOV r10,r10,LSL #3 @ r10= bits to backtrk to word align
RSB r10,r10,#32 @ r10= bits left in word
ADDS r10,r10,r2 @ r10= bits left in word after skip
ADDLE r10,r10,#32
ADDLE r3,r3,#4
BIC r3,r3,#3 @ r3 = Pointer to start (word)
ADDS r2,r2,r12,LSL #3 @ r2 = length in bits after advance
BLE adv_slow_loop
STMIA r0,{r2,r3,r10}
LDMFD r13!,{r10,PC}
adv_end:
MOV r2, #0
MOV r12,#0
STMIA r0,{r2,r3,r12}
LDMFD r13!,{r10,PC}
oggpack_readinit:
@ r0 = oggpack_buffer *b
@ r1 = oggreference *r
STR r1,[r0,#12] @ b->head = r1
STR r1,[r0,#16] @ b->tail = r1
LDMIA r1,{r2,r3,r12} @ r2 = b->head->buffer
@ r3 = b->head->begin
@ r12= b->head->length
LDR r2,[r2] @ r2 = b->head->buffer->data
MOV r1,r12,LSL #3 @ r1 = BitsInSegment
MOV r12,#0
ADD r3,r2,r3 @ r3 = r2+b->head->begin
BIC r2,r3,#3 @ r2 = b->headptr (word)
AND r3,r3,#3
MOV r3,r3,LSL #3
RSB r3,r3,#32 @ r3 = BitsInWord
STMIA r0,{r1,r2,r3}
STR r12,[r0,#20]
BX LR
oggpack_read:
@ r0 = oggpack_buffer *b
@ r1 = int bits
STMFD r13!,{r10,r11,r14}
LDMIA r0,{r2,r3,r12}
@ r2 = bitsLeftInSegment
@ r3 = ptr
@ r12= bitsLeftInWord
SUBS r2,r2,r1 @ bitsLeftinSegment -= bits
BLT read_slow @ Not enough bits in this segment for
@ this request. Do it slowly.
LDR r10,[r3] @ r10= ptr[0]
RSB r14,r12,#32 @ r14= 32-bitsLeftInWord
SUBS r12,r12,r1 @ r12= bitsLeftInWord -= bits
ADDLE r3,r3,#4
LDRLT r11,[r3] @ r11= ptr[1]
MOV r10,r10,LSR r14 @ r10= ptr[0]>>(32-bitsLeftInWord)
ADDLE r12,r12,#32 @ r12= bitsLeftInWord += 32
RSB r14,r14,#32 @ r14= 32-bitsLeftInWord
ORRLT r10,r10,r11,LSL r14 @ r10= Next 32 bits.
STMIA r0,{r2,r3,r12}
MOV r14,#1
RSB r14,r14,r14,LSL r1
AND r0,r10,r14
LDMFD r13!,{r10,r11,PC}
read_slow:
STMFD r13!,{r5,r6}
ADDS r10,r2,r1 @ r10= bitsLeftInSegment + bits (i.e.
@ the initial value of bitsLeftInSeg)
@ r10 = bitsLeftInSegment (initial)
@ r12 = bitsLeftInWord
RSB r14,r12,#32 @ r14= 32-bitsLeftInWord
MOV r5,r10 @ r5 = bitsLeftInSegment (initial)
BLT read_overrun
BEQ read_next_segment @ r10= r12 = 0, if we branch
CMP r12,r10 @ If bitsLeftInWord < bitsLeftInSeg
@ there must be more in the next word
LDR r10,[r3],#4 @ r10= ptr[0]
LDRLT r6,[r3] @ r6 = ptr[1]
MOV r11,#1
MOV r10,r10,LSR r14 @ r10= first bitsLeftInWord bits
ORRLT r10,r10,r6,LSL r12 @ r10= first bitsLeftInSeg bits+crap
RSB r11,r11,r11,LSL r5 @ r11= mask
AND r10,r10,r11 @ r10= first r5 bits
@ Load the next segments data
read_next_segment:
@ At this point, r10 contains the first r5 bits of the result
LDR r11,[r0,#12] @ r11= head = b->head
@ Stall
read_next_segment_2:
@ r11 = head
LDR r6,[r0,#20] @ r6 = count
LDR r12,[r11,#8] @ r12= length
LDR r11,[r11,#12] @ r11= head = head->next
@ Stall
ADD r6,r6,r12 @ count += length
CMP r11,#0
BEQ read_out_of_data
STR r11,[r0,#12]
STR r6,[r0,#20] @ b->count = count
LDMIA r11,{r6,r12,r14} @ r6 = buffer
@ r12= begin
@ r14= length
LDR r6,[r6] @ r6 = buffer->data
CMP r14,#0
BEQ read_next_segment_2
ADD r6,r6,r12 @ r6 = buffer->data+begin
read_slow_loop:
LDRB r12,[r6],#1 @ r12= *buffer
SUBS r14,r14,#1 @ r14= length
@ Stall
ORR r10,r10,r12,LSL r5 @ r10= first r5+8 bits
ADD r5,r5,#8
BLE read_really_slow
CMP r5,r1
BLT read_slow_loop
read_end:
MOV r12,#1
RSB r12,r12,r12,LSL r1
@ Store back the new position
@ r2 = -number of bits to go from this segment
@ r6 = ptr
@ r14= bytesLeftInSegment
@ r11= New head value
LDMIA r11,{r3,r6,r14} @ r3 = buffer
@ r6 = begin
@ r14= length
LDR r3,[r3] @ r3 = buffer->data
ADD r1,r2,r14,LSL #3 @ r1 = bitsLeftInSegment
@ stall
ADD r6,r3,r6 @ r6 = pointer
AND r3,r6,#3 @ r3 = bytes used in first word
RSB r3,r2,r3,LSL #3 @ r3 = bits used in first word
BIC r2,r6,#3 @ r2 = word ptr
RSBS r3,r3,#32 @ r3 = bitsLeftInWord
ADDLE r3,r3,#32
ADDLE r2,r2,#4
STMIA r0,{r1,r2,r3}
AND r0,r10,r12
LDMFD r13!,{r5,r6,r10,r11,PC}
read_really_slow:
CMP r5,r1
BGE read_end
LDR r14,[r11,#8] @ r14= length of segment just done
@ stall
@ stall
ADD r2,r2,r14,LSL #3 @ r2 = -bits to use from next seg
B read_next_segment_2
read_out_of_data:
@ Store back the new position
@ r2 = -number of bits to go from this segment
@ r6 = ptr
@ r14= bytesLeftInSegment
@ RJW: This may be overkill - we leave the buffer empty, with -1
@ bits left in it. We might get away with just storing the
@ bitsLeftInSegment as -1.
LDR r11,[r0,#12] @ r11=head
LDMIA r11,{r3,r6,r14} @ r3 = buffer
@ r6 = begin
@ r14= length
LDR r3,[r3] @ r3 = buffer->data
ADD r6,r3,r6 @ r6 = pointer
ADD r6,r6,r14
AND r3,r6,#3 @ r3 = bytes used in first word
MOV r3,r3,LSL #3 @ r3 = bits used in first word
BIC r2,r6,#3 @ r2 = word ptr
RSBS r3,r3,#32 @ r3 = bitsLeftInWord
MVN r1,#0 @ r1 = -1 = bitsLeftInSegment
STMIA r0,{r1,r2,r3}
@MVN r0,#0 ; return -1
MOV r0,#0
LDMFD r13!,{r5,r6,r10,r11,PC}
read_overrun:
@ We had overrun when we started, so we need to skip -r10 bits.
LDR r11,[r0,#12] @ r11 = head = b->head
@ stall
@ stall
read_overrun_next_segment:
LDR r11,[r11,#12] @ r11 = head->next
@ stall
@ stall
CMP r11,#0
BEQ read_out_of_data
LDMIA r11,{r6,r7,r14} @ r6 = buffer
@ r7 = begin
@ r14= length
LDR r6,[r6] @ r6 = buffer->data
@ stall
@ stall
ADD r6,r6,r7 @ r6 = buffer->data+begin
MOV r14,r14,LSL #3 @ r14= length in bits
ADDS r14,r14,r10 @ r14= length in bits-bits to skip
MOVLE r10,r14
BLE read_overrun_next_segment
RSB r10,r10,#0 @ r10= bits to skip
ADD r6,r10,r10,LSR #3 @ r6 = pointer to data
MOV r10,#0
B read_slow_loop
@ END