Subversion Repositories Kolibri OS

Rev

Rev 5273 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;                                                              ;;
  3. ;; Copyright (C) KolibriOS team 2006-2015. All rights reserved. ;;
  4. ;; Distributed under terms of the GNU General Public License    ;;
  5. ;;                                                              ;;
  6. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  7.  
  8. ; Serge 2006-2008
  9. ; email: infinity_sound@mail.ru
  10.  
  11. format PE DLL native 0.05
  12. entry START
  13.  
  14. DEBUG             equ 1
  15.  
  16.  
  17. CURRENT_API     equ   0x0101      ;1.01
  18. COMPATIBLE_API equ   0x0100      ;1.00
  19.  
  20. API_VERSION     equ   (COMPATIBLE_API shl 16) or CURRENT_API
  21. SOUND_VERSION   equ   CURRENT_API
  22.  
  23.  
  24. FORCE_MMX         equ 0  ;set to 1 to force use mmx or
  25. FORCE_MMX_128     equ 0  ;integer sse2 extensions
  26.                          ;and reduce driver size
  27.  
  28. ;USE_SSE          equ 0
  29.  
  30. USE_SSE2_MIXER   equ 0  ;floating point mixer. Disabled by default
  31.  
  32. OS_BASE           equ 0x80000000
  33.  
  34. CAPS_SSE2         equ 26
  35. PG_SW             equ 0x003
  36.  
  37. RT_INP_EMPTY     equ 0xFF000001
  38. RT_OUT_EMPTY     equ 0xFF000002
  39. RT_INP_FULL       equ 0xFF000003
  40. RT_OUT_FULL       equ 0xFF000004
  41.  
  42. EVENT_WATCHED     equ 0x10000000
  43. EVENT_SIGNALED   equ 0x20000000
  44. MANUAL_RESET     equ 0x40000000
  45. MANUAL_DESTROY   equ 0x80000000
  46.  
  47. DEV_PLAY         equ 1
  48. DEV_STOP         equ 2
  49. DEV_CALLBACK     equ 3
  50. DEV_GET_POS       equ 9
  51.  
  52. section '.flat' code readable executable
  53. include '../../struct.inc'
  54. include '../../macros.inc'
  55. include '../../proc32.inc'
  56. include 'main.inc'
  57. include '../../peimport.inc'
  58.  
  59.  
  60.  
  61. proc START c uses ebx esi edi, state:dword, cmdline:dword
  62.  
  63.         cmp     [state], 1
  64.         jne     .exit
  65.  
  66.         invoke  GetService, szSound
  67.         test    eax, eax
  68.         jz      .fail
  69.         mov     [hSound], eax
  70.  
  71.         invoke  KernelAlloc, 16*512
  72.         test    eax, eax
  73.         jz      .out_of_mem
  74.         mov     [mix_buff], eax
  75.  
  76.         mov     eax, str.fd-FD_OFFSET
  77.         mov     [str.fd], eax
  78.         mov     [str.bk], eax
  79.  
  80. if FORCE_MMX
  81.  if FORCE_MMX_128
  82.   display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
  83.   stop
  84.  end if
  85.         mov     [mix_2_core], mmx_mix_2
  86.         mov     [mix_3_core], mmx_mix_3
  87.         mov     [mix_4_core], mmx_mix_4
  88. end if
  89.  
  90. if FORCE_MMX_128
  91.  if FORCE_MMX
  92.   display 'Use only FORCE_MMX or FORCE_MMX_128 not both together',13,10
  93.   stop
  94.  end if
  95.         mov     [mix_2_core], mmx128_mix_2
  96.         mov     [mix_3_core], mmx128_mix_3
  97.         mov     [mix_4_core], mmx128_mix_4
  98. end if
  99.  
  100. if 0
  101.  
  102. if ~(FORCE_MMX or FORCE_MMX_128)  ;autodetect
  103.         mov     eax, 1
  104.         cpuid
  105.         bt      edx, CAPS_SSE2
  106.         jc      .mmx128
  107.                                            ;old 64-bit mmx
  108.         mov     [mix_2_core], mmx_mix_2
  109.         mov     [mix_3_core], mmx_mix_3
  110.         mov     [mix_4_core], mmx_mix_4
  111.         jmp     @F
  112. .mmx128:                                   ;128-bit integer sse2 extensions
  113.         mov     [mix_2_core], mmx128_mix_2
  114.         mov     [mix_3_core], mmx128_mix_3
  115.         mov     [mix_4_core], mmx128_mix_4
  116. @@:
  117. end if
  118.  
  119. end if
  120.         stdcall set_handler, [hSound], new_mix
  121.         mov     [eng_state], SND_STOP
  122.         invoke  RegService, szInfinity, service_proc
  123.         ret
  124. .fail:
  125.      if DEBUG
  126.         mov     esi, msgFail
  127.         invoke  SysMsgBoardStr
  128.      end if
  129. .exit:
  130.         xor     eax, eax
  131.         ret
  132.  
  133. .out_of_mem:
  134.      if DEBUG
  135.         mov     esi, msgMem
  136.         invoke  SysMsgBoardStr
  137.      end if
  138.         xor     eax, eax
  139.         ret
  140. endp
  141.  
  142. align 4
  143.  
  144. srv_calls  dd service_proc.srv_getversion       ; 0
  145.            dd service_proc.snd_create_buff      ; 1
  146.            dd service_proc.snd_destroy_buff     ; 2
  147.            dd service_proc.snd_setformat        ; 3
  148.            dd service_proc.snd_getformat        ; 4
  149.            dd service_proc.snd_reset            ; 5
  150.            dd service_proc.snd_setpos           ; 6
  151.            dd service_proc.snd_getpos           ; 7
  152.            dd service_proc.snd_setbuff          ; 8
  153.            dd service_proc.snd_out              ; 9
  154.            dd service_proc.snd_play             ; 10
  155.            dd service_proc.snd_stop             ; 11
  156.            dd service_proc.snd_setvolume        ; 12
  157.            dd service_proc.snd_getvolume        ; 13
  158.            dd service_proc.snd_setpan           ; 14
  159.            dd service_proc.snd_getpan           ; 15
  160.            dd service_proc.snd_getbuffsize      ; 16
  161.            dd service_proc.snd_getfreespace     ; 17
  162.            dd service_proc.snd_settimebase      ; 18
  163.            dd service_proc.snd_gettimestamp     ; 19
  164. srv_calls_end:
  165.  
  166. proc service_proc stdcall, ioctl:dword
  167.  
  168.         mov     edi, [ioctl]
  169.         mov     eax, [edi+IOCTL.io_code]
  170.  
  171.         cmp     eax, (srv_calls_end-srv_calls)/4
  172.         ja      .fail
  173.  
  174.         cmp     eax, SND_DESTROY_BUFF
  175.         jb      @F
  176.  
  177. ;           cmp [edi+inp_size], 4
  178. ;           jb .fali
  179.  
  180.         mov     ebx, [edi+IOCTL.input]
  181.         mov     edx, [ebx]
  182.  
  183.         cmp     [edx+STREAM.magic], 'WAVE'
  184.         jne     .fail
  185.  
  186.         cmp     [edx+STREAM.size], STREAM.sizeof
  187.         jne     .fail
  188.  
  189. @@:
  190.         jmp     [srv_calls+eax*4]
  191.  
  192.  
  193. .fail:
  194.         mov     eax, -1
  195.         ret
  196.  
  197. align 4
  198. .srv_getversion:
  199.         mov     eax, [edi+IOCTL.output]
  200.         cmp     [edi+IOCTL.out_size], 4
  201.         jne     .fail
  202.         mov     eax, [eax]
  203.         mov     [eax], dword API_VERSION
  204.         xor     eax, eax
  205.         ret
  206.  
  207. align 4
  208. .snd_create_buff:
  209.         mov     ebx, [edi+IOCTL.input]
  210.         stdcall CreateBuffer, [ebx], [ebx+4]
  211.         mov     edi, [ioctl]
  212.         mov     ecx, [edi+IOCTL.output]
  213.         mov     ecx, [ecx]
  214.         mov     [ecx], ebx
  215.         ret
  216.  
  217. align 4
  218. .snd_destroy_buff:
  219.         mov     eax, edx
  220.         call    DestroyBuffer
  221.         ret
  222.  
  223. align 4
  224. .snd_setformat:
  225.         stdcall SetFormat, edx, [ebx+4]
  226.         ret
  227.  
  228. align 4
  229. .snd_getformat:
  230.         movzx   eax, word [edx+STREAM.format]
  231.         mov     ecx, [edi+IOCTL.output]
  232.         mov     ecx, [ecx]
  233.         mov     [ecx], eax
  234.         xor     eax, eax
  235.         ret
  236.  
  237. align 4
  238. .snd_reset:
  239.         stdcall ResetBuffer, edx, [ebx+4]
  240.         ret
  241.  
  242. align 4
  243. .snd_setpos:
  244.         stdcall SetBufferPos, edx, [ebx+4]
  245.         ret
  246.  
  247. align 4
  248. .snd_getpos:
  249.         stdcall GetBufferPos, edx
  250.         mov     edi, [ioctl]
  251.         mov     ecx, [edi+IOCTL.output]
  252.         mov     ecx, [ecx]
  253.         mov     [ecx], ebx
  254.         ret
  255.  
  256. align 4
  257. .snd_setbuff:
  258.         mov     eax, [ebx+4]
  259.         stdcall set_buffer, edx, eax, [ebx+8], [ebx+12]
  260.         ret
  261.  
  262. align 4
  263. .snd_out:
  264.         mov     eax, [ebx+4]
  265.         stdcall wave_out, edx, eax, [ebx+8]
  266.         ret
  267.  
  268. align 4
  269. .snd_play:
  270.         stdcall play_buffer, edx, [ebx+4]
  271.         ret
  272.  
  273. align 4
  274. .snd_stop:
  275.         stdcall stop_buffer, edx
  276.         ret
  277.  
  278. align 4
  279. .snd_setvolume:
  280.         stdcall SetBufferVol, edx, [ebx+4], [ebx+8]
  281.         ret
  282.  
  283. align 4
  284. .snd_getvolume:
  285.         mov     eax, [edi+IOCTL.output]
  286.         mov     ecx, [eax]
  287.         mov     eax, [eax+4]
  288.         stdcall GetBufferVol, edx, ecx, eax
  289.         ret
  290. align 4
  291. .snd_setpan:
  292.         stdcall SetBufferPan, edx, [ebx+4]
  293.         ret
  294.  
  295. align 4
  296. .snd_getpan:
  297.         mov     eax, [edx+STREAM.pan]
  298.         mov     ebx, [edi+IOCTL.output]
  299.         mov     ebx, [ebx]
  300.         mov     [ebx], eax
  301.         xor     eax, eax
  302.         ret
  303.  
  304. align 4
  305. .snd_getbuffsize:
  306.         test    [edx+STREAM.format], PCM_RING
  307.         mov     eax, [edx+STREAM.in_size]
  308.         jz      @F
  309.  
  310.         mov     eax, [edx+STREAM.r_size]
  311.         add     eax, eax
  312. @@:
  313.         mov     ecx, [edi+IOCTL.output]
  314.         mov     ecx, [ecx]
  315.         mov     [ecx], eax
  316.         xor     eax, eax
  317.         ret
  318.  
  319. align 4
  320. .snd_getfreespace:
  321.         test    [edx+STREAM.format], PCM_OUT
  322.         jz      .fail
  323.  
  324.         mov     ebx, [edx+STREAM.in_free]
  325.         mov     ecx, [edi+IOCTL.output]
  326.         mov     [ecx], ebx
  327.         xor     eax, eax
  328.         ret
  329. align 4
  330. .snd_settimebase:
  331.         cmp     [edi+IOCTL.inp_size], 12
  332.         jne     .fail
  333.  
  334.         mov     eax, [ebx+4]
  335.         mov     ebx, [ebx+8]
  336.  
  337.         pushfd
  338.         cli
  339.         mov     dword [edx+STREAM.time_base], eax
  340.         mov     dword [edx+STREAM.time_base+4], ebx
  341.         xor     eax, eax
  342.         mov     dword [edx+STREAM.time_stamp], eax
  343.         mov     dword [edx+STREAM.time_stamp+4], eax
  344.         popfd
  345.  
  346.         ret
  347.  
  348. align 4
  349. .snd_gettimestamp:
  350.         cmp     [edi+IOCTL.out_size], 8
  351.         jne     .fail
  352.  
  353.         pushfd
  354.         cli
  355.  
  356.         xor     ebx, ebx
  357.         push    48
  358.         push    ebx            ; local storage
  359.  
  360.         cmp     [edx+STREAM.flags], SND_STOP
  361.         je      @F
  362.  
  363.         mov     eax, esp
  364.  
  365.         push    ebx
  366.         push    ecx
  367.         push    edx
  368.         push    esi
  369.         push    edi
  370.  
  371.         push    4              ;.out_size
  372.         push    eax            ;.output
  373.         push    ebx            ;.inp_size
  374.         push    ebx            ;.input
  375.         push    DEV_GET_POS    ;.code
  376.         push    dword [hSound] ;.handle
  377.         mov     eax, esp
  378.  
  379.         invoke  ServiceHandler, eax
  380.         add     esp, 6*4
  381.  
  382.         pop     edi
  383.         pop     esi
  384.         pop     edx
  385.         pop     ecx
  386.         pop     ebx
  387.  
  388.         test    eax, eax
  389.         jz      @F
  390.  
  391.         mov     dword [esp], 0  ; clear offset
  392. @@:
  393.         mov     edi, [edi+IOCTL.output]
  394.  
  395.         emms
  396.         fild    qword [edx+STREAM.time_stamp]
  397.         fiadd   dword [esp]     ; primary buffer offset
  398.         fidiv   dword [esp+4]   ; total_samples / frequency
  399.         fadd    qword [edx+STREAM.time_base]
  400.         fstp    qword [edi]
  401.         add     esp, 8
  402.  
  403.         popfd
  404.  
  405.         xor     eax, eax
  406.         ret
  407. endp
  408.  
  409.  
  410. restore   handle
  411. restore   io_code
  412. restore   input
  413. restore   inp_size
  414. restore   output
  415. restore   out_size
  416.  
  417. align 4
  418. proc CreateBuffer stdcall, format:dword, size:dword
  419.            locals
  420.         str     dd ?
  421.              ring_size   dd ?
  422.              ring_pages  dd ?
  423.            endl
  424.  
  425.         mov     eax, [format]
  426.         cmp     ax, PCM_1_8_8
  427.         ja      .fail
  428.  
  429.         test    eax, PCM_OUT
  430.         jnz     .test_out
  431.         test    eax, PCM_RING
  432.         jnz     .test_ring
  433. ;staic
  434.         test    eax, PCM_STATIC
  435.         jz      .test_out                 ;use PCM_OUT as default format
  436.         jmp     .test_ok
  437. .test_out:
  438.         test    eax, PCM_RING+PCM_STATIC
  439.         jnz     .fail
  440.         or      [format], PCM_OUT         ;force set
  441.         jmp     .test_ok
  442. .test_ring:
  443.         test    eax, PCM_OUT+PCM_STATIC
  444.         jnz     .fail
  445. .test_ok:
  446.  
  447.         invoke  GetPid
  448.         mov     ebx, eax
  449.         mov     eax, STREAM.sizeof
  450.  
  451.         invoke  CreateObject
  452.         test    eax, eax
  453.         jz      .fail
  454.         mov     [str], eax
  455.  
  456.         mov     ebx, [format]
  457.         mov     [eax+STREAM.format], ebx
  458.  
  459.         xor     ecx, ecx
  460.         movzx   ebx, bx
  461.         cmp     ebx, 19
  462.         jb      @f
  463.         mov     ecx, 0x80808080
  464. @@:
  465.         mov     [eax+STREAM.r_silence], ecx
  466.  
  467.         shl     ebx, 2
  468.         lea     ebx, [ebx+ebx*2]    ;ebx*=12
  469.  
  470.         mov     ecx, [resampler_params+ebx]
  471.         mov     edx, [resampler_params+ebx+4]
  472.         mov     esi, [resampler_params+ebx+8]
  473.  
  474.         mov     [eax+STREAM.r_size], ecx
  475.         mov     [eax+STREAM.r_dt], edx
  476.         mov     [eax+STREAM.resample], esi
  477.         xor     ecx, ecx
  478.         mov     [eax+STREAM.l_vol], ecx
  479.         mov     [eax+STREAM.r_vol], ecx
  480.         mov     dword [eax+STREAM.l_amp], 0x7FFF7FFF
  481.         mov     [eax+STREAM.pan], ecx
  482.  
  483.         test    [format], PCM_STATIC
  484.         jnz     .static
  485.  
  486. ; ring and waveout
  487.  
  488.         mov     ebx, 0x10000
  489.         test    [format], PCM_RING
  490.         jz      .waveout
  491.  
  492.         mov     ebx, [eax+STREAM.r_size]
  493.         add     ebx, 4095
  494.         and     ebx, -4096
  495.         add     ebx, ebx
  496. .waveout:
  497.         mov     [ring_size], ebx
  498.         mov     eax, ebx
  499.         shr     ebx, 12
  500.         mov     [ring_pages], ebx
  501.  
  502.         invoke  CreateRingBuffer, eax, PG_SW
  503.  
  504.         mov     edi, [str]
  505.         mov     ecx, [ring_size]
  506.         mov     [edi+STREAM.in_base], eax
  507.         mov     [edi+STREAM.in_size], ecx
  508.         add     eax, 128
  509.         mov     [edi+STREAM.in_wp], eax
  510.         mov     [edi+STREAM.in_rp], eax
  511.         mov     [edi+STREAM.in_count], 0
  512.  
  513.         mov     [edi+STREAM.in_free], ecx
  514.         add     eax, ecx
  515.         mov     [edi+STREAM.in_top], eax
  516.  
  517.         jmp     .out_buff
  518. .static:
  519.         mov     ecx, [size]
  520.         add     ecx, 128         ;resampler required
  521.         mov     [eax+STREAM.in_size], ecx
  522.         invoke  KernelAlloc, ecx
  523.  
  524.         mov     edi, [str]
  525.         mov     [edi+STREAM.in_base], eax
  526.         add     eax, 128
  527.         mov     [edi+STREAM.in_wp], eax
  528.         mov     [edi+STREAM.in_rp], eax
  529.         mov     ebx, [size]
  530.         mov     [edi+STREAM.in_count], ebx
  531.         mov     [edi+STREAM.in_free], ebx
  532.         add     eax, ebx
  533.         mov     [edi+STREAM.in_top], eax
  534.  
  535. .out_buff:
  536.         invoke  AllocKernelSpace, dword 128*1024
  537.  
  538.         mov     edi, [str]
  539.         xor     ebx, ebx
  540.  
  541.         mov     [edi+STREAM.out_base], eax
  542.         mov     [edi+STREAM.out_wp], eax
  543.         mov     [edi+STREAM.out_rp], eax
  544.         mov     [edi+STREAM.out_count], ebx
  545.         add     eax, 64*1024
  546.         mov     [edi+STREAM.out_top], eax
  547.  
  548.         mov     dword [edi+STREAM.time_base], ebx
  549.         mov     dword [edi+STREAM.time_base+4], ebx
  550.  
  551.         mov     dword [edi+STREAM.time_stamp], ebx
  552.         mov     dword [edi+STREAM.time_stamp+4], ebx
  553.         mov     dword [edi+STREAM.last_ts], ebx
  554.  
  555.         invoke  AllocPages, dword 64/4
  556.         mov     edi, [str]
  557.         mov     ebx, [edi+STREAM.out_base]
  558.         mov     ecx, 16
  559.         or      eax, PG_SW
  560.         push    eax
  561.         push    ebx
  562.         invoke  CommitPages ;eax, ebx, ecx
  563.         mov     ecx, 16
  564.         pop     ebx
  565.         pop     eax
  566.         add     ebx, 64*1024
  567.         invoke  CommitPages    ;double mapped
  568.  
  569.         mov     edi, [str]
  570.         mov     ecx, [edi+STREAM.in_top]
  571.         mov     edi, [edi+STREAM.in_base]
  572.         sub     ecx, edi
  573.         xor     eax, eax
  574.         shr     ecx, 2
  575.         cld
  576.         rep stosd
  577.  
  578.         mov     edi, [str]
  579.         mov     edi, [edi+STREAM.out_base]
  580.         mov     ecx, (64*1024)/4
  581.         rep stosd
  582.  
  583.         xor     esi, esi
  584.         mov     ecx, MANUAL_DESTROY
  585.         invoke  CreateEvent
  586.  
  587.         mov     ebx, [str]
  588.         mov     [ebx+STREAM.notify_event], eax
  589.         mov     [ebx+STREAM.notify_id], edx
  590.  
  591.         mov     [ebx+STREAM.magic], 'WAVE'
  592.         mov     [ebx+STREAM.destroy], DestroyBuffer.destroy
  593.         mov     [ebx+STREAM.size], STREAM.sizeof
  594.         mov     [ebx+STREAM.flags], SND_STOP
  595.  
  596.         pushf
  597.         cli
  598.         mov     eax, str.fd-FD_OFFSET
  599.         mov     edx, [eax+STREAM.str_fd]
  600.         mov     [ebx+STREAM.str_fd], edx
  601.         mov     [ebx+STREAM.str_bk], eax
  602.         mov     [eax+STREAM.str_fd], ebx
  603.         mov     [edx+STREAM.str_bk], ebx
  604.         popf
  605.  
  606.         xor     eax, eax
  607.         ret
  608. .fail:
  609.         xor     ebx, ebx
  610.         or      eax, -1
  611.         ret
  612. endp
  613.  
  614. ;param
  615. ; eax= buffer handle
  616.  
  617. align 4
  618. DestroyBuffer:
  619.            .handle equ esp       ;local
  620.  
  621.         mov     [eax+STREAM.flags], SND_STOP
  622. .destroy:
  623.         push    eax
  624.  
  625.         pushfd
  626.         cli
  627.         mov     ebx, [eax+STREAM.str_fd]
  628.         mov     ecx, [eax+STREAM.str_bk]
  629.         mov     [ebx+STREAM.str_bk], ecx
  630.         mov     [ecx+STREAM.str_fd], ebx
  631.         popf
  632.  
  633.         invoke  KernelFree, [eax+STREAM.in_base]
  634.         mov     eax, [.handle]
  635.         invoke  KernelFree, [eax+STREAM.out_base]
  636.  
  637.         pop     eax              ;restore stack
  638.         invoke  DestroyObject    ;eax= stream
  639.         xor     eax, eax
  640.         ret
  641. .fail:
  642.         or      eax, -1
  643.         ret
  644. restore .handle
  645.  
  646. align 4
  647. proc SetFormat stdcall, str:dword, format:dword
  648.  
  649.         cmp     word [format], PCM_1_8_8
  650.         ja      .fail
  651.  
  652.         mov     edx, [str]
  653.         mov     [edx+STREAM.flags], SND_STOP
  654.  
  655.         test    [edx+STREAM.format], PCM_RING
  656.         jnz     .fail
  657.  
  658. ;           mov eax,[edx+STREAM.out_base]
  659. ;           mov [edx+STREAM.out_wp], eax
  660. ;           mov [edx+STREAM.out_rp], eax
  661. ;           mov [edx+STREAM.out_count], 0
  662.  
  663.         movzx   eax, word [format]
  664.         mov     word [edx+STREAM.format], ax
  665.  
  666.         xor     ebx, ebx
  667.         cmp     eax, 19
  668.         jb      @f
  669.         mov     ebx, 0x80808080
  670. @@:
  671.         mov     [edx+STREAM.r_silence], ebx
  672.  
  673.         shl     eax, 2
  674.         lea     eax, [eax+eax*2]    ;eax*=12
  675.  
  676.         mov     edi, [resampler_params+eax]
  677.         mov     ecx, [resampler_params+eax+4]
  678.         mov     ebx, [resampler_params+eax+8]
  679.  
  680.         mov     [edx+STREAM.r_size], edi
  681.         mov     [edx+STREAM.r_dt], ecx
  682.         mov     [edx+STREAM.resample], ebx
  683.  
  684.         mov     edi, [edx+STREAM.in_base]
  685.         mov     ecx, 128/4
  686.         mov     eax, [edx+STREAM.r_silence]
  687.         cld
  688.         rep stosd
  689.         xor     eax, eax
  690.         ret
  691. .fail:
  692.         or      eax, -1
  693.         ret
  694. endp
  695.  
  696. ; for static buffers only
  697. ; use waveout for streams
  698.  
  699. align 4
  700. proc set_buffer stdcall, str:dword,src:dword,offs:dword,size:dword
  701.  
  702.         mov     edx, [str]
  703.         test    [edx+STREAM.format], PCM_OUT
  704.         jnz     .fail
  705.  
  706.         mov     esi, [src]
  707.         mov     edi, [offs]
  708.         add     edi, [edx+STREAM.in_base]
  709.         add     edi, 128
  710.  
  711.         cmp     edi, [edx+STREAM.in_top]
  712.         jae     .fail
  713.  
  714.         mov     ecx, [size]
  715.         lea     ebx, [ecx+edi]
  716.         sub     ebx, [edx+STREAM.in_top]
  717.         jb      @F
  718.         sub     ecx, ebx
  719. @@:
  720.         shr     ecx, 2
  721.         cld
  722.         rep movsd
  723.         xor     eax, eax
  724.         ret
  725. .fail:
  726.         or      eax, -1
  727.         ret
  728. endp
  729.  
  730. ; for stream buffers only
  731.  
  732. align 4
  733. proc wave_out stdcall, str:dword,src:dword,size:dword
  734.            locals
  735.              state_saved  dd ?
  736.              fpu_state    rb 528
  737.            endl
  738.  
  739.         mov     edx, [str]
  740.         mov     eax, [edx+STREAM.format]
  741.         test    eax, PCM_OUT
  742.         jz      .fail
  743.  
  744.         cmp     ax, PCM_ALL
  745.         je      .fail
  746.  
  747.         mov     esi, [src]
  748.         test    esi, esi
  749.         jz      .fail
  750.  
  751.         cmp     esi, OS_BASE
  752.         jae     .fail
  753.  
  754.         mov     [state_saved], 0
  755.  
  756. .main_loop:
  757.         mov     edx, [str]
  758.  
  759.         mov     ebx, [size]
  760.         test    ebx, ebx
  761.         jz      .done
  762.  
  763.         cmp     [edx+STREAM.flags], SND_STOP
  764.         jne     .fill
  765.  
  766.         mov     edi, [edx+STREAM.in_base]
  767.         mov     ecx, 128/4
  768.         mov     eax, [edx+STREAM.r_silence]
  769.         cld
  770.         rep stosd
  771.  
  772.         mov     ecx, [edx+STREAM.in_size]
  773.         sub     ecx, 128
  774.         mov     [edx+STREAM.in_wp], edi
  775.         mov     [edx+STREAM.in_rp], edi
  776.         mov     [edx+STREAM.in_count], 0
  777.         mov     [edx+STREAM.in_free], ecx
  778.  
  779.         mov     eax, [edx+STREAM.out_base]
  780.         mov     [edx+STREAM.out_wp], eax
  781.         mov     [edx+STREAM.out_rp], eax
  782.         mov     [edx+STREAM.out_count], 0
  783. .fill:
  784.         cli
  785.  
  786.         mov     ecx, [edx+STREAM.in_free]
  787.         test    ecx, ecx
  788.         jz      .wait
  789.  
  790.         cmp     ecx, ebx
  791.         jbe     @F
  792.  
  793.         mov     ecx, ebx
  794. @@:
  795.         sub     [size], ecx
  796.         add     [edx+STREAM.in_count], ecx
  797.         sub     [edx+STREAM.in_free], ecx
  798.  
  799.         shr     ecx, 2
  800.         mov     edi, [edx+STREAM.in_wp]
  801.         mov     esi, [src]
  802.         cld
  803.         rep movsd
  804.  
  805.         mov     [src], esi
  806.         cmp     edi, [edx+STREAM.in_top]
  807.         jb      @F
  808.         sub     edi, [edx+STREAM.in_size]
  809. @@:
  810.         mov     [edx+STREAM.in_wp], edi
  811.  
  812.         cmp     [edx+STREAM.out_count], 32768
  813.         jae     .skip
  814.  
  815.         cmp     [state_saved], 0
  816.         jne     @F
  817.         lea     eax, [fpu_state+15]
  818.         and     eax, -16
  819.         invoke  FpuSave
  820.         mov     [state_saved], 1
  821. @@:
  822.         stdcall refill, edx
  823.  
  824. .skip:
  825.         sti
  826.         mov     edx, [str]
  827.         mov     [edx+STREAM.flags], SND_PLAY
  828.         cmp     [eng_state], SND_PLAY
  829.         je      .main_loop
  830.  
  831.         stdcall dev_play, [hSound]
  832.         mov     [eng_state], SND_PLAY
  833.         jmp     .main_loop
  834. .wait:
  835.         sti
  836.         mov     edx, [str]
  837.         mov     eax, [edx+STREAM.notify_event]
  838.         mov     ebx, [edx+STREAM.notify_id]
  839.         invoke  WaitEvent   ;eax ebx
  840.         jmp     .main_loop
  841. .done:
  842.         cmp     [state_saved], 1
  843.         jne     @F
  844.  
  845.         lea     eax, [fpu_state+15]
  846.         and     eax, -16
  847.         invoke  FpuRestore
  848. @@:
  849.         xor     eax, eax
  850.         ret
  851. .fail:
  852.         or      eax, -1
  853.         ret
  854. endp
  855.  
  856. ; both static and stream
  857. ; reset all but not clear buffers
  858.  
  859.  
  860. ; flags reserved
  861. ;  RESET_INPUT  equ 1   ;reset and clear input buffer
  862. ;  RESET_OUTPUT equ 2   ;reset and clear output buffer
  863. ;  RESET_ALL    equ 3
  864.  
  865.  
  866. align 4
  867. proc ResetBuffer stdcall, str:dword, flags:dword
  868.  
  869.         mov     edx, [str]
  870.         mov     [edx+STREAM.flags], SND_STOP
  871.  
  872.         mov     edi, [edx+STREAM.in_base]
  873.         mov     ecx, 128/4
  874.         mov     eax, [edx+STREAM.r_silence]
  875.         cld
  876.         rep stosd
  877.  
  878.         mov     [edx+STREAM.in_wp], edi
  879.         mov     [edx+STREAM.in_rp], edi
  880.  
  881.         test    [edx+STREAM.flags], PCM_STATIC
  882.         jnz     .static
  883.         mov     [edx+STREAM.in_count], 0
  884.         jmp     @F
  885. .static:
  886.         mov     eax, [edx+STREAM.in_size]
  887.         mov     [edx+STREAM.in_count], eax
  888. @@:
  889.  
  890.         mov     eax, [edx+STREAM.in_size]
  891.         sub     eax, 128
  892.         mov     [edx+STREAM.in_free], eax
  893.  
  894.         xor     eax, eax
  895.         mov     ebx, [edx+STREAM.out_base]
  896.         mov     [edx+STREAM.out_wp], ebx
  897.         mov     [edx+STREAM.out_rp], ebx
  898.         mov     [edx+STREAM.out_count], eax
  899.  
  900.         mov     dword [edx+STREAM.time_base], eax
  901.         mov     dword [edx+STREAM.time_base+4], eax
  902.  
  903.         mov     dword [edx+STREAM.time_stamp], eax
  904.         mov     dword [edx+STREAM.time_stamp+4], eax
  905.         mov     dword [edx+STREAM.last_ts], eax
  906.  
  907.  
  908.         mov     eax, [edx+STREAM.r_silence]
  909.         test    [flags], 1
  910.         jz      @F
  911.  
  912.         mov     ecx, [edx+STREAM.in_top]
  913.         mov     edi, [edx+STREAM.in_base]
  914.         sub     ecx, edi
  915.         shr     ecx, 2
  916.         cld
  917.         rep stosd
  918. @@:
  919.         test    [flags], 2
  920.         jz      @F
  921.  
  922.         mov     edi, [edx+STREAM.out_base]
  923.         mov     ecx, (64*1024)/4
  924.         rep stosd
  925. @@:
  926.         ret
  927. .fail:
  928.         or      eax, -1
  929.         ret
  930. endp
  931.  
  932. ; for static buffers only
  933.  
  934. align 4
  935. proc SetBufferPos stdcall, str:dword, pos:dword
  936.  
  937.         mov     edx, [str]
  938.         test    [edx+STREAM.format], PCM_STATIC
  939.         jz      .fail
  940.  
  941.         mov     [edx+STREAM.flags], SND_STOP
  942.  
  943.         mov     eax, [pos]
  944.         add     eax, [edx+STREAM.in_base]
  945.         mov     ebx, [edx+STREAM.in_top]
  946.         add     eax, 128
  947.  
  948.         cmp     eax, ebx
  949.         jae     .fail
  950.  
  951.         mov     [edx+STREAM.in_rp], eax
  952.         sub     ebx, eax
  953.         mov     [edx+STREAM.in_count], ebx
  954.         xor     eax, eax
  955.         ret
  956. .fail:
  957.         or      eax, -1
  958.         ret
  959. endp
  960.  
  961. align 4
  962. proc GetBufferPos stdcall, str:dword
  963.  
  964.         mov     edx, [str]
  965.         test    [edx+STREAM.format], PCM_STATIC
  966.         jz      .fail
  967.  
  968.         mov     ebx, [edx+STREAM.in_rp]
  969.         sub     ebx, [edx+STREAM.in_base]
  970.         sub     ebx, 128
  971.         xor     eax, eax
  972.         ret
  973. .fail:
  974.         xor     ebx, ebx
  975.         or      eax, -1
  976.         ret
  977. endp
  978.  
  979. ; both
  980.  
  981. align 4
  982. proc SetBufferVol stdcall, str:dword,l_vol:dword,r_vol:dword
  983.  
  984.         mov     edx, [str]
  985.         stdcall set_vol_param, [l_vol], [r_vol], [edx+STREAM.pan]
  986.         ret
  987. endp
  988.  
  989.  
  990. proc minw stdcall, arg1:dword, arg2:dword
  991.         mov     ax, word [arg1]
  992.         cmp     ax, word [arg2]
  993.         jle     @f
  994.         mov     eax, [arg2]
  995. @@:
  996.         ret
  997. endp
  998.  
  999. proc maxw stdcall, arg1:dword, arg2:dword
  1000.         mov     ax, word [arg1]
  1001.         cmp     ax, word [arg2]
  1002.         jge     @f
  1003.         mov     eax, [arg2]
  1004. @@:
  1005.         ret
  1006. endp
  1007.  
  1008.  
  1009. proc set_vol_param stdcall, l_vol:dword,r_vol:dword,pan:dword
  1010.            locals
  1011.              _600    dd ?
  1012.              _32767  dd ?
  1013.              state   rb 108
  1014.            endl
  1015.  
  1016.         mov     [_600], 0x44160000  ;600.0
  1017.         mov     [_32767], 32767
  1018.  
  1019.         lea     ebx, [state]
  1020.         fnsave  [ebx]
  1021.  
  1022.         stdcall minw, [l_vol], [vol_max]
  1023.         stdcall maxw, eax, [vol_min]
  1024.         mov     [l_vol], eax
  1025.         mov     [edx+STREAM.l_vol], eax
  1026.         stdcall minw, [r_vol], [vol_max+4]
  1027.         stdcall maxw, eax, [vol_min+4]
  1028.         mov     [r_vol], eax
  1029.         mov     [edx+STREAM.r_vol], eax
  1030.  
  1031.         stdcall minw, [pan], [pan_max]
  1032.         stdcall maxw, eax, [vol_min]
  1033.         mov     [edx+STREAM.pan], eax
  1034.  
  1035.         cmp     word [edx+STREAM.pan], 0
  1036.         jl      @f
  1037.  
  1038.         mov     ebx, [l_vol]
  1039.         sub     ebx, eax
  1040.         stdcall minw, ebx, [vol_max]
  1041.         stdcall maxw, eax, [vol_min]
  1042.         mov     [l_vol], eax
  1043.         jmp     .calc_amp
  1044. @@:
  1045.         mov     ebx, [r_vol]
  1046.         add     ebx, [pan]
  1047.         stdcall minw, ebx, [vol_max+4]
  1048.         stdcall maxw, eax, [vol_min+4]
  1049.         mov     [r_vol], eax
  1050. .calc_amp:
  1051.         emms
  1052.         fild    word [l_vol]
  1053.  
  1054.         call    .calc
  1055.  
  1056.         fistp   word [edx+STREAM.l_amp]
  1057.         fstp    dword [edx+STREAM.l_amp_f]
  1058.         fstp    st0
  1059.  
  1060.         fild    word [r_vol]
  1061.  
  1062.         call    .calc
  1063.  
  1064.         fistp   word [edx+STREAM.r_amp]
  1065.         fstp    dword [edx+STREAM.r_amp_f]
  1066.         fstp    st0
  1067.  
  1068.         fnclex
  1069.         lea     ebx, [state]
  1070.         frstor  [ebx]
  1071.  
  1072.         xor     eax, eax
  1073.         inc     eax
  1074.         ret
  1075. .calc:
  1076.         fdiv    dword [_600]
  1077.         fld     st0
  1078.         frndint
  1079.         fxch    st1
  1080.         fsub    st, st1
  1081.         f2xm1
  1082.         fld1
  1083.         faddp   st1, st0
  1084.         fscale
  1085.         fld     st0
  1086.         fimul   dword [_32767]
  1087.         ret     0
  1088. endp
  1089.  
  1090.  
  1091. align 4
  1092. proc GetBufferVol stdcall, str:dword,p_lvol:dword,p_rvol:dword
  1093.  
  1094.         mov     edx, [str]
  1095.         mov     eax, [p_lvol]
  1096.         movsx   ecx, word [edx+STREAM.l_vol]
  1097.         mov     [eax], ecx
  1098.  
  1099.         mov     eax, [p_rvol]
  1100.         movsx   ecx, word [edx+STREAM.r_vol]
  1101.         mov     [eax], ecx
  1102.         xor     eax, eax
  1103.         ret
  1104. endp
  1105.  
  1106. align 4
  1107. proc SetBufferPan stdcall, str:dword,pan:dword
  1108.  
  1109.         mov     edx, [str]
  1110.         stdcall set_vol_param, [edx+STREAM.l_vol], \
  1111.                 [edx+STREAM.r_vol],[pan]
  1112.         ret
  1113. endp
  1114.  
  1115. ; for static and ring buffers only
  1116.  
  1117. align 4
  1118. proc play_buffer stdcall, str:dword, flags:dword
  1119.  
  1120.         mov     ebx, [str]
  1121.         mov     eax, [ebx+STREAM.format]
  1122.         test    eax, PCM_OUT
  1123.         jnz     .fail
  1124.  
  1125.         cmp     ax, PCM_ALL
  1126.         je      .fail
  1127.  
  1128.         mov     [ebx+STREAM.flags], SND_PLAY
  1129.         cmp     [eng_state], SND_PLAY
  1130.         je      .done
  1131.  
  1132.         stdcall dev_play, [hSound]
  1133.         mov     [eng_state], SND_PLAY
  1134. .done:
  1135.         test    [flags], PLAY_SYNC
  1136.         jz      @F
  1137.  
  1138.         mov     edx, [str]
  1139. .wait:
  1140.         mov     eax, [edx+STREAM.notify_event]
  1141.         mov     ebx, [edx+STREAM.notify_id]
  1142.         invoke  WaitEvent   ;eax ebx
  1143.  
  1144.         mov     edx, [str]
  1145.         cmp     [edx+STREAM.flags], SND_STOP
  1146.         jne     .wait
  1147. @@:
  1148.         xor     eax, eax
  1149.         ret
  1150. .fail:
  1151.         or      eax, -1
  1152.         ret
  1153. endp
  1154.  
  1155. ; for static and ring buffers only
  1156.  
  1157. align 4
  1158. proc stop_buffer stdcall, str:dword
  1159.  
  1160.         mov     edx, [str]
  1161.         test    [edx+STREAM.format], PCM_STATIC+PCM_RING
  1162.         jz      .fail
  1163.  
  1164.         mov     [edx+STREAM.flags], SND_STOP
  1165.  
  1166.         mov     eax, [edx+STREAM.notify_event]
  1167.         mov     ebx, [edx+STREAM.notify_id]
  1168.         invoke  ClearEvent   ;eax ebx
  1169.  
  1170.         xor     eax, eax
  1171.         ret
  1172. .fail:
  1173.         or      eax, -1
  1174.         ret
  1175. endp
  1176.  
  1177. ; param
  1178. ;  eax= mix_list
  1179.  
  1180. align 4
  1181. do_mix_list:
  1182.  
  1183.         xor     edx, edx
  1184.         mov     esi, str.fd-FD_OFFSET
  1185.         mov     ebx, [esi+STREAM.str_fd]
  1186. @@:
  1187.         cmp     ebx, esi
  1188.         je      .done
  1189.  
  1190.         cmp     [ebx+STREAM.magic], 'WAVE'
  1191.         jne     .next
  1192.  
  1193.         cmp     [ebx+STREAM.size], STREAM.sizeof
  1194.         jne     .next
  1195.  
  1196.         cmp     [ebx+STREAM.flags], SND_PLAY;
  1197.         jne     .next
  1198.  
  1199.         mov     ecx, [ebx+STREAM.out_count]
  1200.         test    ecx, ecx
  1201.         jnz     .l1
  1202.  
  1203.         test    [ebx+STREAM.format], PCM_RING
  1204.         jnz     .next
  1205.         mov     [ebx+STREAM.flags], SND_STOP
  1206.         jmp     .next
  1207. .l1:
  1208.         cmp     ecx, 512
  1209.         jae     .add_buff
  1210.  
  1211.         mov     edi, [ebx+STREAM.out_rp]
  1212.         add     edi, ecx
  1213.         sub     ecx, 512
  1214.         neg     ecx
  1215.         push    eax
  1216.         xor     eax, eax
  1217.         cld
  1218.         rep stosb
  1219.         pop     eax
  1220.  
  1221.         mov     [ebx+STREAM.out_count], 512
  1222.  
  1223. .add_buff:
  1224.         mov     ecx, [ebx+STREAM.out_rp]
  1225.         mov     [eax], ecx
  1226.  
  1227. if USE_SSE2_MIXER
  1228.         mov     edi, dword [ebx+STREAM.l_amp_f]
  1229.         mov     [eax+4], edi
  1230.         mov     edi, dword [ebx+STREAM.r_amp_f]
  1231.         mov     [eax+8], edi
  1232. else
  1233.         mov     edi, dword [ebx+STREAM.l_amp]
  1234.         mov     [eax+4], edi
  1235. end if
  1236.         add     [ebx+STREAM.out_rp], 512
  1237.         sub     [ebx+STREAM.out_count], 512
  1238.  
  1239.         add     eax, 12
  1240.         inc     edx
  1241. .next:
  1242.         mov     ebx, [ebx+STREAM.str_fd]
  1243.         jmp     @B
  1244. .done:
  1245.         mov     eax, edx
  1246.         ret
  1247.  
  1248. align 4
  1249. prepare_playlist:
  1250.  
  1251.         xor     edx, edx
  1252.         mov     [play_count], edx
  1253.         mov     esi, str.fd-FD_OFFSET
  1254.         mov     edi, [esi+STREAM.str_fd]
  1255. @@:
  1256.         cmp     edi, esi
  1257.         je      .done
  1258.  
  1259.         cmp     [edi+STREAM.magic], 'WAVE'
  1260.         jne     .next
  1261.  
  1262.         cmp     [edi+STREAM.size], STREAM.sizeof
  1263.         jne     .next
  1264.  
  1265.         cmp     [edi+STREAM.flags], SND_PLAY;
  1266.         jne     .next
  1267.  
  1268.         mov     [play_list+edx], edi
  1269.         inc     [play_count]
  1270.         add     edx, 4
  1271. .next:
  1272.         mov     edi, [edi+STREAM.str_fd]
  1273.         jmp     @B
  1274. .done:
  1275.         ret
  1276.  
  1277. align 4
  1278. proc set_handler stdcall, hsrv:dword, handler_proc:dword
  1279.            locals
  1280.              handler    dd ?
  1281.              io_code    dd ?
  1282.              input      dd ?
  1283.              inp_size   dd ?
  1284.              output     dd ?
  1285.              out_size   dd ?
  1286.              val        dd ?
  1287.            endl
  1288.  
  1289.         mov     eax, [hsrv]
  1290.         lea     ecx, [handler_proc]
  1291.         xor     ebx, ebx
  1292.  
  1293.         mov     [handler], eax
  1294.         mov     [io_code], DEV_CALLBACK
  1295.         mov     [input], ecx
  1296.         mov     [inp_size], 4
  1297.         mov     [output], ebx
  1298.         mov     [out_size], 0
  1299.  
  1300.         lea     eax, [handler]
  1301.         invoke  ServiceHandler, eax
  1302.         ret
  1303. endp
  1304.  
  1305. align 4
  1306. proc dev_play stdcall, hsrv:dword
  1307.            locals
  1308.              handle     dd ?
  1309.              io_code    dd ?
  1310.              input      dd ?
  1311.              inp_size   dd ?
  1312.              output     dd ?
  1313.              out_size   dd ?
  1314.              val        dd ?
  1315.            endl
  1316.  
  1317.         mov     eax, [hsrv]
  1318.         xor     ebx, ebx
  1319.  
  1320.         mov     [handle], eax
  1321.         mov     [io_code], DEV_PLAY
  1322.         mov     [input], ebx
  1323.         mov     [inp_size], ebx
  1324.         mov     [output], ebx
  1325.         mov     [out_size], ebx
  1326.  
  1327.         lea     eax, [handle]
  1328.         invoke  ServiceHandler, eax
  1329.         ret
  1330. endp
  1331.  
  1332. if 0
  1333. align 4
  1334. dword2str:
  1335.         mov     esi, hex_buff
  1336.         mov     ecx, -8
  1337. @@:
  1338.         rol     eax, 4
  1339.         mov     ebx, eax
  1340.         and     ebx, 0x0F
  1341.         mov     bl, [ebx+hexletters]
  1342.         mov     [8+esi+ecx], bl
  1343.         inc     ecx
  1344.         jnz     @B
  1345.         ret
  1346.  
  1347. hexletters   db '0123456789ABCDEF'
  1348. hex_buff     db 8 dup(0),13,10,0
  1349.  
  1350. end if
  1351.  
  1352. include 'mixer.asm'
  1353. include 'mix_mmx.inc'
  1354. include 'mix_sse2.inc'
  1355.  
  1356. ;if USE_SSE
  1357. ; include 'mix_sse.inc'
  1358. ;end if
  1359.  
  1360. align 16
  1361. resampler_params:
  1362.      ;r_size    r_dt   resampler_func
  1363.      dd 0,0,0                                  ; 0  PCM_ALL
  1364.      dd 16384,      0, copy_stream    ; 1  PCM_2_16_48
  1365.      dd  8192,      0, m16_stereo     ; 2  PCM_1_16_48
  1366.  
  1367.      dd 16384,  30109, resample_2     ; 3  PCM_2_16_44
  1368.      dd  8192,  30109, resample_1     ; 4  PCM_1_16_44
  1369.  
  1370.      dd 16384,  21846, resample_2     ; 5  PCM_2_16_32
  1371.      dd  8192,  21846, resample_1     ; 6  PCM_1_16_32
  1372.  
  1373.      dd 16384,  16384, resample_2     ; 7  PCM_2_16_24
  1374.      dd  8192,  16384, resample_1     ; 8  PCM_1_16_24
  1375.  
  1376.      dd  8192,  15052, resample_2     ; 9  PCM_2_16_22
  1377.      dd  4096,  15052, resample_1     ;10  PCM_1_16_22
  1378.  
  1379.      dd  8192,  10923, resample_2     ;11  PCM_2_16_16
  1380.      dd  4096,  10923, resample_1     ;12  PCM_1_16_16
  1381.  
  1382.      dd  8192,   8192, resample_2     ;13  PCM_2_16_12
  1383.      dd  4096,   8192, resample_1     ;14  PCM_1_16_12
  1384.  
  1385.      dd  4096,   7527, resample_2     ;15  PCM_2_16_11
  1386.      dd  2048,   7527, resample_1     ;16  PCM_1_16_11
  1387.  
  1388.      dd  4096,   5462, resample_2     ;17  PCM_2_16_8
  1389.      dd  2048,   5462, resample_1     ;18  PCM_1_16_8
  1390.  
  1391.      dd 16384,      0, s8_stereo      ;19  PCM_2_8_48
  1392.      dd  8192,      0, m8_stereo      ;20  PCM_1_8_48
  1393.  
  1394.      dd  8192,  30109, resample_28    ;21  PCM_2_8_44
  1395.      dd  4096,  30109, resample_18    ;22  PCM_1_8_44
  1396.  
  1397.      dd  8192,  21846, resample_28    ;23  PCM_2_8_32
  1398.      dd  4096,  21846, resample_18    ;24  PCM_1_8_32
  1399.  
  1400.      dd  8192,  16384, resample_28    ;25  PCM_2_8_24
  1401.      dd  4096,  16384, resample_18    ;26  PCM_1_8_24
  1402.  
  1403.      dd  4096,  15052, resample_28    ;27  PCM_2_8_22
  1404.      dd  2048,  15052, resample_18    ;28  PCM_1_8_22
  1405.  
  1406.      dd  4096,  10923, resample_28    ;29  PCM_2_8_16
  1407.      dd  2048,  10923, resample_18    ;30  PCM_1_8_16
  1408.  
  1409.      dd  4096,   8192, resample_28    ;31  PCM_2_8_12
  1410.      dd  2048,   8192, resample_18    ;32  PCM_1_8_12
  1411.  
  1412.      dd  2048,   7527, resample_28    ;33  PCM_2_8_11
  1413.      dd  1024,   7527, resample_18    ;34  PCM_1_8_11
  1414.  
  1415.      dd  2048,   5462, resample_28    ;35  PCM_2_8_8
  1416.      dd  1024,   5462, resample_18    ;36  PCM_1_8_8
  1417.  
  1418. m7            dw 0x8000,0x8000,0x8000,0x8000
  1419. mm80          dq 0x8080808080808080
  1420. mm_mask       dq 0xFF00FF00FF00FF00
  1421.  
  1422. vol_max       dd 0x00000000,0x00000000
  1423. vol_min       dd 0x0000D8F0,0x0000D8F0
  1424. pan_max       dd 0x00002710,0x00002710
  1425.  
  1426. ;stream_map    dd 0xFFFF       ; 16
  1427.  
  1428. szInfinity    db 'INFINITY',0
  1429. szSound       db 'SOUND',0
  1430.  
  1431. if DEBUG
  1432. msgFail       db 'Sound service not loaded',13,10,0
  1433. msgPlay       db 'Play buffer',13,10,0
  1434. msgStop       db 'Stop',13,10,0
  1435. msgUser       db 'User callback',13,10,0
  1436. msgMem        db 'Not enough memory',13,10,0
  1437. msgDestroy    db 'Destroy sound buffer', 13,10,0
  1438. msgWaveout    db 'Play waveout', 13,10,0
  1439. msgSetVolume  db 'Set volume',13,10,0
  1440. end if
  1441.  
  1442. align 4
  1443. data fixups
  1444. end data
  1445.  
  1446. section '.data' data readable writable
  1447.  
  1448. play_list     rd 16
  1449. mix_input     rd 16
  1450. play_count    rd 1
  1451. hSound        rd 1
  1452. eng_state     rd 1
  1453. mix_buff      rd 1
  1454. mix_buff_map  rd 1
  1455. str.fd        rd 1
  1456. str.bk        rd 1
  1457.  
  1458. mix_2_core    rd 1
  1459. mix_3_core    rd 1
  1460. mix_4_core    rd 1
  1461.