home *** CD-ROM | disk | FTP | other *** search
/ Amiga MA Magazine 1998 #4 / amigamamagazinepolishissue1998.iso / datatypes / gifanimdtc201.lha / gifanim_datatype / prefs.c < prev    next >
C/C++ Source or Header  |  1998-01-16  |  14KB  |  445 lines
  1.  
  2. /*
  3. **
  4. **  $VER: prefs.c 1.5 (16.1.98)
  5. **  gifanim.datatype 1.5
  6. **
  7. **  Preferences
  8. **
  9. **  Written 1997/1998 by Roland 'Gizzy' Mainz
  10. **  Original example source from David N. Junod
  11. **
  12. */
  13.  
  14. /* main includes */
  15. #include "classbase.h"
  16. #include "classdata.h"
  17.  
  18. /* ansi includes */
  19. #include <limits.h>
  20.  
  21. /*****************************************************************************/
  22.  
  23. /* local prototypes */
  24. static STRPTR GetPrefsVar( struct ClassBase *, STRPTR );
  25. static BOOL  matchstr( struct ClassBase *, STRPTR, STRPTR );
  26.  
  27. /*****************************************************************************/
  28.  
  29. /****** gifanim.datatype/preferences *****************************************
  30. *
  31. *   NAME
  32. *       preferences
  33. *
  34. *   DESCRIPTION
  35. *       The "ENV:Classes/DataTypes/gifanim.prefs" file contains global
  36. *       settings for the datatype.
  37. *       The preferences file is an ASCII file containing one line where the
  38. *       preferences can be set.
  39. *       It can be superset by a local variable with the same name.
  40. *
  41. *       Each line can contain settings, special settings for some projects
  42. *       can be set using the MATCHPROJECT option.
  43. *       Lines beginning with a '#' or ';' chars are treated as comments.
  44. *       Lines are limitted to 256 chars.
  45. *
  46. *   TEMPLATE
  47. *       MATCHPROJECT/K,VERBOSE/S,MODEID/K/N,
  48. *       16BITCHUNKY=24BITCHUNKY=TRUECOLOR/S,
  49. *       NO16BITCHUNKY=NO24BITCHUNKY=NOTRUECOLOR/S,FPS/K/N,REPEAT/S,
  50. *       NOREPEAT/S,SAMPLE/K,SAMPLESPERFRAME=SPF/K/N,VOLUME/K/N,LOADALL/S,
  51. *       NOLOADALL/S
  52. *
  53. *       MATCHPROJECT -- The settings in this line belongs only to this
  54. *           project(s), e.g. if the case-insensitive pattern does not match,
  55. *           this line is ignored.
  56. *           The maximum length of the pattern is 128 chars.
  57. *           Defaults to #?, which matches any project.
  58. *
  59. *       VERBOSE -- Print information about the animation. Currently
  60. *          the frame numbers and the used compression are printed, after all
  61. *          number of scanned/loaded frames, set FPS rate, dimensions (width/
  62. *          height/depth), sample information etc.
  63. *
  64. *       MODEID -- Select screen mode id of datatype (will be stored in
  65. *           ADTA_ModeID). Note that the DOS ReadArgs function used for parsing
  66. *           fetches a SIGNED long. The bit 31 will be represented by minus
  67. *           '-'. (example: "MODEID=266240" sets the mode to the A2024 screen
  68. *           mode id)
  69. *           Defaults to -1, which means: Use the best screenmode available for
  70. *           the given width, height and depth.
  71. *
  72. *       16BITCHUNKY
  73. *       24BITCHUNKY
  74. *       TRUECOLOR -- Create 24 bit chunky bitmaps, if possible.
  75. *           Note that the 16BITCHUNKY and the 24BITCHUNKY options will be
  76. *           seperated in the future. The TRUECOLOR option selects the
  77. *           best truecolor depth in this case...
  78. *
  79. *       NO16BITCHUNKY
  80. *       NO24BITCHUNKY
  81. *       NOTRUECOLOR -- Turns 24BITCHUNKY option off. (Default)
  82. *           Note that the 16BITCHUNKY and the 24BITCHUNKY options will be
  83. *           seperated in the future. The TRUECOLOR option selects the
  84. *           best truecolor depth in this case...
  85. *
  86. *       FPS -- Frames Per Second
  87. *           A value of 0 here means: Use default FPS.
  88. *
  89. *       REPEAT -- Turn on repeat mode, e.g. DTA_Repeat == TRUE
  90. *
  91. *       NOREPEAT -- Turns REPEAT mode off.
  92. *
  93. *       SAMPLE -- Attach the given sample to the animation. The sample will
  94. *           be loaded using datatypes (GID_SOUND).
  95. *           Only one sample can be attached to one animation stream, any
  96. *           following attempt to attach a sample will be ignored.
  97. *
  98. *       SAMPLESPERFRAME -- Set samples per frame rate for sound. This
  99. *           overrides the own internal calculations to get rid of rounding
  100. *           errors.
  101. *
  102. *       VOLUME -- Volume of the sound when playing.
  103. *           Defaults to 64, which is the maximum. A value greater than 64 will
  104. *           be set to 64.
  105. *
  106. *       LOADALL -- Load all frames into memory.
  107. *
  108. *       NOLOADALL -- Turns off the LOADALL flag, which may be set in a prefs-
  109. *           line before. This switch is set per default, and can be turned off
  110. *           by the LOADALL option, later it can be turned on again by this
  111. *           option.
  112. *
  113. *   NOTE
  114. *       - An invalid prefs file line will be ignored and forces the VERBOSE
  115. *         output.
  116. *
  117. *       - REPEAT mode may be a hack.
  118. *
  119. *   BUGS
  120. *       - Low memory may cause that the prefs file won't be parsed.
  121. *
  122. *       - Lines are limitted to 256 chars
  123. *
  124. *       - An invalid prefs file line will be ignored.
  125. *
  126. *       - The sample path length is limitted to 200 chars. A larger
  127. *         value may crash the machine if an error occurs.
  128. *
  129. ******************************************************************************
  130. *
  131. */
  132.  
  133.  
  134. static
  135. STRPTR GetPrefsVar( struct ClassBase *cb, STRPTR name )
  136. {
  137.           STRPTR buff;
  138.     const ULONG  buffsize = 16UL;
  139.  
  140.     if( buff = (STRPTR)AllocVec( (buffsize + 2UL), (MEMF_PUBLIC | MEMF_CLEAR) ) )
  141.     {
  142.       if( GetVar( name, buff, buffsize, GVF_BINARY_VAR ) != (-1L) )
  143.       {
  144.         ULONG varsize = IoErr();
  145.  
  146.         varsize += 2UL;
  147.  
  148.         if( varsize > buffsize )
  149.         {
  150.           FreeVec( buff );
  151.  
  152.           if( buff = (STRPTR)AllocVec( (varsize + 2UL), (MEMF_PUBLIC | MEMF_CLEAR) ) )
  153.           {
  154.             if( GetVar( name, buff, varsize, GVF_BINARY_VAR ) != (-1L) )
  155.             {
  156.               return( buff );
  157.             }
  158.           }
  159.         }
  160.         else
  161.         {
  162.           return( buff );
  163.         }
  164.       }
  165.  
  166.       FreeVec( buff );
  167.     }
  168.  
  169.     return( NULL );
  170. }
  171.  
  172.  
  173. static
  174. BOOL matchstr( struct ClassBase *cb, STRPTR pat, STRPTR s )
  175. {
  176.     TEXT buff[ 512 ];
  177.  
  178.     if( pat && s )
  179.     {
  180.       if( ParsePatternNoCase( pat, buff, (sizeof( buff ) - 1) ) != (-1L) )
  181.       {
  182.         if( MatchPatternNoCase( buff, s ) )
  183.         {
  184.           return( TRUE );
  185.         }
  186.       }
  187.     }
  188.  
  189.     return( FALSE );
  190. }
  191.  
  192.  
  193. void ReadENVPrefs( struct ClassBase *cb, struct GIFAnimInstData *gaid )
  194. {
  195.     struct RDArgs envvarrda =
  196.     {
  197.       NULL,
  198.       256L,
  199.       0L,
  200.       0L,
  201.       NULL,
  202.       0L,
  203.       NULL,
  204.       RDAF_NOPROMPT
  205.     };
  206.  
  207.     struct
  208.     {
  209.       STRPTR  matchproject;
  210.       long   *verbose;
  211.       long   *modeid;
  212.       long   *use24bitchunky;
  213.       long   *nouse24bitchunky;
  214.       long   *fps;
  215.       long   *repeat;
  216.       long   *norepeat;
  217.       STRPTR  sample;
  218.       long   *samplesperframe;
  219.       long   *volume;
  220.       long   *loadall;
  221.       long   *noloadall;
  222.     } gifanimargs;
  223.  
  224.     TEXT   varbuff[ 258 ];
  225.     STRPTR var;
  226.  
  227.     if( var = GetPrefsVar( cb, "Classes/DataTypes/gifanim.prefs" ) )
  228.     {
  229.       STRPTR prefsline      = var,
  230.              nextprefsline;
  231.       ULONG  linecount      = 1UL;
  232.  
  233.       /* Be sure that "var" contains at least one break-char */
  234.       strcat( var, "\n" );
  235.  
  236.       while( nextprefsline = strpbrk( prefsline, "\n" ) )
  237.       {
  238.         stccpy( varbuff, prefsline, (int)MIN( (sizeof( varbuff ) - 2UL), (((ULONG)(nextprefsline - prefsline)) + 1UL) ) );
  239.  
  240.         /* be sure that this line isn't a comment line or an empty line */
  241.         if( (varbuff[ 0 ] != '#') && (varbuff[ 0 ] != ';') && (varbuff[ 0 ] != '\n') && (strlen( varbuff ) > 2UL) )
  242.         {
  243.           /* Prepare ReadArgs processing */
  244.           strcat( varbuff, "\n" );                                       /* Add NEWLINE-char            */
  245.           envvarrda . RDA_Source . CS_Buffer = varbuff;                  /* Buffer                      */
  246.           envvarrda . RDA_Source . CS_Length = strlen( varbuff ) + 1UL;  /* Set up input buffer length  */
  247.           envvarrda . RDA_Source . CS_CurChr = 0L;
  248.           envvarrda . RDA_Buffer = NULL;
  249.           envvarrda . RDA_BufSiz = 0L;
  250.           memset( (void *)(&gifanimargs), 0, sizeof( gifanimargs ) );          /* Clear result array          */
  251.  
  252.           if( ReadArgs( "MATCHPROJECT/K,"
  253.                         "VERBOSE/S,"
  254.                         "MODEID/K/N,"
  255.                         "16BITCHUNKY=24BITCHUNKY=TRUECOLOR/S,"
  256.                         "NO16BITCHUNKY=NO24BITCHUNKY=NOTRUECOLOR/S,"
  257.                         "FPS/K/N,"
  258.                         "REPEAT/S,"
  259.                         "NOREPEAT/S,"
  260.                         "SAMPLE/K,"
  261.                         "SAMPLESPERFRAME=SPF/K/N,"
  262.                         "VOLUME/K/N,"
  263.                         "LOADALL/S,"
  264.                         "NOLOADALL/S", (LONG *)(&gifanimargs), (&envvarrda) ) )
  265.           {
  266.             BOOL noignore = TRUE;
  267.  
  268.             if( (gifanimargs . matchproject) && (gaid -> gaid_ProjectName) )
  269.             {
  270.               noignore = matchstr( cb, (gifanimargs . matchproject), (gaid -> gaid_ProjectName) );
  271.             }
  272.  
  273.             if( noignore )
  274.             {
  275.               if( gifanimargs . verbose )
  276.               {
  277.                 OpenLogfile( cb, gaid );
  278.               }
  279.  
  280.               if( gifanimargs . modeid )
  281.               {
  282.                 gaid -> gaid_ModeID = *(gifanimargs . modeid);
  283.               }
  284.  
  285.               if( gifanimargs . use24bitchunky )
  286.               {
  287.                 /* Check if we have animation.datatype V41 (or higher) as superclass */
  288.                 if( (cb -> cb_SuperClassBase -> lib_Version) >= 41U )
  289.                 {
  290.                   /* Check here if we opened the cybergraphics.library. After this point, I'll assume
  291.                    * that (gaid_UseChunkyMap == TRUE) implies a opened CyberGfxBase !!
  292.                    */
  293.                   if( CyberGfxBase )
  294.                   {
  295.                     gaid -> gaid_UseChunkyMap = TRUE;
  296.                   }
  297.                   else
  298.                   {
  299.                     error_printf( cb, gaid, "no cybergraphics.library available, can't output a 24 bit chunky map\n" );
  300.                   }
  301.                 }
  302.                 else
  303.                 {
  304.                   error_printf( cb, gaid, "Requires at least animation.datatype V41 for non-planar bitmap support\n" );
  305.                 }
  306.               }
  307.  
  308.               if( gifanimargs . nouse24bitchunky )
  309.               {
  310.                 gaid -> gaid_UseChunkyMap = FALSE;
  311.               }
  312.  
  313.               if( gifanimargs . fps )
  314.               {
  315.                 gaid -> gaid_FPS = *(gifanimargs . fps);
  316.               }
  317.  
  318.               if( gifanimargs . repeat )
  319.               {
  320.                 gaid -> gaid_Repeat = TRUE;
  321.               }
  322.  
  323.               if( gifanimargs . norepeat )
  324.               {
  325.                 gaid -> gaid_Repeat = FALSE;
  326.               }
  327.  
  328.               if( gifanimargs . loadall )
  329.               {
  330.                 gaid -> gaid_LoadAll = TRUE;
  331.               }
  332.  
  333.               if( gifanimargs . noloadall )
  334.               {
  335.                 gaid -> gaid_LoadAll = FALSE;
  336.               }
  337.  
  338.               if( (gifanimargs . sample) && ((gaid -> gaid_Sample) == NULL) )
  339.               {
  340.                 Object *so;
  341.                 LONG    ioerr = 0L;
  342.  
  343.                 verbose_printf( cb, gaid, "loading sample \"%s\"...\n", (gifanimargs . sample) );
  344.  
  345.                 if( so = NewDTObject( (gifanimargs . sample), DTA_GroupID, GID_SOUND, TAG_DONE ) )
  346.                 {
  347.                   BYTE  *sample;
  348.                   ULONG  length;
  349.                   ULONG  period;
  350.  
  351.                   /* Get sample data from object */
  352.                   if( GetDTAttrs( so, SDTA_Sample,       (&sample),
  353.                                       SDTA_SampleLength, (&length),
  354.                                       SDTA_Period,       (&period),
  355.                                       TAG_DONE ) == 3UL )
  356.                   {
  357.                     if( gaid -> gaid_Sample = (STRPTR)AllocPooled( (gaid -> gaid_Pool), (length + 1UL) ) )
  358.                     {
  359.                       /* Copy sample and context */
  360.                       CopyMem( (APTR)sample, (APTR)(gaid -> gaid_Sample), length );
  361.                       gaid -> gaid_SampleLength = length;
  362.                       gaid -> gaid_Period       = period;
  363.                     }
  364.                     else
  365.                     {
  366.                       /* Can't alloc sample */
  367.                       ioerr = ERROR_NO_FREE_STORE;
  368.                     }
  369.                   }
  370.                   else
  371.                   {
  372.                     /* Object does not support the requested attributes */
  373.                     ioerr = ERROR_OBJECT_WRONG_TYPE;
  374.                   }
  375.  
  376.                   DisposeDTObject( so );
  377.                 }
  378.                 else
  379.                 {
  380.                   /* NewDTObjectA failed, cannot load sample... */
  381.                   ioerr = IoErr();
  382.                 }
  383.  
  384.                 if( (gaid -> gaid_Sample) == NULL )
  385.                 {
  386.                   TEXT errbuff[ 256 ];
  387.  
  388.                   if( ioerr >= DTERROR_UNKNOWN_DATATYPE )
  389.                   {
  390.                     mysprintf( cb, errbuff, GetDTString( ioerr ), (gifanimargs . sample) );
  391.                   }
  392.                   else
  393.                   {
  394.                     Fault( ioerr, (gifanimargs . sample), errbuff, sizeof( errbuff ) );
  395.                   }
  396.  
  397.                   error_printf( cb, gaid, "can't load sample: \"%s\" line %lu\n", errbuff, linecount );
  398.                 }
  399.               }
  400.  
  401.               if( gifanimargs . samplesperframe )
  402.               {
  403.                 gaid -> gaid_SamplesPerFrame = *(gifanimargs . samplesperframe);
  404.               }
  405.  
  406.               if( gifanimargs . volume )
  407.               {
  408.                 gaid -> gaid_Volume = *(gifanimargs . volume);
  409.  
  410.                 if( (gaid -> gaid_Volume) > 64UL )
  411.                 {
  412.                   gaid -> gaid_Volume = 64UL;
  413.                 }
  414.               }
  415.             }
  416.             else
  417.             {
  418.               verbose_printf( cb, gaid, "prefs line %lu ignored\n", linecount );
  419.             }
  420.  
  421.             FreeArgs( (&envvarrda) );
  422.           }
  423.           else
  424.           {
  425.             LONG ioerr = IoErr();
  426.             TEXT errbuff[ 256 ];
  427.  
  428.             Fault( ioerr, "Classes/DataTypes/gifanim.prefs", errbuff, (LONG)sizeof( errbuff ) );
  429.  
  430.             error_printf( cb, gaid, "preferences \"%s\" line %lu\n", errbuff, linecount );
  431.           }
  432.         }
  433.  
  434.         prefsline = ++nextprefsline;
  435.         linecount++;
  436.       }
  437.  
  438.       FreeVec( var );
  439.     }
  440. }
  441.  
  442.  
  443.  
  444.  
  445.