Ŀ
 MMIOTEST UTILITY 

 Use the MMIOTEST utility to exercise the MMIO subsystem
 during code development of I/O and CODEC procedures.  You
 can verify that individual functions are working in your
 procedure without testing the code through an application
 (which might not be written yet).  Each time you add
 support for a particular MMIOM_* message, you can test
 the associated function to see that it works and then
 continue with the development of your procedure.  For
 example, each IOProc must be able to process the
 MMIOM_OPEN message, which requests that a file be opened.
 MMIOTEST simulates calls from a user application and
 sends the appropriate MMIO message to the IOProc, which
 might in turn call on CODEC services.  MMIO functions
 serviced directly within the MMIO Manager are also simulated.
 
 NOTE:  For information on how to write a file format I/O
        procedure, refer to "I/O Procedures" in the MMPM/2
        1.1 Subsystem Development Guide.
 
Ŀ
 STARTING MMIOTEST 

 The MMIOTEST utility is a full-screen, command-driven
 utility.  It is located in the \MMOS2\MMTOOLKT\NEATSTUF
 subdirectory, which contains unsupported tools to assist
 you in your development effort.  Because this utility
 is not considered product-level code, there are some
 functions dealing with MMIO Manager error testing that
 will not be useful.  These selections are not described in
 this section.
 
 To start the MMIOTEST program, enter:
 
   MMIOTEST < [test file]
 
 A keystroke record feature ("R - Record Mode" on the main
 menu) allows you to capture a test sequence and then
 store it in a set of test suites for later processing and
 verification.  To process a recorded test script using
 the MMIOTEST program, specify the test file option.  The
 test file is the name selected during the "R - Record Mode"
 selection, and is redirected as input for the MMIOTEST program.
 
 All returns from the calls have the keyword "RESULTS:" or the
 keyword "ERROR:", so it is easy to write a simple program
 (REXX is a good choice for this) to analyze the output as
 required and make a master compare file to validate
 results from successive runs.  See "MMIOTEST Scenarios"
 for examples of how to use the test scripts.
 
 The following figure illustrates the MMIOTEST main menu
 choices.  To process a command, select a function from
 the main menu and follow submenu prompts to enter associated
 parameters or structure data.  By running these
 functions successfully, you can verify the message-
 processing capability of your I/O or CODEC procedures.
 Note that most (but not all) functions issue a corresponding
 MMIOM_* message to the IOProc.  Your IOProc must be
 able to handle these messages or return
 MMIOERR_UNSUPPORTED_MESSAGE.  If your IOProc does not
 support a specific message, it must support a default
 message handler to pass any message it cannot support to
 a subsequent child IOProc.
 
Ŀ
   Process an MMIO Command                                            
                                                                      
     1 - Open                         C - Command Entry               
     2 - Read                         D - Dump mmioInfo               
     3 - Write                        E - Examine Internal Storage    
     4 - Seek                         F - File Conversion Utilities   
     5 - Flush                        I - Digital Video (SMV)         
     6 - Close                        M - Memory Allocation Test      
     7 - InstallIOProc                P - Process Communication       
     8 - Low Level I/O                S - Start Another Process       
     9 - RIFF                         R - Record mode                 
     0 - Compound File Functions      U - Utility Functions           
     Q - Quit                         O - Options                     
                                                                      
   Enter Choice :                                                     

 MMIO.DLL Test Utility
 
Ŀ
 MMIOTEST FUNCTIONS 

 This section describes the functions available under the
 MMIOTEST utility and covers both the main menu and
 submenu choices.  Refer to the MMPM/2 1.1 Programming
 Reference for multimedia I/O (MMIO) parameters and
 descriptions of the MMIO messages discussed.
 
 Submenu prompts include "<CR>" and "Field Garbage".  The
 "<CR>" prompt represents pressing the Enter key (typically
 indicating a NULL or NO condition).  "Field
 Garbage" checks on the MMIO Manager's error handling.
 Press the Enter key to bypass this prompt.
 
 NOTE:  It is a good idea to keep a backup copy of the
        MMIO initialization file (MMPMMIO.INI).  Certain
        MMIOTEST functions modify the MMPMMMIO.INI file by
        adding, replacing, and removing I/O and CODEC procedure
        entries.
 
 1 - OPEN
     Sends an mmioOpen function to open a file for I/O.
     You are prompted for the input file name, associated
     flags, and the PMMIOINFO structure.
 
 2 - READ
     Sends an mmioRead function, which allows for reading
     data from an open file and displaying the information
     on your screen.  You are prompted for the open file
     handle and the number of bytes to read.   Because it
     is displayed as ASCII data, the main use is the
     return code that indicates bytes read.
 
 3 - WRITE
     Sends an mmioWrite function, which allows for writing
     data to an open file.  You are prompted for the open
     file handle, number of bytes to write, and input byte
     string.
 
 4 - SEEK
     Sends an mmioSeek function, which allows for seeking
     within an open file.  You are prompted for the open
     file handle, associated flags, and the offset, in
     bytes, to move the file position to.
 
 5 - FLUSH
     Sends an mmioFlush function, which writes the I/O
     buffer of a file to disk.  You are prompted for the
     open file handle and can choose to empty the I/O
     buffer.
 
 6 - CLOSE
     Sends an mmioClose function, which closes the specified
     opened file.  You are prompted for the open file
     handle.  If the IOProc is FOURCC_DOS, you can choose
     to tell the IOProc not to call the file-system-close
     function in the DOS file handle (although the open
     file handle itself is closed).  This is useful if a
     file handle was specified on the mmioOpen call in
     aulInfo[] instead of a file name in the szFileName
     parameter of mmioOpen.
 
 7 - INSTALLIOPROC
     Sends an mmioInstallIOProc function, which installs,
     finds, or removes an I/O procedure (for the given
     process only).  You are prompted for the four-
     character code of the IOProc and can choose to
     install, remove, or find a previously installed
     IOProc with the FOURCC identifier.
 
 8 - LOW LEVEL I/O
     Displays a submenu that contains the low-level buffering
     MMIO calls and corresponding routines to help test
     the calls.  Submenu functions include:
 
     A - SET BUFFER
         Sends an mmioSetBuffer function, which enables or
         disables buffered I/O, or changes the buffer size
         for an open file.
 
     B - GET INFO
         Sends an mmioGetInfo function, which gets information
         about an open file.  It also allows the caller
         to access the I/O buffer directly.
 
     C - SET INFO
         Sends an mmioSetInfo function, which updates open
         file information that was retrieved by a
         mmioGetInfo call.  It ends direct caller access
         to the I/O buffer.
 
     D - ADVANCE
         Sends an mmioAdvance function, which advances the
         I/O buffer of a file set up for direct I/O buffer
         manipulation by mmioGetInfo.
 
     E - MANIPULATE BUFFER
         Is used in conjunction with the mmioAdvance function.
 
 9 - RIFF
     Displays a submenu that contains RIFF-related MMIO
     functions and corresponding routines to help test the
     calls.  Submenu functions include:
 
     A - ASCEND
         Sends an mmioAscend function, which moves the
         file position to the end of the chunk.
 
     B - DESCEND
         Sends an mmioDescend function, which descends
         into a chunk of an open RIFF file.
 
     C - CREATE CHUNK
         Sends an mmioCreateChunk function, which creates
         a chunk in an open RIFF file.
 
 0 - COMPOUND FILE FUNCTIONS
     Presents a submenu that contains the RIFF-related
     MMIO compound file functions and corresponding routimes
     to help test the calls.  Submenu functions include:
 
     A - CF OPEN
         Sends an mmioCFOpen function, which opens a RIFF
         compound file.
 
     C - CF CLOSE
         Sends an mmioCFClose function, which closes an
         open RIFF compound file.
 
     D - CF COPY
         Sends an mmioCFCopy function, which copies the
         compound-file table of contents (CTOC) and the
         compound-file resource group (CGRP) chunks from
         an open RIFF compound file to another file.  The
         newly written compound-file resource group (CGRP)
         chunk is compacted; that is, it has no deleted
         elements.
 
     E - CF ADD ENTRY
         Sends an mmioCFAddEntry function, which adds an
         entry to the compound-file table of contents
         (CTOC) of an open RIFF compound file.  Duplicate
         entries are not allowed.
 
     F - CF FIND ENTRY
         Sends an mmioCFFindEntry function, which finds a
         particular entry in an open RIFF compound file.
 
     G - CF DELETE ENTRY
         Sends an mmioCFDeleteEntry function, which
         deletes a compound-file table of contents (CTOC)
         entry from an open RIFF compound file.
 
     H - CF CHANGE ENTRY
         Sends an mmioCFChangeEntry function, which modifies
         a compound-file table of contents (CTOC) entry
         in an open RIFF compound file.
 
     I - CF GET INFO
         Sends an mmioCFGetInfo function, which retrieves
         the compound-file table of contents (CTOC) header
         of an open RIFF compound file.
 
     J - CF SET INFO
         Sends an mmioCFSetInfo function, which modifies
         information that is stored in the compound-file
         table of contents (CTOC) header of an open RIFF
         compound file.
 
     K - CF ADD ELEMENT
         Sends an mmioCFAddElement function, which adds an
         element to the compound-file resource group
         (CGRP) chunk of an open RIFF compound file.
 
     L - OPEN A CF ELEMENT
         Sends an mmioOpen function with a compound-file
         handle and an element name.
 
     M - SEND CF MESSAGES
         Sends RIFF compound-file messages.  MMIOM_GETCF
         requests a handle to a RIFF compound file for a
         specific element.  MMIOM_GETCFENTRY requests a
         handle to a compound-file table of contents
         (CTOC) entry in a RIFF compound file.
 
     N - OPEN A CF ELEMENT SPECIFYING FOURCC
         Sends an mmioOpen function with a compound-file
         handle and an element name and FOURCC.
 
     P - CF COMPACT FILE
         Sends an mmioCFCompact function, which compacts
         the elements of a RIFF compound file.
 
 C - COMMAND ENTRY
     Allows any OS/2 command to be entered and processed
     within the test script.
 
 D - DUMP MMIOINFO
     Dumps the MMIOINFO structure.  It is useful to check
     the FOURCC fields to determine which I/O procedure
     opened the file.
 
 E - EXAMINE INTERNAL STORAGE
     Displays a submenu of functions used mainly for MMIO
     Manager debugging.  Submenu functions include:
 
     9 - RIFF WRAP AN EXISTING FILE
         Allows a file to become a RIFF file.
 
     0 - COMPOUND FILE BUILDER
         Builds a compound file with a BND FOURCC and CTOC
         and CGRP chunks.
 
 F - FILE CONVERSION UTILITIES
     Displays a submenu of functions used mainly for querying
     I/O procedures and file types.  Submenu functions
     include:
 
     A - QUERY FORMATS
         Sends an mmioQueryFormatCount function, which
         provides the number of IOProcs that match the
         format data specified.
 
     B - GET FORMATS
         Sends an mmioGetFormats function, which provides
         a list of MMFORMATINFO structures containing
         descriptive information about the formats supported
         by currently installed IOProcs.
 
     C - GET FORMAT NAME
         Sends an mmioGetFormatName function, which
         returns the format name associated with the
         IOProc.
 
     D - IDENTIFY FILE
         Sends an mmioIdentifyFile function, which determines
         if any of the currently loaded IOProcs can
         process the file specified.  Information about
         the IOProc and file format is also returned.
 
     E - QUERY HEADER
         Sends an mmioQueryHeaderLength function, which
         determines the size of the header for the opened
         file.
 
     F - GET HEADER
         Sends an mmioGetHeader function, which returns
         the header of the media structure of the open
         file.  The header contains information about the
         media that this particular IOProc can process.
 
     G - SET HEADER
         Sends an mmioSetHeader function, which sets
         attributes of the media in a file opened for
         writing by mmioOpen.
 
         This function does not change the current file
         position.  Normally mmioGetHeader is issued to
         obtain the attribute data and mmioSetHeader is
         issued to update it.  You can issue mmioSetHeader
         independently of a mmioGetHeader function to
         create the header initially.
 
 I - DIGITAL VIDEO (SMV)
     Displays a submenu of functions used mainly for simulating
     CODEC related functions.  Submenu functions include:
 
     A - MMIOSET
         Sends an mmioSet function, which sets or queries
         extended file information.
 
     B - MMIOQUERYCODECNAME
         Sends an mmioQueryCODECName function, which
         returns the CODEC procedure name associated with
         the fields defined in the CODECINIFILEINFO structure.
 
     C - MMIOQUERYCODECNAMELENGTH
          Sends an mmioQueryCODECNameLength function, which
         returns the length of the CODEC procedure name
         associated with the fields defined in the
         CODECINIFILEINFO structure.  The returned length
         does not include the NULL terminating character.
 
     F - MMIOLOADCODECPROC
         Sends an mmioLoadCODECProc function, which loads
         the CODEC procedure installed in the MMPMMMIO.INI
         file and returns the entry point.  It is normally
         issued by the IOProc to access the CODEC proce-
         dure.
 
 M - MEMORY ALLOCATION TEST
     Used internally by the MMIO Manager.
 
 O - OPTIONS
     Allows you to set the media type and TRANSLATE flags
     for the mmioOpen function.
 
 P - PROCESS COMMUNICATION
     Is used internally by the MMIO Manager.
 
 S - START ANOTHER PROCESS
     Is used internally by the MMIO Manager.
 
 R - RECORD MODE
     Allows the user to record the succeeding keystrokes
     for the purpose of generating a test suite of script
     files.  It prompts for the name of the test file in
     which to store keystrokes.
 
 U - UTILITY FUNCTIONS
     Submenu functions include:
 
     A - SEND MESSAGE
         Sends an mmioSendMessage function, which sends a
         message to the IOProc associated with an open
         file.
 
     B - GET LAST ERROR
         Sends an mmioGetLastError function, which returns
         the last error condition stored.
 
     C - WORK WITH OLD INI FILE
         Sends an MMPM/2 Release 1.0 mmioIniFileHandler
         function, which modifies the initialization file
         (MMPMMMIO.INI) for MMIO services.  It adds,
         replaces, removes, or finds an entry in the
         MMPMMMIO.INI file.
 
     D - DETERMINE STORAGE SYSTEM
         Sends an mmioDetermineSSIOProc function, which
         attempts to determine the storage system of the
         media data object specified in the file name and
         pmmioinfo parameters.
 
     E - DETERMINE FILE FORMAT
         Is used internally by the MMIO Manager.
 
     F - DETERMINE DATA FORMAT
         Is used internally by the MMIO Manager.
 
     G - QUERY I/O PROC MOD HANDLE
         Sends an mmioQueryIOProcModuleHandle function,
         which provides the module handle of an IOProc's
         DLL.  Use this handle to retrieve resources from
         the DLL.
 
     H - WORK WITH NEW INI FILE
         Sends an Release 1.1 mmioIniFileHandler function,
         which modifies the initialization file
         (MMPMMMIO.INI) for MMIO services.  It adds,
         replaces, removes, or finds an entry in the
         MMPMMMIO.INI file.
 
     I - WORK WITH CODECS
         Sends an mmioIniFileCODEC function, which modifies
         the initialization file (MMPMMMIO.INI) for
         MMIO Manager services.  It adds, replaces,
         removes, or finds a CODEC entry in the
         MMPMMMIO.INI file.
 
     J - VIEW I/O PROC IN INI
         Displays a particular I/O procedure from the
         MMPMMMIO.INI file.
 
     K - VIEW CODEC IN INI
         Displays a particular CODEC procedure from the
         MMPMMMIO.INI file.
 
     L - LIST I/O PROC(S)
         Lists all the I/O procedures in the MMPMMMIO.INI
         file.
 
     M - LIST CODECS PROC(S)
         Lists all the CODECs procedures in the
         MMPMMMIO.INI file.
 
     N - MIGRATE INI FILE
         Is used internally by the MMIO Manager.
 
Ŀ
 MMIOTEST SCENARIOS 

 The following test scenarios are provided:
 
 o   "Creating a Test Script" shows you how to record
     keystrokes in a file (to process as a test file
     at a later date).
 
 o   "Adding a CODEC Procedure to MMPMMMIO.INI"
     illustrates how to add a CODEC procedure into the
     MMPMMMIO.INI file.
 
Ŀ
 CREATING A TEST SCRIPT 

 Follow these steps to create a test script to pipe into
 the MMIOTEST program at a later date.
 
 STEP 1:  To start recording subsequent keystrokes, enter
 R.  At the prompt, enter the name of the test file in
 which you want to store the keystrokes.
 
Ŀ
  Process an MMIO Function                                            
                                                                      
   1 - Open                         C - Commnad Entry                 
   2 - Read                         D - Dump mmioInfo                 
   3 - Write                        E - Examine Internal Storage      
   4 - Seek                         F - File Conversion Utilities     
   5 - Flush                        I - Digital Video (SMV)           
   6 - Close                        M - Memory Allocation Test        
   7 - InstallIOProc                P - Process Communication         
   8 - Low Level I/O                S - Start Another Process         
   9 - RIFF                         R - Record mode                   
   0 - Compound File Functions      U - Utility Functions             
   Q - Quit                         O - Options                       
   Enter Choice : R                                                   
   Starting Record Mode...                                            
                                                                      
   Input File Name : TEST1.SCR                                        

 
 STEP 2:  To set the media type for the mmioOpen function,
 select O.  Next, select 1 to set the default media type.
 For example, select an "AUDIO" media type.  Q returns to
 the previous menu level.
 
Ŀ
   Enter Choice : O                                                   
                                                                      
   MMIOTEST Options                                                   
                                                                      
   1 - Set default Media Type for Open                                
   2 - Set TRANSLATE flags for Open                                   
   Q - Quit                                                           
                                                                      
   Enter Choice : 1                                                   
                                                                      
   MMIO_MEDIATYPE_IMAGE : Y - (ON), <CR> - (OFF), Q - (Quit) :        
   MMIO_MEDIATYPE_AUDIO : Y - (ON), <CR> - (OFF), Q - (Quit) : Y      
   MMIO_MEDIATYPE_MIDI : Y - (ON), <CR> - (OFF), Q - (Quit) : Q       
                                                                      
   MediaType set to 2                                                 
                                                                      
   MMIOTEST Options                                                   
                                                                      
   1 - Set default Media Type for Open                                
   2 - Set TRANSLATE flags for Open                                   
   Q - Quit                                                           
                                                                      
   Enter Choice : Q                                                   

 
 STEP 3:  To open a file, select 1.  You are prompted for
 the input file name.  For example, enter BUBBLE.WAV with
 no additional parameters other than the specified "AUDIO"
 media type.  The Open is successful as indicated by the
 "RESULTS: Open succeeded" response.
 
Ŀ
   Enter Choice : 1                                                   
   Input File Name or <CR> : bubble.wav                               
   Input Flags (Y or <CR> ?) :                                        
   Input mmioinfo (Y or <CR> ?) :                                     
   RESULT: Open succeeded.                                            

 
 STEP 4:  To verify that the fccIOProc is "WAVE", select D
 to dump the MMIOINFO structure.  This is useful to check
 the FOURCC fields to determine which I/O procedure opened
 the file.
 
Ŀ
   Enter Choice : D                                                  
                                                                     
   Handles Available                                                 
                                                                     
    - 00 - bubble.wav                                                
                                                                     
   Input Handle : 0                                                  
                                                                     
   MMIOINFO fields                                                   
                                                                     
   ulFlags (hex) 40000200                                            
   MMIO_DENYNONE is ON                                               
   fccIOProc WAVE                                                    
   pIOProc (addr) 15830000                                           
   ulErrorRet 0                                                      
   cchBuffer 0                                                       
   pchBuffer (addr) 0                                                
   pchNext (addr) 0                                                  
   pchEndRead (addr) 0                                               
   pchEndWrite (addr) 0                                              
   lBufOffset 0                                                      
   lDiskOffset 0                                                     
   aulInfo[0] 0                                                      
   aulInfo[1] 1114112                                                
   aulInfo[2] 0                                                      
   aulInfo[3] 2                                                      
   lLogicalFilePos 0                                                 
   fccChildIOProc DOS                                                
   pExtraInfoStruct 0                                                
   hmmio 2                                                           

 
 STEP 5:  To identify the file as "wave" and display the
 attributes of the Waveform IOProc, select F and option D
 from the submenu.
 
Ŀ
   Enter Choice : F                                                   
                                                                      
   Process a File Conversion function                                 
                                                                      
   A - Query Formats                                                  
   B - Get Formats                                                    
   C - Get Format Name                                                
   D - Identify File                                                  
   E - Query Header                                                   
   F - Get Header                                                     
   G - Set Header                                                     
   Q - Quit                                                           
                                                                      
   Enter Choice : D                                                   
   Input File Name or <CR> : bubble.wav                               
   Use MMIO_VERTBAR (Y or <CR> ?) :                                   
   Send NULL mmFormatInfo (Y or <CR> ?) :                             
   Use MMIO_FORCE_IDENTIFY_SS (Y or <CR> ?) :                         
   Use MMIO_FORCE_IDENTIFY_FF (Y or <CR> ?) :                         
                                                                      
   RESULT: Identify File returned MMIO_SUCCESS                        
   RESULT: fccStorageSystem = DOS                                     
                                                                      
   Dumping MMFORMATINFO data . . .                                    
                                                                      
   fccIOProc : WAVE                                                   
   ulIOProcType : MMIO_IOPROC_FILEFORMAT                              
   ulMediaType : MMIO_MEDIATYPE_AUDIO                                 
   ulFlags (hex) : fff                                                
     MMIO_CANREADTRANSLATED                                           
     MMIO_CANWRITETRANSLATED                                          
     MMIO_CANREADWRITETRANSLATED                                      
     MMIO_CANREADUNTRANSLATED                                         
     MMIO_CANWRITEUNTRANSLATED                                        
     MMIO_CANREADWRITEUNTRANSLATED                                    
     MMIO_CANSEEKTRANSLATED                                           
     MMIO_CANSEEKUNTRANSLATED                                         
     MMIO_CANINSERTUNTRANSLATED                                       
     MMIO_CANSAVEUNTRANSLATED                                         
     MMIO_CANINSERTTRANSLATED                                         
     MMIO_CANSAVETRANSLATED                                           
   achDefaultFormatExt[4] : WAV                                       
   ulCodePage : Country  : 1                                          
   ulCodePage : CodePage : 437                                        
   ulLanguage : Dialect  : 1                                          
   ulLanguage : Language : 9                                          
   lNameLength : 23                                                   
                                                                      
                                                                      
   Process a File Conversion function                                 
                                                                      
   A - Query Formats                                                  
   B - Get Formats                                                    
   C - Get Format Name                                                
   D - Identify File                                                  
   E - Query Header                                                   
   F - Get Header                                                     
   G - Set Header                                                     
   Q - Quit                                                           
                                                                      
   Enter Choice : Q                                                   

 
 STEP 6:  To end the keystroke recording, select Q.
 
 Simple function files can redirect the output to a file
 that then parses for the keywords and generates a valid
 comparison file.  This action can be repeated and a suite
 of test cases developed.
 
Ŀ
   Enter Choice : Q                                                   
   Stop Record Mode (Y or <CR> ?) : Y                                 

 
Ŀ
 ADDING A CODEC PROCEDURE TO MMPMMMIO.INI 

 This scenario shows you how to add a CODEC procedure into the
 MMIO initialization file (MMPMMMIO.INI).
 
 To add a CODEC procedure into the MMPMMMIO.INI file, select
 U and then I as a submenu choice.  You are prompted for
 inputing attributes associated with the CODEC.  The
 "Input Flags (Y or <CR> ?) : Y" then activates the particular
 action to be taken with the CODEC information, which in this
 example is to install it in the INI file.
 
Ŀ
  Process a MMIO function                                             
                                                                      
  1 - Open                         C - Command Entry                  
  2 - Read                         D - Dump mmioInfo                  
  3 - Write                        E - Examine Internal Storage       
  4 - Seek                         F - File Conversion Utilities      
  5 - Flush                        I - Digital Video (SMV)            
  6 - Close                        M - Memory Allocation Test         
  7 - InstallIOProc                P - Process Communication          
  8 - Low Level I/O                S - Start Another Process          
  9 - RIFF                         R - Record mode                    
  0 - Compound File Functions      U - Utility Functions              
  Q - Quit                         O - Options                        
  Enter Choice : U                                                    
                                                                      
  Process a Utility Function                                          
                                                                      
  A - Send Message                        I - Work with CODECs        
  B - Get Last Error                      J - View I/O Proc in INI    
  C - Work with OLD INI file              K - View CODEC in INI       
  D - Determine Storage System            L - List I/O Proc(s)        
  E - Determine File Format               M - List CODECS Proc(s)     
  F - Determine Data Format               N - Migrate INI file        
  G - Query I/O Proc Mod Handle           H - Work with NEW INI file  
  Q - Quit                                                            
                                                                      
                                                                      
  Enter Choice : I                                                    
  Send NULL CODECIniFileInfo (Y or <CR> ?) :                          
  Input FOURCC or <CR> : DUMM                                         
  Input the DLL file name : DUMMYPROC                                 
  Input the I/O procedure name : DUMMYIOProc                          
  Input the Compression Type : RT21                                   
  Input the Compression SubType : 2                                   
  Input the media type:                                               
  MMIO_MEDIATYPE_IMAGE : Y - (ON), <CR> - (OFF), Q - (Quit) : Y       
  MMIO_MEDIATYPE_AUDIO : Y - (ON), <CR> - (OFF), Q - (Quit) : Y       
  MMIO_MEDIATYPE_MIDI : Y - (ON), <CR> - (OFF), Q - (Quit) : Q        
  Input the capabilities flags :                                      
  CODEC_COMPRESSION : Y - (ON), <CR> - (OFF), Q - (Quit) : Y          
  CODEC_DECOMPRESSION : Y - (ON), <CR> - (OFF), Q - (Quit) : Y        
  CODEC_WINDOW_CLIPPING : Y - (ON), <CR> - (OFF), Q - (Quit) : Y      
  CODEC_PALETTE_TRANS : Y - (ON), <CR> - (OFF), Q - (Quit) :          
  CODEC_SELFHEAL : Y - (ON), <CR> - (OFF), Q - (Quit) :               
  CODEC_SCALE_PEL_DOUBLE : Y - (ON), <CR> - (OFF), Q - (Quit) :       
  CODEC_SCALE_PEL_HALVED : Y - (ON), <CR> - (OFF), Q - (Quit) :       
  CODEC_SCALE_CONTINUOUS : Y - (ON), <CR> - (OFF), Q - (Quit) :       
  CODEC_MULAPERTURE : Y - (ON), <CR> - (OFF), Q - (Quit) :            
  CODEC_4_BIT_COLOR : Y - (ON), <CR> - (OFF), Q - (Quit) : Y          
  CODEC_8_BIT_COLOR : Y - (ON), <CR> - (OFF), Q - (Quit) : Y          
  CODEC_16_BIT_COLOR : Y - (ON), <CR> - (OFF), Q - (Quit) : Y         
  CODEC_24_BIT_COLOR : Y - (ON), <CR> - (OFF), Q - (Quit) : Y         
  CODEC_SYMMETRIC : Y - (ON), <CR> - (OFF), Q - (Quit) : Q            
  Input the Max source buffer length : 256                            
  Input the compression turn around time : 1                          
  Input the decompression turn around time : 2                        
  Input any specific information (32 chars) : Just a dummy CODEC      
  Input Flags (Y or <CR> ?) : Y                                       
  MMIO_INSTALLPROC : Y - (ON), <CR> - (OFF), Q - (Quit) : Y           
  MMIO_FINDPROC : Y - (ON), <CR> - (OFF), Q - (Quit) : Q              
  MATCH ADDITIONAL FLAGS: Y - (ON), <CR> - (Quit) : Y                 
  MMIO_MATCHCAPSFLAGS : Y - (ON), <CR> - (OFF), Q - (Quit) : Y        
  MMIO_MATCHCOMPRESSTYPE : Y - (ON), <CR> - (OFF), Q - (Quit) : Y     
  MMIO_MATCHCOMPRESSSUBTYPE : Y - (ON), <CR> - (OFF), Q - (Quit) : Y  
  MMIO_MATCHHWID : Y - (ON), <CR> - (OFF), Q - (Quit) : Y             
  Input the X-alignment value : 240                                   
  Input the Y-alignment value : 360                                   
                                                                      
  RESULT: IniFileCODEC returned MMIO_SUCCESS                          

