home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / cset21v6.zip / MMPM2TK / TK / ULIOT / IOCODEC.C < prev    next >
C/C++ Source or Header  |  1993-04-27  |  32KB  |  645 lines
  1. /*************************START OF SPECIFICATIONS *************************/
  2. /* SOURCE FILE NAME:  IOCODEC.C                                           */
  3. /*                                                                        */
  4. /* DESCRIPTIVE NAME: File Format IO Proc codec interfaces                 */
  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 the routine.                     */
  13. /*                                                                        */
  14. /* NOTES:                                                                 */
  15. /*    DEPENDENCIES: none                                                  */
  16. /*    RESTRICTIONS: Runs in 32 bit protect mode (OS/2 2.0)                */
  17. /*                                                                        */
  18. /* ENTRY POINTS:                                                          */
  19. /*     ioDetermineCodec                                                   */
  20. /*     ioLoadCodecDLL                                                     */
  21. /*     ioLoadCodec                                                        */
  22. /*     ioFindCodec                                                        */
  23. /*     ioCloseCodec                                                       */
  24. /*     ioInitCodecopen                                                    */
  25. /*     ioAssociateCodec                                                   */
  26. /*                                                                        */
  27. /************************* END OF SPECIFICATIONS **************************/
  28.  
  29.  
  30. #include        <stdio.h>
  31. #include        <string.h>
  32. #include        <stdlib.h>
  33. #include        <memory.h>
  34.  
  35. #define         INCL_DOS                      /* #define  INCL_DOSPROCESS  */
  36. #define         INCL_ERRORS
  37. #define         INCL_WIN
  38. #define         INCL_GPI
  39. #include        <os2.h>                       /* OS/2 headers              */
  40. #include        <pmbitmap.h>
  41.  
  42. #define         INCL_OS2MM
  43. #define         INCL_MMIO_CODEC
  44. #define         INCL_MMIO_DOSIOPROC
  45. #include        <os2me.h>                     /* Multi-Media IO extensions */
  46. #include        <hhpheap.h>
  47. #include        <ioi.h>
  48.  
  49.  
  50.    extern HHUGEHEAP hheap;                        /* Heap of memory.        */
  51.    extern CODECINIFILEINFO acifiTable[];
  52.    extern ULONG    ulNumColors;                   /* added to correct multiinstance problem */
  53.    extern HMTX hmtxGlobalHeap;
  54.  
  55.  
  56. /************************** START OF SPECIFICATIONS *************************/
  57. /*                                                                          */
  58. /* SUBROUTINE NAME: ioDetermineCodec                                        */
  59. /*                                                                          */
  60. /* DESCRIPTIVE NAME: Determine which codec should be loaded for this        */
  61. /*                   FOURCC, COMPRESSTYPE, CAPSFLAGS, ColorDepth,           */
  62. /*                   COMPRESS or DECOMPRESS.                                */
  63. /*                                                                          */
  64. /* FUNCTION: This function Determines the CODEC to load.                    */
  65. /*                                                                          */
  66. /* NOTES: Picks the default if there is one.                                */
  67. /*                                                                          */
  68. /* ENTRY POINT: ioDetermineCodec                                            */
  69. /*   LINKAGE:   CALL FAR (00:32)                                            */
  70. /*                                                                          */
  71. /* INPUT:                                                                   */
  72. /*              PINSTANCE  pinstance                                        */
  73. /*              ULONG      ulSearchFlags                                    */
  74. /*              PCODECINIFILEINFO pcifi                                     */
  75. /*                                                                          */
  76. /* EXIT-NORMAL:                                                             */
  77. /*              pcifi  contains found codec info                            */
  78. /*              rc = MMIO_SUCCESS                                           */
  79. /* EXIT-ERROR:                                                              */
  80. /*              MMIO_ERROR                                                  */
  81. /*              MMIOERR_CODEC_NOT_SUPPORTED                                 */
  82. /*                                                                          */
  83. /* SIDE EFFECTS:                                                            */
  84. /*                                                                          */
  85. /*************************** END OF SPECIFICATIONS **************************/
  86. LONG ioDetermineCodec ( PINSTANCE pinstance,
  87.                         ULONG ulSearchFlags,
  88.                         PCODECINIFILEINFO pcifi )
  89.  
  90. {
  91.    LONG              rc = MMIO_SUCCESS;  /* Return code of IOProc's call. */
  92.    USHORT            i;                  /* Loop index.       */
  93.    ULONG             ulFlags;
  94.    HPS               hps;                /* only used to query color support */
  95.    HAB               hab;                /* anchor block */
  96.    HMQ               hmq;                /* anchor block */
  97.  
  98.  
  99.    if (pcifi->ulCapsFlags & CODEC_DECOMPRESS) {
  100.       /* Query the display mode */
  101.       if (ulNumColors == 0) {       /* Get this info once per process */
  102.          hab  = WinInitialize(0);
  103. //       hmq  = WinCreateMsgQueue( hab, 0L );
  104.  
  105.          hps  = WinGetPS(HWND_DESKTOP);
  106.          DevQueryCaps ( GpiQueryDevice(hps),
  107.                         CAPS_COLORS,
  108.                         1L,
  109.                         (PLONG)&ulNumColors);
  110.  
  111.          WinReleasePS (hps);
  112. //       WinDestroyMsgQueue( hmq );
  113.          WinTerminate (hab);
  114.          }
  115.  
  116.       /* Set the color depth for the CODEC we want */
  117.       if (ulNumColors == 16)
  118.          pcifi->ulCapsFlags |= CODEC_4_BIT_COLOR;
  119.       else if (ulNumColors > 256)
  120.          pcifi->ulCapsFlags |= CODEC_16_BIT_COLOR;
  121.       else  /* 256 and anything else */
  122.          pcifi->ulCapsFlags |= CODEC_8_BIT_COLOR;
  123.       }
  124.  
  125.    /***************************************************************************/
  126.    /* Search for the DEFAULT codec of this type from the MMIO INI file        */
  127.    /***************************************************************************/
  128.    pcifi->ulCapsFlags |= CODEC_DEFAULT;   /* Pick default */
  129.    ulFlags = ulSearchFlags |
  130.              MMIO_MATCHFOURCC |
  131.              MMIO_MATCHCOMPRESSTYPE |
  132.              MMIO_MATCHCAPSFLAGS |
  133.              MMIO_MATCHFIRST |
  134.              MMIO_FINDPROC;
  135.  
  136.    if (!(rc = mmioIniFileCODEC(pcifi,ulFlags))) {
  137.       return(MMIO_SUCCESS);
  138.       }
  139.  
  140.    /***************************************************************************/
  141.    /* If no default, find first one and use it from the MMIO INI file         */
  142.    /***************************************************************************/
  143.    pcifi->ulCapsFlags &= ~CODEC_DEFAULT;
  144.    ulFlags = ulSearchFlags |
  145.              MMIO_MATCHFOURCC |
  146.              MMIO_MATCHCOMPRESSTYPE |
  147.              MMIO_MATCHCAPSFLAGS |
  148.              MMIO_MATCHFIRST |
  149.              MMIO_FINDPROC;
  150.  
  151.    /* Match the fourcc, compress type, caps flags */
  152.    if (!(rc = mmioIniFileCODEC(pcifi,ulFlags))) {
  153.       return(MMIO_SUCCESS);
  154.       }
  155.  
  156.    /***************************************************************************/
  157.    /* Search any internal CODEC tables for the necessary CODEC to load.       */
  158.    /* Note: This is used for debugging new CODEC's that have not been added   */
  159.    /*       to the mmpmmmio.ini file.                                         */
  160.    /***************************************************************************/
  161.    for (i = 0; i < NUMBER_CODEC_TABLE; i++) {
  162.  
  163.       if ((acifiTable[i].ulCompressType == pcifi->ulCompressType) &&
  164.           ((acifiTable[i].ulCapsFlags & pcifi->ulCapsFlags) == pcifi->ulCapsFlags)) {
  165.  
  166.          *pcifi = acifiTable[i];         /* Copy contents */
  167.          return(MMIO_SUCCESS);
  168.          }
  169.       }
  170.  
  171.  
  172.    return(MMIOERR_CODEC_NOT_SUPPORTED);
  173. }
  174.  
  175.  
  176.  
  177. /************************** START OF SPECIFICATIONS *************************/
  178. /*                                                                          */
  179. /* SUBROUTINE NAME:  ioLoadCodecDLL                                         */
  180. /*                                                                          */
  181. /* DESCRIPTIVE NAME: Load a CODEC IO Proc and add it the PCCB list          */
  182. /*                                                                          */
  183. /* FUNCTION: This function loads a CODEC IO Proc and adds it to the linked  */
  184. /*           list of CODECs currently loaded for this movie instance.       */
  185. /*                                                                          */
  186. /* NOTES:                                                                   */
  187. /*                                                                          */
  188. /* ENTRY POINT: ioLoadCodecDLL                                              */
  189. /*   LINKAGE:   CALL FAR (00:32)                                            */
  190. /*                                                                          */
  191. /* INPUT:                                                                   */
  192. /*             PINSTANCE pinstance     - Instant structure.                 */
  193. /*             PCODECINIFILEINFO pcifi - CODEC ini file information         */
  194. /*             PULONG phCodec          - Returns hCodec of any sibling codec*/
  195. /*                                                                          */
  196. /* EXIT-NORMAL:                                                             */
  197. /*              pccb                                                        */
  198. /*                                                                          */
  199. /* EXIT-ERROR:                                                              */
  200. /*              0L                                                          */
  201. /*                                                                          */
  202. /* SIDE EFFECTS:                                                            */
  203. /*                                                                          */
  204. /*************************** END OF SPECIFICATIONS **************************/
  205. PCCB ioLoadCodecDLL ( PINSTANCE pinstance,
  206.                       PCODECINIFILEINFO pcifi,
  207.                       PULONG phCodec )
  208.  
  209. {
  210.    LONG      rc = MMIO_SUCCESS;           /* Return code of IOProc's call. */
  211.    SZ        szLoadError[260];            /* Error returns.          */
  212.    PCCB      pccbNew;
  213.    PCCB      pccb;
  214.    HMODULE   hmod = 0L;
  215.    PMMIOPROC pmmioproc;
  216.    ULONG     hCodec = 0L;
  217.  
  218.  
  219.    /**************************************************************************/
  220.    /* Search if the CCB entry has been created for the passed in             */
  221.    /* pszDLLName and pszProcName,if yes, then sets pccb    pointer of        */
  222.    /* ptracki to that node.(different track may share a same CCB)            */
  223.    /**************************************************************************/
  224.    for (pccb = pinstance->pccbList; pccb; pccb = pccb->pccbNext) {
  225.  
  226.       if (!stricmp(pcifi->szDLLName,pccb->cifi.szDLLName)) {
  227.          hCodec = pccb->hCodec;
  228.  
  229.          if (!stricmp(pcifi->szProcName,pccb->cifi.szProcName)) {
  230.             /* Proc entry names match */
  231.             return(pccb);
  232.             }
  233.          }
  234.       } /* end loop */
  235.  
  236.  
  237.    /**************************************************************************/
  238.    /* the above searching can't find the DCIO node, if a same DLLName was    */
  239.    /* found, query IOProc address directly, else load module then query I/O  */
  240.    /* address before allocates a new pccb node.                              */
  241.    /**************************************************************************/
  242.    if (DosLoadModule(szLoadError,
  243.                      (ULONG)sizeof(szLoadError),
  244.                      pcifi->szDLLName,
  245.                      &hmod))   {
  246.       /* Load Error - MMIOERR_INVALID_DLLNAME */
  247.       return(NULL);
  248.       }
  249.  
  250.    if (DosQueryProcAddr(hmod,
  251.                         0L,
  252.                         pcifi->szProcName,
  253.                         (PFN *)&pmmioproc))   {
  254.       /* Query Error - MMIOERR_INVALID_PROCEDURENAME */
  255.       return(NULL);
  256.       }
  257.  
  258.    /**************************************************************************/
  259.    /* The above loading and querying was successful, then create a new node  */
  260.    /* for the DCIO. If HhpAllocMem fails, call DosFreeModule to free DCIO    */
  261.    /* module before returning error.                                         */
  262.    /**************************************************************************/
  263.    if (ENTERCRIT(rc)) {
  264.       return(NULL);
  265.       }
  266.  
  267.    pccbNew = (PCCB)HhpAllocMem(hheap,(ULONG)sizeof(CCB));
  268.  
  269.    EXITCRIT;
  270.  
  271.    if(!pccbNew) {
  272.       DosFreeModule(hmod);
  273.       /* Allocate error - MMIOERR_OUTOFMEMORY */
  274.       return(NULL);
  275.       }
  276.  
  277.    /**************************************************************************/
  278.    /* Assigns the Decompress IOProc information, which is in record map      */
  279.    /* table, to the new DCIO node.                                           */
  280.    /**************************************************************************/
  281.    pccbNew->cifi = *pcifi;
  282.    pccbNew->hmodule = hmod;
  283.    pccbNew->pmmioproc = pmmioproc;
  284.    pccbNew->hCodec = 0L;
  285.    pccbNew->ulLastSrcBuf = 0L;
  286.    pccbNew->ulMisc1 = 0L;
  287.    pccbNew->ulMisc2 = 0L;
  288.  
  289.    /**************************************************************************/
  290.    /* adds new node to the beginning of ccb list.                            */
  291.    /**************************************************************************/
  292.    pccbNew->pccbNext = pinstance->pccbList;
  293.    pinstance->pccbList = pccbNew;
  294.  
  295.    *phCodec = hCodec;
  296.    return(pccbNew);
  297. }
  298.  
  299.  
  300.  
  301. /************************** START OF SPECIFICATIONS *************************/
  302. /*                                                                          */
  303. /* SUBROUTINE NAME:  ioLoadCodec                                            */
  304. /*                                                                          */
  305. /* DESCRIPTIVE NAME: Load a CODEC IO Proc and add it the PCCB list          */
  306. /*                                                                          */
  307. /* FUNCTION: This function loads a CODEC IO Proc and adds it to the linked  */
  308. /*           list of CODECs currently loaded for this movie instance.       */
  309. /*                                                                          */
  310. /* NOTES:                                                                   */
  311. /*                                                                          */
  312. /* ENTRY POINT: ioLoadCodec                                                 */
  313. /*   LINKAGE:   CALL FAR (00:32)                                            */
  314. /*                                                                          */
  315. /* INPUT:                                                                   */
  316. /*             PINSTANCE pinstance     - Instant structure.                 */
  317. /*             PTRACKI ptracki         - Track specific information         */
  318. /*             PCODECINIFILEINFO pcifi - CODEC ini file information         */
  319. /*                                                                          */
  320. /* EXIT-NORMAL:                                                             */
  321. /*              pccb                                                        */
  322. /*                                                                          */
  323. /* EXIT-ERROR:                                                              */
  324. /*              0L                                                          */
  325. /*                                                                          */
  326. /* SIDE EFFECTS:                                                            */
  327. /*                                                                          */
  328. /*************************** END OF SPECIFICATIONS **************************/
  329. PCCB ioLoadCodec ( PINSTANCE pinstance,
  330.                    PTRACKI ptracki,
  331.                    PCODECINIFILEINFO pcifi )
  332.  
  333. {
  334.    LONG      rc = MMIO_SUCCESS;           /* Return code of IOProc's call. */
  335.    PCCB      pccbNew;
  336.    ULONG     hCodec = 0L;
  337.  
  338.  
  339.  
  340.    if (pccbNew = ioLoadCodecDLL(pinstance,pcifi,&hCodec)) {
  341.  
  342.       /**************************************************************************/
  343.       /* Open the Codec IO Proc and save the hCodec in the pccb structure       */
  344.       /**************************************************************************/
  345.       if (rc = ffOpenCodec(pinstance, pccbNew, hCodec, ptracki)) {
  346.  
  347.          pinstance->pccbList = pccbNew->pccbNext;   /* unlink from list */
  348.          ioCloseCodec(pccbNew);
  349.          pccbNew = NULL;  /* return error condition */
  350.          }
  351.       }
  352.  
  353.    return(pccbNew);
  354. }
  355.  
  356.  
  357.  
  358. /************************** START OF SPECIFICATIONS *************************/
  359. /*                                                                          */
  360. /* SUBROUTINE NAME:  ioFindCodec                                            */
  361. /*                                                                          */
  362. /* DESCRIPTIVE NAME:                                                        */
  363. /*                                                                          */
  364. /* FUNCTION: This function finds a compression/decompression control block  */
  365. /*           for this compression type.                                     */
  366. /*                                                                          */
  367. /* NOTES: None                                                              */
  368. /*                                                                          */
  369. /* ENTRY POINT: ioFindCodec                                                 */
  370. /*   LINKAGE:   CALL FAR (00:32)                                            */
  371. /*                                                                          */
  372. /* INPUT:                                                                   */
  373. /*           PINSTANCE   pinstance  - Movie instance structure              */
  374. /*           ULONG       ulCompressType - Compression type                  */
  375. /*                                                                          */
  376. /*                                                                          */
  377. /* EXIT-NORMAL:                                                             */
  378. /*              pccb                                                        */
  379. /*                                                                          */
  380. /* EXIT-ERROR:                                                              */
  381. /*              NULL - 0L                                                   */
  382. /*                                                                          */
  383. /*                                                                          */
  384. /* SIDE EFFECTS:                                                            */
  385. /*                                                                          */
  386. /*************************** END OF SPECIFICATIONS **************************/
  387. PCCB ioFindCodec ( PINSTANCE pinstance,
  388.                    ULONG ulCompressType )
  389.  
  390. {
  391.    PCCB   pccb;
  392.  
  393.    for (pccb = pinstance->pccbList; pccb; pccb = pccb->pccbNext) {
  394.       if (pccb->cifi.ulCompressType == ulCompressType)
  395.          return(pccb);
  396.       }
  397.    return(NULL);  /* not found */
  398. }
  399.  
  400.  
  401.  
  402. /************************** START OF SPECIFICATIONS *************************/
  403. /*                                                                          */
  404. /* SUBROUTINE NAME:  ioCloseCodec                                           */
  405. /*                                                                          */
  406. /* DESCRIPTIVE NAME:                                                        */
  407. /*                                                                          */
  408. /* FUNCTION: This function Closes a codec instance for a movie instance.    */
  409. /*           This is called upon a unrecoverable error or on movie close.   */
  410. /*                                                                          */
  411. /* NOTES: None                                                              */
  412. /*                                                                          */
  413. /* ENTRY POINT: ioCloseCodec                                                */
  414. /*   LINKAGE:   CALL FAR (00:32)                                            */
  415. /*                                                                          */
  416. /* INPUT:                                                                   */
  417. /*           PCCB        pccb       - Pointer to codec control structure.   */
  418. /*                                                                          */
  419. /*                                                                          */
  420. /* EXIT-NORMAL:                                                             */
  421. /*              MMIO_SUCCESS                                                */
  422. /*                                                                          */
  423. /* EXIT-ERROR:                                                              */
  424. /*              MMIO_ERROR                                                  */
  425. /*                                                                          */
  426. /*                                                                          */
  427. /* SIDE EFFECTS:                                                            */
  428. /*                                                                          */
  429. /*************************** END OF SPECIFICATIONS **************************/
  430. LONG ioCloseCodec ( PCCB pccb )
  431.  
  432. {
  433.    LONG       rc = MMIO_SUCCESS;           /* Return code of IOProc's call. */
  434.  
  435.    ENTERCRITX;
  436.    if (pccb->codecopen.pSrcHdr) {
  437.       HhpFreeMem(hheap,(PVOID)pccb->codecopen.pSrcHdr);
  438.       }
  439.  
  440.    if (pccb->codecopen.pDstHdr) {
  441.       HhpFreeMem(hheap,(PVOID)pccb->codecopen.pDstHdr);
  442.       }
  443.  
  444.    if (pccb->codecopen.pControlHdr) {
  445.       HhpFreeMem(hheap,(PVOID)pccb->codecopen.pControlHdr);
  446.       }
  447.  
  448.    if (pccb->codecopen.pOtherInfo) {
  449.       HhpFreeMem(hheap,(PVOID)pccb->codecopen.pOtherInfo);
  450.       }
  451.  
  452.    if (pccb->hCodec) {
  453.       rc = pccb->pmmioproc(&pccb->hCodec,
  454.                            MMIOM_CODEC_CLOSE,
  455.                            0L,
  456.                            0L);
  457.  
  458.       if (!rc) {
  459.          pccb->hCodec = 0L;
  460.          }
  461.       }
  462.  
  463.    if (pccb->hmodule) {
  464. //----DosFreeModule(pccb->hmodule);
  465.       pccb->hmodule = 0;
  466.       }
  467.  
  468.    HhpFreeMem(hheap,(PVOID)pccb);
  469.    pccb = NULL;
  470.    EXITCRIT;
  471.  
  472.    return(rc);
  473. }
  474.  
  475.  
  476. /************************** START OF SPECIFICATIONS *************************/
  477. /*                                                                          */
  478. /* SUBROUTINE NAME: ioInitCodecopen                                         */
  479. /*                                                                          */
  480. /* DESCRIPTIVE NAME: Allocate and initialize a CODECOPEN structure to be    */
  481. /*                   saved in the CCB. Copy info from input CODECOPEN.      */
  482. /*                                                                          */
  483. /* FUNCTION: This function allocates a CODECOPEN structure.                 */
  484. /*                                                                          */
  485. /* NOTES: None                                                              */
  486. /*                                                                          */
  487. /* ENTRY POINT: ioInitCodecopen                                             */
  488. /*   LINKAGE:   CALL FAR (00:32)                                            */
  489. /*                                                                          */
  490. /* INPUT:                                                                   */
  491. /*              PCCB          pccb                                          */
  492. /*              PCODECOPEN    pcodecopen                                    */
  493. /*                                                                          */
  494. /* EXIT-NORMAL:                                                             */
  495. /*              rc = MMIO_SUCCESS                                           */
  496. /* EXIT-ERROR:                                                              */
  497. /*              MMIO_ERROR                                                  */
  498. /*                                                                          */
  499. /* SIDE EFFECTS:                                                            */
  500. /*                                                                          */
  501. /*************************** END OF SPECIFICATIONS **************************/
  502. LONG ioInitCodecopen ( PCCB pccb,
  503.                        PCODECOPEN pcodecopen)
  504.  
  505. {
  506.    ULONG             ulSize;
  507.  
  508.  
  509.    ENTERCRITX;
  510.    pccb->codecopen.ulFlags = pcodecopen->ulFlags;
  511.  
  512.    /* Create and copy Pointers to structures in CODECOPEN structure */
  513.    if (pcodecopen->pControlHdr) {
  514.       ulSize = *((PULONG)pcodecopen->pControlHdr);
  515.       if (!(pccb->codecopen.pControlHdr = (PVOID)HhpAllocMem(hheap,ulSize))) {
  516.          return(MMIO_ERROR);
  517.          }
  518.       memcpy(pccb->codecopen.pControlHdr, pcodecopen->pControlHdr, ulSize);
  519.       }
  520.  
  521.    if (pcodecopen->pSrcHdr) {
  522.       ulSize = *((PULONG)pcodecopen->pSrcHdr);
  523.       if (!(pccb->codecopen.pSrcHdr = (PVOID)HhpAllocMem(hheap,ulSize))) {
  524.          return(MMIO_ERROR);
  525.          }
  526.       memcpy(pccb->codecopen.pSrcHdr, pcodecopen->pSrcHdr, ulSize);
  527.       }
  528.  
  529.    if (pcodecopen->pDstHdr) {
  530.       ulSize = *((PULONG)pcodecopen->pDstHdr);
  531.       if (!(pccb->codecopen.pDstHdr = (PVOID)HhpAllocMem(hheap,ulSize))) {
  532.          return(MMIO_ERROR);
  533.          }
  534.       memcpy(pccb->codecopen.pDstHdr, pcodecopen->pDstHdr, ulSize);
  535.       }
  536.  
  537.    if (pcodecopen->pOtherInfo) {
  538.       ulSize = *((PULONG)pcodecopen->pOtherInfo);
  539.       if (!(pccb->codecopen.pOtherInfo = (PVOID)HhpAllocMem(hheap,ulSize))) {
  540.          return(MMIO_ERROR);
  541.          }
  542.       memcpy(pccb->codecopen.pOtherInfo, pcodecopen->pOtherInfo, ulSize);
  543.       }
  544.  
  545.    EXITCRIT;
  546.    return(MMIO_SUCCESS);
  547. }
  548.  
  549.  
  550. /************************** START OF SPECIFICATIONS *************************/
  551. /*                                                                          */
  552. /* SUBROUTINE NAME: ioAssociateCodec                                        */
  553. /*                                                                          */
  554. /* DESCRIPTIVE NAME: Associate CODECs with a file(track). Use this codec    */
  555. /*                   to compress frames to be written to a file.            */
  556. /*                                                                          */
  557. /* FUNCTION: This function associates a CODEC with a file (track).          */
  558. /*                                                                          */
  559. /* NOTES: None                                                              */
  560. /*                                                                          */
  561. /* ENTRY POINT: ioAssociateCodec                                            */
  562. /*   LINKAGE:   CALL FAR (00:32)                                            */
  563. /*                                                                          */
  564. /* INPUT:                                                                   */
  565. /*              PINSTANCE  pinstance                                        */
  566. /*              PMMEXTENDEDINFO pmmextendedinfo                             */
  567. /*                                                                          */
  568. /* EXIT-NORMAL:                                                             */
  569. /*              rc = MMIO_SUCCESS                                           */
  570. /* EXIT-ERROR:                                                              */
  571. /*              MMIO_ERROR                                                  */
  572. /*                                                                          */
  573. /* SIDE EFFECTS:                                                            */
  574. /*              Codec is added to CCB link-list and the codecs are opened.  */
  575. /*                                                                          */
  576. /*************************** END OF SPECIFICATIONS **************************/
  577. LONG ioAssociateCodec ( PMMIOINFO pmmioinfo,
  578.                         PINSTANCE pinstance,
  579.                         PCODECASSOC pcodecassoc )
  580.  
  581. {
  582.    LONG              rc = MMIO_SUCCESS;  /* Return code of IOProc's call. */
  583.    PCCB              pccb;
  584.    ULONG             hCodec;  /* Possibly returned from ioLoadCodecDLL */
  585.  
  586.    /* Check for NULL pointers */
  587.    if (!pcodecassoc->pCodecOpen || !pcodecassoc->pCODECIniFileInfo) {
  588.       return (MMIOERR_INVALID_PARAMETER);
  589.       }
  590.  
  591.    /* Force the correct values into the codecinfileinfo structure */
  592.    pcodecassoc->pCODECIniFileInfo->ulStructLen = sizeof(CODECINIFILEINFO);
  593.    pcodecassoc->pCODECIniFileInfo->fcc = pmmioinfo->fccIOProc;
  594.    pcodecassoc->pCODECIniFileInfo->ulCapsFlags |= CODEC_COMPRESS;       /* Set this one */
  595.  
  596.    /* Find the codec to load */
  597.    if (rc = ioDetermineCodec(pinstance, 0, pcodecassoc->pCODECIniFileInfo)) {
  598.       return(rc); /* return error */
  599.       }
  600.  
  601.    else { /* load and open the compression codec */
  602.  
  603.       /***********************************************/
  604.       /* Check for previously installed codecs.      */
  605.       /* de-installed any loaded, load new one       */
  606.       /* allows only 1 codec to be loaded at a time  */
  607.       /***********************************************/
  608.       if (pinstance->pccbList) {
  609.          pccb = pinstance->pccbList;
  610.          pinstance->pccbList = pccb->pccbNext;   /* unlink from list */
  611.          ioCloseCodec(pccb);
  612.          }
  613.  
  614.       /* Load the codec dll */
  615.       if (pccb = ioLoadCodecDLL(pinstance,
  616.                                 pcodecassoc->pCODECIniFileInfo,
  617.                                 &hCodec)) {
  618.  
  619.          /* Save the codec open information in the ccb */
  620.          ((PCODECOPEN)pcodecassoc->pCodecOpen)->ulFlags |= CODEC_COMPRESS;    /* Force open of compressor */
  621.  
  622.          if (!(rc = ioInitCodecopen(pccb,(PCODECOPEN)pcodecassoc->pCodecOpen))) {
  623.  
  624.             /* Open the codec */
  625.             if (!(rc = pccb->pmmioproc(&hCodec,
  626.                                        MMIOM_CODEC_OPEN,
  627.                                        (LONG)&pccb->codecopen,
  628.                                        0L)))  {
  629.                pccb->hCodec = hCodec;       /* save handle to codec */
  630.                }
  631.             }
  632.  
  633.          /* handle error conditions */
  634.          if (rc) {
  635.             pinstance->pccbList = pccb->pccbNext;   /* unlink from list */
  636.             ioCloseCodec(pccb);
  637.             }
  638.          }
  639.       else {
  640.          rc = MMIO_ERROR;
  641.          }
  642.       }
  643.    return(rc);
  644. }
  645.