Questo sito utilizza cookies solo per scopi di autenticazione sul sito e nient'altro. Nessuna informazione personale viene tracciata. Leggi l'informativa sui cookies.
Username: Password: oppure
Midgen - writer.s

writer.s

Caricato da: ZioCrocifisso
Scarica il programma completo

  1. %include "src/parser.inc"
  2.  
  3. global write
  4.  
  5. extern fildes
  6. extern parse
  7. extern tokenid
  8. extern tokenval
  9. extern vlqencode
  10. extern vlqlen
  11. extern written
  12.  
  13. section .bss
  14.         buffer resb 1024
  15.         onnotes resb 256
  16.  
  17. section .data
  18.         buflen dd 0
  19.         totlen dd 0
  20.         base dd 70
  21.         channel dd 0
  22.         volume dd 127
  23.         delta dd 64
  24.         nextdelta dd 0
  25.         stopmode dd 0
  26.  
  27. section .text
  28. write:
  29.         mov eax, [tokenid]
  30.         jmp [eax * 4 + .table]
  31.  
  32.         .set_base:
  33.                 cmp dword [tokenval], 127
  34.                 jg parse
  35.                 mov eax, [tokenval]
  36.                 mov [base], eax
  37.                 jmp parse
  38.  
  39.         .write_instrument:
  40.                 cmp dword [tokenval], 127
  41.                 jg parse
  42.                 mov byte [buffer], 0
  43.                 mov eax, 0xC0
  44.                 or eax, [channel]
  45.                 mov byte [buffer + 1], al
  46.                 mov eax, [tokenval]
  47.                 mov byte [buffer + 2], al
  48.                 mov dword [buflen], 3
  49.                 jmp .writeall
  50.  
  51.         .set_channel:
  52.                 cmp dword [tokenval], 15
  53.                 jg parse
  54.                 mov eax, [tokenval]
  55.                 mov [channel], eax
  56.                 jmp parse
  57.  
  58.         .write_tempo:
  59.                 mov byte [buffer], 0
  60.                 mov byte [buffer + 1], 0xFF
  61.                 mov byte [buffer + 2], 0x51
  62.                 mov byte [buffer + 3], 0x03
  63.                 mov ebx, [tokenval]
  64.                 mov eax, 60000000
  65.                 mov edx, 0
  66.                 div ebx
  67.                 shl eax, 8
  68.                 bswap eax
  69.                 mov dword [buffer + 4], eax
  70.  
  71.                 add dword [buflen], 7
  72.                 jmp .writeall
  73.  
  74.         .write_volume:
  75.                 mov ebx, [tokenval]
  76.                 cmp ebx, 127
  77.                 jg parse
  78.                 mov [volume], ebx
  79.                 mov byte [buffer], 0
  80.                 mov eax, 0xB0
  81.                 or eax, [channel]
  82.                 mov byte [buffer + 1], al
  83.                 mov byte [buffer + 2], 0x07
  84.                 mov byte [buffer + 3], bl
  85.                 mov dword [buflen], 4
  86.                 jmp .writeall
  87.  
  88.         .set_delta:
  89.                 mov eax, [tokenval]
  90.                 mov [delta], eax
  91.                 jmp parse
  92.  
  93.         .write_noteon:
  94.                 cmp dword [nextdelta], 0
  95.                 je .nodelete
  96.                 call stopall
  97.  
  98.                 .nodelete:
  99.                 push dword 0x90
  100.                 mov ecx, [tokenval]
  101.                 add ecx, [base]
  102.                 push ecx
  103.                 call writenote
  104.                 pop ecx
  105.                 add esp, 4
  106.  
  107.                 mov eax, [delta]
  108.                 mov [nextdelta], eax
  109.  
  110.                 mov eax, 1
  111.                 mov ebx, ecx
  112.                 mov ecx, [channel]
  113.                 shl eax, cl
  114.                 or [onnotes + ebx * 2], ax
  115.  
  116.                 jmp .writeall
  117.  
  118.         .write_noteoff:
  119.                 mov eax, [tokenval]
  120.                 add eax, [base]
  121.                 push eax
  122.                 call stopnote
  123.                 add esp, 4
  124.                 jmp parse
  125.  
  126.         .set_continue:
  127.                 mov eax, [delta]
  128.                 add dword [nextdelta], eax
  129.                 jmp parse
  130.  
  131.         .set_zerodelta:
  132.                 mov dword [nextdelta], 0
  133.                 jmp parse
  134.  
  135.         .set_incdelta:
  136.                 shl dword [nextdelta], 1
  137.                 jmp parse
  138.  
  139.         .set_decdelta:
  140.                 shr dword [nextdelta], 1
  141.                 jmp parse
  142.  
  143.         .write_incvolume:
  144.                 add dword [volume], 5
  145.                 mov eax, [volume]
  146.                 mov [tokenval], eax
  147.                 cmp eax, 123
  148.                 jl .write_volume
  149.  
  150.         .write_decvolume:
  151.                 sub dword [volume], 5
  152.                 mov eax, [volume]
  153.                 mov [tokenval], eax
  154.                 cmp eax, 4
  155.                 jg .write_volume
  156.  
  157.         .write_start:
  158.                 mov dword [buffer], 0x6468544D
  159.                 mov dword [buffer + 4], 0x06000000
  160.                 mov word [buffer + 8], 0x0000
  161.                 mov word [buffer + 10], 0x0100
  162.                 mov word [buffer + 12], 0x4000
  163.                 mov dword [buffer + 14], 0x6B72544D
  164.                 mov dword [buffer + 18], 0x00FFFF00
  165.                 mov dword [buflen], 22
  166.                 jmp .writeall
  167.  
  168.         .write_end:
  169.                 mov dword [stopmode], 1
  170.                 call stopall
  171.  
  172.                 .write_size:
  173.                 mov eax, 19
  174.                 mov ebx, [fildes]
  175.                 mov ecx, 18
  176.                 mov edx, 0
  177.                 int 0x80
  178.  
  179.                 cmp eax, 0
  180.                 jl .nosize
  181.  
  182.                 mov eax, 0x04
  183.                 mov ebx, [fildes]
  184.                 mov ecx, [totlen]
  185.                 sub ecx, 18
  186.                 bswap ecx
  187.                 mov [buffer], ecx
  188.                 mov ecx, buffer
  189.                 mov edx, 4
  190.                 int 0x80
  191.  
  192.                 mov eax, 19
  193.                 mov ebx, [fildes]
  194.                 mov ecx, 0
  195.                 mov edx, 2
  196.                 int 0x80
  197.  
  198.                 .nosize:
  199.                 mov byte [buffer], 0
  200.                 mov byte [buffer + 1], 0xFF
  201.                 mov byte [buffer + 2], 0x2F
  202.                 mov byte [buffer + 3], 0
  203.                 mov dword [buflen], 4
  204.                 jmp .writeall
  205.  
  206.         .writeall:
  207.                 mov eax, 0x4
  208.                 mov ebx, [fildes]
  209.                 mov ecx, buffer
  210.                 mov edx, [buflen]
  211.                 int 0x80
  212.  
  213.                 mov eax, [buflen]
  214.                 add [totlen], eax
  215.                 mov dword [buflen], 0
  216.  
  217.                 ;mov eax, 118
  218.                 ;mov ebx, 0x01
  219.                 ;int 0x80
  220.  
  221.                 cmp dword [tokenid], TOKEN_END
  222.                 je written
  223.                 jmp parse
  224.  
  225.         .set_stopmode:
  226.                 not dword [stopmode]
  227.                 jmp parse
  228.  
  229.         .table:
  230.                 dd .set_base
  231.                 dd .write_instrument
  232.                 dd .set_channel
  233.                 dd .write_tempo
  234.                 dd .write_volume
  235.                 dd .set_delta
  236.                 dd .write_noteon
  237.                 dd .write_noteoff
  238.                 dd .set_continue
  239.                 dd .set_zerodelta
  240.                 dd .set_incdelta
  241.                 dd .set_decdelta
  242.                 dd .write_incvolume
  243.                 dd .write_decvolume
  244.                 dd .write_start
  245.                 dd .write_end
  246.                 dd .set_stopmode
  247.  
  248. writedelta:
  249.         push dword [nextdelta]
  250.         call vlqencode
  251.         add esp, 4
  252.  
  253.         mov ebx, [buflen]
  254.         mov dword [buffer + ebx], eax
  255.  
  256.         push eax
  257.         call vlqlen
  258.         add esp, 4
  259.  
  260.         ret
  261.  
  262. writenote:
  263.         call writedelta
  264.         mov dword [nextdelta], 0
  265.         lea ebx, [buffer + eax]
  266.         add ebx, [buflen]
  267.  
  268.         mov ecx, [esp + 8]
  269.         or ecx, [channel]
  270.  
  271.         mov byte [ebx], cl
  272.         mov ecx, [esp + 4]
  273.         mov byte [ebx + 1], cl
  274.         mov byte [ebx + 2], 127
  275.         add [buflen], eax
  276.         add dword [buflen], 3
  277.  
  278.         ret
  279.  
  280. stopnote:
  281.         push dword 0x80
  282.         push dword [esp + 8]
  283.         call writenote
  284.         add esp, 8
  285.         mov eax, 1
  286.         mov ecx, [channel]
  287.         mov edx, [esp + 4]
  288.         shl eax, cl
  289.         not eax
  290.         and [onnotes + edx], eax
  291.         ret
  292.  
  293. stopall:
  294.         push dword [channel]
  295.         mov edx, 128
  296.  
  297.         .delloop:
  298.                 dec edx
  299.                 cmp edx, 0
  300.                 jl .exit
  301.  
  302.                 mov ax, [onnotes + edx * 2]
  303.  
  304.                 cmp dword [stopmode], 0
  305.                 mov ecx, 16
  306.                 jne .chanloop
  307.  
  308.                 mov ebx, 1
  309.                 mov ecx, [channel]
  310.                 shl ebx, cl
  311.                 test eax, ebx
  312.                 jz .delloop
  313.  
  314.                 push edx
  315.                 call stopnote
  316.                 pop edx
  317.  
  318.                 jmp .delloop
  319.  
  320.                 .chanloop:
  321.                         test ecx, ecx
  322.                         jz .delloop
  323.  
  324.                         dec ecx
  325.                         mov ebx, 1
  326.                         shl ebx, cl
  327.                         test eax, ebx
  328.                         jz .chanloop
  329.  
  330.                         mov [channel], ecx
  331.                         push ecx
  332.                         push edx
  333.                         call stopnote
  334.                         pop edx
  335.                         pop ecx
  336.  
  337.                         jmp .chanloop
  338.  
  339.         .exit:
  340.         pop dword [channel]
  341.  
  342.         ret