/******************************************************************************
 * $Id$
 *
 * Project:  ASI CEOS Translator
 * Purpose:  CEOS field layout recipes.
 * Author:   Paul Lahaie, pjlahaie@atlsci.com
 *
 ******************************************************************************
 * Copyright (c) 2000, Atlantis Scientific Inc
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ****************************************************************************/

#include "ceos.h"

/* Array of Datatypes and their names/values */

typedef struct
{
    const char *String;
    int Type;
} CeosStringType_t;

typedef struct
{
    int (*function)(CeosSARVolume_t *volume, const void *token);
    const void *token;
    const char *name;
} RecipeFunctionData_t;

static const CeosStringType_t CeosDataType[] = {
    {"IU1", CEOS_TYP_UCHAR},
    {"IU2", CEOS_TYP_USHORT},
    {"UI1", CEOS_TYP_UCHAR},
    {"UI2", CEOS_TYP_USHORT},
    {"CI*2", CEOS_TYP_COMPLEX_CHAR},
    {"CI*4", CEOS_TYP_COMPLEX_SHORT},
    {"CIS4", CEOS_TYP_COMPLEX_SHORT},
    {"CI*8", CEOS_TYP_COMPLEX_LONG},
    {"C*8", CEOS_TYP_COMPLEX_FLOAT},
    {"R*4", CEOS_TYP_FLOAT},
    {NULL, 0}};

static const CeosStringType_t CeosInterleaveType[] = {{"BSQ", CEOS_IL_BAND},
                                                      {" BSQ", CEOS_IL_BAND},
                                                      {"BIL", CEOS_IL_LINE},
                                                      {" BIL", CEOS_IL_LINE},
                                                      {NULL, 0}};

#define IMAGE_OPT                                                              \
    {                                                                          \
        63, 192, 18, 18                                                        \
    }
#define IMAGE_JERS_OPT                                                         \
    {                                                                          \
        50, 192, 18, 18                                                        \
    } /* Some JERS data uses this instead of IMAGE_OPT */
#define PROC_DATA_REC                                                          \
    {                                                                          \
        50, 11, 18, 20                                                         \
    }
#define PROC_DATA_REC_ALT                                                      \
    {                                                                          \
        50, 11, 31, 20                                                         \
    }
#define PROC_DATA_REC_ALT2                                                     \
    {                                                                          \
        50, 11, 31, 50                                                         \
    } /* Some cases of ERS 1, 2 */
#define DATA_SET_SUMMARY                                                       \
    {                                                                          \
        18, 10, 18, 20                                                         \
    }

/* NOTE: This seems to be the generic recipe used for most things */
static const CeosRecipeType_t RadarSatRecipe[] = {
    {CEOS_REC_NUMCHANS, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 233, 4,
     CEOS_REC_TYP_I}, /* Number of channels */
    {CEOS_REC_INTERLEAVE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 269, 4,
     CEOS_REC_TYP_A}, /* Interleaving type */
    {CEOS_REC_DATATYPE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 429, 4,
     CEOS_REC_TYP_A}, /* Data type */
    {CEOS_REC_BPR, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 0, 0,
     CEOS_REC_TYP_A}, /* For Defeault CEOS, this is done using other vals */
    {CEOS_REC_LINES, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 237, 8,
     CEOS_REC_TYP_I}, /* How many lines */
    {CEOS_REC_TBP, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 261, 4, CEOS_REC_TYP_I},
    {CEOS_REC_BBP, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 265, 4,
     CEOS_REC_TYP_I}, /* Bottom border pixels */
    {CEOS_REC_PPL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 249, 8,
     CEOS_REC_TYP_I}, /* Pixels per line */
    {CEOS_REC_LBP, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 245, 4,
     CEOS_REC_TYP_I}, /* Left Border Pixels */
    {CEOS_REC_RBP, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 257, 4,
     CEOS_REC_TYP_I}, /* Right Border Pixels */
    {CEOS_REC_BPP, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 225, 4,
     CEOS_REC_TYP_I}, /* Bytes Per Pixel */
    {CEOS_REC_RPL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 273, 2,
     CEOS_REC_TYP_I}, /* Records per line */
    {CEOS_REC_PPR, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 0, 0,
     CEOS_REC_TYP_I}, /* Pixels Per Record -- need to fill record type */
    {CEOS_REC_PDBPR, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 281, 8,
     CEOS_REC_TYP_I}, /* pixel data bytes per record */
    {CEOS_REC_IDS, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 277, 4,
     CEOS_REC_TYP_I}, /* Prefix data per record */
    {CEOS_REC_FDL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 9, 4,
     CEOS_REC_TYP_B}, /* Length of Imagry Options Header */
    {CEOS_REC_PIXORD, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 0, 0,
     CEOS_REC_TYP_I}, /* Must be calculated */
    {CEOS_REC_LINORD, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 0, 0,
     CEOS_REC_TYP_I}, /* Must be calculated */
    {CEOS_REC_PRODTYPE, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 0, 0,
     CEOS_REC_TYP_I},

    {CEOS_REC_RECORDSIZE, 1, CEOS_IMAGRY_OPT_FILE, PROC_DATA_REC, 9, 4,
     CEOS_REC_TYP_B}, /* The processed image record size */

    /* Some ERS-1 products use an alternate data record subtype2. */
    {CEOS_REC_RECORDSIZE, 1, CEOS_IMAGRY_OPT_FILE, PROC_DATA_REC_ALT, 9, 4,
     CEOS_REC_TYP_B}, /* The processed image record size */

    /* Yet another ERS-1 and ERS-2 alternate data record subtype2. */
    {CEOS_REC_RECORDSIZE, 1, CEOS_IMAGRY_OPT_FILE, PROC_DATA_REC_ALT2, 9, 4,
     CEOS_REC_TYP_B}, /* The processed image record size */

    {CEOS_REC_SUFFIX_SIZE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 289, 4,
     CEOS_REC_TYP_I},                /* Suffix data per record */
    {0, 0, 0, {0, 0, 0, 0}, 0, 0, 0} /* Last record is Zero */
};

static const CeosRecipeType_t JersRecipe[] = {
    {CEOS_REC_NUMCHANS, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 233, 4,
     CEOS_REC_TYP_I}, /* Number of channels */
    {CEOS_REC_INTERLEAVE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 269, 4,
     CEOS_REC_TYP_A}, /* Interleaving type */
    {CEOS_REC_DATATYPE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 429, 4,
     CEOS_REC_TYP_A}, /* Data type */
    {CEOS_REC_BPR, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 0, 0,
     CEOS_REC_TYP_A}, /* For Defeault CEOS, this is done using other vals */
    {CEOS_REC_LINES, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 237, 8,
     CEOS_REC_TYP_I}, /* How many lines */
    {CEOS_REC_TBP, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 261, 4,
     CEOS_REC_TYP_I},
    {CEOS_REC_BBP, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 265, 4,
     CEOS_REC_TYP_I}, /* Bottom border pixels */
    {CEOS_REC_PPL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 249, 8,
     CEOS_REC_TYP_I}, /* Pixels per line */
    {CEOS_REC_LBP, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 245, 4,
     CEOS_REC_TYP_I}, /* Left Border Pixels */
    {CEOS_REC_RBP, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 257, 4,
     CEOS_REC_TYP_I}, /* Isn't available for RadarSAT */
    {CEOS_REC_BPP, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 225, 4,
     CEOS_REC_TYP_I}, /* Bytes Per Pixel */
    {CEOS_REC_RPL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 273, 2,
     CEOS_REC_TYP_I}, /* Records per line */
    {CEOS_REC_PPR, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 0, 0,
     CEOS_REC_TYP_I}, /* Pixels Per Record -- need to fill record type */
    {CEOS_REC_PDBPR, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 281, 8,
     CEOS_REC_TYP_I}, /* pixel data bytes per record */
    {CEOS_REC_IDS, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 277, 4,
     CEOS_REC_TYP_I}, /* Prefix data per record */
    {CEOS_REC_FDL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 9, 4,
     CEOS_REC_TYP_B}, /* Length of Imagry Options Header */
    {CEOS_REC_PIXORD, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 0, 0,
     CEOS_REC_TYP_I}, /* Must be calculated */
    {CEOS_REC_LINORD, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 0, 0,
     CEOS_REC_TYP_I}, /* Must be calculated */
    {CEOS_REC_PRODTYPE, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 0, 0,
     CEOS_REC_TYP_I},

    {CEOS_REC_RECORDSIZE, 1, CEOS_IMAGRY_OPT_FILE, PROC_DATA_REC, 9, 4,
     CEOS_REC_TYP_B}, /* The processed image record size */

    {CEOS_REC_SUFFIX_SIZE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_JERS_OPT, 289, 4,
     CEOS_REC_TYP_I},                /* Suffix data per record */
    {0, 0, 0, {0, 0, 0, 0}, 0, 0, 0} /* Last record is Zero */
};

static const CeosRecipeType_t ScanSARRecipe[] = {
    {CEOS_REC_NUMCHANS, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 233, 4,
     CEOS_REC_TYP_I}, /* Number of channels */
    {CEOS_REC_INTERLEAVE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 269, 4,
     CEOS_REC_TYP_A}, /* Interleaving type */
    {CEOS_REC_DATATYPE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 429, 4,
     CEOS_REC_TYP_A}, /* Data type */
    {CEOS_REC_LINES, 1, CEOS_ANY_FILE, DATA_SET_SUMMARY, 325, 8,
     CEOS_REC_TYP_I}, /* How many lines */
    {CEOS_REC_PPL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 249, 8,
     CEOS_REC_TYP_I}, /* Pixels per line */
    {CEOS_REC_BPP, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 225, 4,
     CEOS_REC_TYP_I}, /* Bytes Per Pixel */
    {CEOS_REC_RPL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 273, 2,
     CEOS_REC_TYP_I}, /* Records per line */
    {CEOS_REC_IDS, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 277, 4,
     CEOS_REC_TYP_I}, /* Prefix data per record */
    {CEOS_REC_FDL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 9, 4,
     CEOS_REC_TYP_B}, /* Length of Imagry Options Header */
    {CEOS_REC_RECORDSIZE, 1, CEOS_IMAGRY_OPT_FILE, PROC_DATA_REC, 9, 4,
     CEOS_REC_TYP_B}, /* The processed image record size */
    {CEOS_REC_SUFFIX_SIZE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 289, 4,
     CEOS_REC_TYP_I},                /* Suffix data per record */
    {0, 0, 0, {0, 0, 0, 0}, 0, 0, 0} /* Last record is Zero */
};

static const CeosRecipeType_t SIRCRecipe[] = {
    {CEOS_REC_NUMCHANS, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 233, 4,
     CEOS_REC_TYP_I}, /* Number of channels */
    {CEOS_REC_INTERLEAVE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 269, 4,
     CEOS_REC_TYP_A}, /* Interleaving type */
    {CEOS_REC_DATATYPE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 429, 4,
     CEOS_REC_TYP_A}, /* Data type */
    {CEOS_REC_LINES, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 237, 8,
     CEOS_REC_TYP_I}, /* How many lines */
    {CEOS_REC_TBP, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 261, 4, CEOS_REC_TYP_I},
    {CEOS_REC_BBP, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 265, 4,
     CEOS_REC_TYP_I}, /* Bottom border pixels */
    {CEOS_REC_PPL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 249, 8,
     CEOS_REC_TYP_I}, /* Pixels per line */
    {CEOS_REC_LBP, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 245, 4,
     CEOS_REC_TYP_I}, /* Left Border Pixels */
    {CEOS_REC_RBP, 0, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 257, 4,
     CEOS_REC_TYP_I}, /* Right Border Pixels */
    {CEOS_REC_BPP, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 225, 4,
     CEOS_REC_TYP_I}, /* Bytes Per Pixel */
    {CEOS_REC_RPL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 273, 2,
     CEOS_REC_TYP_I}, /* Records per line */
    {CEOS_REC_IDS, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 277, 4,
     CEOS_REC_TYP_I}, /* Prefix data per record */
    {CEOS_REC_FDL, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 9, 4,
     CEOS_REC_TYP_B}, /* Length of Imagry Options Header */
    {CEOS_REC_RECORDSIZE, 1, CEOS_IMAGRY_OPT_FILE, PROC_DATA_REC, 9, 4,
     CEOS_REC_TYP_B}, /* The processed image record size */
    {CEOS_REC_SUFFIX_SIZE, 1, CEOS_IMAGRY_OPT_FILE, IMAGE_OPT, 289, 4,
     CEOS_REC_TYP_I}, /* Suffix data per record */

    {0, 0, 0, {0, 0, 0, 0}, 0, 0, 0} /* Last record is Zero */
};

#undef PROC_DATA_REC

static void ExtractInt(CeosRecord_t *record, int type, unsigned int offset,
                       unsigned int length, int *value);

static char *ExtractString(CeosRecord_t *record, unsigned int offset,
                           unsigned int length, char *string);

static int GetCeosStringType(const CeosStringType_t *CeosType,
                             const char *string);

static int SIRCRecipeFCN(CeosSARVolume_t *volume, const void *token);
static int PALSARRecipeFCN(CeosSARVolume_t *volume, const void *token);

Link_t *RecipeFunctions = NULL;

void RegisterRecipes(void)
{

    AddRecipe(SIRCRecipeFCN, SIRCRecipe, "SIR-C");
    AddRecipe(ScanSARRecipeFCN, ScanSARRecipe, "ScanSAR");
    AddRecipe(CeosDefaultRecipe, RadarSatRecipe, "RadarSat");
    AddRecipe(CeosDefaultRecipe, JersRecipe, "Jers");
    AddRecipe(PALSARRecipeFCN, RadarSatRecipe, "PALSAR-ALOS");
    /*  AddRecipe( CeosDefaultRecipe, AtlantisRecipe ); */
}

void FreeRecipes(void)

{
    Link_t *l_link;

    for (l_link = RecipeFunctions; l_link != NULL; l_link = l_link->next)
        HFree(l_link->object);

    DestroyList(RecipeFunctions);
    RecipeFunctions = NULL;
}

void AddRecipe(int (*function)(CeosSARVolume_t *volume, const void *token),
               const void *token, const char *name)
{

    RecipeFunctionData_t *TempData;

    Link_t *Link;

    TempData = HMalloc(sizeof(RecipeFunctionData_t));

    TempData->function = function;
    TempData->token = token;
    TempData->name = name;

    Link = ceos2CreateLink(TempData);

    if (RecipeFunctions == NULL)
    {
        RecipeFunctions = Link;
    }
    else
    {
        RecipeFunctions = InsertLink(RecipeFunctions, Link);
    }
}

int CeosDefaultRecipe(CeosSARVolume_t *volume, const void *token)
{
    const CeosRecipeType_t *recipe;
    CeosRecord_t *record;
    CeosTypeCode_t TypeCode = {0};
    struct CeosSARImageDesc *ImageDesc = &(volume->ImageDesc);
    char temp_str[1024];
    int i /*, temp_int */;

#define DoExtractInt(a)                                                        \
    ExtractInt(record, recipe[i].Type, recipe[i].Offset, recipe[i].Length, &a)

    if (token == NULL)
    {
        return 0;
    }

    memset(ImageDesc, 0, sizeof(struct CeosSARImageDesc));

    /*    temp_imagerecipe = (CeosSARImageDescRecipe_t *) token;
        recipe = temp_imagerecipe->Recipe; */

    recipe = token;

    for (i = 0; recipe[i].ImageDescValue != 0; i++)
    {
        if (recipe[i].Override)
        {
            TypeCode.UCharCode.Subtype1 = recipe[i].TypeCode.Subtype1;
            TypeCode.UCharCode.Type = recipe[i].TypeCode.Type;
            TypeCode.UCharCode.Subtype2 = recipe[i].TypeCode.Subtype2;
            TypeCode.UCharCode.Subtype3 = recipe[i].TypeCode.Subtype3;

            record = FindCeosRecord(volume->RecordList, TypeCode,
                                    recipe[i].FileId, -1, -1);

            if (record == NULL)
            {
                /* temp_int = 0; */
            }
            else
            {

                switch (recipe[i].ImageDescValue)
                {
                    case CEOS_REC_NUMCHANS:
                        DoExtractInt(ImageDesc->NumChannels);
                        break;
                    case CEOS_REC_LINES:
                        DoExtractInt(ImageDesc->Lines);
                        break;
                    case CEOS_REC_BPP:
                        DoExtractInt(ImageDesc->BytesPerPixel);
                        break;
                    case CEOS_REC_RPL:
                        DoExtractInt(ImageDesc->RecordsPerLine);
                        break;
                    case CEOS_REC_PDBPR:
                        DoExtractInt(ImageDesc->PixelDataBytesPerRecord);
                        break;
                    case CEOS_REC_FDL:
                        DoExtractInt(ImageDesc->FileDescriptorLength);
                        break;
                    case CEOS_REC_IDS:
                        DoExtractInt(ImageDesc->ImageDataStart);
                        /*
                        ** This is really reading the quantity of prefix data
                        ** per data record.  We want the offset from the very
                        ** beginning of the record to the data, so we add
                        *another
                        ** 12 to that.  I think some products incorrectly
                        *indicate
                        ** 192 (prefix+12) instead of 180 so if we see 192
                        *assume
                        ** the 12 bytes of record start data has already been
                        ** added.  Frank Warmerdam.
                        */
                        if (ImageDesc->ImageDataStart != 192)
                            ImageDesc->ImageDataStart += 12;
                        break;
                    case CEOS_REC_SUFFIX_SIZE:
                        DoExtractInt(ImageDesc->ImageSuffixData);
                        break;
                    case CEOS_REC_RECORDSIZE:
                        DoExtractInt(ImageDesc->BytesPerRecord);
                        break;
                    case CEOS_REC_PPL:
                        DoExtractInt(ImageDesc->PixelsPerLine);
                        break;
                    case CEOS_REC_TBP:
                        DoExtractInt(ImageDesc->TopBorderPixels);
                        break;
                    case CEOS_REC_BBP:
                        DoExtractInt(ImageDesc->BottomBorderPixels);
                        break;
                    case CEOS_REC_LBP:
                        DoExtractInt(ImageDesc->LeftBorderPixels);
                        break;
                    case CEOS_REC_RBP:
                        DoExtractInt(ImageDesc->RightBorderPixels);
                        break;
                    case CEOS_REC_INTERLEAVE:
                        ExtractString(record, recipe[i].Offset,
                                      recipe[i].Length, temp_str);

                        ImageDesc->ChannelInterleaving =
                            GetCeosStringType(CeosInterleaveType, temp_str);
                        break;
                    case CEOS_REC_DATATYPE:
                        ExtractString(record, recipe[i].Offset,
                                      recipe[i].Length, temp_str);

                        ImageDesc->DataType =
                            GetCeosStringType(CeosDataType, temp_str);
                        break;
                }
            }
        }
    }

    /* Some files (Telaviv) don't record the number of pixel groups per line.
     * Try to derive it from the size of a data group, and the number of
     * bytes of pixel data if necessary.
     */

    if (ImageDesc->PixelsPerLine == 0 &&
        ImageDesc->PixelDataBytesPerRecord != 0 &&
        ImageDesc->BytesPerPixel != 0)
    {
        ImageDesc->PixelsPerLine =
            ImageDesc->PixelDataBytesPerRecord / ImageDesc->BytesPerPixel;
        CPLDebug("SAR_CEOS", "Guessing PixelPerLine to be %d\n",
                 ImageDesc->PixelsPerLine);
    }

    /* Some files don't have the BytesPerRecord stuff, so we calculate it if
     * possible */

    if (ImageDesc->BytesPerRecord == 0 && ImageDesc->RecordsPerLine == 1 &&
        ImageDesc->PixelsPerLine > 0 && ImageDesc->BytesPerPixel > 0)
    {
        CeosRecord_t *img_rec;

        ImageDesc->BytesPerRecord =
            ImageDesc->PixelsPerLine * ImageDesc->BytesPerPixel +
            ImageDesc->ImageDataStart + ImageDesc->ImageSuffixData;

        TypeCode.UCharCode.Subtype1 = 0xed;
        TypeCode.UCharCode.Type = 0xed;
        TypeCode.UCharCode.Subtype2 = 0x12;
        TypeCode.UCharCode.Subtype3 = 0x12;

        img_rec = FindCeosRecord(volume->RecordList, TypeCode,
                                 CEOS_IMAGRY_OPT_FILE, -1, -1);
        if (img_rec == NULL)
        {
            CPLDebug("SAR_CEOS",
                     "Unable to find imagery rec to check record length.");
            return 0;
        }

        if (img_rec->Length != ImageDesc->BytesPerRecord)
        {
            CPLDebug("SAR_CEOS",
                     "Guessed record length (%d) did not match\n"
                     "actual imagery record length (%d), recipe fails.",
                     ImageDesc->BytesPerRecord, img_rec->Length);
            return 0;
        }
    }

    if (ImageDesc->PixelsPerRecord == 0 && ImageDesc->BytesPerRecord != 0 &&
        ImageDesc->BytesPerPixel != 0)
    {
        ImageDesc->PixelsPerRecord =
            ((ImageDesc->BytesPerRecord -
              (ImageDesc->ImageSuffixData + ImageDesc->ImageDataStart)) /
             ImageDesc->BytesPerPixel);

        if (ImageDesc->PixelsPerRecord > ImageDesc->PixelsPerLine)
            ImageDesc->PixelsPerRecord = ImageDesc->PixelsPerLine;
    }

    /* If we didn't get a data type, try guessing. */
    if (ImageDesc->DataType == 0 && ImageDesc->BytesPerPixel != 0 &&
        ImageDesc->NumChannels != 0)
    {
        int nDataTypeSize = ImageDesc->BytesPerPixel / ImageDesc->NumChannels;

        if (nDataTypeSize == 1)
            ImageDesc->DataType = CEOS_TYP_UCHAR;
        else if (nDataTypeSize == 2)
            ImageDesc->DataType = CEOS_TYP_USHORT;
    }

    /* Sanity checking */

    if (ImageDesc->PixelsPerLine == 0 || ImageDesc->Lines == 0 ||
        ImageDesc->RecordsPerLine == 0 || ImageDesc->ImageDataStart == 0 ||
        ImageDesc->FileDescriptorLength == 0 || ImageDesc->DataType == 0 ||
        ImageDesc->NumChannels == 0 || ImageDesc->BytesPerPixel == 0 ||
        ImageDesc->ChannelInterleaving == 0 || ImageDesc->BytesPerRecord == 0)
    {
        return 0;
    }
    else
    {

        ImageDesc->ImageDescValid = TRUE;
        return 1;
    }
}

int ScanSARRecipeFCN(CeosSARVolume_t *volume, const void *token)
{
    struct CeosSARImageDesc *ImageDesc = &(volume->ImageDesc);

    memset(ImageDesc, 0, sizeof(struct CeosSARImageDesc));

    if (CeosDefaultRecipe(volume, token))
    {
        ImageDesc->Lines *= 2;
        return 1;
    }

    return 0;
}

static int SIRCRecipeFCN(CeosSARVolume_t *volume, const void *token)
{
    struct CeosSARImageDesc *ImageDesc = &(volume->ImageDesc);
    CeosTypeCode_t TypeCode = {0};
    CeosRecord_t *record;
    char szSARDataFormat[29];

    memset(ImageDesc, 0, sizeof(struct CeosSARImageDesc));

    /* -------------------------------------------------------------------- */
    /*      First, we need to check if the "SAR Data Format Type            */
    /*      identifier" is set to "COMPRESSED CROSS-PRODUCTS" which is      */
    /*      pretty idiosyncratic to SIRC products.  It might also appear    */
    /*      for some other similarly encoded Polarimetric data I suppose.    */
    /* -------------------------------------------------------------------- */
    /* IMAGE_OPT */
    TypeCode.UCharCode.Subtype1 = 63;
    TypeCode.UCharCode.Type = 192;
    TypeCode.UCharCode.Subtype2 = 18;
    TypeCode.UCharCode.Subtype3 = 18;

    record = FindCeosRecord(volume->RecordList, TypeCode, CEOS_IMAGRY_OPT_FILE,
                            -1, -1);
    if (record == NULL)
        return 0;

    ExtractString(record, 401, 28, szSARDataFormat);
    if (!STARTS_WITH_CI(szSARDataFormat, "COMPRESSED CROSS-PRODUCTS"))
        return 0;

    /* -------------------------------------------------------------------- */
    /*      Apply normal handling...                                        */
    /* -------------------------------------------------------------------- */
    CeosDefaultRecipe(volume, token);

    /* -------------------------------------------------------------------- */
    /*      Make sure this looks like the SIRC product we are expecting.    */
    /* -------------------------------------------------------------------- */
    if (ImageDesc->BytesPerPixel != 10)
        return 0;

    /* -------------------------------------------------------------------- */
    /*      Then fix up a few values.                                       */
    /* -------------------------------------------------------------------- */
    /* It seems the bytes of pixel data per record is just wrong.  Fix. */
    ImageDesc->PixelDataBytesPerRecord =
        ImageDesc->BytesPerPixel * ImageDesc->PixelsPerLine;

    ImageDesc->DataType = CEOS_TYP_CCP_COMPLEX_FLOAT;

    /* -------------------------------------------------------------------- */
    /*      Sanity checking                                                 */
    /* -------------------------------------------------------------------- */
    if (ImageDesc->PixelsPerLine == 0 || ImageDesc->Lines == 0 ||
        ImageDesc->RecordsPerLine == 0 || ImageDesc->ImageDataStart == 0 ||
        ImageDesc->FileDescriptorLength == 0 || ImageDesc->DataType == 0 ||
        ImageDesc->NumChannels == 0 || ImageDesc->BytesPerPixel == 0 ||
        ImageDesc->ChannelInterleaving == 0 || ImageDesc->BytesPerRecord == 0)
    {
        return 0;
    }
    else
    {
        ImageDesc->ImageDescValid = TRUE;
        return 1;
    }
}

static int PALSARRecipeFCN(CeosSARVolume_t *volume, const void *token)
{
    struct CeosSARImageDesc *ImageDesc = &(volume->ImageDesc);
    CeosTypeCode_t TypeCode = {0};
    CeosRecord_t *record;
    char szSARDataFormat[29], szProduct[32];

    memset(ImageDesc, 0, sizeof(struct CeosSARImageDesc));

    /* -------------------------------------------------------------------- */
    /*      First, we need to check if the "SAR Data Format Type            */
    /*      identifier" is set to "COMPRESSED CROSS-PRODUCTS" which is      */
    /*      pretty idiosyncratic to SIRC products.  It might also appear    */
    /*      for some other similarly encoded Polarimetric data I suppose.    */
    /* -------------------------------------------------------------------- */
    /* IMAGE_OPT */
    TypeCode.UCharCode.Subtype1 = 63;
    TypeCode.UCharCode.Type = 192;
    TypeCode.UCharCode.Subtype2 = 18;
    TypeCode.UCharCode.Subtype3 = 18;

    record = FindCeosRecord(volume->RecordList, TypeCode, CEOS_IMAGRY_OPT_FILE,
                            -1, -1);
    if (record == NULL)
        return 0;

    ExtractString(record, 401, 28, szSARDataFormat);
    if (!STARTS_WITH_CI(szSARDataFormat, "INTEGER*18                 "))
        return 0;

    ExtractString(record, 49, 16, szProduct);
    if (!STARTS_WITH_CI(szProduct, "ALOS-"))
        return 0;

    /* -------------------------------------------------------------------- */
    /*      Apply normal handling...                                        */
    /* -------------------------------------------------------------------- */
    CeosDefaultRecipe(volume, token);

    /* -------------------------------------------------------------------- */
    /*      Make sure this looks like the SIRC product we are expecting.    */
    /* -------------------------------------------------------------------- */
    if (ImageDesc->BytesPerPixel != 18)
        return 0;

    /* -------------------------------------------------------------------- */
    /*      Then fix up a few values.                                       */
    /* -------------------------------------------------------------------- */
    ImageDesc->DataType = CEOS_TYP_PALSAR_COMPLEX_SHORT;
    ImageDesc->NumChannels = 6;

    /* -------------------------------------------------------------------- */
    /*      Sanity checking                                                 */
    /* -------------------------------------------------------------------- */
    if (ImageDesc->PixelsPerLine == 0 || ImageDesc->Lines == 0 ||
        ImageDesc->RecordsPerLine == 0 || ImageDesc->ImageDataStart == 0 ||
        ImageDesc->FileDescriptorLength == 0 || ImageDesc->DataType == 0 ||
        ImageDesc->NumChannels == 0 || ImageDesc->BytesPerPixel == 0 ||
        ImageDesc->ChannelInterleaving == 0 || ImageDesc->BytesPerRecord == 0)
    {
        return 0;
    }
    else
    {
        ImageDesc->ImageDescValid = TRUE;
        return 1;
    }
}

void GetCeosSARImageDesc(CeosSARVolume_t *volume)
{
    Link_t *l_link;
    RecipeFunctionData_t *rec_data;
    int (*function)(CeosSARVolume_t * volume, const void *token);

    if (RecipeFunctions == NULL)
    {
        RegisterRecipes();
    }

    if (RecipeFunctions == NULL)
    {
        return;
    }

    for (l_link = RecipeFunctions; l_link != NULL; l_link = l_link->next)
    {
        if (l_link->object)
        {
            rec_data = l_link->object;
            function = rec_data->function;
            if ((*function)(volume, rec_data->token))
            {
                CPLDebug("CEOS", "Using recipe '%s'.", rec_data->name);
                return;
            }
        }
    }

    return;
}

static void ExtractInt(CeosRecord_t *record, int type, unsigned int offset,
                       unsigned int length, int *value)
{
    void *buffer;
    char format[32];

    buffer = HMalloc(length + 1);

    switch (type)
    {
        case CEOS_REC_TYP_A:
            snprintf(format, sizeof(format), "A%u", length);
            GetCeosField(record, offset, format, buffer);
            *value = atoi(buffer);
            break;
        case CEOS_REC_TYP_B:
            snprintf(format, sizeof(format), "B%u", length);
#ifdef notdef
            GetCeosField(record, offset, format, buffer);
            if (length <= 4)
                CeosToNative(value, buffer, length, length);
            else
                *value = 0;
#else
            GetCeosField(record, offset, format, value);
#endif
            break;
        case CEOS_REC_TYP_I:
            snprintf(format, sizeof(format), "I%u", length);
            GetCeosField(record, offset, format, value);
            break;
    }

    HFree(buffer);
}

static char *ExtractString(CeosRecord_t *record, unsigned int offset,
                           unsigned int length, char *string)
{
    char format[12];

    if (string == NULL)
    {
        string = HMalloc(length + 1);
    }

    snprintf(format, sizeof(format), "A%u", length);

    GetCeosField(record, offset, format, string);

    return string;
}

static int GetCeosStringType(const CeosStringType_t *CeosStringType,
                             const char *string)
{
    int i;

    for (i = 0; CeosStringType[i].String != NULL; i++)
    {
        if (strncmp(CeosStringType[i].String, string,
                    strlen(CeosStringType[i].String)) == 0)
        {
            return CeosStringType[i].Type;
        }
    }

    return 0;
}
