Attachment 139 Details for Bug 173 – Source file that fails to compile

Source file that fails to compile

bpeg.s (text/plain), 46.93 KB, created by James Jones on 2020-08-30 13:09:55 CDT

(hide)

Description:

Filename:

MIME Type:

Creator: James Jones

Created: 2020-08-30 13:09:55 CDT

Size: 46.93 KB

patch

obsolete

>; TABSIZE=8 (132 COLUMNS)
>;
>;		BPEG: Brainstorm's JPEG-Like Decoder
>;
>;			 (c)1994 Brainstorm
>;
>;		     Written by Raphael Lemoine
>;
>;       RGB/CRY Output, 2x2 Subsampling, 15/16/24 Bits/Pixel
>;
>;                       Version: 17-feb-1995
>;
>;  #[ Configuration EQUates:
>
>		.68000
>		.TEXT
>
>TRUE		.equ	1
>FALSE		.equ	0
>
>CRY15		.equ	FALSE
>CRY16		.equ	FALSE
>RGB15		.equ	FALSE
>RGB16		.equ	TRUE
>RGB32		.equ	FALSE
>
> .IF !(CRY15|CRY16|RGB15|RGB16|RGB32)
>  .PRINT "No Output Format Specified."
>  .FAIL
> .ENDIF
>
> .IF (CRY15)&(CRY16|RGB15|RGB16|RGB32)
>  .PRINT "Multiple Output Format Specified."
>  .FAIL
> .ENDIF
>
> .IF (CRY16)&(CRY15|RGB15|RGB16|RGB32)
>  .PRINT "Multiple Output Format Specified."
>  .FAIL
> .ENDIF
>
> .IF (RGB15)&(CRY15|CRY16|RGB16|RGB32)
>  .PRINT "Multiple Output Format Specified."
>  .FAIL
> .ENDIF
>
> .IF (RGB16)&(CRY15|CRY16|RGB15|RGB32)
>  .PRINT "Multiple Output Format Specified."
>  .FAIL
> .ENDIF
>
> .IF (RGB32)&(CRY15|CRY16|RGB15|RGB16)
>  .PRINT "Multiple Output Format Specified."
>  .FAIL
> .ENDIF
>
> .IF CRY15
>  .PRINT "BPEG Output Format: CRY15."
> .ENDIF
>
> .IF CRY16
>  .PRINT "BPEG Output Format: CRY16."
> .ENDIF
>
> .IF RGB15
>  .PRINT "BPEG Output Format: RGB15."
> .ENDIF
>
> .IF RGB16
>  .PRINT "BPEG Output Format: RGB16."
> .ENDIF
>
> .IF RGB32
>  .PRINT "BPEG Output Format: RGB32."
> .ENDIF
>
>;  #] Configuration EQUates: 
>;  #[ Global Symbols:
>
> .GLOBL BPEGInit,BPEGDecode,BPEGStatus
>
> .IF (CRY15|CRY16)
>  .EXTERN CRYTable
> .ENDIF
>
>;  #] Global Symbols: 
>;  #[ EQUates:
>
>G_FLAGS 	.equ	$f02100
>G_END		.equ	$f0210c
>G_PC		.equ	$f02110
>G_CTRL		.equ	$f02114
>
>BPEG_RAM	.equ	$f03000			; GPU Decoder Start Address
>
>WORKING		.equ	-1
>FINISHED	.equ	0
>BADFORMAT	.equ	1
>HUFFMANERROR	.equ	2
>
>;  #] EQUates: 
>;  #[ BPEG Init:
>
>BPEGInit:
> movem.l d0/a0-a1,-(sp)
> moveq #0,d0
> move.l d0,G_FLAGS				; Set Default GPU Registers Bank
> lea GPUCode(pc),a0
> lea BPEGStartUp,a1
> move.w #((GPUEndCode-GPUCode)/4)-1,d0
>.Loop:
> move.l (a0)+,(a1)+				; Copy GPU Code in GPU RAM
> dbf d0,.Loop
> movem.l (sp)+,d0/a0-a1
> rts
>
>;  #] BPEG Init: 
>;  #[ BPEG Decode:
>;
>; IN:
>; A0 = BPEG Stream Pointer
>; A1 = Output Buffer Pointer
>; D0 = Output Buffer Width (Bytes)
>; OUT:
>; D0 = Return Code
>BPEGDecode:
> movem.l d1-d2/a0-a5,-(sp)
> cmp.l #'BPEG',(a0)+
> bne .BadFormat
> lea BPEGStartUp,a5
> move.l a1,B_OUTPointer-BPEGStartUp(a5)		; Set Output Buffer Pointer in GPU
> move.l d0,B_OUTLineSize-BPEGStartUp(a5)	; Set Output Buffer Width in GPU
> move.l #WORKING,BPEGStatus			; Set Working Flag
> lsl.l #3,d0
> moveq #0,d1
> .IF (CRY15|CRY16|RGB15|RGB16)
> moveq #$10,d2
> .ENDIF
> .IF (RGB32)
> moveq #$20,d2
> .ENDIF
> move.l d1,4+LastDCY-BPEGStartUp(a5)		; Clear LastDCY in GPU
> move.l d1,4+LastDCCb-BPEGStartUp(a5)		; Clear LastDCCb in GPU
> move.l d1,4+LastDCCr-BPEGStartUp(a5)		; Clear LastDCCr in GPU
> move.l d0,CopyPointers+52-BPEGStartUp(a5)	; Set DU3 Offset in GPU
> add.l d2,d0
> move.l d0,CopyPointers+72-BPEGStartUp(a5)	; Set DU4 Offset in GPU
> move.w (a0)+,d1
> move.l d1,B_XCounter-BPEGStartUp(a5)		; Set MCUs Image Width in GPU
> move.l d1,B_SaveXCounter-BPEGStartUp(a5)
> move.w (a0)+,d1
> move.l d1,B_YCounter-BPEGStartUp(a5)		; Set MCUs Image Height in GPU
> lea $40(a0),a1
> lea ZZQTMatrix(pc),a2
> lea ZZQTLMatrix-BPEGStartUp(a5),a3
> lea ZZQTCMatrix-BPEGStartUp(a5),a4
> moveq #$3f,d2
>.Loop:
> move.l (a2)+,d0				; Get ZigZag Value
> move.l d0,d1
> move.b (a0)+,d0				; Get Luminance Quantization Value
> move.b (a1)+,d1				; Get Chrominance Quantization Value
> swap d0
> swap d1
> move.l d0,(a3)+				; Copy Luminance Quantization Value in GPU
> move.l d1,(a4)+				; Copy Chrominance Quantization Value in GPU
> dbf d2,.Loop
> move.l a1,B_INPointer-BPEGStartUp(a5)		; Set Huffman Stream Address in GPU
> move.l #$00070007,G_END			; Set Big-Endian Order
> move.l a5,G_PC					; Set GPU PC
> neg.w d2
> move.l d2,G_CTRL				; Run GPU
> moveq #0,d0
>.End:
> movem.l (sp)+,d1-d2/a0-a5
> rts
>
>.BadFormat:
> moveq #BADFORMAT,d0
> bra.s .End
>
>;  #] BPEG Decode: 
>;  #[ MC68000 Tables:				; 2808 Bytes
>;	 #[ DC Luma Table:			; 256 Bytes
>
>	.LONG
>
>DCLTable:
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$75
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$86
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$75
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$97
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$75
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$86
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$75
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$a8
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$75
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$86
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$75
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$97
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$75
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$86
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$75
> .dc.b $02,$33,$13,$53,$02,$43,$23,$64,$02,$33,$13,$53,$02,$43,$23,$b9
>
>;	 #] DC Luma Table: 
>;	 #[ AC Luma Tree:			; 2176 Bytes
>;		#[ Level 1:
>
>ACLTree:
> .dc.l Skip2Bits,$00000001			; xx00			2	0/1
> .dc.l Skip3Bits,$00000003			; x001			3	0/3
> .dc.l Skip2Bits,$00000002			; xx10			2	0/2
> .dc.l Skip4Bits,$00010001			; 0011			4	1/1
> .dc.l Skip2Bits,$00000001			; xx00			2	0/1
> .dc.l EndOfBlock,0				; 0101			4	0/0 (EOB)
> .dc.l Skip2Bits,$00000002			; xx10			2	0/2
> .dc.l NextLevel,Level_0111			; 0111
> .dc.l Skip2Bits,$00000001			; xx00			2	0/1
> .dc.l Skip3Bits,$00000003			; x001			3	0/3
> .dc.l Skip2Bits,$00000002			; xx10			2	0/2
> .dc.l NextLevel,Level_1011			; 1011
> .dc.l Skip2Bits,$00000001			; xx00			2	0/1
> .dc.l Skip4Bits,$00000004			; 1101			4	0/4
> .dc.l Skip2Bits,$00000002			; xx10			2	0/2
> .dc.l NextLevel,Level_1111			; 1111
>
>;		#] Level 1: 
>;		#[ Level 2:
>
>Level_0111:
> .dc.l Skip1Bit,$00020001			; xxx0 0111		5	2/1
> .dc.l Skip2Bits,$00030001			; xx01 0111		6	3/1
> .dc.l Skip1Bit,$00020001			; xxx0 0111		5	2/1
> .dc.l Skip2Bits,$00040001			; xx11 0111		6	4/1
> .dc.l Skip1Bit,$00020001			; xxx0 0111		5	2/1
> .dc.l Skip2Bits,$00030001			; xx01 0111		6	3/1
> .dc.l Skip1Bit,$00020001			; xxx0 0111		5	2/1
> .dc.l Skip2Bits,$00040001			; xx11 0111		6	4/1
> .dc.l Skip1Bit,$00020001			; xxx0 0111		5	2/1
> .dc.l Skip2Bits,$00030001			; xx01 0111		6	3/1
> .dc.l Skip1Bit,$00020001			; xxx0 0111		5	2/1
> .dc.l Skip2Bits,$00040001			; xx11 0111		6	4/1
> .dc.l Skip1Bit,$00020001			; xxx0 0111		5	2/1
> .dc.l Skip2Bits,$00030001			; xx01 0111		6	3/1
> .dc.l Skip1Bit,$00020001			; xxx0 0111		5	2/1
> .dc.l Skip2Bits,$00040001			; xx11 0111		6	4/1
>
>Level_1011:
> .dc.l Skip1Bit,$00000005			; xxx0 1011		5	0/5
> .dc.l Skip1Bit,$00010002			; xxx1 1011		5	1/2
> .dc.l Skip1Bit,$00000005			; xxx0 1011		5	0/5
> .dc.l Skip1Bit,$00010002			; xxx1 1011		5	1/2
> .dc.l Skip1Bit,$00000005			; xxx0 1011		5	0/5
> .dc.l Skip1Bit,$00010002			; xxx1 1011		5	1/2
> .dc.l Skip1Bit,$00000005			; xxx0 1011		5	0/5
> .dc.l Skip1Bit,$00010002			; xxx1 1011		5	1/2
> .dc.l Skip1Bit,$00000005			; xxx0 1011		5	0/5
> .dc.l Skip1Bit,$00010002			; xxx1 1011		5	1/2
> .dc.l Skip1Bit,$00000005			; xxx0 1011		5	0/5
> .dc.l Skip1Bit,$00010002			; xxx1 1011		5	1/2
> .dc.l Skip1Bit,$00000005			; xxx0 1011		5	0/5
> .dc.l Skip1Bit,$00010002			; xxx1 1011		5	1/2
> .dc.l Skip1Bit,$00000005			; xxx0 1011		5	0/5
> .dc.l Skip1Bit,$00010002			; xxx1 1011		5	1/2
>
>Level_1111:
> .dc.l Skip3Bits,$00000006			; x000 1111		7	0/6
> .dc.l Skip4Bits,$00000007			; 0001 1111		8	0/7
> .dc.l Skip3Bits,$00050001			; x010 1111		7	5/1
> .dc.l NextLevel,Level_0011_1111 		; 0011
> .dc.l Skip3Bits,$00010003			; x100 1111		7	1/3
> .dc.l Skip4Bits,$00070001			; 0101 1111		8	7/1
> .dc.l Skip3Bits,$00060001			; x110 1111		7	6/1
> .dc.l NextLevel,Level_0111_1111 		; 0111
> .dc.l Skip3Bits,$00000006			; x000 1111		7	0/6
> .dc.l Skip4Bits,$00020002			; 1001 1111		8	2/2
> .dc.l Skip3Bits,$00050001			; x010 1111		7	5/1
> .dc.l NextLevel,Level_1011_1111 		; 1011
> .dc.l Skip3Bits,$00010003			; x100 1111		7	1/3
> .dc.l NextLevel,Level_1101_1111 		; 1101
> .dc.l Skip3Bits,$00060001			; x110 1111		7	6/1
> .dc.l NextLevel,Level_1111_1111 		; 1111
>
>;		#] Level 2: 
>;		#[ Level 3:
>
>Level_0011_1111:
> .dc.l Skip1Bit,$00080001			; xxx0 0011 1111	9	8/1
> .dc.l Skip1Bit,$00090001			; xxx1 0011 1111	9	9/1
> .dc.l Skip1Bit,$00080001			; xxx0 0011 1111	9	8/1
> .dc.l Skip1Bit,$00090001			; xxx1 0011 1111	9	9/1
> .dc.l Skip1Bit,$00080001			; xxx0 0011 1111	9	8/1
> .dc.l Skip1Bit,$00090001			; xxx1 0011 1111	9	9/1
> .dc.l Skip1Bit,$00080001			; xxx0 0011 1111	9	8/1
> .dc.l Skip1Bit,$00090001			; xxx1 0011 1111	9	9/1
> .dc.l Skip1Bit,$00080001			; xxx0 0011 1111	9	8/1
> .dc.l Skip1Bit,$00090001			; xxx1 0011 1111	9	9/1
> .dc.l Skip1Bit,$00080001			; xxx0 0011 1111	9	8/1
> .dc.l Skip1Bit,$00090001			; xxx1 0011 1111	9	9/1
> .dc.l Skip1Bit,$00080001			; xxx0 0011 1111	9	8/1
> .dc.l Skip1Bit,$00090001			; xxx1 0011 1111	9	9/1
> .dc.l Skip1Bit,$00080001			; xxx0 0011 1111	9	8/1
> .dc.l Skip1Bit,$00090001			; xxx1 0011 1111	9	9/1
>
>Level_0111_1111:
> .dc.l Skip2Bits,$00040002			; xx00 0111 1111	10	4/2
> .dc.l Skip2Bits,$000c0001			; xx01 0111 1111	10	c/1
> .dc.l Skip2Bits,$000b0001			; xx10 0111 1111	10	b/1
> .dc.l Skip3Bits,$00010005			; x011 0111 1111	11	1/5
> .dc.l Skip2Bits,$00040002			; xx00 0111 1111	10	4/2
> .dc.l Skip2Bits,$000c0001			; xx01 0111 1111	10	c/1
> .dc.l Skip2Bits,$000b0001			; xx10 0111 1111	10	b/1
> .dc.l Skip3Bits,$00050002			; x111 0111 1111	11	5/2
> .dc.l Skip2Bits,$00040002			; xx00 0111 1111	10	4/2
> .dc.l Skip2Bits,$000c0001			; xx01 0111 1111	10	c/1
> .dc.l Skip2Bits,$000b0001			; xx10 0111 1111	10	b/1
> .dc.l Skip3Bits,$00010005			; x011 0111 1111	11	1/5
> .dc.l Skip2Bits,$00040002			; xx00 0111 1111	10	4/2
> .dc.l Skip2Bits,$000c0001			; xx01 0111 1111	10	c/1
> .dc.l Skip2Bits,$000b0001			; xx10 0111 1111	10	b/1
> .dc.l Skip3Bits,$00050002			; x111 0111 1111	11	5/2
>
>Level_1011_1111:
> .dc.l Skip1Bit,$000a0001			; xxx0 1011 1111	9	a/1
> .dc.l Skip2Bits,$00000008			; xx01 1011 1111	10	0/8
> .dc.l Skip1Bit,$000a0001			; xxx0 1011 1111	9	a/1
> .dc.l Skip2Bits,$00020003			; xx11 1011 1111	10	2/3
> .dc.l Skip1Bit,$000a0001			; xxx0 1011 1111	9	a/1
> .dc.l Skip2Bits,$00000008			; xx01 1011 1111	10	0/8
> .dc.l Skip1Bit,$000a0001			; xxx0 1011 1111	9	a/1
> .dc.l Skip2Bits,$00020003			; xx11 1011 1111	10	2/3
> .dc.l Skip1Bit,$000a0001			; xxx0 1011 1111	9	a/1
> .dc.l Skip2Bits,$00000008			; xx01 1011 1111	10	0/8
> .dc.l Skip1Bit,$000a0001			; xxx0 1011 1111	9	a/1
> .dc.l Skip2Bits,$00020003			; xx11 1011 1111	10	2/3
> .dc.l Skip1Bit,$000a0001			; xxx0 1011 1111	9	a/1
> .dc.l Skip2Bits,$00000008			; xx01 1011 1111	10	0/8
> .dc.l Skip1Bit,$000a0001			; xxx0 1011 1111	9	a/1
> .dc.l Skip2Bits,$00020003			; xx11 1011 1111	10	2/3
>
>Level_1101_1111:
> .dc.l Skip1Bit,$00010004			; xxx0 1101 1111	9	1/4
> .dc.l Skip1Bit,$00030002			; xxx1 1101 1111	9	3/2
> .dc.l Skip1Bit,$00010004			; xxx0 1101 1111	9	1/4
> .dc.l Skip1Bit,$00030002			; xxx1 1101 1111	9	3/2
> .dc.l Skip1Bit,$00010004			; xxx0 1101 1111	9	1/4
> .dc.l Skip1Bit,$00030002			; xxx1 1101 1111	9	3/2
> .dc.l Skip1Bit,$00010004			; xxx0 1101 1111	9	1/4
> .dc.l Skip1Bit,$00030002			; xxx1 1101 1111	9	3/2
> .dc.l Skip1Bit,$00010004			; xxx0 1101 1111	9	1/4
> .dc.l Skip1Bit,$00030002			; xxx1 1101 1111	9	3/2
> .dc.l Skip1Bit,$00010004			; xxx0 1101 1111	9	1/4
> .dc.l Skip1Bit,$00030002			; xxx1 1101 1111	9	3/2
> .dc.l Skip1Bit,$00010004			; xxx0 1101 1111	9	1/4
> .dc.l Skip1Bit,$00030002			; xxx1 1101 1111	9	3/2
> .dc.l Skip1Bit,$00010004			; xxx0 1101 1111	9	1/4
> .dc.l Skip1Bit,$00030002			; xxx1 1101 1111	9	3/2
>
>Level_1111_1111:
> .dc.l Skip3Bits,$000d0001			; x000 1111 1111	11	d/1
> .dc.l NextLevel,Level_0001_1111_1111		; 0001
> .dc.l Skip4Bits,$00020004			; 0010 1111 1111	12	2/4
> .dc.l NextLevel,Level_0011_1111_1111		; 0011
> .dc.l ZeroRunLength,$00000040			; x100 1111 1111	11	f/0 (ZRL)
> .dc.l NextLevel,Level_0101_1111_1111		; 0101
> .dc.l Skip4Bits,$00060002			; 0110 1111 1111	12	6/2
> .dc.l NextLevel,Level_0111_1111_1111		; 0111
> .dc.l Skip3Bits,$000d0001			; x000 1111 1111	11	d/1
> .dc.l NextLevel,Level_1001_1111_1111		; 1001
> .dc.l Skip4Bits,$00030003			; 1010 1111 1111	12	3/3
> .dc.l NextLevel,Level_1011_1111_1111		; 1011
> .dc.l ZeroRunLength,$00000040			; x100 1111 1111	11	f/0 (ZRL)
> .dc.l NextLevel,Level_1101_1111_1111		; 1101
> .dc.l Skip4Bits,$00070002			; 1110 1111 1111	12	7/2
> .dc.l NextLevel,Level_1111_1111_1111		; 1111
>
>;		#] Level 3: 
>;		#[ Level 4:
>
>Level_0001_1111_1111:
> .dc.l Skip3Bits,$00080002			; x000 0001 1111 1111	15	8/2
> .dc.l Skip4Bits,$0001000a			; 0001 0001 1111 1111	16	1/a
> .dc.l Skip4Bits,$00010006			; 0010 0001 1111 1111	16	1/6
> .dc.l Skip4Bits,$00020008			; 0011 0001 1111 1111	16	2/8
> .dc.l Skip4Bits,$00000009			; 0100 0001 1111 1111	16	0/9
> .dc.l Skip4Bits,$00020006			; 0101 0001 1111 1111	16	2/6
> .dc.l Skip4Bits,$00010008			; 0110 0001 1111 1111	16	1/8
> .dc.l Skip4Bits,$0002000a			; 0111 0001 1111 1111	16	2/a
> .dc.l Skip3Bits,$00080002			; x000 0001 1111 1111	15	8/2
> .dc.l Skip4Bits,$00020005			; 1001 0001 1111 1111	16	2/5
> .dc.l Skip4Bits,$00010007			; 1010 0001 1111 1111	16	1/7
> .dc.l Skip4Bits,$00020009			; 1011 0001 1111 1111	16	2/9
> .dc.l Skip4Bits,$0000000a			; 1100 0001 1111 1111	16	0/a
> .dc.l Skip4Bits,$00020007			; 1101 0001 1111 1111	16	2/7
> .dc.l Skip4Bits,$00010009			; 1110 0001 1111 1111	16	1/9
> .dc.l Skip4Bits,$00030004			; 1111 0001 1111 1111	16	3/4
>
>Level_0011_1111_1111:
> .dc.l Skip4Bits,$00090004			; 0000 0011 1111 1111	16	9/4
> .dc.l Skip4Bits,$000a0003			; 0001 0011 1111 1111	16	a/3
> .dc.l Skip4Bits,$00090008			; 0010 0011 1111 1111	16	9/8
> .dc.l Skip4Bits,$000a0007			; 0011 0011 1111 1111	16	a/7
> .dc.l Skip4Bits,$00090006			; 0100 0011 1111 1111	16	9/6
> .dc.l Skip4Bits,$000a0005			; 0101 0011 1111 1111	16	a/5
> .dc.l Skip4Bits,$0009000a			; 0110 0011 1111 1111	16	9/a
> .dc.l Skip4Bits,$000a0009			; 0111 0011 1111 1111	16	a/9
> .dc.l Skip4Bits,$00090005			; 1000 0011 1111 1111	16	9/5
> .dc.l Skip4Bits,$000a0004			; 1001 0011 1111 1111	16	a/4
> .dc.l Skip4Bits,$00090009			; 1010 0011 1111 1111	16	9/9
> .dc.l Skip4Bits,$000a0008			; 1011 0011 1111 1111	16	a/8
> .dc.l Skip4Bits,$00090007			; 1100 0011 1111 1111	16	9/7
> .dc.l Skip4Bits,$000a0006			; 1101 0011 1111 1111	16	a/6
> .dc.l Skip4Bits,$000a0002			; 1110 0011 1111 1111	16	a/2
> .dc.l Skip4Bits,$000a000a			; 1111 0011 1111 1111	16	a/a
>
>Level_0101_1111_1111:
> .dc.l Skip4Bits,$00050005			; 0000 0101 1111 1111	16	5/5
> .dc.l Skip4Bits,$00060005			; 0001 0101 1111 1111	16	6/5
> .dc.l Skip4Bits,$00050009			; 0010 0101 1111 1111	16	5/9
> .dc.l Skip4Bits,$00060009			; 0011 0101 1111 1111	16	6/9
> .dc.l Skip4Bits,$00050007			; 0100 0101 1111 1111	16	5/7
> .dc.l Skip4Bits,$00060007			; 0101 0101 1111 1111	16	6/7
> .dc.l Skip4Bits,$00060003			; 0110 0101 1111 1111	16	6/3
> .dc.l Skip4Bits,$00070003			; 0111 0101 1111 1111	16	7/3
> .dc.l Skip4Bits,$00050006			; 1000 0101 1111 1111	16	5/6
> .dc.l Skip4Bits,$00060006			; 1001 0101 1111 1111	16	6/6
> .dc.l Skip4Bits,$0005000a			; 1010 0101 1111 1111	16	5/a
> .dc.l Skip4Bits,$0006000a			; 1011 0101 1111 1111	16	6/a
> .dc.l Skip4Bits,$00050008			; 1100 0101 1111 1111	16	5/8
> .dc.l Skip4Bits,$00060008			; 1101 0101 1111 1111	16	6/8
> .dc.l Skip4Bits,$00060004			; 1110 0101 1111 1111	16	6/4
> .dc.l Skip4Bits,$00070004			; 1111 0101 1111 1111	16	7/4
>
>Level_0111_1111_1111:
> .dc.l Skip4Bits,$000c0009			; 0000 0111 1111 1111	16	c/9
> .dc.l Skip4Bits,$000d0008			; 0001 0111 1111 1111	16	d/8
> .dc.l Skip4Bits,$000d0004			; 0010 0111 1111 1111	16	d/4
> .dc.l Skip4Bits,$000e0002			; 0011 0111 1111 1111	16	e/2
> .dc.l Skip4Bits,$000d0002			; 0100 0111 1111 1111	16	d/2
> .dc.l Skip4Bits,$000d000a			; 0101 0111 1111 1111	16	d/a
> .dc.l Skip4Bits,$000d0006			; 0110 0111 1111 1111	16	d/6
> .dc.l Skip4Bits,$000e0004			; 0111 0111 1111 1111	16	e/4
> .dc.l Skip4Bits,$000c000a			; 1000 0111 1111 1111	16	c/a
> .dc.l Skip4Bits,$000d0009			; 1001 0111 1111 1111	16	d/9
> .dc.l Skip4Bits,$000d0005			; 1010 0111 1111 1111	16	d/5
> .dc.l Skip4Bits,$000e0003			; 1011 0111 1111 1111	16	e/3
> .dc.l Skip4Bits,$000d0003			; 1100 0111 1111 1111	16	d/3
> .dc.l Skip4Bits,$000e0001			; 1101 0111 1111 1111	16	e/1
> .dc.l Skip4Bits,$000d0007			; 1110 0111 1111 1111	16	d/7
> .dc.l Skip4Bits,$000e0005			; 1111 0111 1111 1111	16	e/5
>
>Level_1001_1111_1111:
> .dc.l Skip4Bits,$00030005			; 0000 1001 1111 1111	16	3/5
> .dc.l Skip4Bits,$00040005			; 0001 1001 1111 1111	16	4/5
> .dc.l Skip4Bits,$00030009			; 0010 1001 1111 1111	16	3/9
> .dc.l Skip4Bits,$00040009			; 0011 1001 1111 1111	16	4/9
> .dc.l Skip4Bits,$00030007			; 0100 1001 1111 1111	16	3/7
> .dc.l Skip4Bits,$00040007			; 0101 1001 1111 1111	16	4/7
> .dc.l Skip4Bits,$00040003			; 0110 1001 1111 1111	16	4/3
> .dc.l Skip4Bits,$00050003			; 0111 1001 1111 1111	16	5/3
> .dc.l Skip4Bits,$00030006			; 1000 1001 1111 1111	16	3/6
> .dc.l Skip4Bits,$00040006			; 1001 1001 1111 1111	16	4/6
> .dc.l Skip4Bits,$0003000a			; 1010 1001 1111 1111	16	3/a
> .dc.l Skip4Bits,$0004000a			; 1011 1001 1111 1111	16	4/a
> .dc.l Skip4Bits,$00030008			; 1100 1001 1111 1111	16	3/8
> .dc.l Skip4Bits,$00040008			; 1101 1001 1111 1111	16	4/8
> .dc.l Skip4Bits,$00040004			; 1110 1001 1111 1111	16	4/4
> .dc.l Skip4Bits,$00050004			; 1111 1001 1111 1111	16	5/4
>
>Level_1011_1111_1111:
> .dc.l Skip4Bits,$000b0002			; 0000 1011 1111 1111	16	b/2
> .dc.l Skip4Bits,$000b000a			; 0001 1011 1111 1111	16	b/a
> .dc.l Skip4Bits,$000b0006			; 0010 1011 1111 1111	16	b/6
> .dc.l Skip4Bits,$000c0005			; 0011 1011 1111 1111	16	c/5
> .dc.l Skip4Bits,$000b0004			; 0100 1011 1111 1111	16	b/4
> .dc.l Skip4Bits,$000c0003			; 0101 1011 1111 1111	16	c/3
> .dc.l Skip4Bits,$000b0008			; 0110 1011 1111 1111	16	b/8
> .dc.l Skip4Bits,$000c0007			; 0111 1011 1111 1111	16	c/7
> .dc.l Skip4Bits,$000b0003			; 1000 1011 1111 1111	16	b/3
> .dc.l Skip4Bits,$000c0002			; 1001 1011 1111 1111	16	c/2
> .dc.l Skip4Bits,$000b0007			; 1010 1011 1111 1111	16	b/7
> .dc.l Skip4Bits,$000c0006			; 1011 1011 1111 1111	16	c/6
> .dc.l Skip4Bits,$000b0005			; 1100 1011 1111 1111	16	b/5
> .dc.l Skip4Bits,$000c0004			; 1101 1011 1111 1111	16	c/4
> .dc.l Skip4Bits,$000b0009			; 1110 1011 1111 1111	16	b/9
> .dc.l Skip4Bits,$000c0008			; 1111 1011 1111 1111	16	c/8
>
>Level_1101_1111_1111:
> .dc.l Skip4Bits,$00070005			; 0000 1101 1111 1111	16	7/5
> .dc.l Skip4Bits,$00080005			; 0001 1101 1111 1111	16	8/5
> .dc.l Skip4Bits,$00070009			; 0010 1101 1111 1111	16	7/9
> .dc.l Skip4Bits,$00080009			; 0011 1101 1111 1111	16	8/9
> .dc.l Skip4Bits,$00070007			; 0100 1101 1111 1111	16	7/7
> .dc.l Skip4Bits,$00080007			; 0101 1101 1111 1111	16	8/7
> .dc.l Skip4Bits,$00080003			; 0110 1101 1111 1111	16	8/3
> .dc.l Skip4Bits,$00090002			; 0111 1101 1111 1111	16	9/2
> .dc.l Skip4Bits,$00070006			; 1000 1101 1111 1111	16	7/6
> .dc.l Skip4Bits,$00080006			; 1001 1101 1111 1111	16	8/6
> .dc.l Skip4Bits,$0007000a			; 1010 1101 1111 1111	16	7/a
> .dc.l Skip4Bits,$0008000a			; 1011 1101 1111 1111	16	8/a
> .dc.l Skip4Bits,$00070008			; 1100 1101 1111 1111	16	7/8
> .dc.l Skip4Bits,$00080008			; 1101 1101 1111 1111	16	8/8
> .dc.l Skip4Bits,$00080004			; 1110 1101 1111 1111	16	8/4
> .dc.l Skip4Bits,$00090003			; 1111 1101 1111 1111	16	9/3
>
>Level_1111_1111_1111:
> .dc.l Skip4Bits,$000e0006			; 0000 1111 1111 1111	16	e/6
> .dc.l Skip4Bits,$000f0004			; 0001 1111 1111 1111	16	f/4
> .dc.l Skip4Bits,$000e000a			; 0010 1111 1111 1111	16	e/a
> .dc.l Skip4Bits,$000f0008			; 0011 1111 1111 1111	16	f/8
> .dc.l Skip4Bits,$000e0008			; 0100 1111 1111 1111	16	e/8
> .dc.l Skip4Bits,$000f0006			; 0101 1111 1111 1111	16	f/6
> .dc.l Skip4Bits,$000f0002			; 0110 1111 1111 1111	16	f/2
> .dc.l Skip4Bits,$000f000a			; 0111 1111 1111 1111	16	f/a
> .dc.l Skip4Bits,$000e0007			; 1000 1111 1111 1111	16	e/7
> .dc.l Skip4Bits,$000f0005			; 1001 1111 1111 1111	16	f/5
> .dc.l Skip4Bits,$000f0001			; 1010 1111 1111 1111	16	f/1
> .dc.l Skip4Bits,$000f0009			; 1011 1111 1111 1111	16	f/9
> .dc.l Skip4Bits,$000e0009			; 1100 1111 1111 1111	16	e/9
> .dc.l Skip4Bits,$000f0007			; 1101 1111 1111 1111	16	f/7
> .dc.l Skip4Bits,$000f0003			; 1110 1111 1111 1111	16	f/3
> .dc.l HuffmanError,0				; 1111 1111 1111 1111	16	(Error)
>
>;		#] Level 4: 
>;	 #] AC Luma Tree: 
>;	 #[ ZigZag & Quantization Matrix:	; 256 Bytes
>
>ZZQTMatrix:
> .dc.l $00010000,$00030400,$00052000,$00114000
> .dc.l $00092400,$00010800,$00030c00,$00052800
> .dc.l $00214400,$00416000,$01018000,$00816400
> .dc.l $00114800,$00092c00,$00011000,$00031400
> .dc.l $00053000,$00214c00,$00416800,$02018400
> .dc.l $0401a000,$1001c000,$0801a400,$01018800
> .dc.l $00816c00,$00115000,$00093400,$00011800
> .dc.l $00031c00,$00053800,$00215400,$00417000
> .dc.l $02018c00,$0401a800,$2001c400,$4001e000
> .dc.l $8001e400,$1001c800,$0801ac00,$01019000
> .dc.l $00817400,$00115800,$00093c00,$00215c00
> .dc.l $00417800,$02019400,$0401b000,$2001cc00
> .dc.l $4001e800,$8001ec00,$1001d000,$0801b400
> .dc.l $01019800,$00817c00,$02019c00,$0401b800
> .dc.l $2001d400,$4001f000,$8001f400,$1001d800
> .dc.l $0801bc00,$2001dc00,$4001f800,$8001fc00
>
>;	 #] ZigZag & Quantization Matrix: 
>;	 #[ Bank 0 Table:			; 52 bytes
>
>Bank0Table:
> .dc.l ACCoefLoop
> .dc.l Fetch32Bits
> .dc.l DCLTable
> .dc.l DataMaskTable-4				; First Coef. Unused
> .dc.l StoreDC
> .dc.l ACLTree
> .dc.l FastDCT
> .dc.l ConvertLoop
> .dc.l 359
> .dc.l -88
> .dc.l -183
> .dc.l 454
> .dc.l 255
>
>;	 #] Bank 0 Table: 
>;	 #[ Bank 1 Table:			; 68 Bytes
>
>Bank1Table:
> .dc.l DCTLoop
> .dc.l MCUTmpBuffer
> .dc.l EndDCTPass
> .dc.l DUEndLoop
> .dc.l DCTPointers
> .dc.l NormTable+24
> .dc.l MCUPointers
> .dc.l 23170
> .dc.l 12540
> .dc.l 30274
> .dc.l 8035
> .dc.l 1598
> .dc.l 4551
> .dc.l 6811
> .dc.l 128
> .dc.l 4096
> .dc.l $ff7f
>
>;	 #] Bank 1 Table: 
>;  #] MC68000 Tables: 
>;  #[ GPU Declarations:
>
>		.LONG
>GPUCode:
>		.GPU
>
>;
>; Huffman & Color Space Conversion Stuff (Bank0)
>;
>;			r0: Temporary Register
>_CurrentBits	.equr	r1,0
>;			r2: Temporary Register
>;			r3: Temporary Register
>_Prefetch0	.equr	r4,0
>_Prefetch1	.equr	r5,0
>_BitsCounter	.equr	r6,0
>_BitsMissing	.equr	r7,0
>_StreamPtr	.equr	r8,0
>_ZZQTMatrix	.equr	r9,0
>_MCUBuffer	.equr	r10,0
>_DCLTable	.equr	r11,0			; MC68000 Table Pointer (Unchanged)
>_DataMaskTable	.equr	r12,0			; GPU Table pointer (Unchanged)
>_StoreDC	.equr	r13,0			; Routine Pointer (Unchanged)
>;			r14: Temporary Register
>;			r15: Temporary Register
>_Fetch32Bits	.equr	r16,0			; Routine Pointer (Unchanged)
>_ACCoefLoop	.equr	r17,0			; Routine Pointer (Unchanged)
>_DULoopTable	.equr	r18,0
>_0xff		.equr	r19,0			; Huffman Constant (Unchanged)
>_ACLTree	.equr	r20,0			; MC68000 Table Pointer (Unchanged)
>_DCTMask	.equr	r21,0
>_FastDCT	.equr	r22,0			; Routine Pointer (Unchanged)
>_SP		.equr	r23,0
>_OUTLineSize	.equr	r24,0			; Output Buffer Line Size (Unchanged)
>;			r25: Temporary Register
>_ConvertLoop	.equr	r26,0			; Routine Pointer (Unchanged)
>_RedCoef1	.equr	r27,0			; Color Conversion Constant (Unchanged)
>_GreenCoef1	.equr	r28,0			; Color Conversion Constant (Unchanged)
>_GreenCoef2	.equr	r29,0			; Color Conversion Constant (Unchanged)
>_BlueCoef1	.equr	r30,0			; Color Conversion Constant (Unchanged)
>
>;
>; Inverse DCT Stuff (Bank1)
>;
>;			r0: Temporary Register
>;			r1: Temporary Register
>;			r2: Temporary Register
>;			r3: Temporary Register
>;			r4: Temporary Register
>;			r5: Temporary Register
>;			r6: Temporary Register
>;			r7: Temporary Register
>;			r8: Temporary Register
>;			r9: Temporary Register
>_DCTLoopCounter .equr	r10,1			; Constant (Changed & Restored)
>_NormConstant	.equr	r11,1
>_MCUPointers	.equr	r12,1			; Table Pointer (Unchanged)
>_cos1_4 	.equr	r13,1			; Inv. DCT Constant (Unchanged)
>_SrcPointer	.equr	r14,1
>_DstPointer	.equr	r15,1
>_sin1_8 	.equr	r16,1			; Inv. DCT Constant (Unchanged)
>_cos1_8 	.equr	r17,1			; Inv. DCT Constant (Unchanged)
>_cos1_16	.equr	r18,1			; Inv. DCT Constant (Unchanged)
>_sin1_16	.equr	r19,1			; Inv. DCT Constant (Unchanged)
>_cos5_16	.equr	r20,1			; Inv. DCT Constant (Unchanged)
>_sin5_16	.equr	r21,1			; Inv. DCT Constant (Unchanged)
>_0x1000 	.equr	r22,1			; Inv. DCT Constant (Unchanged)
>_DCTSwitch	.equr	r23,1
>_0x80		.equr	r24,1			; Inv. DCT Constant (Unchanged)
>_DCTLoop	.equr	r25,1			; Routine Pointer (Unchanged)
>_DCTTmpBuffer	.equr	r26,1			; Buffer Pointer (Unchanged)
>_EndDCTPass	.equr	r27,1			; Routine Pointer (Unchanged)
>_DUEndLoop	.equr	r28,1			; Routine Pointer (Unchanged)
>_NormTable	.equr	r29,1
>_DCTPointers	.equr	r30,1			; Table Pointer (Unchanged)
>
>;
>; Common Stuff (Bank0 & Bank1)
>;
>_G_Flags	.equr	r31
>
>		.ORG	BPEG_RAM		; BPEG GPU Code
>		.NOJPAD 			; Real programmers don't use Padding:-)
>		.REGBANK0			; Start GPU Code in Bank0
>
>;  #] GPU Declarations: 
>;  #[ GPU Start Up:
>
>BPEGStartUp:	movei	#G_FLAGS,_G_Flags
>		moveta	_G_Flags,_G_Flags
>		movei	#Bank0Table,r14
>		load	(r14),_ACCoefLoop
>		load	(r14+1),_Fetch32Bits
>		load	(r14+2),_DCLTable
>		load	(r14+3),_DataMaskTable
>		load	(r14+4),_StoreDC
>		load	(r14+5),_ACLTree
>		load	(r14+6),_FastDCT
>		load	(r14+7),_ConvertLoop
>		load	(r14+8),_RedCoef1
>		load	(r14+9),_GreenCoef1
>		load	(r14+10),_GreenCoef2
>		load	(r14+11),_BlueCoef1
>		load	(r14+12),_0xff
>		movei	#B_OUTLineSize,r0
>		moveq	#0,_BitsCounter
>		load	(r0),_OUTLineSize
>		movei	#B_INPointer,r0
>		moveq	#0,_BitsMissing
>		load	(r0),_StreamPtr
>		load	(_StreamPtr),_Prefetch1
>		addqt	#4,_StreamPtr
>		load	(_G_Flags),r0
>		bset	#$e,r0
>		store	r0,(_G_Flags)
>		.REGBANK1
>		nop
>		nop
>		movei	#Bank1Table,r14
>		load	(r14),_DCTLoop
>		load	(r14+1),_DCTTmpBuffer
>		load	(r14+2),_EndDCTPass
>		load	(r14+3),_DUEndLoop
>		load	(r14+4),_DCTPointers
>		load	(r14+5),_NormTable
>		load	(r14+6),_MCUPointers
>		load	(r14+7),_cos1_4
>		load	(r14+8),_sin1_8
>		load	(r14+9),_cos1_8
>		load	(r14+10),_cos1_16
>		load	(r14+11),_sin1_16
>		load	(r14+12),_cos5_16
>		load	(r14+13),_sin5_16
>		load	(r14+14),_0x80
>		load	(r14+15),_0x1000
>		load	(r14+16),_DCTLoopCounter
>		load	(_G_Flags),r0
>		bclr	#$e,r0
>		store	r0,(_G_Flags)
>		.REGBANK0
>		nop
>		nop
>
>;  #] GPU Start Up: 
>;  #[ Fill MCU Buffer:
>
>FillMCUBuffer:	moveq	#0,r0
>		movefa	_MCUPointers,_DULoopTable
>		moveq	#$10,r3
>		load	(_DULoopTable),r2
>		shlq	#2,r3			; $40
>		move	r2,_MCUBuffer
>		movefa	_NormTable,r14
>		addqt	#4,_DULoopTable
>		subqt	#24,r14
>.Loop:		store	r0,(r2)
>		addqt	#4,r2
>		store	r0,(r2)
>		addqt	#4,r2
>		store	r0,(r2)
>		addqt	#4,r2
>		store	r0,(r2)
>		addqt	#4,r2
>		store	r0,(r2)
>		addqt	#4,r2
>		subq	#1,r3
>		store	r0,(r2)
>		jr	NE,.Loop
>		addqt	#4,r2
>		moveta	r14,_NormTable
>
>;  #] Fill MCU Buffer: 
>;  #[ Decode DUs (Huffman, Inv. DCT):
>;	 #[ Decode DU:
>
>DULoop:		cmpq	#8,_BitsCounter
>		move	_0xff,r14
>		jr	PL,DCHeader
>		moveq	#0,_DCTMask
>		move	PC,_SP
>		jump	(_Fetch32Bits)
>		sub	_BitsCounter,_BitsMissing
>DCHeader:	and	_CurrentBits,r14	; Get 8 Bits
>		load	(_DULoopTable),r15	; Get Last DC Pointer
>		add	_DCLTable,r14
>		loadb	(r14),r3		; Get Datas Size | Header Size
>		moveq	#$f,r14
>		addqt	#4,_DULoopTable
>		and	r3,r14			; Get Header Size
>		load	(r15),_ZZQTMatrix
>		sub	r14,_BitsCounter 	; Substract Header Size
>		shrq	#4,r3			; Get Datas Size
>		addqt	#4,r15
>		jump	EQ,(_StoreDC)		; Test Datas Size (If Jump, R3 Null)
>		sh	r14,_CurrentBits 	; Remove Header Bits
>		cmp	r3,_BitsCounter
>		move	r3,r2			; Copy Datas Size
>		jr	PL,DCDatas		; Test Datas Size &
>		shlq	#2,r2
>		move	PC,_SP
>		jump	(_Fetch32Bits)
>		sub	_BitsCounter,_BitsMissing
>DCDatas:	add	_DataMaskTable,r2
>		sub	r3,_BitsCounter		; Substract Datas Size
>		load	(r2),r14
>		move	_CurrentBits,r0
>		move	r14,r2
>		and	r14,r0			; Mask Datas Bits
>		shrq	#1,r2
>		sh	r3,_CurrentBits		; Remove Datas Bits
>		sub	r0,r2			; Get Datas Sign
>		load	(_ZZQTMatrix),r3	; Get Quantization Value
>		jr	MI,PosDC		; Test Datas Sign &
>		shrq	#16,r3
>		sub	r14,r0			; Convert Negative Datas
>PosDC:		imult	r0,r3			; DC*QT[0]
>StoreDC:	load	(r15),r2		; Get Last DC Coef.
>		addqt	#4,_ZZQTMatrix		; Increment ZigZag & Quantization Table Pointer
>		add	r3,r2			; Add to Last DC Coef.
>		store	r2,(_MCUBuffer) 	; Store DC Coef.
>		store	r2,(r15)		; And Last DC Value
>ACCoefLoop:	cmpq	#4,_BitsCounter 	; Test if Enough Bits Available
>		move	_ACLTree,r2		; Get Luma AC Tree Pointer
>ACNibbleLoop:	jr	PL,ScanACTree
>		moveq	#$f,r14
>		move	PC,_SP
>		jump	(_Fetch32Bits)
>		sub	_BitsCounter,_BitsMissing
>ScanACTree:	and	_CurrentBits,r14	; Get 4 Bits
>		shlq	#3,r14			; * 8
>		add	r2,r14
>		load	(r14),r0		; Get AC Manager Address
>		addqt	#4,r14
>		jump	(r0)			; Jump to Next AC Manager &
>		load	(r14),r2		; Get Run/Size Values / New Tree Address
>NextLevel:	shrq	#4,_CurrentBits
>		cmpq	#8,_BitsCounter
>		jr	ACNibbleLoop
>		subqt	#4,_BitsCounter
>ZeroRunLength:	shrq	#3,_CurrentBits
>		subqt	#3,_BitsCounter
>		jump	(_ACCoefLoop)
>		add	r2,_ZZQTMatrix
>Skip4Bits:	subqt	#4,_BitsCounter
>		jr	HandleACCoef
>		shrq	#4,_CurrentBits
>Skip3Bits:	subqt	#3,_BitsCounter
>		jr	HandleACCoef
>		shrq	#3,_CurrentBits
>Skip2Bits:	subqt	#2,_BitsCounter
>		jr	HandleACCoef
>		shrq	#2,_CurrentBits
>Skip1Bit:	subqt	#1,_BitsCounter
>		shrq	#1,_CurrentBits
>HandleACCoef:	move	_0xff,r14
>		and	r2,r14
>		shrq	#14,r2
>		cmp	r14,_BitsCounter
>		move	r14,r3
>		jr	PL,ACDatas
>		shlq	#2,r14
>		move	PC,_SP
>		jump	(_Fetch32Bits)
>		sub	_BitsCounter,_BitsMissing
>ACDatas:	add	_DataMaskTable,r14
>		add	r2,_ZZQTMatrix
>		load	(r14),r14		; Get Datas Mask
>		move	_CurrentBits,r0
>		move	r14,r2
>		sub	r3,_BitsCounter
>		shrq	#1,r2			; Get Sign Mask
>		and	r14,r0
>		sh	r3,_CurrentBits		; Remove Datas Bits
>		sub	r0,r2			; Get Datas Sign
>		load	(_ZZQTMatrix),r15	; Get Quantization Value
>		jr	MI,PosAC		; Test Datas Sign &
>		move	_0xff,r3
>		sub	r14,r0			; Convert Negative Datas
>PosAC:		or	r15,_DCTMask		; Add AC Coef. to DCT Mask
>		shrq	#16,r15
>		addqt	#4,_ZZQTMatrix		; Increment ZigZag & Quantization Matrix
>		and	r15,r3
>		shrq	#8,r15	 		; Get ZigZag position
>		imult	r3,r0
>		add	_MCUBuffer,r15
>		jump	(_ACCoefLoop) 		; Loop &
>		store	r0,(r15)		; Store AC Coef.
>
>EndOfBlock:	load	(_G_Flags),r0
>		shrq	#4,_CurrentBits		; Remove EOB Code
>		bset	#$e,r0
>		shlq	#16,_DCTMask
>		subqt	#4,_BitsCounter		; Substract EOB Size
>		jump	EQ,(_FastDCT)
>		store	r0,(_G_Flags)
>		.REGBANK1
>
>;	 #] Decode DU: 
>;	 #[ Inverse DCT DU:
>;		#[ DCT StartUp:
>
>InvDCTDU:	nop
>		nop
>		movefa	_DCTMask,_DCTSwitch
>		moveq	#8,_NormConstant
>		shrq	#14,_DCTSwitch
>		shlq	#12,_NormConstant	; $8000 (1st Pass Rounding Constant)
>		movefa	_MCUBuffer,_SrcPointer
>		move	_DCTTmpBuffer,_DstPointer
>DCTLoop:	moveq	#$c,r1
>		load	(_SrcPointer),r0	; Preload Input[0] (FullPass, EvenPass, FastPass)
>		and	_DCTSwitch,r1
>		load	(_SrcPointer+2),r2	; Preload Input[2] (FullPass, EvenPass)
>		add	_DCTPointers,r1
>		load	(r1),r1
>		jump	(r1)			; Switch To Best DCT Handler
>		load	(_SrcPointer+4),r4	; Preload Input[4] (FullPass, EvenPass)
>
>;		#] DCT StartUp: 
>;		#[ Full Pass:
>
>FullPass:	move	r0,r8
>		add	r4,r0
>		sub	r4,r8
>		imult	_cos1_4,r0
>		imult	_cos1_4,r8
>		load	(_SrcPointer+6),r6
>		move	r2,r9
>		imult	_sin1_8,r2
>		imult	_cos1_8,r9
>		load	(_SrcPointer+3),r3
>		move	r6,r4
>		imult	_sin1_8,r6
>		imult	_cos1_8,r4
>		add	r6,r9
>		sub	r4,r2
>		load	(_SrcPointer+5),r5
>		move	r8,r4
>		add	r2,r8
>		sub	r2,r4
>		load	(_SrcPointer+1),r1
>		move	r0,r6
>		sub	r9,r0
>		add	r9,r6
>		load	(_SrcPointer+7),r7
>		move	r3,r2
>		add	r5,r3
>		sub	r5,r2
>		imult	_cos1_4,r3
>		imult	_cos1_4,r2
>		add	_0x1000,r3
>		add	_0x1000,r2
>		sharq	#$d,r3
>		sharq	#$d,r2
>		shlq	#2,r1
>		shlq	#2,r7
>		move	r1,r5
>		add	r3,r1
>		sub	r3,r5
>		move	r7,r3
>		add	r2,r7
>		sub	r2,r3
>		imultn	_cos1_16,r1
>		imacn	_sin1_16,r7
>		resmac	r9
>		imultn	_cos5_16,r5
>		imacn	_sin5_16,r3
>		resmac	r2
>		imult	_sin1_16,r1
>		imult	_cos1_16,r7
>		imult	_sin5_16,r5
>		imult	_cos5_16,r3
>		sub	r7,r1
>		sub	r3,r5
>		move	r6,r3
>		add	r9,r6
>		sub	r9,r3
>		move	r8,r7
>		add	r5,r8
>		sub	r5,r7
>		move	r4,r5
>		add	r2,r4
>		sub	r2,r5
>		move	r0,r2
>		add	r1,r0
>		sub	r1,r2
>		add	_NormConstant,r6
>		add	_NormConstant,r8
>		sharq	#$10,r6
>		sharq	#$10,r8
>		store	r6,(_DstPointer)
>		add	_NormConstant,r4
>		add	_NormConstant,r0
>		store	r8,(_DstPointer+8)
>		sharq	#$10,r4
>		sharq	#$10,r0
>		store	r4,(_DstPointer+$10)
>		add	_NormConstant,r2
>		add	_NormConstant,r5
>		store	r0,(_DstPointer+$18)
>		sharq	#$10,r2
>		add	_0x80,_DstPointer
>		sharq	#$10,r5
>		store	r2,(_DstPointer)
>		add	_NormConstant,r7
>		add	_NormConstant,r3
>		store	r5,(_DstPointer+8)
>		sharq	#$10,r7
>		sharq	#$10,r3
>		store	r7,(_DstPointer+$10)
>		store	r3,(_DstPointer+$18)
>
>;		#] Full Pass: 
>;		#[ End DCT Pass:
>
>EndDCTPass:	shrq	#2,_DCTSwitch
>		addqt	#$20,_SrcPointer	; Increment Source Pointer
>		rorq	#1,_DCTLoopCounter	; Test X Counter
>		addqt	#4,_DstPointer		; Increment Destination Pointer
>		jump	CS,(_DCTLoop)
>		sub	_0x80,_DstPointer
>		move	_DCTTmpBuffer,_SrcPointer
>		movefa	_MCUBuffer,_DstPointer
>		rorq	#1,_DCTLoopCounter	; Test Y Counter
>		load	(_NormTable),_NormConstant
>		jump	CS,(_DCTLoop)
>		subc	_DCTSwitch,_DCTSwitch	; Perform Full 2nd Pass
>		load	(_G_Flags),r0
>		jump	(_DUEndLoop)
>		rorq	#14,_DCTLoopCounter	; Restore X/Y Counter
>
>;		#] End DCT Pass: 
>;		#[ Even Pass:
>
>EvenPass:	move	r0,r8
>		add	r4,r0
>		sub	r4,r8
>		imult	_cos1_4,r0
>		imult	_cos1_4,r8
>		load	(_SrcPointer+6),r6
>		move	r2,r9
>		imult	_sin1_8,r2
>		imult	_cos1_8,r9
>		move	r6,r4
>		imult	_sin1_8,r6
>		imult	_cos1_8,r4
>		add	r6,r9
>		sub	r4,r2
>		move	r0,r6
>		sub	r9,r0
>		add	r9,r6
>		move	r8,r4
>		add	r2,r8
>		sub	r2,r4
>		add	_NormConstant,r6
>		add	_NormConstant,r8
>		sharq	#$10,r6
>		sharq	#$10,r8
>		store	r6,(_DstPointer)
>		add	_NormConstant,r4
>		store	r8,(_DstPointer+8)
>		sharq	#$10,r4
>		add	_NormConstant,r0
>		store	r4,(_DstPointer+$10)
>		sharq	#$10,r0
>		store	r0,(_DstPointer+$18)
>		add	_0x80,_DstPointer
>		store	r0,(_DstPointer)
>		store	r4,(_DstPointer+8)
>		store	r8,(_DstPointer+$10)
>		jump	(_EndDCTPass)
>		store	r6,(_DstPointer+$18)
>
>;		#] Even Pass: 
>;		#[ Odd Pass:
>
>OddPass:	load	(_SrcPointer+3),r3
>		load	(_SrcPointer+5),r5
>		move	r3,r2
>		add	r5,r3
>		sub	r5,r2
>		load	(_SrcPointer+1),r1
>		imult	_cos1_4,r3
>		imult	_cos1_4,r2
>		add	_0x1000,r3
>		load	(_SrcPointer+7),r7
>		add	_0x1000,r2
>		sharq	#$d,r3
>		sharq	#$d,r2
>		shlq	#2,r1
>		shlq	#2,r7
>		move	r1,r5
>		add	r3,r1
>		sub	r3,r5
>		move	r7,r3
>		add	r2,r7
>		sub	r2,r3
>		imultn	_cos1_16,r1
>		imacn	_sin1_16,r7
>		resmac	r9
>		imultn	_cos5_16,r5
>		imacn	_sin5_16,r3
>		resmac	r2
>		imult	_sin1_16,r1
>		imult	_cos1_16,r7
>		imult	_sin5_16,r5
>		imult	_cos5_16,r3
>		sub	r7,r1
>		sub	r3,r5
>		add	_NormConstant,r9
>		add	_NormConstant,r5
>		sharq	#$10,r9
>		sharq	#$10,r5
>		store	r9,(_DstPointer)
>		add	_NormConstant,r2
>		add	_NormConstant,r1
>		store	r5,(_DstPointer+8)
>		sharq	#$10,r2
>		sharq	#$10,r1
>		store	r2,(_DstPointer+$10)
>		neg	r9
>		store	r1,(_DstPointer+$18)
>		add	_0x80,_DstPointer
>		neg	r5
>		store	r9,(_DstPointer+$18)
>		neg	r2
>		store	r5,(_DstPointer+$10)
>		neg	r1
>		store	r2,(_DstPointer+8)
>		jump	(_EndDCTPass)
>		store	r1,(_DstPointer)
>
>;		#] Odd Pass: 
>;		#[ Fast Pass:
>
>FastPass:	store	r0,(_DstPointer)
>		store	r0,(_DstPointer+8)
>		store	r0,(_DstPointer+$10)
>		store	r0,(_DstPointer+$18)
>		add	_0x80,_DstPointer
>		store	r0,(_DstPointer)
>		store	r0,(_DstPointer+8)
>		store	r0,(_DstPointer+$10)
>		jump	(_EndDCTPass)
>		store	r0,(_DstPointer+$18)
>
>;		#] Fast Pass: 
>;		#[ Fast DCT:
>
>FastDCT:	nop
>		nop
>		movefa	_MCUBuffer,r1
>		load	(r1),r0
>		load	(_NormTable),_NormConstant
>		shlq	#13,r0
>		add	_NormConstant,r0
>		moveq	#$10,r5
>		sharq	#16,r0
>.Loop:		store	r0,(r1)
>		addqt	#4,r1
>		store	r0,(r1)
>		addqt	#4,r1
>		store	r0,(r1)
>		addqt	#4,r1
>		subq	#1,r5
>		store	r0,(r1)
>		jr	NE,.Loop
>		addqt	#4,r1
>		load	(_G_Flags),r0
>
>;		#] Fast DCT: 
>;	 #] Inverse DCT DU: 
>;	 #[ DU End Loop:
>
>DUEndLoop:	addqt	#4,_NormTable
>		bclr	#$e,r0
>		store	r0,(_G_Flags)
>		.REGBANK0
>		nop
>		nop
>		load	(_DULoopTable),r2
>		addqt	#1,_MCUBuffer
>		addqt	#4,_DULoopTable
>		jump	(r2)
>		add	_0xff,_MCUBuffer	; Next MCUBuffer 
>
>;	 #] DU End Loop: 
>;  #] Decode DUs (Huffman, Inv. DCT): 
>;  #[ Convert MCU:
>;	 #[ Convert CRY15/CRY16 MCU:
>
>		.IF	(CRY15|CRY16)
>ConvertMCU:	movei	#CopyPointers,r2
>		moveta	r4,r4
>		movei	#B_OUTPointer,r0
>		moveta	r5,r5
>		load	(r0),r0
>		moveta	r6,r6
>		moveta	r7,r7
>		moveta	r8,r8
>		moveta	r11,r2
>		moveta	r12,r3
>		moveta	r13,r9
>		moveta	r2,r0
>		moveta	r0,r1
>		movei	#RGBToCRY,r11
>		movei	#CRYTable,r12
>BlockLoop:	movefa	r0,r15
>		load	(r15),r14		; Y Pointer
>		load	(r15+1),r9		; Cb Pointer
>		load	(r15+2),r25		; Cr Pointer
>		movefa	r1,r0
>		load	(r15+3),r15		; Output Offset
>		movei	#$3def7,r5
>		add	r0,r15
>ConvertLoop:	load	(r9),r2
>		load	(r25),r3
>		imultn	_GreenCoef1,r2
>		imacn	_GreenCoef2,r3
>		resmac	r0
>		imult	_BlueCoef1,r2
>		imult	_RedCoef1,r3
>		sharq	#8,r2			; - Cb * 0.31414 - Cr * 0.71414
>		sharq	#8,r3			; + Cb * 1.77200
>		load	(r14),r6
>		move	PC,_SP
>		jump	(r11)
>		sharq	#8,r0			; + Cr * 1.40200
>		load	(r14+1),r6
>		move	r7,r8
>		move	PC,_SP
>		jump	(r11)
>		shlq	#16,r8
>		or	r7,r8
>		load	(r14+8),r6
>		store	r8,(r15)		; CCCCRRRR YYYYYYY? CCCCRRRR YYYYYYY?
>		move	PC,_SP
>		jump	(r11)
>		addq	#4,r9
>		load	(r14+9),r6
>		move	r7,r8
>		move	PC,_SP
>		jump	(r11)
>		shlq	#16,r8
>		addqt	#8,r14
>		or	r7,r8
>		shrq	#1,r5
>		store	r8,(r15+_OUTLineSize)	; CCCCRRRR YYYYYYY? CCCCRRRR YYYYYYY?
>		addqt	#4,r25
>		jump	CS,(_ConvertLoop)
>		addq	#4,r15
>		add	_OUTLineSize,r15
>		shrq	#1,r5
>		subqt	#$10,r15
>		addqt	#$20,r14
>		addqt	#$10,r9
>		addqt	#$10,r25
>		jump	CS,(_ConvertLoop)
>		add	_OUTLineSize,r15
>		movefa	r0,r14
>		load	(r14+4),r0
>		addqt	#$14,r14
>		jump	(r0)
>		moveta	r14,r0
>		.ENDIF
>
>;	 #] Convert CRY15/CRY16 MCU: 
>;	 #[ Convert RGB15/RGB16 MCU:
>
>		.IF	(RGB15|RGB16)
>ConvertMCU:	movei	#CopyPointers,r2
>		moveta	r4,r4
>		movei	#B_OUTPointer,r0
>		moveta	r5,r5
>		load	(r0),r0
>		.IF	RGB15
>		moveta	r7,r7
>		.ENDIF
>		moveta	r6,r6
>		.IF	RGB15
>		moveq	#1,r7
>		.ENDIF
>		moveta	r2,r0
>		.IF	RGB15
>		shlq	#16,r7
>		.ENDIF
>		moveta	r0,r1
>		.IF	RGB15
>		addqt	#1,r7
>		.ENDIF
>BlockLoop:	movefa	r0,r15
>		load	(r15),r14		; Y Pointer
>		load	(r15+1),r23		; Cb Pointer
>		load	(r15+2),r25		; Cr Pointer
>		movefa	r1,r0
>		load	(r15+3),r15		; Output Offset
>		movei	#$3def7,r5
>		add	r0,r15
>ConvertLoop:	load	(r23),r2
>		load	(r25),r3
>		imultn	_GreenCoef1,r2
>		imacn	_GreenCoef2,r3
>		resmac	r0
>		imult	_BlueCoef1,r2
>		imult	_RedCoef1,r3
>		sharq	#8,r0			; - Cb * 0.31414 - Cr * 0.71414
>		sharq	#8,r2			; + Cb * 1.77200
>		sharq	#8,r3			; + Cr * 1.40200
>		load	(r14),r6
>		addq	#4,r23
>		move	r6,r10
>		move	r6,r4
>		add	r3,r6			; Y + Cr * 1.40200
>		add	r0,r10			; Y - Cb * 0.31414 - Cr * 0.71414
>		add	r2,r4			; Y + Cb * 1.77200
>		sat8	r10
>		sat8	r6
>		sat8	r4
>		shrq	#2,r10
>		shrq	#3,r6
>		shrq	#3,r4
>		shlq	#16,r10
>		shlq	#27,r6
>		shlq	#22,r4
>		or	r10,r6
>		load	(r14+1),r10
>		or	r4,r6
>		move	r10,r4
>		.IF	RGB15
>		or	r7,r6
>		.ENDIF
>		add	r0,r10			; Y - Cb * 0.31414 - Cr * 0.71414
>		move	r4,r9
>		add	r2,r4			; Y + Cb * 1.77200
>		add	r3,r9			; Y + Cr * 1.40200
>		sat8	r10
>		sat8	r9
>		sat8	r4
>		shrq	#2,r10
>		shrq	#3,r9
>		shrq	#3,r4
>		shlq	#11,r9
>		shlq	#6,r4
>		or	r10,r9
>		load	(r14+8),r10
>		or	r4,r9
>		move	r10,r4
>		or	r6,r9
>		add	r0,r10			; Y - Cb * 0.31414 - Cr * 0.71414
>		store	r9,(r15)		; RRRRRBBB BBGGGGG? RRRRRBBB BBGGGGG?
>		move	r4,r6
>		add	r2,r4			; Y + Cb * 1.77200
>		add	r3,r6			; Y + Cr * 1.40200
>		sat8	r10
>		sat8	r6
>		sat8	r4
>		shrq	#2,r10
>		shrq	#3,r6
>		shrq	#3,r4
>		shlq	#16,r10
>		shlq	#27,r6
>		shlq	#22,r4
>		or	r10,r6
>		load	(r14+9),r10
>		or	r4,r6
>		move	r10,r4
>		.IF	RGB15
>		or	r7,r6
>		.ENDIF
>		add	r0,r10			; Y - Cb * 0.31414 - Cr * 0.71414
>		move	r4,r9
>		add	r2,r4			; Y + Cb * 1.77200
>		add	r3,r9			; Y + Cr * 1.40200
>		sat8	r10
>		sat8	r9
>		sat8	r4
>		shrq	#2,r10
>		shrq	#3,r9
>		shrq	#3,r4
>		shlq	#11,r9
>		shlq	#6,r4
>		or	r10,r9
>		or	r4,r9
>		or	r6,r9
>		store	r9,(r15+_OUTLineSize)	; RRRRRBBB BBGGGGG? RRRRRBBB BBGGGGG?
>		shrq	#1,r5
>		addqt	#4,r15
>		addqt	#8,r14
>		jump	CS,(_ConvertLoop)
>		addq	#4,r25
>		add	_OUTLineSize,r15
>		shrq	#1,r5
>		subqt	#$10,r15
>		addqt	#$20,r14
>		addqt	#$10,r23
>		addqt	#$10,r25
>		jump	CS,(_ConvertLoop)
>		add	_OUTLineSize,r15
>		movefa	r0,r14
>		load	(r14+4),r0
>		addqt	#$14,r14
>		jump	(r0)
>		moveta	r14,r0
>		.ENDIF
>
>;	 #] Convert RGB15/RGB16 MCU: 
>;	 #[ Convert RGB32 MCU:
>
>		.IF	RGB32
>ConvertMCU:	movei	#CopyPointers,r2
>		moveta	r4,r4
>		movei	#B_OUTPointer,r0
>		moveta	r5,r5
>		load	(r0),r0
>		moveta	r2,r0
>		moveta	r0,r1
>BlockLoop:	movefa	r0,r15
>		load	(r15),r14		; Y Pointer
>		load	(r15+1),r23		; Cb Pointer
>		load	(r15+2),r25		; Cr Pointer
>		movefa	r1,r0
>		load	(r15+3),r15		; Output Offset
>		movei	#$3def7,r5
>		add	r0,r15
>ConvertLoop:	load	(r23),r2
>		load	(r25),r3
>		imultn	_GreenCoef1,r2
>		imacn	_GreenCoef2,r3
>		resmac	r0
>		imult	_BlueCoef1,r2
>		imult	_RedCoef1,r3
>		sharq	#8,r0			; - Cb * 0.31414 - Cr * 0.71414
>		sharq	#8,r2			; + Cb * 1.77200
>		sharq	#8,r3			; + Cr * 1.40200
>		load	(r14),r9
>		addq	#4,r23
>		move	r9,r10
>		move	r9,r4
>		add	r3,r9			; Y + Cr * 1.40200
>		add	r0,r10			; Y - Cb * 0.31414 - Cr * 0.71414
>		add	r2,r4			; Y + Cb * 1.77200
>		sat8	r9
>		sat8	r10
>		sat8	r4
>		shlq	#16,r9
>		shlq	#24,r10
>		or	r10,r9
>		load	(r14+8),r10
>		or	r4,r9
>		move	r10,r4
>		add	r0,r10			; Y - Cb * 0.31414 - Cr * 0.71414
>		store	r9,(r15)		; GGGGGGGG RRRRRRRR 00000000 BBBBBBBB
>		move	r4,r9
>		add	r2,r4			; Y + Cb * 1.77200
>		add	r3,r9			; Y + Cr * 1.40200
>		sat8	r10
>		sat8	r9
>		sat8	r4
>		shlq	#16,r9
>		shlq	#24,r10
>		or	r10,r9
>		load	(r14+1),r10
>		or	r4,r9
>		move	r10,r4
>		add	r0,r10			; Y - Cb * 0.31414 - Cr * 0.71414
>		store	r9,(r15+_OUTLineSize)	; GGGGGGGG RRRRRRRR 00000000 BBBBBBBB
>		move	r4,r9
>		add	r2,r4			; Y + Cb * 1.77200
>		add	r3,r9			; Y + Cr * 1.40200
>		sat8	r10
>		sat8	r9
>		sat8	r4
>		addqt	#4,r15
>		shlq	#16,r9
>		shlq	#24,r10
>		or	r10,r9
>		load	(r14+9),r10
>		or	r4,r9			; GGGGGGGG RRRRRRRR 00000000 BBBBBBBB
>		move	r10,r4
>		add	r0,r10			; Y - Cb * 0.31414 - Cr * 0.71414
>		store	r9,(r15)
>		move	r4,r9
>		add	r2,r4			; Y + Cb * 1.77200
>		add	r3,r9			; Y + Cr * 1.40200
>		sat8	r10
>		sat8	r9
>		sat8	r4
>		shlq	#16,r9
>		shlq	#24,r10
>		or	r10,r9
>		or	r4,r9
>		store	r9,(r15+_OUTLineSize)	; GGGGGGGG RRRRRRRR 00000000 BBBBBBBB
>		shrq	#1,r5
>		addqt	#4,r15
>		addqt	#8,r14
>		jump	CS,(_ConvertLoop)
>		addq	#4,r25
>		add	_OUTLineSize,r15
>		shrq	#1,r5
>		subqt	#$20,r15
>		addqt	#$20,r14
>		addqt	#$10,r23
>		addqt	#$10,r25
>		jump	CS,(_ConvertLoop)
>		add	_OUTLineSize,r15
>		movefa	r0,r14
>		load	(r14+4),r0
>		addqt	#$14,r14
>		jump	(r0)
>		moveta	r14,r0
>		.ENDIF
>
>;	 #] Convert RGB32 MCU: 
>;  #] Convert MCU: 
>;  #[ MCU Loop:
>
>MCULoop:	movefa	r1,r0
>		movei	#B_Struct,r14
>		addqt	#$20,r0
>		movefa	r4,r4
>		.IF	RGB32
>		addqt	#$20,r0
>		.ENDIF
>		movefa	r5,r5
>		store	r0,(r14+3)
>		load	(r14+1),r25		; Current XCounter
>		load	(r14),r3		; Loop Pointer
>		subq	#1,r25
>		.IF	(CRY15|CRY16|RGB15|RGB16)
>		movefa	r6,r6
>		.ENDIF
>		.IF	(CRY15|CRY16|RGB15)
>		movefa	r7,r7
>		.ENDIF
>		.IF	(CRY15|CRY16)
>		movefa	r8,r8
>		movefa	r2,r11
>		movefa	r3,r12
>		movefa	r9,r13
>		.ENDIF
>		jump	NE,(r3)
>		store	r25,(r14+1)
>		load	(r14+4),r25		; XCounter Backup
>		move	_OUTLineSize,r15
>		load	(r14+2),r2		; Current YCounter
>		or	r25,r25			; GPU Score-Board Bug...
>		store	r25,(r14+1)		; Restore XCounter
>		.IF	(CRY15|CRY16|RGB15|RGB16)
>		shlq	#5,r25
>		.ENDIF
>		.IF	RGB32
>		shlq	#6,r25
>		.ENDIF
>		shlq	#4,r15
>		sub	r25,r0
>		add	r15,r0
>		subq	#1,r2
>		store	r0,(r14+3)
>		jump	NE,(r3)
>		store	r2,(r14+2)
>		moveq	#FINISHED,r0
>
>;  #] MCU Loop: 
>;  #[ GPU End:
>
>BPEGEnd:	movei	#BPEGStatus,r1
>		store	r0,(r1)
>		moveq	#0,r0
>		movei	#G_CTRL,r1
>.Wait:		jr	.Wait
>		store	r0,(r1)			; Stop the GPU
>
>;  #] GPU End: 
>;  #[ Huffman Error:
>
>HuffmanError:	jr	BPEGEnd
>		moveq	#HUFFMANERROR,r0
>
>;  #] Huffman Error: 
>;  #[ Fetch 32 Bits:
>
>Fetch32Bits:	addqt	#6,_SP
>		moveq	#0,_BitsCounter
>		jr	MI,.SameLong
>		addqt	#$20,_BitsCounter
>		move	_Prefetch1,_Prefetch0
>		load	(_StreamPtr),_Prefetch1
>		addqt	#4,_StreamPtr
>		jr	.NextLong
>.SameLong:	move	_Prefetch0,_CurrentBits
>		add	_BitsCounter,_BitsMissing
>.NextLong:	move	_Prefetch1,r0
>		sh	_BitsMissing,_CurrentBits
>		sub	_BitsCounter,_BitsMissing
>		sh	_BitsMissing,r0
>		add	_BitsCounter,_BitsMissing
>		jump	(_SP)
>		or	r0,_CurrentBits
>
>;  #] Fetch 32 Bits: 
>;  #[ RGB To CRY:
>
>		.IF (CRY15|CRY16)
>RGBToCRY:	move	r6,r10
>		move	r6,r4
>		add	r3,r6			; Y + Cr * 1.40200
>		add	r2,r4			; Y + Cb * 1.77200
>		add	r0,r10			; Y - Cb * 0.31414 - Cr * 0.71414
>		sat8	r6
>		sat8	r10
>		sat8	r4
>		cmp	r10,r6
>		move	r6,r7
>		jr	PL,.1
>		mult	_0xff,r6
>		move	r10,r7
>.1:		cmp	r4,r7
>		addqt	#6,_SP
>		jr	PL,.2
>		mult	_0xff,r10
>		move	r4,r7
>.2:		mult	_0xff,r4
>		cmpq	#0,r7
>		move	_0xff,r13
>		jr	NE,.3
>		shlq	#8,r13
>		jump	(_SP)
>		nop
>.3:		div	r7,r13
>		mult	r13,r10
>		mult	r13,r6
>		mult	r13,r4
>		shrq	#19,r10
>		shrq	#19,r6
>		shlq	#5,r10
>		shlq	#10,r6
>		shrq	#19,r4
>		add	r10,r6
>		add	r12,r4
>		add	r6,r4
>		.IF	CRY15
>		bclr	#0,r7
>		.ENDIF
>		loadb	(r4),r6
>		shlq	#8,r6
>		jump	(_SP)
>		or	r6,r7
>		.ENDIF
>
>;  #] RGB To CRY: 
>;  #[ GPU Variables:				; 52 Bytes
>
>		.LONG
>
>B_Struct:	.dc.l	FillMCUBuffer		; MCU Loop Pointer
>B_XCounter:	.dc.l	0			; Current X Counter
>B_YCounter:	.dc.l	0			; Current Y Counter
>B_OUTPointer:	.dc.l	0			; Current MCU Output Pointer
>B_SaveXCounter:	.dc.l	0			; X Counter Backup
>B_INPointer:	.dc.l	0			; BPEG Input Stream Pointer
>B_OUTLineSize:	.dc.l	0			; BPEG Output Buffer Line Size (Bytes)
>
>LastDCY:	.dc.l	ZZQTLMatrix,0		; Last Y DC Coef., Y Matrix Pointer
>LastDCCb:	.dc.l	ZZQTCMatrix,0		; Last Cb DC Coef., Cb/Cr Matrix Pointer
>LastDCCr:	.dc.l	ZZQTCMatrix,0		; Last Cr DC Coef., Cb/Cr Matrix Pointer
>
>;  #] GPU Variables: 
>;  #[ GPU Tables:				; 216 Bytes
>;	 #[ MCU Pointers:			; 52 Bytes
>
>MCUPointers:	.dc.l	MCUBuffer
>		.dc.l	LastDCY,DULoop		; Last DC Coef. & Matrix Pointer, Loop Pointer
>		.dc.l	LastDCY,DULoop
>		.dc.l	LastDCY,DULoop
>		.dc.l	LastDCY,DULoop
>		.dc.l	LastDCCb,DULoop
>		.dc.l	LastDCCr,ConvertMCU
>
>;	 #] MCU Pointers: 
>;	 #[ DCT Pointers:			; 16 Bytes
>
>DCTPointers:	.dc.l	FastPass
>		.dc.l	EvenPass
>		.dc.l	OddPass
>		.dc.l	FullPass
>
>;	 #] DCT Pointers: 
>;	 #[ Normalization Table:		; 24 Bytes
>
>NormTable:	.dc.l	$808000			; Y (Output Range: $00 -> $ff)
>		.dc.l	$808000			; Y (Output Range: $00 -> $ff)
>		.dc.l	$808000			; Y (Output Range: $00 -> $ff)
>		.dc.l	$808000			; Y (Output Range: $00 -> $ff)
>		.dc.l	$008000			; Cb (Output Range: $80 -> $7f)
>		.dc.l	$008000			; Cr (Output Range: $80 -> $7f)
>
>;	 #] Normalization Table: 
>;	 #[ Copy Pointers:			; 80 Bytes
>
>		.IF	(CRY15|CRY16|RGB15|RGB16)
>CopyPointers:	.dc.l	MCUBuffer,MCUBuffer+$400,MCUBuffer+$500,0,BlockLoop
>		.dc.l	MCUBuffer+$100,MCUBuffer+$410,MCUBuffer+$510,$10,BlockLoop
>		.dc.l	MCUBuffer+$200,MCUBuffer+$480,MCUBuffer+$580,0,BlockLoop
>		.dc.l	MCUBuffer+$300,MCUBuffer+$490,MCUBuffer+$590,0,MCULoop
>		.ENDIF
>
>		.IF	RGB32
>CopyPointers:	.dc.l	MCUBuffer,MCUBuffer+$400,MCUBuffer+$500,0,BlockLoop
>		.dc.l	MCUBuffer+$100,MCUBuffer+$410,MCUBuffer+$510,$20,BlockLoop
>		.dc.l	MCUBuffer+$200,MCUBuffer+$480,MCUBuffer+$580,0,BlockLoop
>		.dc.l	MCUBuffer+$300,MCUBuffer+$490,MCUBuffer+$590,0,MCULoop
>		.ENDIF
>
>;	 #] Copy Pointers: 
>;	 #[ Data Mask Table:			; 44 Bytes
>
>DataMaskTable:	.dc.l	%00000000001,%00000000011,%00000000111,%00000001111
>		.dc.l	%00000011111,%00000111111,%00001111111,%00011111111
>		.dc.l	%00111111111,%01111111111,%11111111111
>
>;	 #] Data Mask Table: 
>;  #] GPU Tables: 
>;  #[ MCU Buffers:				; 2304 Bytes
>
>ZZQTLMatrix	.equ	*			; Luminance Quantization Matrix ($100 Bytes)
>
>ZZQTCMatrix	.equ	*+$100			; Chrominance Quantization Matrix ($100 Bytes)
>
>MCUBuffer	.equ	*+$200			; I/O MCU Buffer ($600 Bytes)
>
>MCUTmpBuffer	.equ	*+$800			; Inv. DCT Temporary Buffer ($100 Bytes)
>
>;  #] MCU Buffers: 
>;  #[ GPU EQURs Undefinition:
>
>		.equrundef	_CurrentBits,_Prefetch0,_Prefetch1,_BitsCounter
>		.equrundef	_BitsMissing,_StreamPtr,_ZZQTMatrix,_MCUBuffer
>		.equrundef	_DCLTable,_DataMaskTable,_StoreDC,_Fetch32Bits
>		.equrundef	_ACCoefLoop,_DULoopTable,_0xff,_ACLTree,_DCTMask
>		.equrundef	_FastDCT,_SP,_OUTLineSize,_ConvertLoop,_RedCoef1
>		.equrundef	_GreenCoef1,_GreenCoef2,_BlueCoef1
>
>		.equrundef	_DCTLoopCounter,_NormConstant,_MCUPointers,_cos1_4
>		.equrundef	_SrcPointer,_DstPointer,_sin1_8,_cos1_8,_cos1_16
>		.equrundef	_sin1_16,_cos5_16,_sin5_16,_0x1000,_DCTSwitch
>		.equrundef	_0x80,_DCTLoop,_DCTTmpBuffer,_EndDCTPass,_DUEndLoop
>		.equrundef	_NormTable,_DCTPointers
>
>		.equrundef	_G_Flags
>
>;  #] GPU EQURs Undefinition: 
>;  #[ MC68000 Variables:
>
> .LONG
> .68000
>GPUEndCode:
>
> .BSS
>
>BPEGStatus:
> .ds.l 1
>
>;  #] MC68000 Variables: 
>;  #[ GPU RAM Check:
>
> .IF ((GPUEndCode-GPUCode)+2304)>4096
>  .PRINT "G-RAM Overflow: ",/u/w ((GPUEndCode-GPUCode)+2304)-4096, " Bytes."
>  .FAIL
> .ELSE
>  .PRINT "G-RAM Used: ",/u/w (GPUEndCode-GPUCode), " Bytes (Code & Tables)."
>  .PRINT "            ",/u/w 2304, " Bytes (Buffers)."
>  .PRINT "            ",/u/w 4096-((GPUEndCode-GPUCode)+2304), " Bytes (Free)."
> .ENDIF
> .END
>
>;  #] GPU RAM Check: 
>

Actions: View

Attachments on bug 173: 139 | 140 | 141 | 142 | 143 | 144 | 145