home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga Shareware Floppies / ma58.dms / ma58.adf / superplay-lib_DEV / Programmers / Docs / SuperPlay_Ref_ENG.doc < prev   
Encoding:
Text File  |  1996-05-27  |  19.9 KB  |  844 lines
  1.  
  2.    $VER: SuperPlay_Ref_ENG.doc V4.5 (21.10.95)
  3.  
  4.    © 1994-95 by Andreas R. Kleinert. All rights reserved.
  5.  
  6.    - Feel free to translate this Doc-File into other languages. -
  7.  
  8.           Andreas R. Kleinert,
  9.           Sandstrasse 1,
  10.           D-57072 Siegen,
  11.           Germany.
  12.  
  13.     EMail:  Fido             Andreas Kleinert 2:2457/435.10
  14.             Usenet/InterNet  Andreas_Kleinert@superview.ftn.sub.org
  15.  
  16.       If nothing else works, try one of these Fido-InterNet gateways:
  17.  
  18.             Andreas_Kleinert@p10.f435.n2457.z2.fido.sub.org (in Germany)
  19.             Andreas_Kleinert@p10.f435.n2457.z2.fidonet.org  (USA or other)
  20.  
  21.    Request at least :  V2+    for bug-fixed ClipBoard-Support
  22.                               with the supplied SPObjects
  23.                        V3+    for a working combination of
  24.                               SVL_SetSampleList() and SuperWrite() calls
  25.                        V4+    for filetype recognition without loading
  26.  
  27.    Here is a listing of all currently available functions of the
  28.    superplay.library in an Autodoc-like style of description :
  29.  
  30.         SPL_AllocHandle            ; since Version 1
  31.         SPL_FreeHandle
  32.         SPL_StopReplay
  33.         SPL_FreeResources
  34.         SPL_SuperPlay
  35.         SPL_SuperWrite
  36.         SPL_InitHandleAsDOS
  37.         SPL_InitHandleAsClip
  38.         SPL_SetWriteType
  39.         SPL_GetErrorString
  40.         SPL_SetWriteName
  41.         SPL_FileInfoRequest
  42.         SPL_SetReqIOWindow
  43.         SPL_ReadPlayData
  44.         SPL_ContinueReplay
  45.         SPL_FastForward
  46.         SPL_FastBackward
  47.         SPL_GetSampleList          ; since Version 2
  48.         SPL_SetSampleList
  49.                    ; no functions added in Version 3
  50.         SPL_GetFileType            ; since Version 4
  51.  
  52. -----------------------------------------------------------------------------
  53.    Functions available since Version 1 :
  54. -----------------------------------------------------------------------------
  55.  
  56.    NAME
  57.         SPL_AllocHandle
  58.  
  59.    SYNOPSIS
  60.  
  61.         APTR SPL_AllocHandle(APTR future)
  62.         D0   -$1e            A1
  63.  
  64.    FUNCTION
  65.  
  66.         Allocates a handle for accessing a Sample/Module via SPObjects.
  67.  
  68.    INPUT(S)
  69.  
  70.         future - always NULL yet
  71.  
  72.    RESULT
  73.  
  74.         A pointer to a new allocated Handle or NULL, if allocation failed.
  75.  
  76.    WARNING
  77.  
  78.         Test, if the result was NULL, or not !
  79.  
  80.    SINCE
  81.  
  82.         ... version 1 of the superplay.library.
  83.  
  84.    SEE ALSO
  85.  
  86.         SPL_FreeResources, SPL_FreeHandle
  87.  
  88. -----------------------------------------------------------------------------
  89.  
  90.    NAME
  91.         SPL_FreeHandle
  92.  
  93.    SYNOPSIS
  94.  
  95.         VOID SPL_FreeHandle(APTR handle)
  96.         D0   -$24           A1
  97.  
  98.    FUNCTION
  99.  
  100.        Stops playing, frees all Resources and delocates a Handle, which has
  101.        been allocated with SPL_AllocHandle before.
  102.  
  103.    INPUT(S)
  104.  
  105.         handle - a valid handle
  106.  
  107.    RESULT
  108.  
  109.         -
  110.  
  111.    SINCE
  112.  
  113.         ... version 1 of the superplay.library.
  114.  
  115.    SEE ALSO
  116.  
  117.         SPL_AllocHandle, SPL_StopReplay, SPL_FreeResources
  118.  
  119. -----------------------------------------------------------------------------
  120.  
  121.    NAME
  122.         SPL_StopReplay
  123.  
  124.    SYNOPSIS
  125.  
  126.         VOID SPL_StopReplay(APTR handle)
  127.         D0   -$2a           A1
  128.  
  129.    FUNCTION
  130.  
  131.         Stops playing the Sample/Module, indentified by the handle.
  132.         Some SPObjects support to continue the Sample/Module with
  133.         SPL_ContinueReplay after calling SPL_StopReplay.
  134.  
  135.    INPUT(S)
  136.  
  137.         handle - a valid handle
  138.  
  139.    RESULT
  140.  
  141.         -
  142.  
  143.    SINCE
  144.  
  145.         ... version 1 of the superplay.library.
  146.  
  147.    SEE ALSO
  148.  
  149.         SPL_ContinueReplay, SPL_FreeResources, SPL_FreeHandle
  150.  
  151. -----------------------------------------------------------------------------
  152.  
  153.    NAME
  154.         SPL_FreeResources
  155.  
  156.    SYNOPSIS
  157.  
  158.         VOID SPL_FreeResources(APTR handle)
  159.         D0   -$30              A1
  160.  
  161.    FUNCTION
  162.  
  163.         Frees all resources belonging to the specific Sample/Module,
  164.         indentified by the handle, which are not needed to just replay it.
  165.         Playing of the Sample/Module is not stopped and/or interrupted.
  166.  
  167.    INPUT(S)
  168.  
  169.         handle - a valid handle
  170.  
  171.    RESULT
  172.  
  173.         -
  174.  
  175.    SINCE
  176.  
  177.         ... version 1 of the superplay.library.
  178.  
  179.    SEE ALSO
  180.  
  181.         SPL_AllocHandle, SPL_StopReplay, SPL_FreeHandle
  182.  
  183. -----------------------------------------------------------------------------
  184.  
  185.    NAME
  186.         SPL_SuperPlay
  187.  
  188.    SYNOPSIS
  189.  
  190.         ULONG SPL_SuperPlay(APTR handle, char *filename)
  191.         D0    -$36          A1           A2
  192.  
  193.    FUNCTION
  194.  
  195.         Loads and plays the Sample/Module described by FileName.
  196.         The handle is initialized and the fitting SPObject is opened
  197.         and accessed for replaying the Sample/Module.
  198.  
  199.         Playing can be stopped either via full delocation of the handle
  200.         or temporal interruption with SPL_StopReplay.
  201.  
  202.    INPUT(S)
  203.  
  204.         handle   - a valid handle
  205.         filename - a valid AmigaDOS FilePath and -Name
  206.  
  207.    RESULT
  208.  
  209.         NULL or an adequate SPERR-Errorcode.
  210.  
  211.    SINCE
  212.  
  213.         ... version 1 of the superplay.library.
  214.  
  215.    SEE ALSO
  216.  
  217.         SPL_AllocHandle, SPL_StopReplay, SPL_ContinueReplay,
  218.         SPL_FastForward, SPL_FastBackward, SPL_FreeHandle
  219.  
  220. -----------------------------------------------------------------------------
  221.  
  222.    NAME
  223.         SPL_SuperWrite
  224.  
  225.    SYNOPSIS
  226.  
  227.         ULONG SPL_SuperWrite(APTR handle, APTR source_handle)
  228.         D0    -$3c           A1           A2
  229.  
  230.    FUNCTION
  231.  
  232.         Usually a Sample/Module is loaded AND played via SPL_SuperPlay :
  233.         No separate reading and playing calls are done.
  234.  
  235.         For writing - that means : converting - a Sample/Module, you
  236.         have to use the following order :
  237.  
  238.         source_handle = SPL_AllocHandle(N);
  239.         result        = SPL_ReadPlayData(source_handle, source_name);
  240.         dest_handle   = SPL_AllocHandle(N);
  241.         /* result     = SPL_InitHandleAsDOS(dest_handle, N); */ /* default */
  242.         result        = SPL_SetWriteName(dest_handle, dest_name, N);
  243.         result        = SPL_SetWriteType(dest_handle, dest_type, N);
  244.         result        = SPL_SuperWrite(dest_handle, source_handle);
  245.         SPL_FreeHandle(dest_handle);
  246.         SPL_FreeHandle(source_handle);
  247.  
  248.  
  249.         Also : Check the "result" value AFTER EACH function call (see
  250.                Example SourceCodes) !
  251.  
  252.         All available values for dest_type can be found in the specific
  253.         SPOBject-List in the SuperPlayBase.
  254.         The values WILL change with every re-initialization of
  255.         superplay.library, so update them with every new opening !
  256.  
  257.         *** NEW FEATURE : ***
  258.  
  259.         This functions acts different in Versions >= 3 :
  260.  
  261.         1) If "source_handle" is NULL,
  262.            it is checked, whether a SampleList has been set via
  263.            "SPL_SetSampleList()", and then this SampleList is completely
  264.            saved.
  265.  
  266.            ELSE
  267.  
  268.         2) a) If a Version 1 SPObject is the Source, the old behaviour
  269.               takes place.
  270.            b) If a Version 2 SPObject takes place, the new SampleList
  271.               functions are supported (and completely saved).
  272.  
  273.         So, what's new ? Well, if you've any self-created SampleLists,
  274.         you now can save them by just setting them via SPL_SetSampleList()
  275.         and then calling SPL_SuperWrite() with NULL parameter for the
  276.         Source-SPObject handle.
  277.  
  278.  
  279.         It is suggested to use the old style for converting between
  280.         FileFormats and the new style for saving single (self-created)
  281.         SampleLists.
  282.  
  283.    INPUT(S)
  284.  
  285.         handle        - a valid handle        (used for Write Access)
  286.         source_handle - an other valid handle (used for Read Access)
  287.                         (may be NULL for V2+ SPObjects)
  288.  
  289.    RESULT
  290.  
  291.         NULL or an adequate SPERR-Errorcode.
  292.  
  293.    BUGS
  294.  
  295.         Not a bug, but a limitation in V2 :
  296.         The new SampleList feature (NULL as parameter) was first
  297.         introduced with the V3 release's SPObjects and Library.
  298.  
  299.    SINCE
  300.  
  301.         ... version 1 of the superplay.library.
  302.  
  303.    SEE ALSO
  304.  
  305.  
  306.  
  307.         SPL_AllocHandle, SPL_ReadPlayData, SPL_FreeHandle
  308.  
  309. -----------------------------------------------------------------------------
  310.  
  311.    NAME
  312.         SPL_InitHandleAsDOS
  313.  
  314.    SYNOPSIS
  315.  
  316.         ULONG SPL_InitHandleAsDOS(APTR handle, APTR future)
  317.         D0    -$42                A1           A2
  318.  
  319.    FUNCTION
  320.  
  321.         Initializes a Handle for AmigaDOS access, so that the given
  322.         AmigaDOS FileNames are used.
  323.         Another possibility is sometimes to initialize Handles
  324.         for ClipBoard Access (depending on the specific SPObject,
  325.         e.g. IFF-8SVX).
  326.  
  327.    INPUT(S)
  328.  
  329.         handle - a valid handle
  330.         future - always NULL yet
  331.  
  332.  
  333.    RESULT
  334.  
  335.         NULL or an adequate SPERR-Errorcode.
  336.  
  337.    BUGS
  338.  
  339.         During V1.1 upto V1.6 this was done automatically ALWAYS.
  340.         This was fixed in V2.1
  341.         See BUGS under SPL_InitHandleAsClip.
  342.  
  343.    SINCE
  344.  
  345.         ... version 1 of the superplay.library.
  346.  
  347.    SEE ALSO
  348.  
  349.  
  350.  
  351.         SPL_InitHandleAsClip
  352.  
  353. -----------------------------------------------------------------------------
  354.  
  355.    NAME
  356.         SPL_InitHandleAsClip
  357.  
  358.    SYNOPSIS
  359.  
  360.         ULONG SPL_InitHandleAsClip(APTR handle, APTR future)
  361.         D0    -$48                 A1           A2
  362.  
  363.    FUNCTION
  364.  
  365.         Initializes a Handle for ClipBoard access, so that the (possibly)
  366.         given AmigaDOS FileNames are ignored.
  367.         The nearly always used possibility is to initialize Handles
  368.         for AmigaDOS Access (supported by ALL SPObjects).
  369.  
  370.    INPUT(S)
  371.  
  372.         handle - a valid handle
  373.         future - always NULL yet
  374.  
  375.  
  376.    RESULT
  377.  
  378.         NULL or an adequate SPERR-Errorcode.
  379.  
  380.    BUGS
  381.  
  382.         From 1.1 to 1.6 this function-call was useless, since
  383.         superview.library blocked all medias other than
  384.         SPO_MEDIUM_DISK for external SPObjects :
  385.         For reading calls, this resulted in a "file not found" message
  386.         from superplay.library, for writing calls, this resulted in an
  387.         empty filename string, which caused the SPObject to reject the
  388.         disk access (other accesses were not set correctly).
  389.         This was fixed in 2.1, by using the SPO_SetAccessMode() function
  390.         with the right parameters now and by using the "future" parameter
  391.         of SPO_CheckFileType() - only when using other media than
  392.         SPO_MEDIUM_DISK - as a pointer to an additional SPOCheckFileInfo
  393.         structure now.
  394.         This is 100% compatible, since superplay.library has always set
  395.         this value to NULL, so that older SPObjects will simply ignore
  396.         this pointer and newer versions will only interpret it, if it's
  397.         not NULL.
  398.  
  399.    SINCE
  400.  
  401.         ... version 1 of the superplay.library. (request V2+)
  402.  
  403.    SEE ALSO
  404.  
  405.         SPL_InitHandleAsDOS
  406.  
  407. -----------------------------------------------------------------------------
  408.  
  409.    NAME
  410.         SPL_SetWriteType
  411.  
  412.    SYNOPSIS
  413.  
  414.         ULONG SPL_SetWriteType(APTR handle, ULONG write_type, APTR future)
  415.         D0    -$4e             A1           A2                A3
  416.  
  417.    FUNCTION
  418.  
  419.         Sets the write_type for a SPL_SuperWrite() call.
  420.         See description there and example SourceCodes for more and
  421.         detailed information.
  422.  
  423.    INPUT(S)
  424.  
  425.         handle     - a valid handle
  426.         write_type - a valid temporary write_type code form the SPObject List
  427.         future     - always NULL yet
  428.  
  429.  
  430.    RESULT
  431.  
  432.         NULL or an adequate SPERR-Errorcode.
  433.  
  434.    SINCE
  435.  
  436.         ... version 1 of the superplay.library.
  437.  
  438.    SEE ALSO
  439.  
  440.         SPL_SuperWrite
  441.  
  442. -----------------------------------------------------------------------------
  443.  
  444.    NAME
  445.         SPL_GetErrorString
  446.  
  447.    SYNOPSIS
  448.  
  449.         char * SPL_GetErrorString(ULONG error_code)
  450.         D0    -$54                A1
  451.  
  452.    FUNCTION
  453.  
  454.         Returns the Error Message for a specific Error Code, returned
  455.         by any function of the superplay.library.
  456.  
  457.    INPUT(S)
  458.  
  459.         error_code - any SPERR Error Code
  460.  
  461.    RESULT
  462.  
  463.         read-only pointer to a SPERR Error String
  464.  
  465.    SINCE
  466.  
  467.         ... version 1 of the superplay.library.
  468.  
  469.    SEE ALSO
  470.  
  471.         -
  472.  
  473. -----------------------------------------------------------------------------
  474.  
  475.    NAME
  476.         SPL_SetWriteName
  477.  
  478.    SYNOPSIS
  479.  
  480.         ULONG SPL_SetWriteNameClip(APTR handle, ULONG write_name, APTR future)
  481.         D0    -$5a                 A1           A2                A3
  482.  
  483.    FUNCTION
  484.  
  485.         Sets the write_name for a SPL_SuperWrite() call.
  486.         See description there and example SourceCodes for more and
  487.         detailed information.
  488.  
  489.    INPUT(S)
  490.  
  491.         handle     - a valid handle
  492.         write_name - a valid AmigaDOS FilePath and -Name description
  493.         future     - always NULL yet
  494.  
  495.  
  496.    RESULT
  497.  
  498.         NULL or an adequate SPERR-Errorcode.
  499.  
  500.    SINCE
  501.  
  502.         ... version 1 of the superplay.library.
  503.  
  504.    SEE ALSO
  505.  
  506.         SPL_SuperWrite
  507.  
  508. -----------------------------------------------------------------------------
  509.  
  510.    NAME
  511.         SPL_FileInfoRequest
  512.  
  513.    SYNOPSIS
  514.  
  515.         ULONG SPL_FileInfoRequest(APTR handle, struct Window *window,
  516.         D0    -$60                A1           A2
  517.  
  518.                                   APTR future)
  519.                                   A3
  520.  
  521.    FUNCTION
  522.  
  523.         Pops up an Info-Requester with more or less detailed information
  524.         on the currently loaded Sample/Module.
  525.         A window pointer may be given to select the place to pop it up.
  526.  
  527.    INPUT(S)
  528.  
  529.         handle - a valid handle
  530.         window - a valid Window Pointer or NULL
  531.         future - always NULL yet
  532.  
  533.  
  534.    RESULT
  535.  
  536.         NULL or an adequate SPERR-Errorcode.
  537.  
  538.    SINCE
  539.  
  540.         ... version 1 of the superplay.library.
  541.  
  542.    SEE ALSO
  543.  
  544.         SPL_SetReqIOWindow
  545.  
  546. -----------------------------------------------------------------------------
  547.  
  548.    NAME
  549.         SPL_SetReqIOWindow
  550.  
  551.    SYNOPSIS
  552.  
  553.         ULONG SPL_SetReqIOWindow(APTR handle, struct Window *window)
  554.         D0    -$66               A1           A2
  555.  
  556.    FUNCTION
  557.  
  558.         Sets a new Default-Window (default : IntuitionBase->FirstWindow)
  559.         for any Requester IO.
  560.  
  561.    INPUT(S)
  562.  
  563.         handle - a valid handle
  564.         window - a valid Window Pointer or NULL
  565.  
  566.    RESULT
  567.  
  568.         NULL or an adequate SPERR-Errorcode.
  569.  
  570.    SINCE
  571.  
  572.         ... version 1 of the superplay.library.
  573.  
  574.    SEE ALSO
  575.  
  576.         SPL_FileInfoReq
  577.  
  578. -----------------------------------------------------------------------------
  579.  
  580.    NAME
  581.         SPL_ReadPlayData
  582.  
  583.    SYNOPSIS
  584.  
  585.         ULONG SPL_ReadPlayData(APTR handle, char *filename)
  586.         D0    -$6c             A1           A2
  587.  
  588.    FUNCTION
  589.  
  590.         Loads but NOT plays the data of the Sample/Module described by
  591.         FileName.
  592.         The handle is initialized and the fitting SPObject is opened
  593.         to access the Sample/Module data for use with SPL_SuperWrite.
  594.  
  595.    INPUT(S)
  596.  
  597.         handle   - a valid handle
  598.         filename - a valid AmigaDOS FilePath and -Name
  599.  
  600.    RESULT
  601.  
  602.         NULL or an adequate SPERR-Errorcode.
  603.  
  604.    SINCE
  605.  
  606.         ... version 1 of the superplay.library.
  607.  
  608.    SEE ALSO
  609.  
  610.         SPL_SetWriteName, SPL_SetWriteType, SPL_SuperWrite
  611.  
  612. -----------------------------------------------------------------------------
  613.  
  614.    NAME
  615.         SPL_ContinueReplay
  616.  
  617.    SYNOPSIS
  618.  
  619.         ULONG SPL_ContinueReplay(APTR handle)
  620.         D0    -$72               A1
  621.  
  622.    FUNCTION
  623.  
  624.         Some SPObjects support to continue a Sample/Module which
  625.         has been stopped by calling SPL_StopReplay.
  626.  
  627.    INPUT(S)
  628.  
  629.         handle - a valid handle
  630.  
  631.    RESULT
  632.  
  633.         NULL or an adequate SPERR-Errorcode.
  634.  
  635.    SINCE
  636.  
  637.         ... version 1 of the superplay.library.
  638.  
  639.    SEE ALSO
  640.  
  641.         SPL_SuperPlay, SPL_StopReplay
  642.  
  643. -----------------------------------------------------------------------------
  644.  
  645.    NAME
  646.         SPL_FastForward
  647.  
  648.    SYNOPSIS
  649.  
  650.         ULONG SPL_FastForward(APTR handle)
  651.         D0    -$78            A1
  652.  
  653.    FUNCTION
  654.  
  655.         Some SPObjects might support a "cassette recorder"-like way
  656.         to browse trough a Sample/Module via FastForward and Rewind.
  657.  
  658.    INPUT(S)
  659.  
  660.         handle - a valid handle
  661.  
  662.    RESULT
  663.  
  664.         NULL or an adequate SPERR-Errorcode.
  665.  
  666.    SINCE
  667.  
  668.         ... version 1 of the superplay.library.
  669.  
  670.    SEE ALSO
  671.  
  672.         SPL_FastBackward
  673.  
  674. -----------------------------------------------------------------------------
  675.  
  676.    NAME
  677.         SPL_FastBackward
  678.  
  679.    SYNOPSIS
  680.  
  681.         ULONG SPL_FastBackward(APTR handle)
  682.         D0    -$7e            A1
  683.  
  684.    FUNCTION
  685.  
  686.         Some SPObjects might support a "cassette recorder"-like way
  687.         to browse trough a Sample/Module via FastForward and Rewind.
  688.  
  689.    INPUT(S)
  690.  
  691.         handle - a valid handle
  692.  
  693.    RESULT
  694.  
  695.         NULL or an adequate SPERR-Errorcode.
  696.  
  697.    SINCE
  698.  
  699.         ... version 1 of the superplay.library.
  700.  
  701.    SEE ALSO
  702.  
  703.         SPL_FastForward
  704.  
  705. -----------------------------------------------------------------------------
  706.    Functions added with Version 2 :
  707. -----------------------------------------------------------------------------
  708.  
  709.    NAME
  710.         SPL_GetSampleList
  711.  
  712.    SYNOPSIS
  713.  
  714.         ULONG SPL_GetSampleList(APTR handle, struct SPO_SampleList **list)
  715.         D0    -$84              A1           A2
  716.  
  717.    FUNCTION
  718.  
  719.         While/after loading a Sample-File Version 2 SPObjects might create
  720.         a special list of all Samples, which appear in the File.
  721.         This will usually be one one Sample for SampleFiles, but many more
  722.         for ModuleFiles.
  723.  
  724.         Not all SPObjects, especially not all ModuleType-SPObjects,
  725.         may support this and will return an error value or an empty list.
  726.  
  727.    INPUT(S)
  728.  
  729.         handle - a valid handle
  730.         list   - a pointer to a SPO_SampleList pointer
  731.  
  732.    RESULT
  733.  
  734.         NULL or an adequate SPERR-Errorcode.
  735.  
  736.    SINCE
  737.  
  738.         ... version 2 of the superplay.library.
  739.  
  740.    SEE ALSO
  741.  
  742.         SPL_SetSampleList
  743.  
  744. -----------------------------------------------------------------------------
  745.  
  746.    NAME
  747.         SPL_SetSampleList
  748.  
  749.    SYNOPSIS
  750.  
  751.         ULONG SPL_SetSampleList(APTR handle, struct SPO_SampleList *list)
  752.         D0    -$8a              A1           A2
  753.  
  754.    FUNCTION
  755.  
  756.         For saving Sample-Files with Version 2 SPObjects, there may be used
  757.         a special list of all Samples, which should appear in the File.
  758.  
  759.         This will usually be one one Sample for SampleFiles, but many more
  760.         for ModuleFiles.
  761.  
  762.         Not all SPObjects, especially not all ModuleType-SPObjects,
  763.         may support this and can return SPERR_ACTION_NOT_SUPPORTED.
  764.  
  765.    INPUT(S)
  766.  
  767.         handle - a valid handle
  768.         list   - a pointer to a SPO_SampleList
  769.  
  770.    RESULT
  771.  
  772.         NULL or an adequate SPERR-Errorcode.
  773.  
  774.    BUGS
  775.  
  776.         Did not work in V2, because SuperWrite() cannot handle
  777.         NULL values for "source_handle", which should indicate, that
  778.         a SampleList has been set.
  779.  
  780.    SINCE
  781.  
  782.         ... version 2 of the superplay.library (request V3+).
  783.  
  784.    SEE ALSO
  785.  
  786.         SPL_GetSampleList
  787.  
  788. -----------------------------------------------------------------------------
  789.    Functions added with Version 4 :
  790. -----------------------------------------------------------------------------
  791.  
  792.    NAME
  793.         SPL_GetFileType
  794.  
  795.    SYNOPSIS
  796.  
  797.         ULONG SPL_GetFileType(APTR handle, char *filename, ULONG *filetype)
  798.         D0    -$90            A1           A2              A3
  799.  
  800.    FUNCTION
  801.  
  802.         Finds out superplay-specific FileType-Code
  803.         (redefined with every re-initialization of the Library) or
  804.         SP_FILE_TYPE_UNKNOWN (== NULL == FALSE).
  805.  
  806.         Use the following call for a simple check :
  807.  
  808.         handle   = SPL_AllocHandle(N);
  809.         SPerr    = SPL_GetFileType(handle, filename, &filetype);
  810.                    SPL_FreeHandle(handle);
  811.  
  812.         This handle should NOT be used for any further operations
  813.         on the file (will be opened and checked twice but only
  814.         closed once, etc).
  815.         Initialization operations are allowed nevertheless
  816.         (e.g. SPL_InitHandleAsClip() ).
  817.  
  818.         Note, that this function fills in FILETYPES, not SUBTYPES.
  819.         For e.g. writing you must specify SUBTYPES.
  820.  
  821.         FILETYPES are only for short identification and do only
  822.         specify the global file type (8SVX, ST).
  823.  
  824.    INPUT(S)
  825.  
  826.         handle   - a valid handle
  827.         filename - a valid AmigaDOS FilePath and -Name
  828.         filetype - pointer to ULONG for SP_FILETYPE-Value
  829.  
  830.    RESULT
  831.  
  832.         NULL or an adequate SPERR-Errorcode.
  833.  
  834.    SINCE
  835.  
  836.         ... version 4 of the superplay.library.
  837.  
  838.    SEE ALSO
  839.  
  840.         SPL_AllocHandle(), SVL_FreeHandle()
  841.  
  842. -----------------------------------------------------------------------------
  843.  
  844.