Subversion Repositories Kolibri OS

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