use32
	org	0x0

	db	'MENUET01'	; 8 byte id
	dd	38		; required os
	dd	STARTAPP	; program start
	dd	I_END		; program image size
	dd	0x100000	; required amount of memory
	dd	0x100000	; reserved= extended header
	dd	filename, 0x0	; I_Param , I_Icon

include "aspAPI.inc"

;Clock_Hz       equ     4608    ; Frequency of clock
;Monitor_Hz     equ     70      ; Frequency of monitor
;Clock_Scale    equ     Clock_Hz / Monitor_Hz
CData		equ	0x40	; Port number of timer 0
CMode		equ	0x43	; Port number of timer control word
BufSize 	equ	65528	; Frame buffer size - Must be even

struc	MainHeaderRec
{
	.Padding1	dd	?	; size of the file
	.ID		dw	?	; magic
	.Frames 	dw	?	; frames
	.Padding2	dd	?	; width/height
	.Padding3	dd	?	; depth/flags
	.Speed		dw	?	; speed
	.Reserv 	dw	?	; always = 0
	; Only for FLC
	.Created	dd	?	; date file attribute
	.Creator	dd	?	; creator serial number
	.Updated	dd	?	; date of the last change
	.Updater	dd	?	; updater serial number
	.Aspectx	dw	?	; scale by x
	.Aspecty	dw	?	; scale by Y
	.Padding4	db	38     dup(?)  ; Reserved. All zeroes.
	.Oframe1	dd	?	; offset to the 1st frame
	.Oframe2	dd	?	; offset to the 2nd frame
	.Padding5	db	40     dup(?)  ; Reserved. All zeroes.
}

struc	FrameHeaderRec
{
	.Size	dd	?	; size
	.Padding1	dw	?	; magic
	.Chunks dw	?	; chunks
	.Padding2	db	8	dup(?)	;Pad to 16 Bytes.       All zeroes.
}


; in:           esi = pointer to the buffer

DrawFrame:
	; this is the routine that takes a frame and put it on the screen
  @Fli_Loop:					; main loop that goes through all the chunks in a frame
    cmp  word [Chunks],0	      ;are there any more chunks to draw?
    je	 @Exit
    dec  word [Chunks]		      ;decrement Chunks For the chunk to process now
	
	mov  ax, word [esi+4]		; let AX have the ChunkType
	add  esi, 6		     ; skip the ChunkHeader
	cmp  ax, 0Bh				; is it a FLI_COLor chunk?
	je   @Fli_Color
	cmp  ax, 0Ch				; is it a FLI_LC chunk?
	je   @Fli_Lc
	cmp  ax, 0Dh				; is it a FLI_BLACK chunk?
	je   @Fli_Black
	cmp  ax, 0Fh				; is it a FLI_BRUN chunk?
	je   @Fli_Brun
	cmp  ax, 10h				; is it a FLI_COPY chunk?
	je   @Fli_Copy
	jmp  @Fli_Loop				; This command should not be necessary

  @Fli_Color:
	mov  bx, word [esi]			; number of packets in this chunk (always 1?)
	add  esi, 2					; skip the NumberofPackets
;_________________________________________________________________________________________
	mov  al, 0					; start at color 0
	xor  cx, cx					; reset CX
  @Color_Loop:
	or   bx, bx					; set flags
	jz   @Fli_Loop				; Exit if no more packages
	dec  bx 					; decrement NumberofPackages For the package to process now
	mov  cl, byte [esi]			; first Byte in packet tells how many colors to skip
	add  al, cl					; add the skiped colors to the start to get the new start
	mov  edi, pal
	add	di,	cx

		;push  cx       ;----- save how many colors to skip ----->
	mov  cl, byte [esi+1]		; next Byte in packet tells how many colors to change
	or   cl, cl					; set the flags
	jnz  @Jump_Over 			; if NumberstoChange=0 then NumberstoChange=256
	inc  ch 					; CH=1 and CL=0 => CX=256
  @Jump_Over:
	;add  al, cl                                     ; update the color to start at
	add  esi, 2					; skip the NumberstoSkip and NumberstoChange Bytes
	.set_next_color:
	     lodsb	   ; B
	     shl     al, 2 ; Enlight the color r*4, g*4, b*4
	     push    ax

	     lodsb	   ; G
	     shl     al, 2 ; Enlight the color r*4, g*4, b*4
	     push    ax

	     lodsb	   ; R
	     shl     al, 2 ; Enlight the color r*4, g*4, b*4

	     stosb	   ; R
	     pop     ax
	     stosb	   ; G
	     pop     ax
	     stosb	   ; B
	     xor     al, al
	     stosb	   ; 0
	  loop	.set_next_color

	jmp  @Color_Loop			; finish With this packet - jump back
  @Fli_Lc:
	mov  di, word [esi]			; put LinestoSkip into DI -
	mov  ax, di					; - to get the offset address to this line we have to multiply With 320 -
	shl  ax, 8					; - DI = old_DI shl 8 + old_DI shl 6 -
	shl  di, 6					; - it is the same as DI = old_DI*256 + old_DI*64 = old_DI*320 -
	add  di, ax					; - but this way is faster than a plain mul
		add  edi, dword [image]
	mov  bx, word [esi+2]		; put LinestoChange into BX
	add  esi, 4					; skip the LinestoSkip and LinestoChange Words
	xor  cx, cx					; reset cx
  @Line_Loop:
	or   bx, bx					; set flags
	jz   @Fli_Loop				; Exit if no more lines to change
	dec  bx
	mov  dl, byte [esi]			; put PacketsInLine into DL
	inc  esi						; skip the PacketsInLine Byte
	push edi						; save the offset address of this line
  @Pack_Loop:
	or   dl, dl					; set flags
	jz   @Next_Line 			; Exit if no more packets in this line

	dec  dl
	mov  cl, byte [esi]			; put BytestoSkip into CL
	add  di, cx					; update the offset address
	mov  cl, byte [esi+1]		; put BytesofDatatoCome into CL
	or   cl, cl					; set flags
	jns  @Copy_Bytes			; no SIGN means that CL number of data is to come -
								; - else the next data should be put -CL number of times
	mov  al, byte [esi+2]		; put the Byte to be Repeated into AL
	add  esi, 3					; skip the packet
	neg  cl 					; Repeat -CL times
	rep  stosb
	jmp  @Pack_Loop 			; finish With this packet
  @Copy_Bytes:
	add  esi, 2					; skip the two count Bytes at the start of the packet
	rep  movsb
	jmp  @Pack_Loop 			; finish With this packet
  @Next_Line:
	pop  edi						; restore the old offset address of the current line
	add  edi, 320				; offset address to the next line
	jmp  @Line_Loop
  @Fli_Black:
	mov  edi, dword [image]
	mov  cx, 32000				; number of Words in a screen
	xor  ax, ax					; color 0 is to be put on the screen
	rep  stosw
	jmp  @Fli_Loop				; jump back to main loop
  @Fli_Brun:
	mov  edi, dword [image]
	mov  bx, 200				; numbers of lines in a screen
	xor  cx, cx
  @Line_Loop2:
	mov  dl, byte [esi]			; put PacketsInLine into DL
	inc  esi						; skip the PacketsInLine Byte
	push edi						; save the offset address of this line
  @Pack_Loop2:
	or   dl, dl					; set flags
	jz   @Next_Line2			; Exit if no more packets in this line
	dec  dl
	mov  cl, byte [esi]			; put BytesofDatatoCome into CL
	or   cl, cl					; set flags
	js   @Copy_Bytes2			; SIGN meens that CL number of data is to come -
								; - else the next data should be put -CL number of times
	mov  al, byte [esi+1]		; put the Byte to be Repeated into AL
	add  esi, 2					; skip the packet
	rep  stosb
	jmp  @Pack_Loop2			; finish With this packet
  @Copy_Bytes2:
	inc  esi						; skip the count Byte at the start of the packet
	neg  cl 					; Repeat -CL times
	rep  movsb
	jmp  @Pack_Loop2			; finish With this packet
  @Next_Line2:
	pop  edi						; restore the old offset address of the current line
	add  edi, 320				; offset address to the next line
	dec  bx 					; any more lines to draw?
	jnz  @Line_Loop2
	jmp  @Fli_Loop				; jump back to main loop
  @Fli_Copy:
	mov  edi, dword [image]
	mov  cx, 32000				; number of Words in a screen
	rep  movsw
	jmp  @Fli_Loop				; jump back to main loop
  @Exit:

		mov	eax, 65
		mov	ebx, dword [image]
		mov	ecx, 320*65536+200
		mov	edx, 10*65536+100
		mov	esi, 8
		mov	edi, pal
		xor	ebp, ebp
		int	0x40
	
	ret	; DrawFrame end.

TFliPlayer_Init:
	mov	eax, 68 	; Init process memory
	mov	ebx, 11
	int	0x40
	cmp	eax, BufSize	
	jl	.fail	
  .ok:
    ;GetMem(Buffer,BufSize);
	mov	eax, 68
	mov	ebx, 12
	mov	ecx, BufSize
	int	0x40
	mov	dword [Buffer], eax

		;GetMem(image,32000);
		mov	eax, 68
		mov	ebx, 12
		mov	ecx, 320*200*4		;32000
		int	0x40
		mov	dword [image], eax

	
    mov word [Interval],  -1	; ClearSpeed
	mov	ax,	1
	ret
  .fail:
	xor	ax, ax
	ret	; TFliPlayer_Init end.

TFliPlayer_Done:
    ;FreeMem(Buffer,BufSize);
	mov	eax, 68
	mov	ebx, 13
	mov	ecx, dword [Buffer]
	int	0x40

		;FreeMem(image,32000);
	mov	eax, 68
	mov	ebx, 13
	mov	ecx, dword [image]
	int	0x40

	ret	; TFliPlayer_Done end.

;       in:     ax = Speed
;TFliPlayer_SetSpeed:
;       mov     bl,     byte Clock_Scale
;       mul     bl
;    mov        word [Interval], ax     ;= Speed * Clock_Scale;
;       ret     ; TFliPlayer_SetSpeed end.



ReadHeader: ;Boolean;
	;BlockRead(FliFile,MainHeader,SizeOf(MainHeader))       ; Read header record
	mov	eax, dword [filepos]
	mov	dword [InfoStructure+4], eax
	mov	dword [InfoStructure+12], 128
	mov	dword [InfoStructure+16], MainHeader
	mov	eax, 70
	mov	ebx, InfoStructure
	
	int	0x40
	
	mov	eax, 128
	mov	dword [filepos], eax
	
    mov ax, word [MainHeader.ID]
	cmp	ax, 0xAF11 ; FLI ?
	je	.fli

	cmp	ax, 0xAF12 ; FLC ?
	je	.flc

	xor	ax,	ax	; Not a .FLI File
	ret
  .fli:
	mov	byte [filetype], 1
	jmp	.ok
  .flc:
	mov	byte [filetype], 2
  .ok:
;       cmp     word [Interval], -1
;       jne     @f
;       ; Read speed from header
;       mov     ax,     word [MainHeader.Speed]
;       mov     bl,     byte Clock_Scale
;       mul     bl
;    mov        word [Interval], ax     ;= Speed * Clock_Scale; 
	mov	ax, 1
;  @@:
	ret	; ReadHeader end.

ReadFrame:
	;BlockRead(FliFile,FrameHeader,SizeOf(FrameHeader));
	mov	eax, dword [filepos]
	mov	dword [InfoStructure+4], eax
	mov	dword [InfoStructure+12], 16
	mov	dword [InfoStructure+16], FrameHeader
	mov	eax, 70
	mov	ebx, InfoStructure
	
	int	0x40

	add	dword [filepos], 16
	;FrameSize := FrameHeader.Size - SizeOf(FrameHeader);
	mov	eax, dword [FrameHeader.Size]
	sub	eax, 16
	mov dword [FrameSize], eax
    xor ecx, ecx

	ret	; ReadFrame end.

ProcessFrame:
	;BlockRead(FliFile,Buffer^,FrameSize);
	mov	eax, dword [filepos]
	mov	dword [InfoStructure+4], eax
	mov	eax,	dword [FrameSize]
	mov	dword [InfoStructure+12], eax
	mov	eax, dword [Buffer]
	mov	dword [InfoStructure+16], eax
	mov	eax, 70
	mov	ebx, InfoStructure
	
	int	0x40

	mov	eax,	dword [FrameSize]
	add	dword [filepos], eax
	mov	esi, dword [Buffer]
	mov	dx, word [FrameHeader.Chunks]
	mov	word [Chunks], dx
	call DrawFrame
	
	ret	; ProcessFrame end.
	
	
;       in:     esi = pointer to the filename
TFliPlayer_Play:
	mov	eax, 70
	mov	ebx, InfoStructure
	mov	dword [InfoStructure+12], 1
	mov	dword [InfoStructure+16], FrameHeader
	int	0x40
	test	ax,	ax
	jnz	.err

	call	ReadHeader
	test	ax,	ax
	jz	.err

	call	ReadFrame

	mov	eax, dword [FrameSize]
	add	eax, 128+16
	mov	dword [RestartPos], eax
	call	ProcessFrame


  .play_again:
	mov	word [Frame], 1
	  .show_next_frame:
			
			call	ReadFrame
			cmp	dword [FrameSize], 0
			je	@f
			call	ProcessFrame
		  @@:

		  ;REPEAT UNTIL GetClock > Timeout;
			mov	eax, 5
			mov	ebx, 2
			int	0x40
			
			push	edi		
			call	process_events
			pop	edi

			mov	al, byte [stop]
			cmp	al, 1
			je	.end
			
			mov	ax, word [Frame]
			inc	ax
			mov	word [Frame], ax

			cmp	ax, word [MainHeader.Frames]
			jng	.show_next_frame
		mov	eax,	dword [RestartPos]
		mov	dword [InfoStructure+4], eax
		mov	eax, 128
		mov	dword [filepos], eax

	jmp	.play_again
  .end:
	mov	dword [filepos], 0
	xor	ax, ax
  .err:
  
	ret	; TFliPlayer_Play end.


;       in:     esi = pointer to filename
AAPlay:
	mov	byte [pausetime], 0
	mov	byte [stop], 0
	cmp	byte [playtime], 1
	je	.end
	call	unprint_error

	mov	byte [playtime], 1
	call	TFliPlayer_Play
	test	ax, ax
	jz	.end
	call	print_error
  .end:
	mov	byte [playtime], 0
	ret	; AAPlay end.


	
N_KEYCOLOR equ 0x00444444 ; Normal button color
TEXTCOLOR  equ 0x80FFFFFF ; Text color
BUTCAPCOLOR  equ 0x0000FF00 ; Button caption color


unprint_error:
	mov eax, 13
	mov ebx, 10*65536+320
	mov ecx, 50*65536+15
	mov edx, 0 ; color
	int 0x40
ret

print_error:
	;call   unprint_error
	
	mov	ebx, 15*65536+54
	mov	edx, error_text
	mov	ecx, TEXTCOLOR - 0x0000FFFF
	mov	eax, 4
	int	0x40

ret

print_filename:
	mov eax, 13
	mov ebx, 10*65536+320
	mov ecx, 30*65536+15
	mov edx, 0 ; color
	int 0x40

	mov	ebx, 15*65536+34
	mov	edx, filename
	mov	ecx, TEXTCOLOR - 0x00FF00FF
	mov	eax, 4
	int	0x40
	
ret

;**********************************
;*  input: ecx = type of map      *
;**********************************
get_keyboard_map:
	mov	eax, 26
	mov	ebx, 2
	mov	edx, keymap
	int	0x40
ret

;**********************************
;*  input: ecx = type of mode    *
;**********************************
set_keyboard_mode:
	mov	eax, 66
	mov	ebx, 1	   ; Set keyboard mode
	int	0x40
ret

get_control_keys_state:
	mov	eax, 66
	mov	ebx, 3
	int	0x40
ret

reload_ascii_keymap:
	pusha
	call	get_control_keys_state
	mov	ecx, 1

	test	ax, 1				; Left  Shift pressed ?
	jnz	 @f
	test	ax, 2				; Right Shift pressed ?
	jnz	 @f
	test	ax, 0x40			; Caps  Lock  on ?
	jz	.load_ascii_keymap
      @@:
	mov	ecx, 2
      .load_ascii_keymap:
	call	get_keyboard_map
	popa
  ret


STARTAPP:

	call	TFliPlayer_Init
	test	ax, ax
	jz	close_app

	mov	ecx, 1	   ; to send scancodes.
	call	set_keyboard_mode
	call	reload_ascii_keymap
	call	draw_window
	call	print_filename

	cmp  [filename], byte 0
	je   .noparam
	call	AAPlay
  .noparam:
	jmp	still


draw_window:
	start_draw_window 20,170,340,310,0x14224466,labelt
	draw_button 15,70,20,20,2,N_KEYCOLOR,keyText,1,BUTCAPCOLOR		; Play

	mov	ecx, BUTCAPCOLOR

	mov	edx, keyText
	mov	ebx, 21*65536+77	       ; |
	call	out_symbol

	mov	edx, keyText+1
	mov	ebx, 22*65536+75	       ; -
	call	out_symbol

	mov	ebx, 24*65536+76	       ; -
      @@:
	call	out_symbol
	inc	ebx
	cmp	ebx, 24*65536+79
	jl	@b
		
	mov	ebx, 22*65536+79	       ; -
	call	out_symbol

	mov	ebx, 26*65536+77	       ; -
	call	out_symbol
		
	draw_button 45,70,20,20,3,N_KEYCOLOR,keyText,1,BUTCAPCOLOR		; Pause

	mov	ecx, BUTCAPCOLOR

	mov	edx, keyText
	mov	ebx, 49*65536+77	       ; |
	call	out_symbol

	mov	ebx, 51*65536+77	       ; |
	call	out_symbol

	mov	ebx, 54*65536+77	       ; |
	call	out_symbol

	mov	ebx, 55*65536+77	       ; |
	call	out_symbol

	mov	ebx, 56*65536+77	       ; |
	call	out_symbol

	draw_button 75,70,20,20,4,N_KEYCOLOR,keyText,1,BUTCAPCOLOR		; Stop

	bar	81,77,8,7,BUTCAPCOLOR

	end_draw_window
	ret

process_events:
	mov	eax, 11 	    ; Test if there is an event in the queue.
	int	0x40

	cmp	eax,1		       ; redraw request ?
	jnz	@f
	call	red
	ret
      @@:		
	cmp	eax,3		       ; button in buffer ?
	jnz	@f
	call	button
	ret
      @@:
	cmp	eax,2		       ; key in buffer ?
	jnz	@f

	call	key
      @@:
	;jz      key
      ;  cmp     eax, 2
      ;  jnz     @f
      ;
      ;  cmp     byte [playtime], 0
      ;  je      @f
	;int     0x40
      ;@@:

	ret	
	
still:
	call	process_events
	jmp	still

red:
	call	draw_window
	ret	;jmp    still

key:
	mov	eax, 2
	int	0x40

	test	al, al
	jnz	.end

	cmp	ah, 1 ; Esc
	jne	@f
	jmp	close_app
  @@:
	cmp	ah, 28 ; Enter
	jne	@f
	call	AAPlay
	jmp	.end
  @@:
	cmp	ah, 15 ; Tab
	je	.end
	cmp	ah, 29 ; Left Control
	je	.end
	cmp	ah, 42 ; Left Shift
	je	.end

	cmp	ah, 14 ; BackSpace
	jne	@f
	
	; strlen(filename)
	mov	edi, filename
	xor	al, al	; search for the end of the filename
	repne	scasb
	cmp	edi, filename+2
	jl	.end

	cmp	edi, filename+2
	jl	.end
	mov	byte [edi-2], 0
	
	call	print_filename
	jmp	.end

  @@:
	cmp	ah, 57 ; Space
	je	.input_symbol
	cmp	ah, 2
	jl	.end
	cmp	ah, 54
	jg	.end

  .input_symbol:
	mov	byte [stop], 1
	call	reload_ascii_keymap
	; strlen(filename)
	mov	edi, filename
	xor	al, al	; search for the end of the filename
	repne	scasb
	cmp	edi, filename+52
	jg	.end
	
	shr	ax, 8
	and	eax, 0x7F
	mov	al, byte [keymap+eax]	; Read ASCII from the keymap table.
	mov	byte [edi-1], al
	mov	byte [edi], 0
	
	call	print_filename
  .end:
	ret
	
button:
	mov	eax, 17 	    ; Get pressed button code
	int	0x40

	cmp	ah, 1		    ; Test x button
	je	close_app

	cmp	ah, 2		    ; Test "Play" button
	jne	@f
	call	AAPlay
	jmp	.end
  @@:
	
	cmp	ah, 3		    ; Test "Pause" button
	jne	@f
	cmp	byte [playtime], 1
	jne	@f
	
	not	byte [pausetime]
      .pause:
	call	process_events
	cmp	byte [pausetime], 0
	jne	.pause

  @@:
	cmp	ah, 4		    ; Test "Stop" button
	jne	@f
	mov	byte [stop], 1
	jne	@f
  @@:

  .end:
	ret
close_app:

    cmp     dword [image], 0
    je	    @f
    call    TFliPlayer_Done
  @@:
    mov  eax,-1 		 ; close this program
    int  0x40
	
	
; DATA  
; Application Title
labelt		db	'FLI Player v0.31',0
keyText 	db	'|-_'


error_text	db	"Can't load file.",0
filepos 	dd	0x0
filetype	db	0     ; 0 - unsupported, 1 - fli, 2 - flc

playtime	db	0
pausetime	db	0
stop		db	0

pal		rb	256*4
image		dd	0
InfoStructure:	
			dd	0x0	; subfunction number
			dd	filepos ; position in the file in bytes
			dd	0x0	; upper part of the position address
			dd	0x0	; number of     bytes to read
			dd	0x0	; pointer to the buffer to write data
			db	0
			dd	filename

keymap	rb	128
			
I_END:

Buffer		dd	?
Interval	dw	?

Chunks		dw	?

FrameSize	dd	?
RestartPos	dd	?
Frame		dw	?

MainHeader	MainHeaderRec
FrameHeader	FrameHeaderRec

filename	db	'/hd0/2/',0
		rb	46