home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / mmpm21tk.zip / TK / ULIOT / IOSRV.C < prev    next >
C/C++ Source or Header  |  1993-04-08  |  24KB  |  437 lines
  1. /*************************START OF SPECIFICATIONS *************************/
  2. /* SOURCE FILE NAME:  IOSRV.C                                             */
  3. /*                                                                        */
  4. /* DESCRIPTIVE NAME: File Format IO Proc service routines                 */
  5. /*                                                                        */
  6. /* COPYRIGHT:     IBM - International Business Machines                   */
  7. /*            Copyright (c) IBM Corporation  1991, 1992, 1993             */
  8. /*                        All Rights Reserved                             */
  9. /*                                                                        */
  10. /* STATUS: OS/2 Release 2.0                                               */
  11. /*                                                                        */
  12. /* FUNCTION: This source module contains service routines for the IOProc. */
  13. /*                                                                        */
  14. /* NOTES:                                                                 */
  15. /*    DEPENDENCIES: none                                                  */
  16. /*    RESTRICTIONS: Runs in 32 bit protect mode (OS/2 2.0)                */
  17. /*                                                                        */
  18. /* ENTRY POINTS:                                                          */
  19. /*      ioGetPtrInstance                                                  */
  20. /*      ioFindTracki                                                      */
  21. /*      ioFindTrackMapEntry                                               */
  22. /*      ioIdentifyStorageSystem                                           */
  23. /*      ioInstanceInit                                                    */
  24. /*      ioAddTracksToMovieHeader                                          */
  25. /*      ioValidateRead                                                    */
  26. /*                                                                        */
  27. /************************** END OF SPECIFICATIONS *************************/
  28.  
  29. #include        <stdio.h>
  30. #include        <string.h>
  31. #include        <stdlib.h>
  32. #include        <memory.h>
  33.  
  34. #define         INCL_DOS                      /* #define  INCL_DOSPROCESS  */
  35. #define         INCL_ERRORS
  36. #define         INCL_WIN
  37. #define         INCL_GPI
  38. #include        <os2.h>                       /* OS/2 headers              */
  39. #include        <pmbitmap.h>
  40.  
  41. #define         INCL_OS2MM
  42. #define         INCL_MMIO_CODEC
  43. #define         INCL_MMIO_DOSIOPROC
  44. #include        <os2me.h>                     /* Multi-Media IO extensions */
  45. #include        <hhpheap.h>
  46. #include        <ioi.h>
  47.  
  48.  
  49.  
  50. /************************** START OF SPECIFICATIONS *************************/
  51. /*                                                                          */
  52. /* SUBROUTINE NAME: ioGetPtrInstance                                        */
  53. /*                                                                          */
  54. /* DESCRIPTIVE NAME: Validate input parameters, get ptr to instance         */
  55. /*                                                                          */
  56. /* FUNCTION:                                                                */
  57. /*                                                                          */
  58. /* NOTES: None                                                              */
  59. /*                                                                          */
  60. /* ENTRY POINT: ioGetPtrInstance                                            */
  61. /*   LINKAGE:   CALL FAR (00:32)                                            */
  62. /*                                                                          */
  63. /* INPUT:                                                                   */
  64. /*   PMMIOINFO             pmmioinfo          - ptr to mmio info            */
  65. /*   PINSTANCE             pinstance          - ptr to instance info        */
  66. /*                                                                          */
  67. /* EXIT-NORMAL:                                                             */
  68. /*              MMIO_SUCCESS                                                */
  69. /*                                                                          */
  70. /* EXIT-ERROR:                                                              */
  71. /*              MMIO_ERROR                                                  */
  72. /*                                                                          */
  73. /* SIDE EFFECTS:                                                            */
  74. /*                                                                          */
  75. /*************************** END OF SPECIFICATIONS **************************/
  76. LONG ioGetPtrInstance ( PMMIOINFO pmmioinfo,
  77.                         PINSTANCE *ppinstance)
  78.  
  79. {
  80.    /*
  81.     * Validates parameters passed.
  82.     */
  83.    if (pmmioinfo == NULL){
  84.       return(MMIO_ERROR);
  85.       }
  86.  
  87.    if (CheckMem((PVOID)pmmioinfo, sizeof(MMIOINFO), PAG_WRITE))
  88.       return (MMIO_ERROR);
  89.  
  90.    if (pmmioinfo->hmmio == 0){
  91.       pmmioinfo->ulErrorRet = MMIOERR_INVALID_HANDLE;
  92.       return(MMIO_ERROR);
  93.       }
  94.  
  95.    *ppinstance = (PINSTANCE)pmmioinfo->pExtraInfoStruct;
  96.  
  97.    if (*ppinstance == NULL) {
  98.       pmmioinfo->ulErrorRet = MMIOERR_INVALID_STRUCTURE;
  99.       return(MMIO_ERROR);
  100.       }
  101.  
  102.    return(MMIO_SUCCESS);
  103. }
  104.  
  105.  
  106. /************************** START OF SPECIFICATIONS *************************/
  107. /*                                                                          */
  108. /* SUBROUTINE NAME: ioFindTracki                                            */
  109. /*                                                                          */
  110. /* DESCRIPTIVE NAME: Verify that the track number is a valid  movie track.  */
  111. /*                                                                          */
  112. /* FUNCTION: This function searches all known movie tracks for a match.     */
  113. /*           and returns a ptr to movie track entry.                        */
  114. /*                                                                          */
  115. /* NOTES: None                                                              */
  116. /*                                                                          */
  117. /* ENTRY POINT: ioFindTracki                                                */
  118. /*   LINKAGE:   CALL FAR (00:32)                                            */
  119. /*                                                                          */
  120. /* INPUT:                                                                   */
  121. /*           PINSTANCE      pinstance  - Ptr to instance structure.         */
  122. /*           ULONG          ulTrackID - Track number to search for.         */
  123. /*                                                                          */
  124. /* EXIT-NORMAL:    Ptr to movie track entry                                 */
  125. /*                                                                          */
  126. /*                                                                          */
  127. /* EXIT-ERROR:     NULL, not found                                          */
  128. /*                                                                          */
  129. /*                                                                          */
  130. /* SIDE EFFECTS:                                                            */
  131. /*                                                                          */
  132. /*************************** END OF SPECIFICATIONS **************************/
  133. PTRACKI ioFindTracki ( PINSTANCE pinstance,
  134.                        ULONG ulTrackID )
  135.  
  136. {
  137.    PTRACKI ptracki;
  138.  
  139.    for (ptracki = pinstance->ptrackiList; ptracki; ptracki = ptracki->ptrackiNext) {
  140.       if (ptracki->ulTrackID == ulTrackID) {
  141.           return(ptracki);
  142.           }
  143.       }
  144.  
  145.   return(NULL);
  146. }
  147.  
  148.  
  149. /************************** START OF SPECIFICATIONS *************************/
  150. /*                                                                          */
  151. /* SUBROUTINE NAME: ioFindTrackMapEntry                                     */
  152. /*                                                                          */
  153. /* DESCRIPTIVE NAME: Find Track Map Entry from Track list.                  */
  154. /*                                                                          */
  155. /* FUNCTION: This function matches Track from Track list.                   */
  156. /*                                                                          */
  157. /*                                                                          */
  158. /* NOTES: None                                                              */
  159. /*                                                                          */
  160. /* ENTRY POINT: ioFindTrackMapEntry                                         */
  161. /*   LINKAGE:   CALL FAR (00:32)                                            */
  162. /*                                                                          */
  163. /* INPUT:                                                                   */
  164. /*                                                                          */
  165. /*              PATRACKMAP     patrackmap                                   */
  166. /*              ULONG          ulNumTracks                                  */
  167. /*              ULONG          ulTrackID                                    */
  168. /* EXIT-NORMAL:                                                             */
  169. /*                                                                          */
  170. /*                                                                          */
  171. /* EXIT-ERROR:                                                              */
  172. /*                                                                          */
  173. /*                                                                          */
  174. /* SIDE EFFECTS:                                                            */
  175. /*                                                                          */
  176. /*************************** END OF SPECIFICATIONS **************************/
  177. PTRACKMAP ioFindTrackMapEntry ( PTRACKMAP patrackmapList,
  178.                                 ULONG ulNumTracks,
  179.                                 ULONG ulTrackID)
  180.  
  181. {
  182.    ULONG i;
  183.    PTRACKMAP ptrackmap = patrackmapList;
  184.  
  185.    for(i=0; i < ulNumTracks; i++, ptrackmap++ ) {
  186.  
  187.       if (ptrackmap->ulTrackID == ulTrackID) {
  188.          return(ptrackmap);
  189.          }
  190.       }
  191.  
  192.    return(NULL);
  193. }
  194.  
  195.  
  196. /************************** START OF SPECIFICATIONS *************************/
  197. /*                                                                          */
  198. /* SUBROUTINE NAME:  ioIdentifyStorageSystem                                */
  199. /*                                                                          */
  200. /* DESCRIPTIVE NAME: IOProc identifies storage system.                      */
  201. /*                                                                          */
  202. /* FUNCTION: This function identifies the storage system for the current    */
  203. /*           file.                                                          */
  204. /*                                                                          */
  205. /* NOTES: None                                                              */
  206. /*                                                                          */
  207. /* ENTRY POINT: ioIdentifyStorageSystem                                     */
  208. /*   LINKAGE:   CALL FAR (00:32)                                            */
  209. /*                                                                          */
  210. /* INPUT:                                                                   */
  211. /*         PMMIOINFO pmmioinfo   - MMIOINFO structure.                      */
  212. /*         PSZ       pszFileName - File name.                               */
  213. /*                                                                          */
  214. /* EXIT-NORMAL:                                                             */
  215. /*              MMIO_SUCCESS                                                */
  216. /*                                                                          */
  217. /* EXIT-ERROR:                                                              */
  218. /*              MMIO_ERROR                                                  */
  219. /*                                                                          */
  220. /* SIDE EFFECTS:                                                            */
  221. /*                                                                          */
  222. /*************************** END OF SPECIFICATIONS **************************/
  223. LONG ioIdentifyStorageSystem ( PMMIOINFO pmmioinfo,
  224.                                PSZ pszFileName )
  225.  
  226. {
  227.    FOURCC  fccStorageSystem;                      /* fcc of SS I/O Proc.    */
  228.    LONG    rc;                                    /* return code.           */
  229.  
  230.    fccStorageSystem = pmmioinfo->fccIOProc;
  231.  
  232.    if (!fccStorageSystem) {
  233.  
  234.       if (pszFileName == NULL) {
  235.          fccStorageSystem = FOURCC_DOS;
  236.          }
  237.       else {
  238.          rc = mmioIdentifyStorageSystem(pszFileName,
  239.                                         pmmioinfo,
  240.                                         &fccStorageSystem);
  241.          if (rc != MMIO_SUCCESS) {
  242.             return(rc);
  243.             }
  244.          }
  245.       }
  246.    pmmioinfo->fccIOProc = fccStorageSystem;
  247.  
  248.    return(MMIO_SUCCESS);
  249. }
  250.  
  251.  
  252. /************************** START OF SPECIFICATIONS *************************/
  253. /*                                                                          */
  254. /* SUBROUTINE NAME: ioInstanceInit                                          */
  255. /*                                                                          */
  256. /* DESCRIPTIVE NAME: Initialize all fields.                                 */
  257. /*                                                                          */
  258. /* FUNCTION: Initialize all fields to NULL and zero.                        */
  259. /*                                                                          */
  260. /*                                                                          */
  261. /* NOTES: None                                                              */
  262. /*                                                                          */
  263. /* ENTRY POINT: ioInstanceInit                                              */
  264. /*   LINKAGE:   CALL FAR (00:32)                                            */
  265. /*                                                                          */
  266. /* INPUT:                                                                   */
  267. /*              PINSTANCE    pinstance -- pointer to instance structure.    */
  268. /*                                                                          */
  269. /* EXIT-NORMAL:                                                             */
  270. /*              (none)                                                      */
  271. /*                                                                          */
  272. /* EXIT-ERROR:                                                              */
  273. /*              (none)                                                      */
  274. /*                                                                          */
  275. /* SIDE EFFECTS:                                                            */
  276. /*                                                                          */
  277. /*************************** END OF SPECIFICATIONS **************************/
  278. VOID ioInstanceInit ( PINSTANCE pinstance)
  279.  
  280. {
  281.    pinstance->pRawHdr              = NULL;
  282.    pinstance->ulRawHdrLength       = 0L;
  283.    pinstance->pmmhdr               = NULL;
  284.    pinstance->ulMmHdrLength        = 0L;
  285.    pinstance->ptrackiList          = NULL;
  286.    pinstance->lLastTrack           = -1L;
  287.    pinstance->lCurrentTrack        = -1L;
  288.    pinstance->pccbList             = NULL;
  289.    pinstance->hmmioFileHandle      = 0L;
  290.    pinstance->lFileCurrentPosition = 0L;
  291.    pinstance->ulFileLen            = 0L;
  292.    pinstance->ulFlags              = 0L;
  293.    pinstance->ulMode               = 0L;
  294.    pinstance->pTempBuffer          = NULL;
  295.    pinstance->ulTempBufferSize     = 0L;
  296.    pinstance->ulDataInTempBuffer   = 0L;
  297.    pinstance->pLastBuffer          = NULL;
  298.    pinstance->ulLastBufferOffset   = 0L;
  299.    pinstance->pccbLastUsed         = NULL;
  300.    pinstance->ulMisc1              = 0L;
  301.    pinstance->ulMisc2              = 0L;
  302.    pinstance->ulMisc3              = 0L;
  303.    pinstance->ulMisc4              = 0L;
  304.    return;
  305. }
  306.  
  307.  
  308. /************************** START OF SPECIFICATIONS *************************/
  309. /*                                                                          */
  310. /* SUBROUTINE NAME: ioAddTracksToMovieHeader                                */
  311. /*                                                                          */
  312. /* DESCRIPTIVE NAME: Updates tracks to track list in MMOVIEHEADER.          */
  313. /*                                                                          */
  314. /* FUNCTION: This function copies the current file's valid tracks to caller.*/
  315. /*                                                                          */
  316. /*                                                                          */
  317. /* NOTES: None                                                              */
  318. /*                                                                          */
  319. /* ENTRY POINT: ioAddTracksToMovieHeader                                    */
  320. /*   LINKAGE:   CALL FAR (00:32)                                            */
  321. /*                                                                          */
  322. /* INPUT:                                                                   */
  323. /*          PINSTANCE     pinstance    - IOProc instant structure.          */
  324. /*                                                                          */
  325. /*                                                                          */
  326. /* EXIT-NORMAL:                                                             */
  327. /*              MMIO_SUCCESS                                                */
  328. /*                                                                          */
  329. /* EXIT-ERROR:                                                              */
  330. /*              MMIO Error message.                                         */
  331. /*                                                                          */
  332. /*                                                                          */
  333. /* SIDE EFFECTS:                                                            */
  334. /*                                                                          */
  335. /*************************** END OF SPECIFICATIONS **************************/
  336. LONG ioAddTracksToMovieHeader ( PINSTANCE pinstance )
  337.  
  338. {
  339.    ULONG    i;                      /* Loop index.            */
  340.    PTRACKI  ptracki;                /* Track list of pinstance. */
  341.  
  342.    /**************************************************************************/
  343.    /* Copy track information into the movie header                           */
  344.    /**************************************************************************/
  345.    for (i = 0, ptracki = pinstance->ptrackiList;
  346.         (i < pinstance->pmmhdr->ulNumEntries) && ptracki;
  347.         i++, ptracki = ptracki->ptrackiNext ) {
  348.  
  349.       pinstance->pmmhdr->pmmTrackInfoList[i].ulTrackID   = ptracki->ulTrackID;
  350.       pinstance->pmmhdr->pmmTrackInfoList[i].ulMediaType = ptracki->ulMediaType;
  351.       pinstance->pmmhdr->pmmTrackInfoList[i].ulCountry   = 0L;                        /* TEMP TEMP */
  352.       pinstance->pmmhdr->pmmTrackInfoList[i].ulCodePage  = 0L;                        /* TEMP TEMP */
  353.       }
  354.  
  355.    if (i > pinstance->pmmhdr->ulNumEntries)
  356.       return(MMIOERR_INVALID_BUFFER_LENGTH);
  357.  
  358.    return(MMIO_SUCCESS);
  359. }
  360.  
  361.  
  362. /************************** START OF SPECIFICATIONS *************************/
  363. /*                                                                          */
  364. /* SUBROUTINE NAME: ioValidateRead                                          */
  365. /*                                                                          */
  366. /* DESCRIPTIVE NAME: Validate parameters passed from user.                  */
  367. /*                                                                          */
  368. /* FUNCTION:                                                                */
  369. /*                                                                          */
  370. /* NOTES:                                                                   */
  371. /*                                                                          */
  372. /* ENTRY POINT: ioValidateRead                                              */
  373. /*   LINKAGE:   CALL Near (00:32)                                           */
  374. /*                                                                          */
  375. /* INPUT:       PINSTANCE              pinstance                            */
  376. /*              PVOID                  pReadBuffer                          */
  377. /*              ULONG                  ulNumTracks                          */
  378. /*              PTRACKMAP              patrackmapList                       */
  379. /*                                                                          */
  380. /* EXIT-NORMAL:                                                             */
  381. /*              MMIO_SUCCESS                                                */
  382. /*                                                                          */
  383. /* EXIT-ERROR:                                                              */
  384. /*              MMIO error return code                                      */
  385. /*                                                                          */
  386. /*                                                                          */
  387. /* SIDE EFFECTS:                                                            */
  388. /*                                                                          */
  389. /*************************** END OF SPECIFICATIONS **************************/
  390. LONG ioValidateRead ( PINSTANCE pinstance,
  391.                       PVOID pReadBuffer,
  392.                       ULONG ulNumTracks,
  393.                       PTRACKMAP patrackmapList)
  394.  
  395. {
  396.    PTRACKI    ptracki;                         /* Ptr to ptracki entry */
  397.    ULONG      i;
  398.    ULONG      j;
  399.  
  400.  
  401.    /**************************************************************************/
  402.    /* For each track to read, validate that it is a valid movie track.       */
  403.    /* And for each valid track, save the number of entries and reset the     */
  404.    /* srcbuftab entries. Also init each srcbuftab entry.                     */
  405.    /**************************************************************************/
  406.    for ( i = 0; i < ulNumTracks; i++) {
  407.  
  408.       if (ptracki = ioFindTracki(pinstance,patrackmapList[i].ulTrackID)) {
  409.          ptracki->ulNumEntries = patrackmapList[i].ulNumEntries;
  410.          patrackmapList[i].ulNumEntries = 0;
  411.  
  412.         /***************************************************************/
  413.         /* initialize the pasrcbuftabs' pBuffers and pRecords.         */
  414.         /***************************************************************/
  415.          for ( j = 0; j < ptracki->ulNumEntries; j++) {
  416.              patrackmapList[i].pRecordTabList[j].pRecord  = (PVOID)NULL;
  417.              patrackmapList[i].pRecordTabList[j].ulLength = (ULONG)0L;
  418.              }
  419.          }
  420.  
  421.       else {
  422.          return(MMIOERR_READ_FAILED);
  423.          }
  424.       }
  425.  
  426.    if (pinstance->lFileCurrentPosition >= pinstance->ulFileLen) {
  427.       return(MMIOERR_EOF_SEEN);
  428.       }
  429.  
  430.    if (pReadBuffer == NULL) {
  431.        return(MMIOERR_NO_BUFFER_ALLOCATED);
  432.        }
  433.  
  434.    pinstance->pLastBuffer = pReadBuffer; /* set this ptr for read_notdone used.  */
  435.    return (MMIO_SUCCESS);
  436. }
  437.