home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / samples / mm / ultimoio / iosrv.c < prev    next >
C/C++ Source or Header  |  1999-05-11  |  24KB  |  448 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.  
  77. LONG ioGetPtrInstance ( PMMIOINFO pmmioinfo,
  78.                         PINSTANCE *ppinstance)
  79.  
  80. {
  81.    /*
  82.     * Validates parameters passed.
  83.     */
  84.    if (pmmioinfo == NULL){
  85.       return(MMIO_ERROR);
  86.       }
  87.  
  88. //   if (CheckMem((PVOID)pmmioinfo, sizeof(MMIOINFO), PAG_WRITE))
  89. //      return (MMIO_ERROR);
  90.  
  91.    if (pmmioinfo->hmmio == 0){
  92.       pmmioinfo->ulErrorRet = MMIOERR_INVALID_HANDLE;
  93.       return(MMIO_ERROR);
  94.       }
  95.  
  96.    *ppinstance = (PINSTANCE)pmmioinfo->pExtraInfoStruct;
  97.  
  98.    if (*ppinstance == NULL) {
  99.       pmmioinfo->ulErrorRet = MMIOERR_INVALID_STRUCTURE;
  100.       return(MMIO_ERROR);
  101.       }
  102.  
  103.    return(MMIO_SUCCESS);
  104. }
  105.  
  106.  
  107. /************************** START OF SPECIFICATIONS *************************/
  108. /*                                                                          */
  109. /* SUBROUTINE NAME: ioFindTracki                                            */
  110. /*                                                                          */
  111. /* DESCRIPTIVE NAME: Verify that the track number is a valid  movie track.  */
  112. /*                                                                          */
  113. /* FUNCTION: This function searches all known movie tracks for a match.     */
  114. /*           and returns a ptr to movie track entry.                        */
  115. /*                                                                          */
  116. /* NOTES: None                                                              */
  117. /*                                                                          */
  118. /* ENTRY POINT: ioFindTracki                                                */
  119. /*   LINKAGE:   CALL FAR (00:32)                                            */
  120. /*                                                                          */
  121. /* INPUT:                                                                   */
  122. /*           PINSTANCE      pinstance  - Ptr to instance structure.         */
  123. /*           ULONG          ulTrackID - Track number to search for.         */
  124. /*                                                                          */
  125. /* EXIT-NORMAL:    Ptr to movie track entry                                 */
  126. /*                                                                          */
  127. /*                                                                          */
  128. /* EXIT-ERROR:     NULL, not found                                          */
  129. /*                                                                          */
  130. /*                                                                          */
  131. /* SIDE EFFECTS:                                                            */
  132. /*                                                                          */
  133. /*************************** END OF SPECIFICATIONS **************************/
  134.  
  135. PTRACKI ioFindTracki ( PINSTANCE pinstance,
  136.                        ULONG ulTrackID )
  137.  
  138. {
  139.    PTRACKI ptracki;
  140.  
  141.    for (ptracki = pinstance->ptrackiList; ptracki; ptracki = ptracki->ptrackiNext) {
  142.       if (ptracki->ulTrackID == ulTrackID) {
  143.           return(ptracki);
  144.           }
  145.       }
  146.  
  147.   return(NULL);
  148. }
  149.  
  150.  
  151. /************************** START OF SPECIFICATIONS *************************/
  152. /*                                                                          */
  153. /* SUBROUTINE NAME: ioFindTrackMapEntry                                     */
  154. /*                                                                          */
  155. /* DESCRIPTIVE NAME: Find Track Map Entry from Track list.                  */
  156. /*                                                                          */
  157. /* FUNCTION: This function matches Track from Track list.                   */
  158. /*                                                                          */
  159. /*                                                                          */
  160. /* NOTES: None                                                              */
  161. /*                                                                          */
  162. /* ENTRY POINT: ioFindTrackMapEntry                                         */
  163. /*   LINKAGE:   CALL FAR (00:32)                                            */
  164. /*                                                                          */
  165. /* INPUT:                                                                   */
  166. /*                                                                          */
  167. /*              PATRACKMAP     patrackmap                                   */
  168. /*              ULONG          ulNumTracks                                  */
  169. /*              ULONG          ulTrackID                                    */
  170. /* EXIT-NORMAL:                                                             */
  171. /*                                                                          */
  172. /*                                                                          */
  173. /* EXIT-ERROR:                                                              */
  174. /*                                                                          */
  175. /*                                                                          */
  176. /* SIDE EFFECTS:                                                            */
  177. /*                                                                          */
  178. /*************************** END OF SPECIFICATIONS **************************/
  179.  
  180. PTRACKMAP ioFindTrackMapEntry ( PTRACKMAP patrackmapList,
  181.                                 ULONG ulNumTracks,
  182.                                 ULONG ulTrackID)
  183.  
  184. {
  185.    ULONG i;
  186.    PTRACKMAP ptrackmap = patrackmapList;
  187.  
  188.    for(i=0; i < ulNumTracks; i++, ptrackmap++ ) {
  189.  
  190.       if (ptrackmap->ulTrackID == ulTrackID) {
  191.          return(ptrackmap);
  192.          }
  193.       }
  194.  
  195.    return(NULL);
  196. }
  197.  
  198.  
  199. /************************** START OF SPECIFICATIONS *************************/
  200. /*                                                                          */
  201. /* SUBROUTINE NAME:  ioIdentifyStorageSystem                                */
  202. /*                                                                          */
  203. /* DESCRIPTIVE NAME: IOProc identifies storage system.                      */
  204. /*                                                                          */
  205. /* FUNCTION: This function identifies the storage system for the current    */
  206. /*           file.                                                          */
  207. /*                                                                          */
  208. /* NOTES: None                                                              */
  209. /*                                                                          */
  210. /* ENTRY POINT: ioIdentifyStorageSystem                                     */
  211. /*   LINKAGE:   CALL FAR (00:32)                                            */
  212. /*                                                                          */
  213. /* INPUT:                                                                   */
  214. /*         PMMIOINFO pmmioinfo   - MMIOINFO structure.                      */
  215. /*         PSZ       pszFileName - File name.                               */
  216. /*                                                                          */
  217. /* EXIT-NORMAL:                                                             */
  218. /*              MMIO_SUCCESS                                                */
  219. /*                                                                          */
  220. /* EXIT-ERROR:                                                              */
  221. /*              MMIO_ERROR                                                  */
  222. /*                                                                          */
  223. /* SIDE EFFECTS:                                                            */
  224. /*                                                                          */
  225. /*************************** END OF SPECIFICATIONS **************************/
  226.  
  227. LONG ioIdentifyStorageSystem ( PMMIOINFO pmmioinfo,
  228.                                PSZ pszFileName )
  229.  
  230. {
  231.    FOURCC  fccStorageSystem;                      /* fcc of SS I/O Proc.    */
  232.    LONG    rc;                                    /* return code.           */
  233.  
  234.    fccStorageSystem = pmmioinfo->fccIOProc;
  235.  
  236.    if (!fccStorageSystem) {
  237.  
  238.       if (pszFileName == NULL) {
  239.          fccStorageSystem = FOURCC_DOS;
  240.          }
  241.       else {
  242.          rc = mmioIdentifyStorageSystem(pszFileName,
  243.                                         pmmioinfo,
  244.                                         &fccStorageSystem);
  245.          if (rc != MMIO_SUCCESS) {
  246.             return(rc);
  247.             }
  248.          }
  249.       }
  250.    pmmioinfo->fccIOProc = fccStorageSystem;
  251.  
  252.    return(MMIO_SUCCESS);
  253. }
  254.  
  255.  
  256. /************************** START OF SPECIFICATIONS *************************/
  257. /*                                                                          */
  258. /* SUBROUTINE NAME: ioInstanceInit                                          */
  259. /*                                                                          */
  260. /* DESCRIPTIVE NAME: Initialize all fields.                                 */
  261. /*                                                                          */
  262. /* FUNCTION: Initialize all fields to NULL and zero.                        */
  263. /*                                                                          */
  264. /*                                                                          */
  265. /* NOTES: None                                                              */
  266. /*                                                                          */
  267. /* ENTRY POINT: ioInstanceInit                                              */
  268. /*   LINKAGE:   CALL FAR (00:32)                                            */
  269. /*                                                                          */
  270. /* INPUT:                                                                   */
  271. /*              PINSTANCE    pinstance -- pointer to instance structure.    */
  272. /*                                                                          */
  273. /* EXIT-NORMAL:                                                             */
  274. /*              (none)                                                      */
  275. /*                                                                          */
  276. /* EXIT-ERROR:                                                              */
  277. /*              (none)                                                      */
  278. /*                                                                          */
  279. /* SIDE EFFECTS:                                                            */
  280. /*                                                                          */
  281. /*************************** END OF SPECIFICATIONS **************************/
  282.  
  283. VOID ioInstanceInit (PINSTANCE pinstance)
  284.  
  285. {
  286.    pinstance->pRawHdr              = NULL;
  287.    pinstance->ulRawHdrLength       = 0L;
  288.    pinstance->pmmhdr               = NULL;
  289.    pinstance->ulMmHdrLength        = 0L;
  290.    pinstance->ptrackiList          = NULL;
  291.    pinstance->lLastTrack           = -1L;
  292.    pinstance->lCurrentTrack        = -1L;
  293.    pinstance->pccbList             = NULL;
  294.    pinstance->hmmioFileHandle      = 0L;
  295.    pinstance->lFileCurrentPosition = 0L;
  296.    pinstance->ulFileLen            = 0L;
  297.    pinstance->ulFlags              = 0L;
  298.    pinstance->ulMode               = 0L;
  299.    pinstance->pTempBuffer          = NULL;
  300.    pinstance->ulTempBufferSize     = 0L;
  301.    pinstance->ulDataInTempBuffer   = 0L;
  302.    pinstance->pLastBuffer          = NULL;
  303.    pinstance->ulLastBufferOffset   = 0L;
  304.    pinstance->pccbLastUsed         = NULL;
  305.    pinstance->ulMisc1              = 0L;
  306.    pinstance->ulMisc2              = 0L;
  307.    pinstance->ulMisc3              = 0L;
  308.    pinstance->ulMisc4              = 0L;
  309.    pinstance->ulDeltaCount         = 0;
  310.    pinstance->ulCurrentFrame       = 0;
  311.    pinstance->pmmVideoHdr          = NULL;
  312.    pinstance->ulCurrentVideoTrack  = 0xFFFFFFFF;
  313.    pinstance->ulCurrentAudioTrack  = 0xFFFFFFFF;
  314.    return;
  315. }
  316.  
  317. /************************** START OF SPECIFICATIONS *************************/
  318. /*                                                                          */
  319. /* SUBROUTINE NAME: ioAddTracksToMovieHeader                                */
  320. /*                                                                          */
  321. /* DESCRIPTIVE NAME: Updates tracks to track list in MMOVIEHEADER.          */
  322. /*                                                                          */
  323. /* FUNCTION: This function copies the current file's valid tracks to caller.*/
  324. /*                                                                          */
  325. /*                                                                          */
  326. /* NOTES: None                                                              */
  327. /*                                                                          */
  328. /* ENTRY POINT: ioAddTracksToMovieHeader                                    */
  329. /*   LINKAGE:   CALL FAR (00:32)                                            */
  330. /*                                                                          */
  331. /* INPUT:                                                                   */
  332. /*          PINSTANCE     pinstance    - IOProc instant structure.          */
  333. /*                                                                          */
  334. /*                                                                          */
  335. /* EXIT-NORMAL:                                                             */
  336. /*              MMIO_SUCCESS                                                */
  337. /*                                                                          */
  338. /* EXIT-ERROR:                                                              */
  339. /*              MMIO Error message.                                         */
  340. /*                                                                          */
  341. /*                                                                          */
  342. /* SIDE EFFECTS:                                                            */
  343. /*                                                                          */
  344. /*************************** END OF SPECIFICATIONS **************************/
  345.  
  346. LONG ioAddTracksToMovieHeader ( PINSTANCE pinstance )
  347.  
  348. {
  349.    ULONG    i;                      /* Loop index.            */
  350.    PTRACKI  ptracki;                /* Track list of pinstance. */
  351.  
  352.    /**************************************************************************/
  353.    /* Copy track information into the movie header                           */
  354.    /**************************************************************************/
  355.    for (i = 0, ptracki = pinstance->ptrackiList;
  356.         (i < pinstance->pmmhdr->ulNumEntries) && ptracki;
  357.         i++, ptracki = ptracki->ptrackiNext ) {
  358.  
  359.       pinstance->pmmhdr->pmmTrackInfoList[i].ulTrackID   = ptracki->ulTrackID;
  360.       pinstance->pmmhdr->pmmTrackInfoList[i].ulMediaType = ptracki->ulMediaType;
  361.       pinstance->pmmhdr->pmmTrackInfoList[i].ulCountry   = 0L;                        /* TEMP TEMP */
  362.       pinstance->pmmhdr->pmmTrackInfoList[i].ulCodePage  = 0L;                        /* TEMP TEMP */
  363.       }
  364.  
  365.    if (i > pinstance->pmmhdr->ulNumEntries)
  366.       return(MMIOERR_INVALID_BUFFER_LENGTH);
  367.  
  368.    return(MMIO_SUCCESS);
  369. }
  370.  
  371.  
  372. /************************** START OF SPECIFICATIONS *************************/
  373. /*                                                                          */
  374. /* SUBROUTINE NAME: ioValidateRead                                          */
  375. /*                                                                          */
  376. /* DESCRIPTIVE NAME: Validate parameters passed from user.                  */
  377. /*                                                                          */
  378. /* FUNCTION:                                                                */
  379. /*                                                                          */
  380. /* NOTES:                                                                   */
  381. /*                                                                          */
  382. /* ENTRY POINT: ioValidateRead                                              */
  383. /*   LINKAGE:   CALL Near (00:32)                                           */
  384. /*                                                                          */
  385. /* INPUT:       PINSTANCE              pinstance                            */
  386. /*              PVOID                  pReadBuffer                          */
  387. /*              ULONG                  ulNumTracks                          */
  388. /*              PTRACKMAP              patrackmapList                       */
  389. /*                                                                          */
  390. /* EXIT-NORMAL:                                                             */
  391. /*              MMIO_SUCCESS                                                */
  392. /*                                                                          */
  393. /* EXIT-ERROR:                                                              */
  394. /*              MMIO error return code                                      */
  395. /*                                                                          */
  396. /*                                                                          */
  397. /* SIDE EFFECTS:                                                            */
  398. /*                                                                          */
  399. /*************************** END OF SPECIFICATIONS **************************/
  400.  
  401. LONG ioValidateRead ( PINSTANCE pinstance,
  402.                       PVOID pReadBuffer,
  403.                       ULONG ulNumTracks,
  404.                       PTRACKMAP patrackmapList)
  405.  
  406. {
  407.    PTRACKI    ptracki;                         /* Ptr to ptracki entry */
  408.    ULONG      i;
  409.    ULONG      j;
  410.  
  411.  
  412.    /**************************************************************************/
  413.    /* For each track to read, validate that it is a valid movie track.       */
  414.    /* And for each valid track, save the number of entries and reset the     */
  415.    /* srcbuftab entries. Also init each srcbuftab entry.                     */
  416.    /**************************************************************************/
  417.    for ( i = 0; i < ulNumTracks; i++) {
  418.  
  419.       if (ptracki = ioFindTracki(pinstance,patrackmapList[i].ulTrackID)) {
  420.          ptracki->ulNumEntries = patrackmapList[i].ulNumEntries;
  421.          patrackmapList[i].ulNumEntries = 0;
  422.  
  423.         /***************************************************************/
  424.         /* initialize the pasrcbuftabs' pBuffers and pRecords.         */
  425.         /***************************************************************/
  426.          for ( j = 0; j < ptracki->ulNumEntries; j++) {
  427.              patrackmapList[i].pRecordTabList[j].pRecord  = (PVOID)NULL;
  428.              patrackmapList[i].pRecordTabList[j].ulLength = (ULONG)0L;
  429.              }
  430.          }
  431.  
  432.       else {
  433.          return(MMIOERR_READ_FAILED);
  434.          }
  435.       }
  436.  
  437.    if (pinstance->lFileCurrentPosition >= pinstance->ulFileLen) {
  438.       return(MMIOERR_EOF_SEEN);
  439.       }
  440.  
  441.    if (pReadBuffer == NULL) {
  442.        return(MMIOERR_NO_BUFFER_ALLOCATED);
  443.        }
  444.  
  445.    pinstance->pLastBuffer = pReadBuffer; /* set this ptr for read_notdone used.  */
  446.    return (MMIO_SUCCESS);
  447. }
  448.