home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / tolkit45.zip / os2tk45 / samples / mm / ultimoio / ioheader.c < prev    next >
C/C++ Source or Header  |  1999-05-11  |  14KB  |  273 lines
  1. /*************************START OF SPECIFICATIONS *************************/
  2. /* SOURCE FILE NAME:  IOHEADER.C                                          */
  3. /*                                                                        */
  4. /* DESCRIPTIVE NAME: File Format IO Proc file header access module        */
  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 routines to access the file      */
  13. /*           header.                                                      */
  14. /*                                                                        */
  15. /* NOTES:                                                                 */
  16. /*    DEPENDENCIES: none                                                  */
  17. /*    RESTRICTIONS: Runs in 32 bit protect mode (OS/2 2.0)                */
  18. /*                                                                        */
  19. /* ENTRY POINTS:                                                          */
  20. /*      IOProcGetHeader                                                   */
  21. /*      IOProcQueryHeaderLength                                           */
  22. /*      ioGetTrackHeader                                                  */
  23. /*                                                                        */
  24. /************************* END OF SPECIFICATIONS **************************/
  25.  
  26.  
  27. #include        <stdio.h>
  28. #include        <string.h>
  29. #include        <stdlib.h>
  30. #include        <memory.h>
  31.  
  32. #define         INCL_DOS                        /* #define  INCL_DOSPROCESS.*/
  33. #define         INCL_ERRORS
  34. #define         INCL_WIN
  35. #define         INCL_GPI
  36. #include        <os2.h>                         /* OS/2 headers.            */
  37. #include        <pmbitmap.h>
  38.  
  39. #define         INCL_OS2MM
  40. #define         INCL_MMIO_CODEC
  41. #define         INCL_MMIO_DOSIOPROC
  42. #include        <os2me.h>                      /* Multi-Media IO extensions.*/
  43. #include        <hhpheap.h>
  44. #include        <ioi.h>
  45.  
  46.  
  47.  
  48. /************************** START OF SPECIFICATIONS *************************/
  49. /*                                                                          */
  50. /* SUBROUTINE NAME: IOProcGetHeader                                         */
  51. /*                                                                          */
  52. /* DESCRIPTIVE NAME: Read MM Digital video header structure                 */
  53. /*                                                                          */
  54. /* FUNCTION: copy either the standard presentation header or the file       */
  55. /*           format specific header to the caller's buffer.                 */
  56. /*                                                                          */
  57. /* NOTES: None                                                              */
  58. /*                                                                          */
  59. /* ENTRY POINT: IOProcGetHeader                                             */
  60. /*   LINKAGE:   CALL FAR (00:32)                                            */
  61. /*                                                                          */
  62. /* INPUT:                                                                   */
  63. /*              PMMIOINFO  pmmioinfo - Pointer to MMIOINFO status structure */
  64. /*              LONG       Unknown1  - Pointer to caller's buffer.          */
  65. /*              LONG       Unknown2  - Length of caller's buffer.           */
  66. /*                                                                          */
  67. /* EXIT-NORMAL:                                                             */
  68. /*              Length of header returned                                   */
  69. /*                                                                          */
  70. /* EXIT-ERROR:                                                              */
  71. /*              0L                                                          */
  72. /*                                                                          */
  73. /* SIDE EFFECTS:                                                            */
  74. /*                                                                          */
  75. /*************************** END OF SPECIFICATIONS **************************/
  76. LONG IOProcGetHeader ( PMMIOINFO pmmioinfo,
  77.                        PVOID pHeader,
  78.                        LONG  lHeaderLength,
  79.                        LONG  lCurrentTrack )
  80.  
  81. {
  82.    LONG             rc;                       /* return code                */
  83.    PTRACKI          ptracki;
  84.    PINSTANCE        pinstance;                /* Local work structure.      */
  85.  
  86.    /**************************************************************************/
  87.    /* Validates parameters passed:                                           */
  88.    /* -- Must have valid pmmioinfo.                                          */
  89.    /* -- File must be opened.                                                */
  90.    /**************************************************************************/
  91.    if (rc = ioGetPtrInstance(pmmioinfo,&pinstance))
  92.       return(0L);
  93.  
  94.   if (pHeader == NULL) {
  95.      pmmioinfo->ulErrorRet = MMIOERR_NO_BUFFER_ALLOCATED;
  96.      return(0L);
  97.      }
  98.  
  99.   if (CheckMem((PVOID)pHeader, lHeaderLength, PAG_WRITE)) {
  100.      pmmioinfo->ulErrorRet = MMIOERR_INVALID_BUFFER_LENGTH;
  101.      return(0L);
  102.      }
  103.  
  104.    if (pinstance->lCurrentTrack == MMIO_RESETTRACKS){
  105.  
  106.       if(pmmioinfo->ulTranslate & MMIO_TRANSLATEHEADER){
  107.          if (lHeaderLength < pinstance->ulMmHdrLength) {
  108.             pmmioinfo->ulErrorRet = MMIOERR_INVALID_BUFFER_LENGTH;
  109.             return(0L);
  110.             }
  111.          lHeaderLength = pinstance->ulMmHdrLength;
  112.          memcpy(pHeader,pinstance->pmmhdr,lHeaderLength);  // copy all fields
  113.          return (lHeaderLength);
  114.          }
  115.  
  116.       else { /* not translateheader. */
  117.          if (lHeaderLength < pinstance->ulRawHdrLength) {
  118.             pmmioinfo->ulErrorRet = MMIOERR_INVALID_BUFFER_LENGTH;
  119.             return(0L);
  120.             }
  121.          lHeaderLength = pinstance->ulRawHdrLength;
  122.          memcpy(pHeader,pinstance->pRawHdr,lHeaderLength);
  123.          return(lHeaderLength);
  124.          }
  125.       }
  126.  
  127.    else { /* Get a raw or translated track header */
  128.       if (ptracki = ioFindTracki(pinstance,(ULONG)pinstance->lCurrentTrack)) {
  129.          rc = ioGetTrackHeader(ptracki,
  130.                                pHeader,
  131.                                (ULONG)lHeaderLength,
  132.                                pmmioinfo->ulTranslate & MMIO_TRANSLATEHEADER);
  133.          if (rc)
  134.             return(rc);      /* ok, return length */
  135.          else {
  136.             pmmioinfo->ulErrorRet = MMIOERR_INVALID_BUFFER_LENGTH;
  137.             return(0L);
  138.             }
  139.          }
  140.  
  141.       else { /* lCurrrent Track is not a valid track. */
  142.          pmmioinfo->ulErrorRet = MMIOERR_MATCH_NOT_FOUND;
  143.          return(0L);
  144.          }
  145.       }
  146. }
  147.  
  148.  
  149. /************************** START OF SPECIFICATIONS *************************/
  150. /*                                                                          */
  151. /* SUBROUTINE NAME: ioGetTrackHeader                                        */
  152. /*                                                                          */
  153. /* DESCRIPTIVE NAME: Get Track header.                                      */
  154. /*                                                                          */
  155. /* FUNCTION: This function copies track header information to caller.       */
  156. /*                                                                          */
  157. /*                                                                          */
  158. /* NOTES: None                                                              */
  159. /*                                                                          */
  160. /* ENTRY POINT: ioGetTracksHeader                                           */
  161. /*   LINKAGE:   CALL FAR (00:32)                                            */
  162. /*                                                                          */
  163. /* INPUT:                                                                   */
  164. /*     PTRACKI     ptracki        - Pointer to track info                   */
  165. /*     PVOID       pHeader        - pointer to header.                      */
  166. /*     ULONG       ulHeaderLength - Length of header.                       */
  167. /*     ULONG       ulFlag         - Raw or Translated                       */
  168. /*                                                                          */
  169. /* EXIT-NORMAL:                                                             */
  170. /*              ulHeaderLength                                              */
  171. /*                                                                          */
  172. /* EXIT-ERROR:                                                              */
  173. /*              0L                                                          */
  174. /*                                                                          */
  175. /*                                                                          */
  176. /* SIDE EFFECTS:                                                            */
  177. /*                                                                          */
  178. /*************************** END OF SPECIFICATIONS **************************/
  179. LONG ioGetTrackHeader ( PTRACKI ptracki,
  180.                         PVOID   pTrackHeader,
  181.                         ULONG   ulHeaderLength,
  182.                         ULONG   ulFlag )
  183.  
  184. {
  185.  
  186.    if (ulFlag & MMIO_TRANSLATEHEADER) {
  187.       /* Get translated header */
  188.       if (ulHeaderLength < ptracki->ulTrackHdrLength) {
  189.          return(0L);
  190.          }
  191.       ulHeaderLength = ptracki->ulTrackHdrLength;
  192.       memcpy(pTrackHeader,ptracki->pTrackHeader,ulHeaderLength);
  193.       }
  194.  
  195.    else { /* Get raw header */
  196.       if (ulHeaderLength < ptracki->ulRawHdrLength) {
  197.          return(0L);
  198.          }
  199.       ulHeaderLength = ptracki->ulRawHdrLength;
  200.       memcpy(pTrackHeader,ptracki->pRawHdr,ulHeaderLength);
  201.       }
  202.  
  203.    return(ulHeaderLength);
  204. }
  205.  
  206.  
  207. /************************** START OF SPECIFICATIONS *************************/
  208. /*                                                                          */
  209. /* SUBROUTINE NAME: IOProcQueryHeaderLength                                 */
  210. /*                                                                          */
  211. /* DESCRIPTIVE NAME: Query header length of Digital Video file.             */
  212. /*                                                                          */
  213. /* FUNCTION: Returns either the length of translated header or the          */
  214. /*           length of movieheader.                                         */
  215. /*                                                                          */
  216. /*                                                                          */
  217. /* NOTES: None                                                              */
  218. /*                                                                          */
  219. /* ENTRY POINT: IOProcQueryHeaderLength                                     */
  220. /*   LINKAGE:   CALL FAR (00:32)                                            */
  221. /*                                                                          */
  222. /* INPUT:       PMMIOINFO pmmioinfo - pointer to MMIOINFO status structure  */
  223. /*                                                                          */
  224. /* EXIT-NORMAL:                                                             */
  225. /*              MMIO_SUCCESS                                                */
  226. /*                                                                          */
  227. /* EXIT-ERROR:                                                              */
  228. /*              0L                                                          */
  229. /*                                                                          */
  230. /*                                                                          */
  231. /* SIDE EFFECTS:                                                            */
  232. /*                                                                          */
  233. /*************************** END OF SPECIFICATIONS **************************/
  234. LONG IOProcQueryHeaderLength ( PMMIOINFO pmmioinfo,
  235.                                LONG      lCurrentTrack )
  236.  
  237. {
  238.    LONG            rc; 
  239.    PINSTANCE       pinstance;                   /* Local work structure.     */
  240.    PTRACKI         ptracki;
  241.  
  242.  
  243.    if (rc = ioGetPtrInstance(pmmioinfo,&pinstance))
  244.       return(0L);
  245.  
  246.    if (pinstance->lCurrentTrack == MMIO_RESETTRACKS) {
  247.  
  248.       if (pmmioinfo->ulTranslate & MMIO_TRANSLATEHEADER) {
  249.          return (pinstance->ulMmHdrLength);
  250.          }
  251.       else { /* Raw Header */
  252.          return(pinstance->ulRawHdrLength);
  253.          }
  254.       }
  255.    else {
  256.       if (ptracki = ioFindTracki(pinstance,(ULONG)pinstance->lCurrentTrack)) {
  257.  
  258.          if (pmmioinfo->ulTranslate & MMIO_TRANSLATEHEADER) {
  259.             return(ptracki->ulTrackHdrLength);
  260.             }
  261.          else {
  262.             return(ptracki->ulRawHdrLength);
  263.             }
  264.          }
  265.       else {
  266.          pmmioinfo->ulErrorRet = MMIOERR_MATCH_NOT_FOUND;
  267.          return(MMIO_ERROR);
  268.          }
  269.       }
  270. }
  271.  
  272.  
  273.