Rate of streaming data to the SPC700?

ReceiveStreamTransferLoop:         ;66 cycles per scanline. this loop must be exactly 66 bytes long while looping.
;26 cycles               ;59 cycles per scanline left for actual transfer

   movw   ya,$f4            
   push a               ;save data on stack cause that's the fastest way possible
   push y
   movw   ya,$f6
   push a
   push y
   
;waste 33 cyles:
;******************************
   mov   a,TempBuffer1         ;real snes/bsnes need a total of 33 cycles here
   mov   a,TempBuffer1
   mov   a,TempBuffer1
   mov   a,TempBuffer1
   mov   a,TempBuffer1
   mov   a,TempBuffer1
   mov   a,TempBuffer1
   mov   a,TempBuffer1
   mov   a,TempBuffer1
   mov   a,TempBuffer1
   mov   a,TempBuffer1

;7 cycles when looping back
   dbnz   TempBuffer5,ReceiveStreamTransferLoop

get_data_HDMA:
   mov A, $F4                ; 3 cycles - get byte 0 of the data shot
   mov !buf+X, A             ; 6 cycles - write it to the current buffer position
   mov A, $F5                ; 3 cycles - get byte 1
   mov !(buf+1)+X, A         ; 6 cycles - write it to the current buffer position plus one
   mov A, $F6                ; 3 cycles - get byte 2
   mov !(buf+2)+X, A         ; 6 cycles
   mov A, $F7                ; 3 cycles - get byte 3
   mov !(buf+3)+X, A         ; 6 cycles
   inc X                     ; 2 cycles - increment the current buffer position four times
   inc X                     ; 2 cycles
   inc X                     ; 2 cycles
   inc X                     ; 2 cycles
   cmp (X), (Y)              ; waste 5 cycles
   cmp (X), (Y)              ; waste 5 cycles
   cmp (X), (Y)              ; waste 5 cycles
   dbnz Y, get_data_HDMA     ; 6/4 cycles - repeat for next scanline, or exit if done
; TOTAL:  65 cycles

; FOR PAL, REPLACE 15-CYCLE TIME DELAY IN DATA PICKUP LOOP WITH:
   mov A, Y      ; 2 cycles
   and #$01      ; 2 cycles
   beq +         ; 4/2 cycles
   cmp A, (X)    ; 0/3 cycles
+  nop           ; 2 cycles
   cmp (X), (Y)  ; 5 cycles

huffman:
rep #$20
sep #$20
ldx tree
-;
lda (source)
sta byte_buffer
inc source
ldy #$0008
-;
lda $0000,x
beq found_byte
lsr byte_buffer
bcs +
inx #3
dey
bne -
bra --
+;
lda $0002,x
xba
lda $0001,x
tax
dey
bne -
bra --

found_byte:
lda $0001,x
sta (destination)
inc destination
ldx tree
dec legnth
bne -
rts

; BUFFER METADATA STRUCTURE (WIP):
; byte 0-1:  current buffer write position
; byte 2-3:  buffer start address
; byte 4-5:  buffer end address
; This data is stored in zero page.  More complex bookkeeping can be done elsewhere,
; so as not to waste space.

; HDMA STREAMING CODE:
data_incoming_HDMA:
   mov A, #data_start_HDMA      ; 2 cycles - load data start code value
-  cbne $F4, -                  ; 7 cycles - listen for the write
; TOTAL: roughly 3-9 cycles since data start code written to $2140

; Pick up transfer parameters written to $2141 and $2142:
   mov X, $F5                   ; 3 cycles - load direct-page address of buffer pointer
   mov temp, $F6                ; 5 cycles - load transfer size in scanlines
; TOTALS:  8 cycles since start code noticed in $F4, 11-17 cycles since $2140 written

; Now rewrite the pickup loop to target the current buffer position:
   mov A, (X)                   ; 3 cycles - get low byte of buffer address
   mov Y, $01+X                 ; 4 cycles - get high byte of buffer address
   mov !(get_data_HDMA+3), A    ; 5 cycles - write buffer address low byte
   mov !(get_data_HDMA+4), Y    ; 5 cycles - write buffer address high byte
   addw YA, one                 ; 5 cycles - "one" is a constant in zero page
   mov !(get_data_HDMA+8), A    ; 5 cycles
   mov !(get_data_HDMA+9), Y    ; 5 cycles
   addw YA, one                 ; 5 cycles
   mov !(get_data_HDMA+13), A   ; 5 cycles
   mov !(get_data_HDMA+14), Y   ; 5 cycles
   addw YA, one                 ; 5 cycles
   mov !(get_data_HDMA+18), A   ; 5 cycles
   mov !(get_data_HDMA+19), Y   ; 5 cycles
; TOTALS:  62 cycles since parameters loaded, 73-79 since start code written to $2140

; Set Y to the number of scanlines in the current transfer and set X to zero:
   mov Y, temp                  ; 3 cycles - pick up transfer size in scanlines
   mov temp, X                  ; 4 cycles - store buffer pointer address
   mov X, #$00                  ; 2 cycles - set X to zero
; TOTALS:  9 cycles since loop rewritten, 82-88 since start code written to $2140

; Ideally, one NTSC scanline should be almost exactly 65 cycles long.  The port reads
; are between cycles 3 and 30 past this point, putting them between ~18 cycles after
; the first HDMA write and about 13 cycles before the fourth one on the next line.
; That leaves room for about -6‰ to +9‰ worth of clock inaccuracy over 32 lines.
; Putting the buffer metadata in page one adds 4 cycles to the preceding code, which
; reduces the margin to about -4‰ on the slow side.

; STREAMING LOOP:
get_data_HDMA:
   mov A, $F4                   ; 3 cycles - get byte 0 of the data shot
   mov !buf+X, A                ; 6 cycles - write it to the current buffer position
   mov A, $F5                   ; 3 cycles - get byte 1
   mov !(buf+1)+X, A            ; 6 cycles - write it to the current buffer position plus one
   mov A, $F6                   ; 3 cycles - get byte 2
   mov !(buf+2)+X, A            ; 6 cycles
   mov A, $F7                   ; 3 cycles - get byte 3
   mov !(buf+3)+X, A            ; 6 cycles
   inc X                        ; 2 cycles - increment the current buffer position four times
   inc X                        ; 2 cycles
   inc X                        ; 2 cycles
   inc X                        ; 2 cycles
   [                                           ]
   [      INSERT TIME DELAY BLOCK HERE         ]
   [                                           ]
   dbnz Y, get_data_HDMA        ; 6/4 cycles - repeat for next scanline, or exit if done
; ITERATION TIME:  (50+delay) cycles if branch taken
; END STREAMING LOOP

; Allow dead space after this instruction, so the delay section can be hot-swapped
; without requiring uniform code size:
   jmp !data_finished_HDMA      ; 3 cycles

; Add X to the current buffer position and handle page rollover and end-of-buffer:
data_finished_HDMA:
   mov A, X                     ; 2 cycles - load the buffer address index into A
   mov X, temp                  ; 3 cycles - pick up the buffer pointer address
   clrc                         ; 2 cycles - clear carry
   adc A, (X)                   ; 3 cycles - add the index to the low byte of the buffer pointer
   mov (X), A                   ; 4 cycles - store the result back
   mov A, Y                     ; 2 cycles - Y should be zero after the main pickup loop
   adc A, $01+X                 ; 4 cycles - add zero to the high byte of the buffer pointer, with carry
   mov $01+X, A                 ; 5 cycles - store the result back
   cbne $05+X, done_HDMA        ; 8/6 cycles - check high byte against buffer end address
   mov A, (X)                   ; 0/3 cycles - pick up low byte
   cbne $04+X, done_HDMA        ; 0/8/6 cycles check low byte against buffer end address
   mov A, $02+X                 ; 0/0/4 cycles - if end of buffer reached, load buffer start address low byte
   mov (X)+, A                  ; 0/0/4 cycles - store to buffer pointer low byte and increment X
   mov A, $02+X                 ; 0/0/4 cycles - load buffer start address high byte
   mov (X), A                   ; 0/0/4 cycles - store to buffer pointer high byte
done_HDMA:

; TIME DELAY IN DATA PICKUP LOOP (proof of concept)
; very short - 14.5 cycles (APU oscillator -8.3‰ vs. NTSC nominal, or -17.6‰ vs. PAL nominal):
   mov A, Y                     ; 2 cycles
   and #$01                     ; 2 cycles - get bottom bit of scanline counter
   beq +                        ; 4/2 cycles (avg. 3)
   cmp A, (X)                   ; 0/3 cycles (avg. 1.5)
+  mov A, [$01+X]               ; 6 cycles

; short - 14.75 cycles (-4.4/-13.6):
   mov A, Y                     ; 2 cycles
   and #$03                     ; 2 cycles - get bottom two bits of scanline counter
   beq +                        ; 4/2 cycles (avg. 2.5)
   cmp A, (X)                   ; 0/3 cycles (avg. 2.25)
+  mov A, [$01+X]               ; 6 cycles

; NTSC - 15 cycles (-0.5/-9.7):
   cmp (X), (Y)                 ; 5 cycles
   cmp (X), (Y)                 ; 5 cycles
   cmp (X), (Y)                 ; 5 cycles

; intermediate - 15.25 cycles (+3.3/-5.9):
   mov A, Y                     ; 2 cycles
   and #$03                     ; 2 cycles
   bne +                        ; 4/2 cycles (avg. 3.5)
   cmp A, (X)                   ; 0/3 cycles (avg. 0.75)
+  nop                          ; 2 cycles
   cmp (X), (Y)                 ; 5 cycles

; PAL - 15.5 cycles (+7.2/-2.0):
   mov A, Y                     ; 2 cycles
   and #$01                     ; 2 cycles
   beq +                        ; 4/2 cycles (avg. 3)
   cmp A, (X)                   ; 0/3 cycles (avg. 1.5)
+  nop                          ; 2 cycles
   cmp (X), (Y)                 ; 5 cycles

; long - 15.75 cycles (+11.0/+1.8):
   mov A, Y                     ; 2 cycles
   and #$03                     ; 2 cycles
   beq +                        ; 4/2 cycles (avg. 2.5)
   cmp A, (X)                   ; 0/3 cycles (avg. 2.25)
+  nop                          ; 2 cycles
   cmp (X), (Y)                 ; 5 cycles

; very long - 16 cycles (+14.9/+5.6):
   cmp (X), (Y)                 ; 5 cycles
   cmp (X), (Y)                 ; 5 cycles
   mov A, [$01+X]               ; 6 cycles