开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > GPS编程 > 查看源码
mapoutput.c
资源名称：mapserver-4.8.1.tar.gz　[点击查看]
上传用户：renmgy007
上传日期：2013-06-15
资源大小：1526k
文件大小：35k
源码类别：

GPS编程

开发平台：

C/C++

mapoutput.c：源码内容
  1. /******************************************************************************
  2.  *
  3.  * Project:  MapServer
  4.  * Purpose:  Various support code related to the outputFormatObj.
  5.  * Author:   Frank Warmerdam, warmerdam@pobox.com
  6.  *
  7.  ******************************************************************************
  8.  * Copyright (c) 2002, Frank Warmerdam
  9.  *
  10.  * Permission is hereby granted, free of charge, to any person obtaining a
  11.  * copy of this software and associated documentation files (the "Software"),
  12.  * to deal in the Software without restriction, including without limitation
  13.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  14.  * and/or sell copies of the Software, and to permit persons to whom the
  15.  * Software is furnished to do so, subject to the following conditions:
  16.  *
  17.  * The above copyright notice and this permission notice shall be included
  18.  * in all copies or substantial portions of the Software.
  19.  *
  20.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  21.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  23.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  25.  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  26.  * DEALINGS IN THE SOFTWARE.
  27.  ******************************************************************************
  28.  *
  29.  * $Log: mapoutput.c,v $
  30.  * Revision 1.35  2005/11/10 15:41:16  frank
  31.  * Added missing function header.
  32.  *
  33.  * Revision 1.34  2005/04/07 17:23:16  assefa
  34.  * Remove #ifdef USE_SVG. It was added during development.
  35.  *
  36.  * Revision 1.33  2005/03/08 19:53:25  frank
  37.  * adjusted png24 mimetype per bug 1231
  38.  *
  39.  * Revision 1.32  2005/02/08 21:36:23  frank
  40.  * Return actual error code.
  41.  *
  42.  * Revision 1.31  2005/02/03 00:06:57  assefa
  43.  * Add SVG function prototypes and related calls.
  44.  *
  45.  * Revision 1.30  2004/11/18 20:55:38  frank
  46.  * In msOutputFormatValidate() we now ensure that GD/JPEG does not have
  47.  * alpha enabled, or transparent turned on.   Bug 1073.
  48.  *
  49.  * Revision 1.29  2004/11/18 19:27:16  frank
  50.  * Fixed formatting of debug message.
  51.  *
  52.  * Revision 1.28  2004/11/17 23:53:07  assefa
  53.  * Advertize only gd and gdal formats for wms capabilities (Bug 455).
  54.  *
  55.  * Revision 1.27  2004/11/05 23:04:50  assefa
  56.  * Change a bit test in function msGetOutputFormatMimeListGD.
  57.  *
  58.  * Revision 1.26  2004/11/05 16:29:40  assefa
  59.  * add function msGetOutputFormatMimeListGD.
  60.  *
  61.  * Revision 1.25  2004/10/21 04:30:54  frank
  62.  * Added standardized headers.  Added MS_CVSID().
  63.  *
  64.  * Revision 1.24  2004/10/20 20:46:51  frank
  65.  * msOutputFormatValidate() now also fixes stuff up including setting
  66.  * imagemode to MS_RENDER_WITH_RAWDATA if appropriate, and setting
  67.  * imagemode to MS_IMAGEMODE_RGBA from RGB if transparent enabled.
  68.  * See Bugs 724 and 425/977.
  69.  *
  70.  * Revision 1.23  2004/04/23 16:44:54  frank
  71.  * msRemoteOutputFormat() now frees output formats if refcount==0
  72.  *
  73.  * Revision 1.22  2004/03/08 04:28:46  sean
  74.  * New functions to support mapscript interface to outputformatlist
  75.  *
  76.  * Revision 1.21  2004/03/05 05:57:04  frank
  77.  * support multi-band rawmode output
  78.  *
  79.  * Revision 1.20  2003/07/08 12:36:11  frank
  80.  * don't crash if format==NULL
  81.  *
  82.  * Revision 1.19  2003/07/03 03:01:58  assefa
  83.  * Add support for saving the output formats.
  84.  *
  85.  * Revision 1.18  2003/03/14 13:12:11  attila
  86.  * Introduce MySQL generic support, enabled with --with-mygis when configuring
  87.  *
  88.  * Revision 1.17  2003/02/20 19:49:14  frank
  89.  * fixed implicit setting of JPEG quality from IMAGEQUALITY keyword
  90.  *
  91.  * Revision 1.16  2003/01/17 15:47:48  frank
  92.  * ensure that msApplyDefaultOutputFormats() does not modify map->imagetype
  93.  *
  94.  * Revision 1.15  2003/01/11 23:25:48  frank
  95.  * Bug 249: msApplyOutputFormat() will switch imagemode from RGB to RGBA if
  96.  * transparency is requested.
  97.  * Added msOutputFormatValidate() function.
  98.  *
  99.  * Revision 1.14  2003/01/11 17:32:27  frank
  100.  * When GD2 isn't available create a PC256 mode JPEG driver by default
  101.  *
  102.  * Revision 1.13  2002/12/21 22:04:54  frank
  103.  * I regressed the changes Julien made, and reimplemented the same effect
  104.  * with the logic in msApplyDefaultOutputFormats().  Should be much safer now.
  105.  *
  106.  * Revision 1.11  2002/12/17 23:02:19  dan
  107.  * I assigned the wrong value to map->imagetype.  Duh!
  108.  *
  109.  * Revision 1.10  2002/12/17 22:52:43  dan
  110.  * Update value of map->imagetype in msSelectOutputFormat()
  111.  *
  112.  * Revision 1.9  2002/12/17 22:04:58  dan
  113.  * Added PNG24 to the list of default output formats with GD2
  114.  *
  115.  * Revision 1.8  2002/11/19 14:38:39  frank
  116.  * fixed bug in msApplyOutputFormat with transparent override
  117.  *
  118.  * Revision 1.7  2002/11/19 05:47:37  frank
  119.  * cleanup memory leak
  120.  *
  121.  * Revision 1.6  2002/10/05 16:32:40  zak
  122.  * updated e-mail address
  123.  *
  124.  * Revision 1.5  2002/10/04 21:15:59  assefa
  125.  * Add PDF support using the new output architecture. Work done
  126.  * by Zak James (zak-ms@aiya.dhs.org).
  127.  *
  128.  * Revision 1.4  2002/06/21 18:29:45  frank
  129.  * Added support for GD/PC256 as a pseudo-driver
  130.  *
  131.  * Revision 1.3  2002/06/13 19:56:15  frank
  132.  * don't automatically emit Imagine format support
  133.  *
  134.  * Revision 1.2  2002/06/11 20:45:22  frank
  135.  * add renderer copy to output format clone function
  136.  *
  137.  * Revision 1.1  2002/06/11 13:49:52  frank
  138.  * New
  139.  *
  140.  */
  142. #include <assert.h>
  143. #include "map.h"
  145. MS_CVSID("$Id: mapoutput.c,v 1.35 2005/11/10 15:41:16 frank Exp $")
  147. static outputFormatObj *msAllocOutputFormat( mapObj *map, const char *name, 
  148.                                              const char *driver );
  150. /*************************************************************************
  152. NOTES on outputFormatObj:
  154. typedef struct {
  155.   char *name;
  156.   char *mimetype;
  157.   char *driver;
  158.   int  imagemode; // MS_IMAGEMODE_* value.
  159.   int  transparent;
  160.   int  numformatoptions;
  161.   char **formatoptions;
  162. } outputFormatObj;
  164.  NAME - Associates an internal name with the declaration.  The value used
  165.         has not intrinsic meaning and is just used to associate with the
  166.         MAP level IMAGETYPE.  It is also the "name" used for the format
  167.         in WMS capabilities documents, and FORMAT= requests. (required)
  169.  MIMETYPE - The mime type to use for this format.  If omitted, the value
  170.             will be derived from the DRIVER or default to the value for
  171.             untyped binary data will be used.  (optional - may be NULL)
  173.  DRIVER - This indicates which internal driver mechanism is to be used. 
  174.           Anything prefixed by "GDAL/" will be handled by the GDAL driver, with
  175.           the remainder taken as the GDAL format name. (required)
  177.  IMAGEMODE - Has one of "PC256", "RGB", or "RGBA" indicating whether
  178.              the imaging should be done to a 256 pseudo-colored, 24bit RGB, or
  179.              32bit RGBA (A=alpha/transparency) result image.  Note that the 
  180.              IMAGEMODE actually affects how all the rendering for the map is 
  181.              done, long before it is output to a particular output format.  
  182.              The default value is the traditional "PC256".  Some output 
  183.              formats can only support some IMAGEMODE values. (optional)
  185.              Translate as MS_IMAGEMODE_PC256, MS_IMAGEMODE_RGB and 
  186.              MS_IMAGEMODE_RGBA. 
  188.              Not too sure what this should be set to for output formats like
  189.              flash and SVG.
  191.  TRANSPARENT - A value of "ON" or "OFF" indicating whether transparency 
  192.                support should be enabled.  Same as the old TRANSPARENT flag
  193.                at the MAP level.
  195.  FORMATOPTION - Contains an argument for the specific driver used.  There may 
  196.                 be any number of format options for a given OUTPUTFORMAT 
  197.                 declaration.  FORMATOPTION will be used to encode the older
  198.                 INTERLACE, and QUALITY values. 
  200.                 Handled as a MapServer style CharArray.
  202.  *************************************************************************/
  204. /************************************************************************/
  205. /*                  msPostMapParseOutputFormatSetup()                   */
  206. /************************************************************************/
  208. int msPostMapParseOutputFormatSetup( mapObj *map )
  210. {
  211.     outputFormatObj *format;
  213.     /* Provide default output formats. */
  214.     msApplyDefaultOutputFormats( map );
  216.     /* default to the first of these if IMAGETYPE not set. */
  217.     if( map->imagetype == NULL && map->numoutputformats > 0 )
  218.         map->imagetype = strdup(map->outputformatlist[0]->name);
  220.     /* select the current outputformat into map->outputformat */
  221.     format = msSelectOutputFormat( map, map->imagetype );
  222.     if( format == NULL ) 
  223.     {
  224.         msSetError(MS_MISCERR, 
  225.                    "Unable to select IMAGETYPE `%s'.", 
  226.                    "msPostMapParseOutputFormatSetup()",
  227.                    map->imagetype ? map->imagetype : "(null)" );
  228.         return MS_FAILURE;
  229.     }
  231.     msApplyOutputFormat( &(map->outputformat), format, 
  232.                          map->transparent, map->interlace, map->imagequality );
  234.     return MS_SUCCESS;
  235. }
  237. /************************************************************************/
  238. /*                    msCreateDefaultOutputFormat()                     */
  239. /************************************************************************/
  241. outputFormatObj *msCreateDefaultOutputFormat( mapObj *map, 
  242.                                               const char *driver )
  244. {
  245.     outputFormatObj *format = NULL;
  247.     if( strcasecmp(driver,"GD/PC256") == 0 )
  248.     {
  249. #ifdef USE_GD_GIF
  250.         return msCreateDefaultOutputFormat( map, "GD/GIF" );
  251. #elif defined(USE_GD_PNG)
  252.         return msCreateDefaultOutputFormat( map, "GD/PNG" );
  253. #else
  254.         return NULL;
  255. #endif
  256.     }
  258. #ifdef USE_GD_GIF
  259.     if( strcasecmp(driver,"GD/GIF") == 0 )
  260.     {
  261.         format = msAllocOutputFormat( map, "gif", driver );
  262.         format->mimetype = strdup("image/gif");
  263.         format->imagemode = MS_IMAGEMODE_PC256;
  264.         format->extension = strdup("gif");
  265.         format->renderer = MS_RENDER_WITH_GD;
  266.     }
  267. #endif
  269. #ifdef USE_GD_PNG
  270.     if( strcasecmp(driver,"GD/PNG") == 0 )
  271.     {
  272.         format = msAllocOutputFormat( map, "png", driver );
  273.         format->mimetype = strdup("image/png");
  274.         format->imagemode = MS_IMAGEMODE_PC256;
  275.         format->extension = strdup("png");
  276.         format->renderer = MS_RENDER_WITH_GD;
  277.     }
  278. #endif /* USE_GD_PNG */
  281. #if defined(USE_GD_PNG) && GD2_VERS > 1
  282.     if( strcasecmp(driver,"GD/PNG24") == 0 )
  283.     {
  284.         format = msAllocOutputFormat( map, "png24", "GD/PNG" );
  285.         format->mimetype = strdup("image/png; mode=24bit");
  286.         format->imagemode = MS_IMAGEMODE_RGB;
  287.         format->extension = strdup("png");
  288.         format->renderer = MS_RENDER_WITH_GD;
  289.     }
  290. #endif /* USE_GD_PNG */
  292. #ifdef USE_GD_JPEG
  293.     if( strcasecmp(driver,"GD/JPEG") == 0 )
  294.     {
  295.         format = msAllocOutputFormat( map, "jpeg", driver );
  296.         format->mimetype = strdup("image/jpeg");
  297. #if GD2_VERS > 1
  298.         format->imagemode = MS_IMAGEMODE_RGB;
  299. #else
  300.         format->imagemode = MS_IMAGEMODE_PC256;
  301. #endif
  302.         format->extension = strdup("jpg");
  303.         format->renderer = MS_RENDER_WITH_GD;
  304.     }
  305. #endif
  306. #ifdef USE_GD_WBMP
  307.     if( strcasecmp(driver,"GD/WBMP") == 0 )
  308.     {
  309.         format = msAllocOutputFormat( map, "wbmp", driver );
  310.         format->mimetype = strdup("image/wbmp");
  311.         format->imagemode = MS_IMAGEMODE_PC256;
  312.         format->extension = strdup("wbmp");
  313.         format->renderer = MS_RENDER_WITH_GD;
  314.     }
  315. #endif
  316. #ifdef USE_MING_FLASH
  317.     if( strcasecmp(driver,"swf") == 0 )
  318.     {
  319.         format = msAllocOutputFormat( map, "swf", driver );
  320.         format->mimetype = strdup("application/x-shockwave-flash");
  321.         format->imagemode = MS_IMAGEMODE_PC256;
  322.         format->extension = strdup("swf");
  323.         format->renderer = MS_RENDER_WITH_SWF;
  324.     }
  325. #endif
  326. #ifdef USE_PDF
  327.     if( strcasecmp(driver,"pdf") == 0 )
  328.     {
  329.         format = msAllocOutputFormat( map, "pdf", driver );
  330.         format->mimetype = strdup("application/x-pdf");
  331.         format->imagemode = MS_IMAGEMODE_PC256;
  332.         format->extension = strdup("pdf");
  333.         format->renderer = MS_RENDER_WITH_PDF;
  334.     }
  335. #endif
  336. #ifdef USE_GDAL
  337.     if( strncasecmp(driver,"gdal/",5) == 0 )
  338.     {
  339.         format = msAllocOutputFormat( map, driver+5, driver );
  340.         if( msInitDefaultGDALOutputFormat( format ) == MS_FAILURE )
  341.         {
  342.             if( map != NULL )
  343.             {
  344.                 map->numoutputformats--;
  345.                 map->outputformatlist[map->numoutputformats] = NULL;
  346.             }
  348.             msFreeOutputFormat( format );
  349.             format = NULL;
  350.         }
  351.     }
  352. #endif
  353.     if( strcasecmp(driver,"imagemap") == 0 )
  354.     {
  355.         format = msAllocOutputFormat( map, "imagemap", driver );
  356.         format->mimetype = strdup("text/html");
  357.         format->extension = strdup("html");
  358.         format->imagemode = 0;
  359.         format->renderer = MS_RENDER_WITH_IMAGEMAP;
  360.     }
  361.     if( strcasecmp(driver,"svg") == 0 )
  362.     {
  363.         format = msAllocOutputFormat( map, "svg", driver );
  364.         format->mimetype = strdup("image/svg+xml");
  365.         format->imagemode = 0;
  366.         format->extension = strdup("svg");
  367.         format->renderer = MS_RENDER_WITH_SVG;
  368.     }
  369.     if( format != NULL )
  370.         format->inmapfile = MS_FALSE;
  372.     return format;
  373. }
  375. /************************************************************************/
  376. /*                    msApplyDefaultOutputFormats()                     */
  377. /************************************************************************/
  379. void msApplyDefaultOutputFormats( mapObj *map )
  381. {
  382.     char *saved_imagetype;
  384.     if( map->imagetype == NULL )
  385.         saved_imagetype = NULL;
  386.     else
  387.         saved_imagetype = strdup(map->imagetype);
  389.     if( msSelectOutputFormat( map, "gif" ) == NULL )
  390.         msCreateDefaultOutputFormat( map, "GD/GIF" );
  392.     if( msSelectOutputFormat( map, "png" ) == NULL )
  393.         msCreateDefaultOutputFormat( map, "GD/PNG" );
  395.     if( msSelectOutputFormat( map, "png24" ) == NULL )
  396.         msCreateDefaultOutputFormat( map, "GD/PNG24" );
  398.     if( msSelectOutputFormat( map, "jpeg" ) == NULL )
  399.         msCreateDefaultOutputFormat( map, "GD/JPEG" );
  401.     if( msSelectOutputFormat( map, "wbmp" ) == NULL )
  402.         msCreateDefaultOutputFormat( map, "GD/WBMP" );
  404.     if( msSelectOutputFormat( map, "swf" ) == NULL )
  405.         msCreateDefaultOutputFormat( map, "swf" );
  407.     if( msSelectOutputFormat( map, "imagemap" ) == NULL )
  408.         msCreateDefaultOutputFormat( map, "imagemap" );
  410.     if( msSelectOutputFormat( map, "pdf" ) == NULL )
  411.         msCreateDefaultOutputFormat( map, "pdf" );
  413.     if( msSelectOutputFormat( map, "GTiff" ) == NULL )
  414.         msCreateDefaultOutputFormat( map, "GDAL/GTiff" );
  416.     if( msSelectOutputFormat( map, "svg" ) == NULL )
  417.         msCreateDefaultOutputFormat( map, "svg" );
  419.     if( map->imagetype != NULL )
  420.         free( map->imagetype );
  421.     map->imagetype = saved_imagetype;
  422. }
  424. /************************************************************************/
  425. /*                         msFreeOutputFormat()                         */
  426. /************************************************************************/
  428. void msFreeOutputFormat( outputFormatObj *format )
  430. {
  431.     if( format == NULL )
  432.         return;
  434.     msFree( format->name );
  435.     msFree( format->mimetype );
  436.     msFree( format->driver );
  437.     msFree( format->extension );
  438.     msFreeCharArray( format->formatoptions, format->numformatoptions );
  440.     msFree( format );
  441. }
  443. /************************************************************************/
  444. /*                        msAllocOutputFormat()                         */
  445. /************************************************************************/
  447. static outputFormatObj *msAllocOutputFormat( mapObj *map, const char *name, 
  448.                                              const char *driver )
  450. {
  451.     outputFormatObj *format;
  453. /* -------------------------------------------------------------------- */
  454. /*      Allocate the format object.                                     */
  455. /* -------------------------------------------------------------------- */
  456.     format = (outputFormatObj *) calloc(1,sizeof(outputFormatObj));
  457.     if( format == NULL )
  458.     {
  459.         msSetError( MS_MEMERR, NULL, "msAllocOutputFormat()" );
  460.         return NULL;
  461.     }
  463. /* -------------------------------------------------------------------- */
  464. /*      Initialize various fields.                                      */
  465. /* -------------------------------------------------------------------- */
  466.     format->bands = 1;
  467.     format->name = strdup(name);
  468.     format->driver = strdup(driver);
  469.     format->refcount = 0;
  471.     format->imagemode = MS_IMAGEMODE_PC256;
  473. /* -------------------------------------------------------------------- */
  474. /*      Attach to map.                                                  */
  475. /* -------------------------------------------------------------------- */
  476.     if( map != NULL )
  477.     {
  478.         map->numoutputformats++;
  479.         if( map->outputformatlist == NULL )
  480.             map->outputformatlist = (outputFormatObj **) malloc(sizeof(void*));
  481.         else
  482.             map->outputformatlist = (outputFormatObj **)
  483.                 realloc(map->outputformatlist,
  484.                         sizeof(void*) * map->numoutputformats );
  486.         map->outputformatlist[map->numoutputformats-1] = format;
  487.         format->refcount++;
  488.     }
  489.     
  490.     return format;
  491. }
  493. /************************************************************************/
  494. /*                        msAppendOutputFormat()                        */
  495. /*                                                                      */
  496. /*      Add an output format  .                                         */
  497. /*      http://mapserver.gis.umn.edu/bugs/show_bug.cgi?id=511           */
  498. /************************************************************************/
  499. int msAppendOutputFormat(mapObj *map, outputFormatObj *format) 
  500. {
  501. /* -------------------------------------------------------------------- */
  502. /*      Attach to map.                                                  */
  503. /* -------------------------------------------------------------------- */
  504.     if (map != NULL)
  505.     {
  506.         map->numoutputformats++;
  507.         if (map->outputformatlist == NULL)
  508.             map->outputformatlist = (outputFormatObj **) malloc(sizeof(void*));
  509.         else
  510.             map->outputformatlist = (outputFormatObj **)
  511.                 realloc(map->outputformatlist,
  512.                         sizeof(void*) * map->numoutputformats );
  514.         map->outputformatlist[map->numoutputformats-1] = format;
  515.         format->refcount++;
  516.     }
  517.     
  518.     return map->numoutputformats;
  519. }
  521. /************************************************************************/
  522. /*                        msRemoveOutputFormat()                        */
  523. /*                                                                      */
  524. /*      Remove an output format (by name).                              */
  525. /*      http://mapserver.gis.umn.edu/bugs/show_bug.cgi?id=511           */
  526. /************************************************************************/
  527. int msRemoveOutputFormat(mapObj *map, const char *name)
  528. {
  529.     int i, j;
  530. /* -------------------------------------------------------------------- */
  531. /*      Detach from map.                                                */
  532. /* -------------------------------------------------------------------- */
  533.     if (map != NULL)
  534.     {
  535.         if (map->outputformatlist == NULL)
  536.         {
  537.             msSetError(MS_CHILDERR, "Can't remove format from empty outputformatlist", "msRemoveOutputFormat()");
  538.             return MS_FAILURE;
  539.         }
  540.         else
  541.         {
  542.             i = msGetOutputFormatIndex(map, name);
  543.             if (i >= 0) 
  544.             {
  545.                 map->numoutputformats--;
  546.                 if( map->outputformatlist[i]->refcount-- < 1 )
  547.                     msFreeOutputFormat( map->outputformatlist[i] );
  549.                 for (j=i; j<map->numoutputformats-1; j++)
  550.                 {
  551.                     map->outputformatlist[j] = map->outputformatlist[j+1];
  552.                 }
  553.             }
  554.             map->outputformatlist = (outputFormatObj **)
  555.                 realloc(map->outputformatlist,
  556.                     sizeof(void*) * (map->numoutputformats) );
  557.             return MS_SUCCESS;
  558.         }
  559.     }
  560.     return MS_FAILURE;
  561. }
  563. /************************************************************************/
  564. /*                       msGetOutputFormatIndex()                       */
  565. /*                                                                      */
  566. /*      Pulled this out of msSelectOutputFormat for use in other cases. */
  567. /************************************************************************/
  569. int msGetOutputFormatIndex(mapObj *map, const char *imagetype)
  570. {
  571.     int i;
  572. /* -------------------------------------------------------------------- */
  573. /*      Try to find the format in the maps list of formats, first by    */
  574. /*      mime type, and then by output format name.                      */
  575. /* -------------------------------------------------------------------- */
  576.     for (i = 0; i < map->numoutputformats; i++)
  577.     {
  578.         if (map->outputformatlist[i]->mimetype != NULL
  579.             && strcasecmp(imagetype,
  580.                           map->outputformatlist[i]->mimetype) == 0 )
  581.             return i;
  582.     }
  583.     
  584.     for( i = 0; i < map->numoutputformats; i++ )
  585.     {
  586.         if( strcasecmp(imagetype,map->outputformatlist[i]->name) == 0 )
  587.             return i;
  588.     }
  590.     return -1;
  591. }
  593. /************************************************************************/
  594. /*                        msSelectOutputFormat()                        */
  595. /************************************************************************/
  597. outputFormatObj *msSelectOutputFormat( mapObj *map, 
  598.                                        const char *imagetype )
  600. {
  601.     int i, index;
  602.     outputFormatObj *format = NULL;
  604.     if( map == NULL || imagetype == NULL || strlen(imagetype) == 0 )
  605.         return NULL;
  606.     
  607.     index = msGetOutputFormatIndex(map, imagetype);
  608.     if (index >= 0)
  609.         format = map->outputformatlist[index];
  611. /* -------------------------------------------------------------------- */
  612. /*      Try to find the format in the maps list of formats, first by    */
  613. /*      mime type, and then by output format name.                      */
  614. /* -------------------------------------------------------------------- */
  615.     for( i = 0; i < map->numoutputformats && format == NULL; i++ )
  616.     {
  617.         if( map->outputformatlist[i]->mimetype != NULL
  618.             && strcasecmp(imagetype,
  619.                           map->outputformatlist[i]->mimetype) == 0 )
  620.             format = map->outputformatlist[i];
  621.     }
  622.     
  623.     for( i = 0; i < map->numoutputformats && format == NULL; i++ )
  624.     {
  625.         if( strcasecmp(imagetype,map->outputformatlist[i]->name) == 0 )
  626.             format = map->outputformatlist[i];
  627.     }
  628.     
  629.     if (format)
  630.     {
  631.         if (map->imagetype)
  632.             free(map->imagetype);
  633.         map->imagetype = strdup(format->name);
  634.     }
  636.     if( format != NULL )
  637.         msOutputFormatValidate( format );
  639.     return format;
  640. }
  642. /************************************************************************/
  643. /*                        msApplyOutputFormat()                         */
  644. /************************************************************************/
  646. void msApplyOutputFormat( outputFormatObj **target, 
  647.                           outputFormatObj *format,
  648.                           int transparent, 
  649.                           int interlaced, 
  650.                           int imagequality )
  652. {
  653.     int       change_needed = MS_FALSE;
  654.     int       old_imagequality, old_interlaced;
  655.     outputFormatObj *formatToFree = NULL;
  657.     assert( target != NULL );
  659.     
  660.     if( *target != NULL && --((*target)->refcount) < 1 )
  661.     {
  662.         formatToFree = *target;
  663.         *target = NULL;
  664.     }
  666.     if( format == NULL )
  667.     {
  668.         if( formatToFree )
  669.             msFreeOutputFormat( formatToFree );
  670.         return;
  671.     }
  673.     msOutputFormatValidate( format );
  675. /* -------------------------------------------------------------------- */
  676. /*      Do we need to change any values?  If not, then just apply       */
  677. /*      and return.                                                     */
  678. /* -------------------------------------------------------------------- */
  679.     if( transparent != MS_NOOVERRIDE && !format->transparent != !transparent )
  680.         change_needed = MS_TRUE;
  682.     old_imagequality = atoi(msGetOutputFormatOption( format, "QUALITY", "75"));
  683.     if( imagequality != MS_NOOVERRIDE && old_imagequality != imagequality )
  684.         change_needed = MS_TRUE;
  686.     old_interlaced = 
  687.         strcasecmp(msGetOutputFormatOption( format, "INTERLACE", "ON"),
  688.                    "OFF") != 0;
  689.     if( interlaced != MS_NOOVERRIDE && !interlaced != !old_interlaced )
  690.         change_needed = MS_TRUE;
  692.     if( change_needed )
  693.     {
  694.         char new_value[128];
  696.         if( format->refcount > 0 )
  697.             format = msCloneOutputFormat( format );
  699.         if( transparent != MS_NOOVERRIDE )
  700.         {
  701.             format->transparent = transparent;
  702.             if( format->imagemode == MS_IMAGEMODE_RGB )
  703.                 format->imagemode = MS_IMAGEMODE_RGBA;
  704.         }
  706.         if( imagequality != MS_NOOVERRIDE && imagequality != old_imagequality )
  707.         {
  708.             sprintf( new_value, "%d", imagequality );
  709.             msSetOutputFormatOption( format, "QUALITY", new_value );
  710.         }
  712.         if( interlaced != MS_NOOVERRIDE && !interlaced != !old_interlaced )
  713.         {
  714.             if( interlaced )
  715.                 msSetOutputFormatOption( format, "INTERLACE", "ON" );
  716.             else
  717.                 msSetOutputFormatOption( format, "INTERLACE", "OFF" );
  718.         }
  719.     }
  721.     *target = format;
  722.     format->refcount++;
  724.     if( formatToFree )
  725.         msFreeOutputFormat( formatToFree );
  726. }
  728. /************************************************************************/
  729. /*                        msCloneOutputFormat()                         */
  730. /************************************************************************/
  732. outputFormatObj *msCloneOutputFormat( outputFormatObj *src )
  734. {
  735.     outputFormatObj *dst;
  736.     int             i;
  738.     dst = msAllocOutputFormat( NULL, src->name, src->driver );
  740.     msFree( dst->mimetype );
  741.     if( src->mimetype )
  742.         dst->mimetype = strdup( src->mimetype );
  743.     else
  744.         dst->mimetype = NULL;
  746.     msFree( dst->extension );
  747.     if( src->extension )
  748.         dst->extension = strdup( src->extension );
  749.     else
  750.         dst->extension = NULL;
  752.     dst->imagemode = src->imagemode;
  753.     dst->renderer = src->renderer;
  755.     dst->transparent = src->transparent;
  756.     dst->bands = src->bands;
  758.     dst->numformatoptions = src->numformatoptions;
  759.     dst->formatoptions = (char **) 
  760.         malloc(sizeof(char *) * src->numformatoptions );
  762.     for( i = 0; i < src->numformatoptions; i++ )
  763.         dst->formatoptions[i] = strdup(src->formatoptions[i]);
  765.     return dst;
  766. }
  768. /************************************************************************/
  769. /*                      msGetOutputFormatOption()                       */
  770. /*                                                                      */
  771. /*      Fetch the value of a particular option.  It is assumed the      */
  772. /*      options are in "KEY=VALUE" format.                              */
  773. /************************************************************************/
  775. const char *msGetOutputFormatOption( outputFormatObj *format, 
  776.                                      const char *optionkey, 
  777.                                      const char *defaultresult )
  779. {
  780.     int    i, len = strlen(optionkey);
  782.     for( i = 0; i < format->numformatoptions; i++ )
  783.     {
  784.         if( strncasecmp(format->formatoptions[i],optionkey,len) == 0
  785.             && format->formatoptions[i][len] == '=' )
  786.             return format->formatoptions[i] + len + 1;
  787.     }
  789.     return defaultresult;
  790. }
  792. /************************************************************************/
  793. /*                      msSetOutputFormatOption()                       */
  794. /************************************************************************/
  796. void msSetOutputFormatOption( outputFormatObj *format,
  797.                               const char *key, const char *value )
  799. {
  800.     char *newline;
  801.     int   i, len;
  803. /* -------------------------------------------------------------------- */
  804. /*      Format the name=value pair into a newly allocated string.       */
  805. /* -------------------------------------------------------------------- */
  806.     newline = (char *) malloc(strlen(key)+strlen(value)+2);
  807.     if( newline == NULL )
  808.     {
  809.         assert( newline != NULL );
  810.         return;
  811.     }
  813.     sprintf( newline, "%s=%s", key, value );
  814.     
  815. /* -------------------------------------------------------------------- */
  816. /*      Does this key already occur?  If so replace it.                 */
  817. /* -------------------------------------------------------------------- */
  818.     len = strlen(key);
  820.     for( i = 0; i < format->numformatoptions; i++ )
  821.     {
  822.         if( strncasecmp(format->formatoptions[i],key,len) == 0
  823.             && format->formatoptions[i][len] == '=' )
  824.         {
  825.             free( format->formatoptions[i] );
  826.             format->formatoptions[i] = newline;
  827.             return;
  828.         }
  829.     }
  831. /* -------------------------------------------------------------------- */
  832. /*      otherwise, we need to grow the list.                            */
  833. /* -------------------------------------------------------------------- */
  834.     format->numformatoptions++;
  835.     format->formatoptions = (char **) 
  836.         realloc( format->formatoptions, 
  837.                  sizeof(char*) * format->numformatoptions );
  839.     format->formatoptions[format->numformatoptions-1] = newline;
  841. /* -------------------------------------------------------------------- */
  842. /*      Capture generic value(s) we are interested in.                  */
  843. /* -------------------------------------------------------------------- */
  844.     if( strcasecmp(key,"BAND_COUNT") == 0 )
  845.         format->bands = atoi(value);
  846. }
  848. /************************************************************************/
  849. /*                     msGetOutputFormatMimeList()                      */
  850. /************************************************************************/
  852. void msGetOutputFormatMimeList( mapObj *map, char **mime_list, int max_mime )
  854. {
  855.     int mime_count = 0, i;
  857.     for( i = 0; i < map->numoutputformats && mime_count < max_mime; i++ )
  858.     {
  859.         int  j;
  860.         
  861.         if( map->outputformatlist[i]->mimetype == NULL )
  862.             continue;
  864.         for( j = 0; j < mime_count; j++ )
  865.         {
  866.             if( strcasecmp(mime_list[j],
  867.                            map->outputformatlist[i]->mimetype) == 0 )
  868.                 break;
  869.         }
  871.         if( j == mime_count )
  872.             mime_list[mime_count++] = map->outputformatlist[i]->mimetype;
  873.     }
  875.     if( mime_count < max_mime )
  876.         mime_list[mime_count] = NULL;
  877. }
  879. /************************************************************************/
  880. /*                     msGetOutputFormatMimeList()                      */
  881. /************************************************************************/
  883. void msGetOutputFormatMimeListGD( mapObj *map, char **mime_list, int max_mime )
  885. {
  886.     int mime_count = 0, i;
  888.     for( i = 0; i < map->numoutputformats && mime_count < max_mime; i++ )
  889.     {
  890.         int  j;
  891.         
  892.         if( map->outputformatlist[i]->mimetype == NULL )
  893.             continue;
  895.         for( j = 0; j < mime_count; j++ )
  896.         {
  897.             if( strcasecmp(mime_list[j],
  898.                            map->outputformatlist[i]->mimetype) == 0 )
  899.                 break;
  900.         }
  902.         if( j == mime_count && map->outputformatlist[i]->driver &&
  903.             strncasecmp(map->outputformatlist[i]->driver, "GD/", 3)==0)
  904.             mime_list[mime_count++] = map->outputformatlist[i]->mimetype;
  905.     }
  907.     if( mime_count < max_mime )
  908.         mime_list[mime_count] = NULL;
  909. }
  912. /************************************************************************/
  913. /*                  msGetOutputFormatMimeListRaster()                   */
  914. /************************************************************************/
  916. void msGetOutputFormatMimeListRaster( mapObj *map, char **mime_list, int max_mime )
  918. {
  919.     int mime_count = 0, i;
  921.     for( i = 0; i < map->numoutputformats && mime_count < max_mime; i++ )
  922.     {
  923.         int  j;
  924.         
  925.         if( map->outputformatlist[i]->mimetype == NULL )
  926.             continue;
  928.         for( j = 0; j < mime_count; j++ )
  929.         {
  930.             if( strcasecmp(mime_list[j],
  931.                            map->outputformatlist[i]->mimetype) == 0 )
  932.                 break;
  933.         }
  935.         if( j == mime_count && map->outputformatlist[i]->driver &&
  936.             (strncasecmp(map->outputformatlist[i]->driver, "GD/", 3)==0 ||
  937.              strncasecmp(map->outputformatlist[i]->driver, "GDAL/", 5)==0))
  938.             mime_list[mime_count++] = map->outputformatlist[i]->mimetype;
  939.     }
  941.     if( mime_count < max_mime )
  942.         mime_list[mime_count] = NULL;
  943. }
  945. /************************************************************************/
  946. /*                       msOutputFormatValidate()                       */
  947. /*                                                                      */
  948. /*      Do some validation of the output format, and report to debug    */
  949. /*      output if it doesn't seem valid.  Fixup in place as best as     */
  950. /*      possible.                                                       */
  951. /************************************************************************/
  953. int msOutputFormatValidate( outputFormatObj *format )
  955. {
  956.     int result = MS_TRUE;
  958.     format->bands = 
  959.             atoi(msGetOutputFormatOption( format, "BAND_COUNT", "1" ));
  961.     /* Enforce the requirement that GD/JPEG be RGB and TRANSPARENT=OFF */
  962.     if( strcasecmp(format->driver,"GD/JPEG") == 0 && format->transparent )
  963.     {
  964.         msDebug( "GD/JPEG OUTPUTFORMAT %s has TRANSPARENT set ON, but this is not supported.n"
  965.                  "It has been disabled.n", 
  966.                  format->name );
  967.         format->transparent = MS_FALSE;
  968.         result = MS_FALSE;
  969.     }
  971.     if( strcasecmp(format->driver,"GD/JPEG") == 0 
  972.         && format->imagemode == MS_IMAGEMODE_RGBA )
  973.     {
  974.         msDebug( "GD/JPEG OUTPUTFORMAT %s has IMAGEMODE RGBA, but this is not supported.n"
  975.                  "IMAGEMODE forced to RGB.n", 
  976.                  format->name );
  977.         format->imagemode = MS_IMAGEMODE_RGB;
  978.         result = MS_FALSE;
  979.     }
  981.     if( format->transparent && format->imagemode == MS_IMAGEMODE_RGB )
  982.     {
  983.         msDebug( "OUTPUTFORMAT %s has TRANSPARENT set ON, but an IMAGEMODEn"
  984.                  " of RGB instead of RGBA.  Changing imagemode to RGBA.n", 
  985.                  format->name );
  986.         format->imagemode = MS_IMAGEMODE_RGBA;
  987.         result = MS_FALSE;
  988.     }
  990.     /* see bug 724 */
  991.     if( ( format->imagemode == MS_IMAGEMODE_INT16 
  992.           || format->imagemode == MS_IMAGEMODE_FLOAT32 
  993.           || format->imagemode == MS_IMAGEMODE_BYTE )
  994.         && format->renderer != MS_RENDER_WITH_RAWDATA )
  995.         format->renderer = MS_RENDER_WITH_RAWDATA;
  997.     return result;
  998. }