SharedSound_InstallHandler

SharedSound

» SWI Calls

» SharedSound_InstallHandler

SharedSound_InstallHandler

(SWI &4B440)

Use

Each handler is called when the current driver is called if the handler is an immediate handler or on call back if the handler is either a call back or process handler. The handlers in each type are called in the order in which they were installed. Process handlers are called after call back handlers.

Each handler is passed a buffer to fill with the registers set as follows:

R4, R5 and R6 are set by SharedSound to the current values as passed in from the lower level Sound Handler, thus may change between calls to the clients handler.

On exit
R3 contains flags as above, modified according to the action of the handler. The important requirement on exit is that bit 0 of R3 should be set if any data has been written into the buffer. In fact, SharedSound cannot currently cope with no data being filled, so zeros should always be written.

Helpful fill routines
On entry to the fill code, R8 points to a table in the following format:
[R8,#0]=Flags word; currently 0.
[R8,#4]=Pointer to silence fill routine.
[R8,#8]=Pointer to data fill routine.

This table may be extended in future to include more fill variants; it is anticipated that the presence/absence of these routines will be indicated by bits in the flag word.

The data fill routine is called in the following way:

The fill code will fill/mix from the given buffer to the output buffer. It will return either when the buffer is filled, or when it runs out of data.

The silence code is identical except that R4 and R5 are not used, and no data is read; the code fills/mixes zeros.

The silence/data fill code entry points understand all the currently defined flags in R3. The intention is that if future flags are added to R3 then the supplied fill routines will be extended to understand them too.
This should provide a degree of forwards compatibility.

The overall sound fill code in a client can therefore look something like this (assuming the client is filling from a cyclic buffer):

fill
	STMFD	r13!,{r0-r2,r4-r12,r14}

MOV	r12,r0

	; We are filling from play_ptr to where?

	LDR	r4,play_ptr

	LDR	r5,fill_ptr

	LDR	r9,buffer_start

	ADD	r4,r4,r9

	ADD	r5,r5,r9

	LDR	r9,accumulator

	; Are we wrapped, or unwrapped?

	CMP	r4,r5

	BEQ	out_of_data

	BLO	unwrapped

	; |*————————————-********|

	;       ^fill ptr                ^play ptr

	LDR	r5,buffer_end	; Fill from fill ptr to buffer_end

	; Call the fill code

	MOV	R14,PC

	LDR	PC,[R8,#8]

	; Did we run out of data?

	CMP	R4,R5		;

	LDRHS	R4,buffer_start	; If r4 >= r5 then we used all the

				; data in the buffer.

	CMP	R1,R2		; Did we finish the fill?

	BHS	finish		; If r1 >= r2 then we finished.

	LDR	R5,fill_ptr	; No, so we ran out of data. Jump

	CMP	R5,#0		; Check if there any data there -

	BEQ	out_of_data	; If not, play silence.

	ADD	R5,R5,R4

unwrapped

	; |——-*************************————|

	;       ^play ptr                ^fill ptr

	; Call the fill code

	MOV	R14,PC

	LDR	PC,[R8,#8]

	; Either we finished the fill, or we ran out of data.

	CMP	R1,R2		; Did we finish?

	BEQ	finish

out_of_data

	; Fill with silence

	MOV	R14,PC

	LDR	PC,[R8,#4]

finish

	LDR	r3,buffer_start

	STR	R9,accumulator

	SUB	r4,r4,r3

	STR	R4,play_ptr

	MOV	r3,r0
LDMFD	r13!,{r0-r2,r4-r12,PC}