home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 4 Drivers / 04-Drivers.zip / cs0929a.zip / ssm_idc.lst < prev    next >
Encoding:
File List  |  1999-09-29  |  22.9 KB  |  596 lines
  1.  
  2. Module: D:\dev\csrc\os2dd\scd\ssm_idc.c
  3. Group: 'DGROUP' CONST,CONST2,_DATA,_BSS
  4.  
  5. Segment: _TEXT  PARA   000002c0 bytes  
  6.  0000  93 00             L1              DW      L4
  7.  0002  ee 00                             DW      L7
  8.  0004  2f 01                             DW      L9
  9.  0006  65 01                             DW      L10
  10.  0008  95 01                             DW      L11
  11.  000a  4e 02                             DW      L20
  12.  000c  84 02                             DW      L23
  13.  000e  c0 01             L2              DW      L12
  14.  0010  cd 01                             DW      L13
  15.  0012  ef 01                             DW      L14
  16.  0014  11 02                             DW      L15
  17.  0016  1e 02                             DW      L16
  18.  0018  1e 02                             DW      L16
  19.  001a  29 02                             DW      L17
  20.  001c  38 02                             DW      L18
  21.  001e  89 c0                             mov     ax,ax
  22.  
  23. //
  24. // ssm_idc.c
  25. // 3-Feb-99
  26. //
  27. // ULONG __far __loadds __cdecl idcDDCMD(DDCMDCOMMON __far *commonPtr);
  28.  
  29. #include "cs40.h"
  30.  
  31. ULONG __far __loadds __cdecl idcDDCMD(DDCMDCOMMON __far *commonPtr) {
  32.  
  33.  0020  1e                _idcDDCMD       push    ds
  34.  0021  b8 00 00                          mov     ax,seg L28
  35.  0024  8e d8                             mov     ds,ax
  36.  0026  56                                push    si
  37.  0027  57                                push    di
  38.  0028  55                                push    bp
  39.  0029  89 e5                             mov     bp,sp
  40.  002b  83 ec 0e                          sub     sp,000eH
  41.  002e  8b 76 0c                          mov     si,[bp+0cH]
  42.  
  43.  ULONG rc = NO_ERROR;
  44.  USHORT function;
  45.  STREAM *streamPtr;
  46.  
  47. //static USHORT cnt=0;
  48.  
  49.  0031  31 ff                             xor     di,di
  50.  
  51.  if (commonPtr == 0) {
  52. #ifdef TRACE_IDC_DDCMD
  53.  0033  8b 5e 0e                          mov     bx,[bp+0eH]
  54.  0036  89 7e fe                          mov     [bp-2H],di
  55.  0039  85 db                             test    bx,bx
  56.  003b  75 17                             jne     L3
  57.  003d  85 f6                             test    si,si
  58.  003f  75 13                             jne     L3
  59.  
  60.     tracePerf(TRACE_IDC_DDCMD_IN, 0xA5A5); // can't get function since commonPtr = 0
  61. #endif
  62.  0041  bb a5 a5                          mov     bx,0a5a5H
  63.  0044  b8 44 00                          mov     ax,0044H
  64.  0047  31 c9                             xor     cx,cx
  65.  0049  e8 00 00                          call    tracePerf_
  66.  
  67.     return(ERROR_INVALID_BLOCK);
  68.  }
  69.  
  70.  004c  b8 09 00                          mov     ax,0009H
  71.  004f  31 d2                             xor     dx,dx
  72.  0051  e9 65 02                          jmp     L27
  73.  
  74.  function = commonPtr->ulFunction;
  75.  0054  8e c3             L3              mov     es,bx
  76.  0056  26 8b 04                          mov     ax,es:[si]
  77.  0059  26 8b 54 06                       mov     dx,es:[si+6H]
  78.  005d  89 46 fa                          mov     [bp-6H],ax
  79.  
  80.  streamPtr = streamFindStreamHandle(commonPtr->hStream);
  81.  
  82. //cnt++;
  83. //ddprintf("idcDDCMD, cnt=%u, func=%u, streamPtr=%x \n",cnt,function, streamPtr);
  84.  
  85.  
  86. #ifdef TRACE_IDC_DDCMD
  87.  0060  26 8b 44 04                       mov     ax,es:[si+4H]
  88.  0064  e8 00 00                          call    streamFindStreamHandle_
  89.  0067  89 46 fc                          mov     [bp-4H],ax
  90.  006a  89 46 f6                          mov     [bp-0aH],ax
  91.  
  92.  tracePerf(TRACE_IDC_DDCMD_IN, ((ULONG)function << 16) | _IF());  // high-word is function is USHORT, 0-6
  93. #endif
  94.  
  95.  006d  9c                                pushf   
  96.  006e  58                                pop     ax
  97.  006f  25 00 02                          and     ax,0200H
  98.  0072  99                                cwd     
  99.  0073  8b 4e fa                          mov     cx,[bp-6H]
  100.  0076  89 c3                             mov     bx,ax
  101.  0078  09 d1                             or      cx,dx
  102.  007a  b8 44 00                          mov     ax,0044H
  103.  007d  e8 00 00                          call    tracePerf_
  104.  
  105.  switch(function) {
  106.  case DDCMD_SETUP:      // 0
  107.  
  108.  0080  8b 4e fa                          mov     cx,[bp-6H]
  109.  0083  83 f9 06                          cmp     cx,0006H
  110.  0086  0f 87 0f 02                       ja      L24
  111.  008a  89 cb                             mov     bx,cx
  112.  008c  01 cb                             add     bx,cx
  113.  008e  2e ff a7 00 00                    jmp     word ptr cs:[bx+L1]
  114.  
  115.     if (streamPtr) {
  116.  
  117.  0093  83 7e f6 00       L4              cmp     word ptr [bp-0aH],0000H
  118.  0097  74 4f                             je      L6
  119.  
  120.        DDCMDSETUP __far *setupPtr = (DDCMDSETUP __far *)commonPtr;
  121.  0099  89 76 f2                          mov     [bp-0eH],si
  122.  009c  8b 46 0e                          mov     ax,[bp+0eH]
  123.  009f  8b 5e f2                          mov     bx,[bp-0eH]
  124.  
  125.        SETUP_PARM __far *setupParmPtr = setupPtr->pSetupParm;
  126.  
  127.        // here, yes, setupParmPtr is passed in, and am to set timeBase to its ulStreamTime value
  128.  
  129.  00a2  8e c0                             mov     es,ax
  130.  00a4  89 46 f4                          mov     [bp-0cH],ax
  131.  00a7  26 8b 47 0a                       mov     ax,es:[bx+0aH]
  132.  
  133.        wavestreamSetCurrentTime(setupParmPtr->ulStreamTime, streamPtr->wsParentPtr);
  134.  
  135.        // if flags' field (based on size) then indicate to mmpm that recurring events
  136.        // are supported...only they're not just yet
  137.  
  138.  00ab  8b 5e f6                          mov     bx,[bp-0aH]
  139.  00ae  26 8b 74 08                       mov     si,es:[si+8H]
  140.  00b2  8b 5f 24                          mov     bx,[bx+24H]
  141.  00b5  8e c0                             mov     es,ax
  142.  00b7  89 46 f8                          mov     [bp-8H],ax
  143.  00ba  26 8b 04                          mov     ax,es:[si]
  144.  00bd  26 8b 54 02                       mov     dx,es:[si+2H]
  145.  00c1  e8 00 00                          call    wavestreamSetCurrentTime_
  146.  
  147.        if (setupPtr->ulSetupParmSize > sizeof(ULONG)) {
  148.           //setupParmPtr->ulFlags = SETUP_RECURRING_EVENTS;
  149.  00c4  c4 5e f2                          les     bx,dword ptr [bp-0eH]
  150.  00c7  26 8b 4f 0e                       mov     cx,es:[bx+0eH]
  151.  00cb  26 8b 47 0c                       mov     ax,es:[bx+0cH]
  152.  00cf  85 c9                             test    cx,cx
  153.  00d1  75 07                             jne     L5
  154.  00d3  3d 04 00                          cmp     ax,0004H
  155.  00d6  0f 86 c7 01                       jbe     L26
  156.  
  157.           setupParmPtr->ulFlags = 0;
  158.  00da  8e 46 f8          L5              mov     es,[bp-8H]
  159.  00dd  26 89 7c 04                       mov     es:[si+4H],di
  160.  00e1  26 89 7c 06                       mov     es:[si+6H],di
  161.  
  162.        }
  163.     }
  164.     else {
  165.  00e5  e9 b9 01                          jmp     L26
  166.  
  167.        rc = ERROR_INVALID_STREAM;
  168.  00e8  bf 7d 15          L6              mov     di,157dH
  169.  
  170.     }
  171.     break;
  172.  
  173.  case DDCMD_READ:       // 1
  174.  
  175.  00eb  e9 b3 01                          jmp     L26
  176.  
  177.     if (streamPtr) {
  178.  
  179.        DDCMDREADWRITE __far *rwPtr = (DDCMDREADWRITE __far *)commonPtr;
  180.  
  181.        // rc = 8 if can't allocate memory for STREAM_BUFFER
  182.  
  183.  00ee  8b 7e fc          L7              mov     di,[bp-4H]
  184.  00f1  85 ff                             test    di,di
  185.  00f3  74 2f                             je      L8
  186.  00f5  8e 46 0e                          mov     es,[bp+0eH]
  187.  
  188.        rc = streamRead(rwPtr->pBuffer, rwPtr->ulBufferSize, streamPtr);
  189.  00f8  57                                push    di
  190.  00f9  26 8b 5c 0c                       mov     bx,es:[si+0cH]
  191.  00fd  26 8b 4c 0e                       mov     cx,es:[si+0eH]
  192.  0101  26 8b 44 08                       mov     ax,es:[si+8H]
  193.  0105  26 8b 54 0a                       mov     dx,es:[si+0aH]
  194.  0109  e8 00 00                          call    streamRead_
  195.  010c  89 c7                             mov     di,ax
  196.  010e  31 db                             xor     bx,bx
  197.  0110  89 5e fe                          mov     [bp-2H],bx
  198.  
  199.        if (rc == 8) rc = ERROR_TOO_MANY_BUFFERS;  // 5901;
  200.     }
  201.  0113  0f 85 8a 01                       jne     L26
  202.  0117  3d 08 00                          cmp     ax,0008H
  203.  011a  0f 85 83 01                       jne     L26
  204.  011e  bf 0d 17                          mov     di,170dH
  205.  0121  e9 7d 01                          jmp     L26
  206.  
  207.     else {
  208.  0124  31 c0             L8              xor     ax,ax
  209.  
  210.        rc = ERROR_INVALID_STREAM;
  211.  0126  bf 7d 15                          mov     di,157dH
  212.  0129  89 46 fe                          mov     [bp-2H],ax
  213.  
  214.     }
  215.     break;
  216.  
  217.  case DDCMD_WRITE:      // 2
  218.  
  219.  012c  e9 72 01                          jmp     L26
  220.  
  221.     if (streamPtr) {
  222.  
  223.        DDCMDREADWRITE __far *rwPtr = (DDCMDREADWRITE __far *)commonPtr;
  224.  
  225.        // rc = 8 if can't allocate memory for STREAM_BUFFER
  226.  
  227.  012f  8b 7e fc          L9              mov     di,[bp-4H]
  228.  0132  85 ff                             test    di,di
  229.  0134  74 ee                             je      L8
  230.  0136  8e 46 0e                          mov     es,[bp+0eH]
  231.  
  232.        rc = streamWrite(rwPtr->pBuffer, rwPtr->ulBufferSize, streamPtr);
  233.  0139  57                                push    di
  234.  013a  26 8b 5c 0c                       mov     bx,es:[si+0cH]
  235.  013e  26 8b 4c 0e                       mov     cx,es:[si+0eH]
  236.  0142  26 8b 44 08                       mov     ax,es:[si+8H]
  237.  0146  26 8b 54 0a                       mov     dx,es:[si+0aH]
  238.  014a  e8 00 00                          call    streamWrite_
  239.  014d  89 c7                             mov     di,ax
  240.  014f  31 db                             xor     bx,bx
  241.  0151  89 5e fe                          mov     [bp-2H],bx
  242.  
  243.        if (rc == 8) rc = ERROR_TOO_MANY_BUFFERS;  // 5901;
  244.     }
  245.     else {
  246.        rc = ERROR_INVALID_STREAM;
  247.     }
  248.     break;
  249.  
  250.  case DDCMD_STATUS:     // 3
  251.  
  252.  0154  0f 85 49 01                       jne     L26
  253.  0158  3d 08 00                          cmp     ax,0008H
  254.  015b  0f 85 42 01                       jne     L26
  255.  015f  bf 0d 17                          mov     di,170dH
  256.  0162  e9 3c 01                          jmp     L26
  257.  
  258.     if (streamPtr) {
  259.  
  260.        DDCMDSTATUS __far *statusPtr = (DDCMDSTATUS __far *)commonPtr;
  261.  
  262.  0165  8b 5e fc          L10             mov     bx,[bp-4H]
  263.  0168  85 db                             test    bx,bx
  264.  016a  0f 84 7a ff                       je      L6
  265.  
  266.        streamPtr->currentTime = wavestreamGetCurrentTime(streamPtr->wsParentPtr);
  267.  
  268.        // yes, give it a -pointer- to this stream's current time var (NOT the time itself)
  269.  
  270.        statusPtr->pStatus = &streamPtr->currentTime;    // should be a far pointer
  271.  016e  8b 47 24                          mov     ax,[bx+24H]
  272.  0171  e8 00 00                          call    wavestreamGetCurrentTime_
  273.  0174  89 47 20                          mov     [bx+20H],ax
  274.  0177  89 57 22                          mov     [bx+22H],dx
  275.  017a  8e 46 0e                          mov     es,[bp+0eH]
  276.  
  277.  017d  26 c7 44 0c 04 00                 mov     word ptr es:[si+0cH],0004H
  278.  
  279.        statusPtr->ulStatusSize = 4;     // or use sizeof(STATUS_PARM)
  280.     }
  281.  0183  8d 47 20                          lea     ax,[bx+20H]
  282.  0186  26 8c 5c 0a                       mov     es:[si+0aH],ds
  283.  018a  26 89 44 08                       mov     es:[si+8H],ax
  284.  018e  26 89 7c 0e                       mov     es:[si+0eH],di
  285.  
  286.     else {
  287.        rc = ERROR_INVALID_STREAM;
  288.     }
  289.     break;
  290.  
  291.  case DDCMD_CONTROL:    // 4
  292.  
  293.  0192  e9 0c 01                          jmp     L26
  294.  
  295.     if (streamPtr) {
  296.  
  297.        DDCMDCONTROL __far *controlPtr = (DDCMDCONTROL __far *)commonPtr;
  298.  0195  8b 56 fc          L11             mov     dx,[bp-4H]
  299.  0198  85 d2                             test    dx,dx
  300.  019a  0f 84 4a ff                       je      L6
  301.  
  302.        WAVESTREAM *wsPtr = streamPtr->wsParentPtr;
  303.  019e  89 d3                             mov     bx,dx
  304.  01a0  8b 47 24                          mov     ax,[bx+24H]
  305.  
  306.        USHORT cmd = (USHORT)controlPtr->ulCmd;
  307.  
  308.  01a3  8e 46 0e                          mov     es,[bp+0eH]
  309.  01a6  26 8b 54 0c                       mov     dx,es:[si+0cH]
  310.  
  311.        switch(cmd) {
  312.        case DDCMD_START: // 1
  313.  01aa  4a                                dec     dx
  314.  01ab  83 fa 07                          cmp     dx,0007H
  315.  01ae  0f 87 92 00                       ja      L19
  316.  01b2  89 d3                             mov     bx,dx
  317.  01b4  01 d3                             add     bx,dx
  318.  01b6  89 c2                             mov     dx,ax
  319.  01b8  83 c2 1c                          add     dx,001cH
  320.  01bb  2e ff a7 0e 00                    jmp     word ptr cs:[bx+L2]
  321.  
  322.           rc = wavestreamStart(wsPtr);
  323.  01c0  e8 00 00          L12             call    wavestreamStart_
  324.  01c3  31 d2                             xor     dx,dx
  325.  01c5  89 c7                             mov     di,ax
  326.  01c7  89 56 fe                          mov     [bp-2H],dx
  327.  
  328.           break;
  329.        case DDCMD_STOP:  // 2
  330.  01ca  e9 d4 00                          jmp     L26
  331.  
  332.           rc = wavestreamStop(wsPtr);
  333.  01cd  e8 00 00          L13             call    wavestreamStop_
  334.  
  335.           controlPtr->pParm = &wsPtr->timeBase;   // since wavestreamStop updated .timeBase
  336.  01d0  8e 46 0e                          mov     es,[bp+0eH]
  337.  
  338.           controlPtr->ulParmSize = sizeof(ULONG); // give it a pointer to that var
  339.  01d3  26 c7 44 14 04 00                 mov     word ptr es:[si+14H],0004H
  340.  01d9  89 c7                             mov     di,ax
  341.  01db  26 8c 5c 12                       mov     es:[si+12H],ds
  342.  01df  31 c0                             xor     ax,ax
  343.  01e1  26 89 54 10                       mov     es:[si+10H],dx
  344.  01e5  89 46 fe                          mov     [bp-2H],ax
  345.  01e8  26 89 44 16                       mov     es:[si+16H],ax
  346.  
  347.           break;
  348.        case DDCMD_PAUSE: // 3
  349.  01ec  e9 b2 00                          jmp     L26
  350.  
  351.           rc = wavestreamPause(wsPtr);
  352.  01ef  e8 00 00          L14             call    wavestreamPause_
  353.  
  354.           controlPtr->pParm = &wsPtr->timeBase;   // since wavestreamPause updated .timeBase
  355.  01f2  8e 46 0e                          mov     es,[bp+0eH]
  356.  
  357.           controlPtr->ulParmSize = sizeof(ULONG); // give it a pointer to that var
  358.  01f5  26 c7 44 14 04 00                 mov     word ptr es:[si+14H],0004H
  359.  01fb  89 c7                             mov     di,ax
  360.  01fd  26 8c 5c 12                       mov     es:[si+12H],ds
  361.  0201  31 c9                             xor     cx,cx
  362.  0203  26 89 54 10                       mov     es:[si+10H],dx
  363.  0207  89 4e fe                          mov     [bp-2H],cx
  364.  020a  26 89 4c 16                       mov     es:[si+16H],cx
  365.  
  366.           break;
  367.        case DDCMD_RESUME: // 4
  368.  020e  e9 90 00                          jmp     L26
  369.  
  370.           rc = wavestreamResume(wsPtr);
  371.  0211  e8 00 00          L15             call    wavestreamResume_
  372.  0214  31 db                             xor     bx,bx
  373.  0216  89 c7                             mov     di,ax
  374.  0218  89 5e fe                          mov     [bp-2H],bx
  375.  
  376.           break;
  377.        case DDCMD_ENABLE_EVENT:  // 5
  378.  021b  e9 83 00                          jmp     L26
  379.  
  380.        case DDCMD_DISABLE_EVENT: // 6
  381.  021e  31 d2             L16             xor     dx,dx
  382.  
  383.           rc = ERROR_INVALID_REQUEST;
  384.  0220  bf 86 15                          mov     di,1586H
  385.  0223  89 56 fe                          mov     [bp-2H],dx
  386.  
  387.           break;
  388.  
  389.        case DDCMD_PAUSE_TIME: // 7 (newish)
  390.  0226  e9 78 00                          jmp     L26
  391.  
  392.           rc = streamPauseTime(streamPtr);
  393.  0229  8b 46 fc          L17             mov     ax,[bp-4H]
  394.  022c  e8 00 00                          call    streamPauseTime_
  395.  022f  89 c7                             mov     di,ax
  396.  0231  31 c0                             xor     ax,ax
  397.  0233  89 46 fe                          mov     [bp-2H],ax
  398.  
  399.           break;
  400.        case DDCMD_RESUME_TIME: // 8 (newish)
  401.  0236  eb 69                             jmp     L26
  402.  
  403.           rc = streamResumeTime(streamPtr);
  404.  0238  8b 46 fc          L18             mov     ax,[bp-4H]
  405.  023b  e8 00 00                          call    streamResumeTime_
  406.  023e  31 f6                             xor     si,si
  407.  0240  89 c7                             mov     di,ax
  408.  
  409.           break;
  410.  0242  eb 5a                             jmp     L25
  411.  
  412.        default:
  413.  0244  31 c9             L19             xor     cx,cx
  414.  
  415.           rc = ERROR_INVALID_REQUEST;
  416.  0246  bf 86 15                          mov     di,1586H
  417.  0249  89 4e fe                          mov     [bp-2H],cx
  418.  
  419.        }
  420.     }
  421.     else {
  422.        rc = ERROR_INVALID_STREAM;
  423.     }
  424.     break;
  425.  case DDCMD_REG_STREAM: // 5
  426.  
  427.  
  428.  024c  eb 53                             jmp     L26
  429.  
  430.     if (streamPtr) {
  431.  024e  83 7e fc 00       L20             cmp     word ptr [bp-4H],0000H
  432.  0252  74 0a                             je      L21
  433.  0254  31 c0                             xor     ax,ax
  434.  
  435.        rc = ERROR_HNDLR_REGISTERED;
  436.     }
  437.  0256  bf f0 15                          mov     di,15f0H
  438.  0259  89 46 fe                          mov     [bp-2H],ax
  439.  
  440.     else {
  441.  025c  eb 43                             jmp     L26
  442.  
  443.        streamPtr = streamFindStreamSFN(((DDCMDREGISTER __far *)commonPtr)->ulSysFileNum);
  444.  025e  8e 46 0e          L21             mov     es,[bp+0eH]
  445.  0261  26 8b 44 08                       mov     ax,es:[si+8H]
  446.  0265  e8 00 00                          call    streamFindStreamSFN_
  447.  
  448.        if (streamPtr == 0) {
  449.  0268  85 c0                             test    ax,ax
  450.  026a  75 05                             jne     L22
  451.  
  452.           rc = ERROR_STREAM_CREATION;
  453.        }
  454.  026c  bf e1 15                          mov     di,15e1H
  455.  
  456.        else {
  457.  026f  eb 30                             jmp     L26
  458.  0271  8b 56 0e          L22             mov     dx,[bp+0eH]
  459.  
  460.           rc = streamRegister((DDCMDREGISTER __far *)commonPtr, streamPtr);
  461.  0274  89 c3                             mov     bx,ax
  462.  0276  89 f0                             mov     ax,si
  463.  0278  31 c9                             xor     cx,cx
  464.  027a  e8 00 00                          call    streamRegister_
  465.  027d  89 4e fe                          mov     [bp-2H],cx
  466.  0280  89 c7                             mov     di,ax
  467.  
  468.        }
  469.     }
  470.     break;
  471.  
  472.  case DDCMD_DEREG_STREAM: // 6
  473.  
  474.  0282  eb 1d                             jmp     L26
  475.  
  476.     if (streamPtr) {
  477.  0284  8b 7e fc          L23             mov     di,[bp-4H]
  478.  0287  85 ff                             test    di,di
  479.  0289  0f 84 97 fe                       je      L8
  480.  
  481.        streamDeregister(streamPtr);
  482.  028d  89 f8                             mov     ax,di
  483.  
  484.        rc = 0;
  485.     }
  486.  028f  31 ff                             xor     di,di
  487.  0291  e8 00 00                          call    streamDeregister_
  488.  0294  89 7e fe                          mov     [bp-2H],di
  489.  
  490.     else {
  491.        rc = ERROR_INVALID_STREAM;
  492.     }
  493.     break;
  494.  
  495.  0297  eb 08                             jmp     L26
  496.  
  497.  default:
  498.  0299  31 f6             L24             xor     si,si
  499.  
  500.     rc = ERROR_INVALID_FUNCTION;
  501.  }
  502.  
  503. #ifdef TRACE_IDC_DDCMD
  504.  029b  bf 01 00                          mov     di,0001H
  505.  029e  89 76 fe          L25             mov     [bp-2H],si
  506.  
  507.  tracePerf(TRACE_IDC_DDCMD_OUT, ((ULONG)function << 16) | _IF());  // high-word is function is USHORT, 0-6
  508. #endif
  509.  
  510.  02a1  9c                L26             pushf   
  511.  02a2  58                                pop     ax
  512.  02a3  25 00 02                          and     ax,0200H
  513.  02a6  99                                cwd     
  514.  02a7  8b 4e fa                          mov     cx,[bp-6H]
  515.  02aa  89 c3                             mov     bx,ax
  516.  02ac  09 d1                             or      cx,dx
  517.  02ae  b8 44 80                          mov     ax,8044H
  518.  02b1  e8 00 00                          call    tracePerf_
  519.  02b4  8b 56 fe                          mov     dx,[bp-2H]
  520.  
  521.  return rc;
  522.  02b7  89 f8                             mov     ax,di
  523.  
  524. }
  525.  
  526. // con printfs (moved down here to get them out of the way)
  527. //ddprintf("~@ idcDDCMD, function=%u, streamPtr=%x\n", function,streamPtr);
  528. //ddprintf("@idcDDCMD, function=DDCMD_SETUP, setupParmPtr=%p, setupSize=%lu, streamPtr=%x\n",
  529. //           setupPtr->pSetupParm, setupPtr->ulSetupParmSize,streamPtr);
  530. //ddprintf("@ idcDDCMD, function=DDCMD_READ,  streamPtr=%x\n", streamPtr);
  531. //ddprintf("~@ idcDDCMD, function=DDCMD_WRITE, streamPtr=%x\n", streamPtr);
  532. //int3();
  533. //ddprintf("@idcDDCMD, function=DDCMD_STATUS,streamPtr=%x\n", streamPtr);
  534. //ddprintf("@idcDDCMD, function=DDCMD_CONTROL, pParm=%p, ulParmSize=%lu, streamPtr=%x wsPtr=%x\n",
  535. //           controlPtr->pParm, controlPtr->ulParmSize, streamPtr, wsPtr);
  536. //ddprintf("@idcDDCMD, function=DDCMD_CONTROL, cmd=START, streamPtr=%x wsPtr=%x\n", streamPtr, wsPtr);
  537. //ddprintf("@idcDDCMD, function=DDCMD_CONTROL, cmd=STOP,  streamPtr=%x wsPtr=%x\n", streamPtr, wsPtr);
  538. //ddprintf("@idcDDCMD, function=DDCMD_CONTROL, cmd=PAUSE, streamPtr=%x wsPtr=%x\n", streamPtr, wsPtr);
  539. //ddprintf("@idcDDCMD, function=DDCMD_CONTROL, cmd=RESUME, streamPtr=%x wsPtr=%x\n", streamPtr, wsPtr);
  540. //ddprintf("@idcDDCMD, function=DDCMD_CONTROL, cmd=EVENTxxx, streamPtr=%x wsPtr=%x\n", streamPtr, wsPtr);
  541. //ddprintf("@idcDDCMD, function=DDCMD_CONTROL, cmd=PAUSETIME, streamPtr=%x wsPtr=%x\n", streamPtr, wsPtr);
  542. //ddprintf("@idcDDCMD, function=DDCMD_CONTROL, cmd=RESUMETIME, streamPtr=%x wsPtr=%x\n", streamPtr, wsPtr);
  543. //ddprintf("@idcDDCMD, function=DDCMD_CONTROL, streamPtr=%x\n", streamPtr);
  544. //ddprintf("@idcDDCMD, function=DDCMD_REG_STREAM, streamPtr=%x\n", streamPtr);
  545. //ddprintf("@idcDDCMD, function=DDCMD_DEREG_STREAM, streamPtr=%x\n", streamPtr);
  546. //ddprintf("* leaving idcDDCMD, (rc=%lx)\n", rc);
  547.  
  548.  
  549.  02b9  89 ec             L27             mov     sp,bp
  550.  02bb  5d                                pop     bp
  551.  02bc  5f                                pop     di
  552.  02bd  5e                                pop     si
  553.  02be  1f                                pop     ds
  554.  02bf  cb                                retf    
  555.  
  556. No disassembly errors
  557.  
  558. List of external symbols
  559.  
  560. Symbol
  561. ----------------
  562. tracePerf_       000002b2 0000007e 0000004a
  563. streamFindStreamHandle_ 
  564.                  00000065
  565. wavestreamSetCurrentTime_ 
  566.                  000000c2
  567. streamRead_      0000010a
  568. streamWrite_     0000014b
  569. wavestreamGetCurrentTime_ 
  570.                  00000172
  571. wavestreamStart_ 
  572.                  000001c1
  573. wavestreamStop_  000001ce
  574. wavestreamPause_ 
  575.                  000001f0
  576. wavestreamResume_ 
  577.                  00000212
  578. streamPauseTime_ 
  579.                  0000022d
  580. streamResumeTime_ 
  581.                  0000023c
  582. streamFindStreamSFN_ 
  583.                  00000266
  584. streamRegister_  0000027b
  585. streamDeregister_ 
  586.                  00000292
  587. ------------------------------------------------------------
  588. List of public symbols
  589.  
  590. SYMBOL          GROUP           SEGMENT          ADDRESS
  591. ---------------------------------------------------------
  592. _idcDDCMD                       _TEXT            00000020
  593.  
  594. ------------------------------------------------------------
  595.  
  596.