/*-------------------------------------------------------------------------- NAME DFPIopen -- open/reopen file for palette interface USAGE int32 DFPIopen(filename,acc_mode) char *filename; IN: name of HDF file intn acc_mode; IN: type of access to open file with RETURNS HDF file handle on success, FAIL on failure. DESCRIPTION Open/reopen a file for the DFP interface to work with. GLOBAL VARIABLES Refset, Readref, Lastfile COMMENTS, BUGS, ASSUMPTIONS This is a hook for someday providing more efficient ways to reopen a file, to avoid re-reading all the headers EXAMPLES REVISION LOG --------------------------------------------------------------------------*/ PRIVATE int32 DFPIopen(const char *filename, intn acc_mode) { CONSTR(FUNC, "DFPIopen"); int32 file_id; int32 ret_value = SUCCEED; /* use reopen if same file as last time - more efficient */ if (HDstrncmp(Lastfile, filename, DF_MAXFNLEN) || (acc_mode == DFACC_CREATE)) { /* treat create as different file */ if ((file_id = Hopen(filename, acc_mode, 0)) == FAIL) HGOTO_ERROR(DFE_BADOPEN, FAIL); Refset = 0; /* no ref to get set for this file */ Readref = 0; } /* end if */ else if ((file_id = Hopen(filename, acc_mode, 0)) == FAIL) HGOTO_ERROR(DFE_BADOPEN, FAIL); /* remember filename, so reopen may be used next time if same file */ HDstrncpy(Lastfile, filename, DF_MAXFNLEN); ret_value = (file_id); done: if(ret_value == FAIL) { /* Error condition cleanup */ } /* end if */ /* Normal function cleanup */ return ret_value; } /* end DFPIopen() */
int32 getElement(int desc, char **pdata) { int32 length; int32 fid; length = he_desc[desc].length; /* alloc memory to read the element in */ *pdata = (char *) HDmalloc(length); if (*pdata == NULL) return FAIL; /* read in the element and check for error */ if ((fid = Hopen(he_file, DFACC_READ, 0)) == 0) { HEprint(stderr, 0); return FAIL; } if (Hgetelement(fid, he_desc[desc].tag, he_desc[desc].ref, (unsigned char *) (*pdata)) < 0) { HDfree(*pdata); fprintf(stderr, "Cannot read element.\n"); return FAIL; } Hclose(fid); return length; }
/* ** NAME ** DFopen -- open HDF file ** USAGE ** DF *DFopen(name, acc_mode, ndds) ** char* name; IN: name of file to open ** int acc_mode; IN: DFACC_READ, DFACC_WRITE, DFACC_CREATE, ** DFACC_ALL ** int ndds; IN: number of DDs in a block ** RETURNS ** DF ptr to open file on success, NULL on failure with DFerror set ** DESCRIPTION ** Open an HDF file, if it exists. If file does not exist and write ** access requested, create file. ** GLOBAL VARIABLES ** COMMENTS, BUGS, ASSUMPTIONS ** The pointer returned by DFopen is NOT a reference to a DF. It is ** just a place keeper for the new type of file handle. Any program that ** relies on the contents of a DF returned by DFopen must be re-written. ** EXAMPLES ** REVISION LOG */ DF * DFopen(char *name, int acc_mode, int ndds) { if (DFIcheck(DFlist) == 0) { DFerror = DFE_TOOMANY; return (NULL); } else DFerror = DFE_NONE; DFaccmode = acc_mode | DFACC_READ; DFid = Hopen(name, DFaccmode, (int16) ndds); if (DFid == -1) { DFerror = (int)HEvalue(1); return (NULL); } else { /* DFlist = makedf(DFid); */ DFlist = (DF *) & DFid; return (DFlist); } }
static void test_vgisinternal() { int32 fid, vgroup_id; intn is_internal = FALSE; int32 vref = -1; intn ii, status; char testfile[H4_MAX_NC_NAME] = ""; char internal_array2[2] = {TRUE, TRUE}; intn num_errs = 0; /* number of errors so far */ /* Use a GR file to test Vgisinternal on internal vgroups */ /* The file GR_FILE is an existing file in the test_files directory, make_datafilename builds the file name with correct path */ if (make_datafilename(GR_FILE, testfile, H4_MAX_NC_NAME) != FAIL) { /* Open the old GR file and initialize the V interface */ fid = Hopen(testfile, DFACC_READ, 0); CHECK_VOID(fid, FAIL, "Hopen: grtdfui83.hdf"); status = Vstart(fid); CHECK_VOID(status, FAIL, "Vstart"); ii = 0; while ((vref = Vgetid(fid, vref)) != FAIL) { /* until no more vgroups */ vgroup_id = Vattach(fid, vref, "r"); /* attach to vgroup */ /* Test that the current vgroup is or is not internal as specified in the array internal_array2 */ is_internal = Vgisinternal(vgroup_id); CHECK_VOID(is_internal, FAIL, "Vgisinternal"); VERIFY_VOID(is_internal, internal_array2[ii], "Vgisinternal"); status = Vdetach(vgroup_id); CHECK_VOID(status, FAIL, "Vdetach"); ii++; /* increment vgroup index */ } /* Terminate access to the V interface and close the file */ status = Vend(fid); CHECK_VOID(status, FAIL, "Vend"); status = Hclose(fid); CHECK_VOID(status, FAIL, "Hclose"); } else { fprintf(stderr, "ERROR>>> Unable to make filename for %s\n", GR_FILE); H4_FAILED() } } /* test_vgisinternal */
int deleteDesc(int desc) { int32 fid; if ((fid = Hopen(he_file, DFACC_WRITE, 0)) == 0) { HEprint(stderr, 0); return FAIL; } if (Hdeldd(fid, he_desc[desc].tag, he_desc[desc].ref) == FAIL) { HEprint(stderr, 0); return FAIL; } return Hclose(fid); }
/* ** NAME ** DFishdf -- is this an HDF file? ** USAGE ** int DFishdf(filename) ** char *filename; IN: name of file to check ** RETURNS ** 0 if it is an HDF file, -1 if it is not. ** DESCRIPTION ** Determine whether file is an HDF file. ** GLOBAL VARIABLES ** COMMENTS, BUGS, ASSUMPTIONS ** EXAMPLES ** REVISION LOG */ int DFishdf(char *filename) { int32 dummy; DFerror = DFE_NONE; dummy = Hopen(filename, DFACC_READ, 0); if (dummy == -1) { DFerror = (int)HEvalue(1); return (-1); } else { Hclose(dummy); return (0); } }
/****************************************************************************** !Description: 'CreateOuptut' creates a new output file. !Input Parameters: file_name output file name !Output Parameters: (returns) status: 'true' = okay 'false' = error return !Team Unique Header: !Design Notes: *****************************************************************************/ bool CreateOutput(char *file_name, char *input_header, char *output_header) { int32 hdf_file_id; /* Create the file with HDF open */ hdf_file_id = Hopen(file_name, DFACC_CREATE, DEF_NDDS); if (hdf_file_id == HDF_ERROR) { RETURN_ERROR("creating output file", "CreateOutput", false); } /* Close the file */ Hclose(hdf_file_id); // Copy input header file std::ifstream src(input_header); std::ofstream dst(output_header); dst << src.rdbuf(); return true; }
bool CreateOutput(char *file_name) /* !C****************************************************************************** !Description: 'CreateOuptut' creates a new HDF output file. !Input Parameters: file_name output file name !Output Parameters: (returns) status: 'true' = okay 'false' = error return !Team Unique Header: ! Design Notes: 1. An error status is returned when: a. the creation of the output file failes. 2. Error messages are handled with the 'LOG_RETURN_ERROR' macro. 3. The output file is in HDF format and closed after it is created. !END**************************************************************************** */ { int32 hdf_file_id; /* Create the file with HDF open */ hdf_file_id = Hopen(file_name, DFACC_CREATE, DEF_NDDS); if(hdf_file_id == HDF_ERROR) { LOG_RETURN_ERROR("creating output file", "CreateOutput", false); } /* Close the file */ Hclose(hdf_file_id); return true; }
int list_main(const char* infname, const char* outfname, options_t *options) { list_table_t *list_tbl=NULL; /* list of objects */ dim_table_t *td1=NULL; /* dimensions */ dim_table_t *td2=NULL; /* dimensions */ int32 sd_id=FAIL, /* SD interface identifier */ sd_out=FAIL, /* SD interface identifier */ gr_id=FAIL, /* GR interface identifier */ gr_out=FAIL, /* GR interface identifier */ infile_id=FAIL, outfile_id=FAIL; int i; const char* err; /*------------------------------------------------------------------------- * initialize tables *------------------------------------------------------------------------- */ list_table_init(&list_tbl); dim_table_init(&td1); dim_table_init(&td2); /*------------------------------------------------------------------------- * open the input file for read and initialize interfaces *------------------------------------------------------------------------- */ if ((infile_id = Hopen (infname,DFACC_READ,(int16)0))==FAIL) { printf("Cannot open file <%s>\n",infname); goto out; } if ((sd_id = SDstart (infname, DFACC_READ))==FAIL) { printf( "Could not start SD for <%s>\n",infname); goto out; } if ((gr_id = GRstart (infile_id))==FAIL) { printf( "Could not start GR for <%s>\n",infname); goto out; } /*------------------------------------------------------------------------- * create the output file and initialize interfaces *------------------------------------------------------------------------- */ if ( options->trip==1 ) { if ((outfile_id = Hopen (outfname,DFACC_CREATE,(int16)0))==FAIL) { printf("Cannot create file <%s>\n",outfname); goto out; } if ((sd_out = SDstart (outfname, DFACC_WRITE))==FAIL) { printf( "Could not start GR for <%s>\n",outfname); goto out; } if ((gr_out = GRstart (outfile_id))==FAIL) { printf( "Could not start GR for <%s>\n",outfname); goto out; } } /* options->trip==1 */ if (options->verbose && options->trip==0) printf("Building list of objects in %s...\n",infname); /*------------------------------------------------------------------------- * iterate tru HDF interfaces *------------------------------------------------------------------------- */ if (options->verbose) { printf("-----------------------------------------------\n"); printf(" Chunk Filter(compression) Name\n"); printf("-----------------------------------------------\n"); } if (list_vg (infile_id,outfile_id,sd_id,sd_out,gr_id,gr_out,list_tbl,td1,td2,options)<0) goto out; if (list_gr (infile_id,outfile_id,gr_id,gr_out,list_tbl,options)<0) goto out; if (list_sds(infile_id,outfile_id,sd_id,sd_out,list_tbl,td1,td2,options)<0) goto out; if (list_vs (infile_id,outfile_id,list_tbl,options)<0) goto out; if (list_glb(infile_id,outfile_id,sd_id,sd_out,gr_id,gr_out,list_tbl,options)<0) goto out; if (list_pal(infname,outfname,list_tbl,options)<0) goto out; if (list_an (infile_id,outfile_id,options)<0) goto out; if ( options->trip==1 ) { match_dim(sd_id,sd_out,td1,td2,options); } /*------------------------------------------------------------------------- * check for objects in the file table: * 1) the input object names are present in the file * 2) they are valid objects (SDS or GR) * check only if selected objects are given (all==0) *------------------------------------------------------------------------- */ if ( options->trip==0 ) { if (options->verbose) printf("Searching for objects to modify...\n"); for ( i = 0; i < options->op_tbl->nelems; i++) { char* obj_name=options->op_tbl->objs[i].objpath; if (options->verbose) printf(PFORMAT1,"","",obj_name); /* the input object names are present in the file and are valid */ err=list_table_check(list_tbl,obj_name); if (err!=NULL) { printf("\nError: <%s> %s in file <%s>. Exiting...\n",obj_name,err,infname); goto out; } if (options->verbose) printf("...Found\n"); } } /*------------------------------------------------------------------------- * close interfaces *------------------------------------------------------------------------- */ if (GRend (gr_id)==FAIL) printf( "Failed to close GR interface <%s>\n", infname); if (SDend (sd_id)==FAIL) printf( "Failed to close file <%s>\n", infname); if (Hclose (infile_id)==FAIL) printf( "Failed to close file <%s>\n", infname); if ( options->trip==1 ) { if (GRend (gr_out)==FAIL) printf( "Failed to close GR interface <%s>\n", outfname); if (SDend (sd_out)==FAIL) printf( "Failed to close file <%s>\n", outfname); if (Hclose (outfile_id)==FAIL) printf( "Failed to close file <%s>\n", outfname); } /*------------------------------------------------------------------------- * free tables *------------------------------------------------------------------------- */ list_table_free(list_tbl); dim_table_free(td1); dim_table_free(td2); return SUCCEED; out: if (list_tbl!=NULL) list_table_free(list_tbl); if (td1!=NULL) dim_table_free(td1); if (td2!=NULL) dim_table_free(td2); if (gr_id!=FAIL) { if (GRend (gr_id)==FAIL) printf( "Failed to close GR interface <%s>\n", infname); } if (gr_out!=FAIL) { if (GRend (gr_out)==FAIL) printf( "Failed to close GR interface <%s>\n", outfname); } if (sd_id!=FAIL) { if (SDend (sd_id)==FAIL) printf( "Failed to close SD interface for <%s>\n", infname); } if (sd_out!=FAIL) { if (SDend (sd_out)==FAIL) printf( "Failed to close SD interface for <%s>\n", outfname); } if (infile_id!=FAIL) { if (Hclose (infile_id)==FAIL) printf( "Failed to close file <%s>\n", infname); } if (outfile_id!=FAIL) { if (Hclose (outfile_id)==FAIL) printf( "Failed to close file <%s>\n", outfname); } return FAIL; }
int main(int argc, char *argv[]) { int32 infile, aid, ret; char *filename; char datafilename[DF_MAXFNLEN]; uint16 tag; uint16 ref; int32 offset, fileoffset; int32 length; int16 special; /* Get invocation name of program */ progname = *argv++; argc--; /* parse arguments */ while (argc > 0 && **argv == '-') { switch ((*argv)[1]) { case 'd': argc--; argv++; if (argc > 0) { strcpy(datafilename, *argv++); argc--; } else { usage(); exit(1); } break; default: usage(); exit(1); } } if (argc == 1) { filename = *argv++; argc--; } else { usage(); exit(1); } if (datafilename[0] == '\0') strcpy(datafilename, DefaultDatafile); /* Check to make sure input file is HDF */ ret = (int) Hishdf(filename); if (ret == FALSE) { error("given file is not an HDF file\n"); } /* check if datafile already exists. If so, set offset to its length. */ { struct stat buf; if (stat(datafilename, &buf) == 0) { printf("External file %s already exists. Using append mode.\n", datafilename); fileoffset = (int32)buf.st_size; } else fileoffset = 0; } /* Open HDF file */ infile = Hopen(filename, DFACC_RDWR, 0); if (infile == FAIL) { error("Can't open the HDF file\n"); } /* Process the file */ ret = aid = Hstartread(infile, DFTAG_SD, DFREF_WILDCARD); while (ret != FAIL) { /* * Get data about the current one */ ret = Hinquire(aid, NULL, &tag, &ref, &length, &offset, NULL, NULL, &special); /* check the tag value since external element object are returned the same. */ if (tag == DFTAG_SD) { printf("moving Scientific Data (%d,%d) to %s\n", tag, ref, datafilename); ret = HXcreate(infile, tag, ref, datafilename, fileoffset, length); fileoffset += length; } /* * Move to the next one */ ret = Hnextread(aid, DFTAG_SD, DFREF_WILDCARD, DF_CURRENT); } /* * Close the access element */ ret = Hendaccess(aid); if (ret == FAIL) hdferror(); /* done; close files */ Hclose(infile); return (0); }
void main(void) { char vdata_name[MAX_NC_NAME], vdata_class[MAX_NC_NAME]; char fields[60]; int32 file_id, vdata_id, istat; int32 n_records, interlace, vdata_size, vdata_ref; int bufsz = (2 * sizeof(float32) + sizeof(char) \ + sizeof(int16)) * NRECORDS; int i; uint8 databuf[((2 * sizeof(float32)) + sizeof(char) \ + sizeof(int16)) * NRECORDS]; VOIDP fldbufptrs[4]; float32 itemp[NRECORDS], ispeed[NRECORDS]; int16 iheight[NRECORDS]; char idents[NRECORDS]; /* Open the HDF file. */ file_id = Hopen("VD_Ex4.hdf", DFACC_READ, 0); /* Initialize the Vset interface. */ istat = Vstart(file_id); /* * Get the reference number for the first Vdata in * the file. */ vdata_ref = -1; vdata_ref = VSgetid(file_id, vdata_ref); /* Attach to the first Vdata in read mode. */ vdata_id = VSattach(file_id, vdata_ref, "r"); for (i=0; i<60; i++) fields[i] = '\0'; /* Get the list of field names. */ istat =VSinquire(vdata_id, &n_records, &interlace, fields, &vdata_size, vdata_name); printf("files: %s, n_records: %d, vdata_size: %d\n", fields, n_records, vdata_size); /* Get the class. */ istat = VSgetclass(vdata_id, vdata_class); /* Determine the fields that will be read. */ istat = VSsetfields(vdata_id, fields); /* Print the Vdata information. */ printf("Current Vdata name: %s \nCurrent Vdata class: %s.\n", vdata_name, vdata_class); /* Read the data. */ istat = VSread(vdata_id, (VOIDP)databuf, n_records, FULL_INTERLACE); /* set fldbufptrs and unpack field values */ fldbufptrs[0] = &idents[0]; fldbufptrs[1] = &ispeed[0]; fldbufptrs[2] = &iheight[0]; fldbufptrs[3] = &itemp[0]; istat = VSfpack(vdata_id, _HDF_VSUNPACK, fields, databuf, bufsz, n_records, "Ident,Speed,Height,Temp", fldbufptrs); printf(" Temp Height Speed Ident\n"); for (i=0; i < n_records; i++) { printf(" %6.2f %6d %6.2f %c\n", itemp[i],iheight[i],ispeed[i],idents[i]); } /* Detach from the Vdata, close the interface and the file. */ istat = VSdetach(vdata_id); istat = Vend(file_id); istat = Hclose(file_id); }
int updateDesc(void) { int32 fid; int32 groupID; int32 aid, status; int i, j; if ((fid = Hopen(he_file, DFACC_READ, 0)) == 0) { printf("failed opening\n"); HEprint(stdout, 0); return FAIL; } aid = Hstartread(fid, DFTAG_WILDCARD, DFREF_WILDCARD); if (aid == FAIL) { HEprint(stderr, 0); return FAIL; } status = SUCCEED; for (i = 0; (i < HE_DESC_SZ) && (status != FAIL); i++) { Hinquire(aid, NULL, &he_desc[i].tag, &he_desc[i].ref, &he_desc[i].length, &he_desc[i].offset, NULL, (int16 *) NULL, (int16 *) NULL); status = Hnextread(aid, DFTAG_WILDCARD, DFREF_WILDCARD, DF_CURRENT); } he_numDesc = i; /* get informations about the groups */ he_numGrp = 0; for (i = 0; i < he_numDesc; i++) { if (isGrp(he_desc[i].tag)) { he_grp[he_numGrp].desc = i; /* he_grp[he_numGrp].size = (int) (he_desc[i].length / sizeof(tag_ref)); he_grp[he_numGrp].ddList = (tag_ref_ptr) HDmalloc(he_desc[i].length); */ he_grp[he_numGrp].size = (int) (he_desc[i].length / 4); he_grp[he_numGrp].ddList = (tag_ref_ptr) HDmalloc(he_grp[he_numGrp].size*sizeof(tag_ref)); if (!he_grp[he_numGrp].ddList) { fprintf(stderr, "Out of memory. Closing file.\n"); closeFile(1); /* keep the backup */ return FAIL; } groupID = DFdiread(fid, he_desc[i].tag, he_desc[i].ref); if (groupID < 0) { HEprint(stderr, 0); return FAIL; } for (j = 0; j < he_grp[he_numGrp].size; j++) DFdiget(groupID, &he_grp[he_numGrp].ddList[j].tag, &he_grp[he_numGrp].ddList[j].ref); he_numGrp++; } } Hendaccess(aid); Hclose(fid); return SUCCEED; }
GDALDataset *HDF4Dataset::Open( GDALOpenInfo * poOpenInfo ) { if( !Identify( poOpenInfo ) ) return NULL; CPLMutexHolderD(&hHDF4Mutex); /* -------------------------------------------------------------------- */ /* Try opening the dataset. */ /* -------------------------------------------------------------------- */ // Attempt to increase maximum number of opened HDF files. #ifdef HDF4_HAS_MAXOPENFILES intn nCurrMax = 0; intn nSysLimit = 0; if ( SDget_maxopenfiles(&nCurrMax, &nSysLimit) >= 0 && nCurrMax < nSysLimit ) { /*intn res = */SDreset_maxopenfiles( nSysLimit ); } #endif /* HDF4_HAS_MAXOPENFILES */ int32 hHDF4 = Hopen(poOpenInfo->pszFilename, DFACC_READ, 0); if( hHDF4 <= 0 ) return NULL; Hclose( hHDF4 ); /* -------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* -------------------------------------------------------------------- */ // Release mutex otherwise we will deadlock with GDALDataset own mutex. CPLReleaseMutex(hHDF4Mutex); HDF4Dataset *poDS = new HDF4Dataset(); CPLAcquireMutex(hHDF4Mutex, 1000.0); if( poOpenInfo->fpL != NULL ) { VSIFCloseL(poOpenInfo->fpL); poOpenInfo->fpL = NULL; } /* -------------------------------------------------------------------- */ /* Open HDF SDS Interface. */ /* -------------------------------------------------------------------- */ poDS->hSD = SDstart( poOpenInfo->pszFilename, DFACC_READ ); if ( poDS->hSD == -1 ) { // Release mutex otherwise we will deadlock with GDALDataset own mutex. CPLReleaseMutex(hHDF4Mutex); delete poDS; CPLAcquireMutex(hHDF4Mutex, 1000.0); CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open HDF4 file \"%s\" for SDS reading.", poOpenInfo->pszFilename ); return NULL; } /* -------------------------------------------------------------------- */ /* Now read Global Attributes. */ /* -------------------------------------------------------------------- */ if ( poDS->ReadGlobalAttributes( poDS->hSD ) != CE_None ) { // Release mutex otherwise we will deadlock with GDALDataset own mutex. CPLReleaseMutex(hHDF4Mutex); delete poDS; CPLAcquireMutex(hHDF4Mutex, 1000.0); CPLError( CE_Failure, CPLE_OpenFailed, "Failed to read global attributes from HDF4 file \"%s\".", poOpenInfo->pszFilename ); return NULL; } poDS->SetMetadata( poDS->papszGlobalMetadata, "" ); /* -------------------------------------------------------------------- */ /* Determine type of file we read. */ /* -------------------------------------------------------------------- */ const char *pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "Signature"); if ( pszValue != NULL && EQUAL( pszValue, pszGDALSignature ) ) { poDS->iSubdatasetType = H4ST_GDAL; poDS->pszSubdatasetType = "GDAL_HDF4"; } else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "Title")) != NULL && EQUAL( pszValue, "SeaWiFS Level-1A Data" ) ) { poDS->iSubdatasetType = H4ST_SEAWIFS_L1A; poDS->pszSubdatasetType = "SEAWIFS_L1A"; } else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "Title")) != NULL && EQUAL( pszValue, "SeaWiFS Level-2 Data" ) ) { poDS->iSubdatasetType = H4ST_SEAWIFS_L2; poDS->pszSubdatasetType = "SEAWIFS_L2"; } else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "Title")) != NULL && EQUAL( pszValue, "SeaWiFS Level-3 Standard Mapped Image" ) ) { poDS->iSubdatasetType = H4ST_SEAWIFS_L3; poDS->pszSubdatasetType = "SEAWIFS_L3"; } else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "L1 File Generated By")) != NULL && STARTS_WITH_CI(pszValue, "HYP version ") ) { poDS->iSubdatasetType = H4ST_HYPERION_L1; poDS->pszSubdatasetType = "HYPERION_L1"; } else { poDS->iSubdatasetType = H4ST_UNKNOWN; poDS->pszSubdatasetType = "UNKNOWN"; } /* -------------------------------------------------------------------- */ /* If we have HDF-EOS dataset, process it here. */ /* -------------------------------------------------------------------- */ int32 aiDimSizes[H4_MAX_VAR_DIMS] = {}; // TODO: Get this off of the stack. int32 iRank = 0; int32 iNumType = 0; int32 nAttrs = 0; bool bIsHDF = true; // Sometimes "HDFEOSVersion" attribute is not defined and we will // determine HDF-EOS datasets using other records // (see ReadGlobalAttributes() method). if ( poDS->bIsHDFEOS || CSLFetchNameValue(poDS->papszGlobalMetadata, "HDFEOSVersion") ) { /* -------------------------------------------------------------------- */ /* Process swath layers. */ /* -------------------------------------------------------------------- */ hHDF4 = SWopen( poOpenInfo->pszFilename, DFACC_READ ); if( hHDF4 < 0) { // Release mutex otherwise we will deadlock with GDALDataset own // mutex. CPLReleaseMutex(hHDF4Mutex); delete poDS; CPLAcquireMutex(hHDF4Mutex, 1000.0); CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open HDF-EOS file \"%s\" for swath reading.", poOpenInfo->pszFilename ); return NULL; } int32 nStrBufSize = 0; int32 nSubDatasets = SWinqswath(poOpenInfo->pszFilename, NULL, &nStrBufSize); #ifdef DEBUG CPLDebug( "HDF4", "Number of HDF-EOS swaths: %d", static_cast<int>( nSubDatasets ) ); #endif if ( nSubDatasets > 0 && nStrBufSize > 0 ) { char *pszSwathList = static_cast<char *>( CPLMalloc( nStrBufSize + 1 ) ); SWinqswath( poOpenInfo->pszFilename, pszSwathList, &nStrBufSize ); pszSwathList[nStrBufSize] = '\0'; #ifdef DEBUG CPLDebug( "HDF4", "List of HDF-EOS swaths: %s", pszSwathList ); #endif char **papszSwaths = CSLTokenizeString2( pszSwathList, ",", CSLT_HONOURSTRINGS ); CPLFree( pszSwathList ); if ( nSubDatasets != CSLCount(papszSwaths) ) { CSLDestroy( papszSwaths ); // Release mutex otherwise we will deadlock with GDALDataset own // mutex. CPLReleaseMutex(hHDF4Mutex); delete poDS; CPLAcquireMutex(hHDF4Mutex, 1000.0); CPLDebug( "HDF4", "Cannot parse list of HDF-EOS grids." ); return NULL; } for( int32 i = 0; i < nSubDatasets; i++) { const int32 hSW = SWattach( hHDF4, papszSwaths[i] ); const int32 nFields = SWnentries( hSW, HDFE_NENTDFLD, &nStrBufSize ); char *pszFieldList = static_cast<char *>( CPLMalloc( nStrBufSize + 1 ) ); int32 *paiRank = static_cast<int32 *>( CPLMalloc( nFields * sizeof(int32) ) ); int32 *paiNumType = static_cast<int32 *>( CPLMalloc( nFields * sizeof(int32) ) ); SWinqdatafields( hSW, pszFieldList, paiRank, paiNumType ); #ifdef DEBUG { char * const pszTmp = SPrintArray( GDT_UInt32, paiRank, nFields, "," ); CPLDebug( "HDF4", "Number of data fields in swath %d: %d", static_cast<int>( i ), static_cast<int>( nFields ) ); CPLDebug( "HDF4", "List of data fields in swath %d: %s", static_cast<int>( i ), pszFieldList ); CPLDebug( "HDF4", "Data fields ranks: %s", pszTmp ); CPLFree( pszTmp ); } #endif char **papszFields = CSLTokenizeString2( pszFieldList, ",", CSLT_HONOURSTRINGS ); char szTemp[256] = {'\0'}; // TODO: Get this off the stack. for( int32 j = 0; j < nFields; j++ ) { SWfieldinfo( hSW, papszFields[j], &iRank, aiDimSizes, &iNumType, NULL ); if ( iRank < 2 ) continue; // Add field to the list of GDAL subdatasets. const int nCount = CSLCount( poDS->papszSubDatasets ) / 2; snprintf( szTemp, sizeof(szTemp), "SUBDATASET_%d_NAME", nCount + 1 ); // We will use the field index as an identificator. poDS->papszSubDatasets = CSLSetNameValue( poDS->papszSubDatasets, szTemp, CPLSPrintf("HDF4_EOS:EOS_SWATH:\"%s\":%s:%s", poOpenInfo->pszFilename, papszSwaths[i], papszFields[j]) ); snprintf( szTemp, sizeof(szTemp), "SUBDATASET_%d_DESC", nCount + 1 ); char *pszString = SPrintArray( GDT_UInt32, aiDimSizes, iRank, "x" ); poDS->papszSubDatasets = CSLSetNameValue( poDS->papszSubDatasets, szTemp, CPLSPrintf( "[%s] %s %s (%s)", pszString, papszFields[j], papszSwaths[i], poDS->GetDataTypeName(iNumType) ) ); CPLFree( pszString ); szTemp[0] = '\0'; } CSLDestroy( papszFields ); CPLFree( paiNumType ); CPLFree( paiRank ); CPLFree( pszFieldList ); SWdetach( hSW ); } CSLDestroy( papszSwaths ); } SWclose( hHDF4 ); /* -------------------------------------------------------------------- */ /* Process grid layers. */ /* -------------------------------------------------------------------- */ hHDF4 = GDopen( poOpenInfo->pszFilename, DFACC_READ ); nSubDatasets = GDinqgrid( poOpenInfo->pszFilename, NULL, &nStrBufSize ); #ifdef DEBUG CPLDebug( "HDF4", "Number of HDF-EOS grids: %d", static_cast<int>( nSubDatasets ) ); #endif if ( nSubDatasets > 0 && nStrBufSize > 0 ) { char *pszGridList = static_cast<char *>( CPLMalloc( nStrBufSize + 1 ) ); GDinqgrid( poOpenInfo->pszFilename, pszGridList, &nStrBufSize ); #ifdef DEBUG CPLDebug( "HDF4", "List of HDF-EOS grids: %s", pszGridList ); #endif char **papszGrids = CSLTokenizeString2( pszGridList, ",", CSLT_HONOURSTRINGS ); CPLFree( pszGridList ); if ( nSubDatasets != CSLCount(papszGrids) ) { CSLDestroy( papszGrids ); GDclose( hHDF4 ); // Release mutex otherwise we will deadlock with GDALDataset own // mutex. CPLReleaseMutex(hHDF4Mutex); delete poDS; CPLAcquireMutex(hHDF4Mutex, 1000.0); CPLDebug( "HDF4", "Cannot parse list of HDF-EOS grids." ); return NULL; } for( int32 i = 0; i < nSubDatasets; i++) { const int32 hGD = GDattach( hHDF4, papszGrids[i] ); const int32 nFields = GDnentries( hGD, HDFE_NENTDFLD, &nStrBufSize ); char *pszFieldList = static_cast<char *>( CPLMalloc( nStrBufSize + 1 ) ); int32 *paiRank = static_cast<int32 *>( CPLMalloc( nFields * sizeof(int32) ) ); int32 *paiNumType = static_cast<int32 *>( CPLMalloc( nFields * sizeof(int32) ) ); GDinqfields( hGD, pszFieldList, paiRank, paiNumType ); #ifdef DEBUG { char* pszTmp = SPrintArray( GDT_UInt32, paiRank, nFields, "," ); CPLDebug( "HDF4", "Number of fields in grid %d: %d", static_cast<int>( i ), static_cast<int>( nFields ) ); CPLDebug( "HDF4", "List of fields in grid %d: %s", static_cast<int>( i ), pszFieldList ); CPLDebug( "HDF4", "Fields ranks: %s", pszTmp ); CPLFree( pszTmp ); } #endif char **papszFields = CSLTokenizeString2( pszFieldList, ",", CSLT_HONOURSTRINGS ); char szTemp[256]; for( int32 j = 0; j < nFields; j++ ) { GDfieldinfo( hGD, papszFields[j], &iRank, aiDimSizes, &iNumType, NULL ); if ( iRank < 2 ) continue; // Add field to the list of GDAL subdatasets const int nCount = CSLCount( poDS->papszSubDatasets ) / 2; snprintf( szTemp, sizeof(szTemp), "SUBDATASET_%d_NAME", nCount + 1 ); // We will use the field index as an identificator. poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets, szTemp, CPLSPrintf( "HDF4_EOS:EOS_GRID:\"%s\":%s:%s", poOpenInfo->pszFilename, papszGrids[i], papszFields[j])); snprintf( szTemp, sizeof(szTemp), "SUBDATASET_%d_DESC", nCount + 1 ); char *pszString = SPrintArray( GDT_UInt32, aiDimSizes, iRank, "x" ); poDS->papszSubDatasets = CSLSetNameValue( poDS->papszSubDatasets, szTemp, CPLSPrintf("[%s] %s %s (%s)", pszString, papszFields[j], papszGrids[i], poDS->GetDataTypeName(iNumType)) ); CPLFree( pszString ); } CSLDestroy( papszFields ); CPLFree( paiNumType ); CPLFree( paiRank ); CPLFree( pszFieldList ); GDdetach( hGD ); } CSLDestroy( papszGrids ); } GDclose( hHDF4 ); bIsHDF = ( nSubDatasets == 0 ); // Try to read as HDF } char szName[VSNAMELENMAX + 1]; if( bIsHDF ) { /* -------------------------------------------------------------------- */ /* Make a list of subdatasets from SDSs contained in input HDF file. */ /* -------------------------------------------------------------------- */ int32 nDatasets = 0; if ( SDfileinfo( poDS->hSD, &nDatasets, &nAttrs ) != 0 ) return NULL; char szTemp[256] = {'\0'}; // TODO: Get this off the stack. const char *pszName = NULL; for( int32 i = 0; i < nDatasets; i++ ) { const int32 iSDS = SDselect( poDS->hSD, i ); if ( SDgetinfo( iSDS, szName, &iRank, aiDimSizes, &iNumType, &nAttrs) != 0 ) return NULL; if ( iRank == 1 ) // Skip 1D datsets continue; // Do sort of known datasets. We will display only image bands if ( (poDS->iSubdatasetType == H4ST_SEAWIFS_L1A ) && !STARTS_WITH_CI(szName, "l1a_data") ) continue; else pszName = szName; // Add datasets with multiple dimensions to the list of GDAL // subdatasets. const int nCount = CSLCount( poDS->papszSubDatasets ) / 2; snprintf( szTemp, sizeof(szTemp), "SUBDATASET_%d_NAME", nCount + 1 ); // We will use SDS index as an identificator, because SDS names // are not unique. Filename also needed for further file opening poDS->papszSubDatasets = CSLSetNameValue( poDS->papszSubDatasets, szTemp, CPLSPrintf( "HDF4_SDS:%s:\"%s\":%ld", poDS->pszSubdatasetType, poOpenInfo->pszFilename, static_cast<long>( i ) ) ); snprintf( szTemp, sizeof(szTemp), "SUBDATASET_%d_DESC", nCount + 1 ); char *pszString = SPrintArray( GDT_UInt32, aiDimSizes, iRank, "x" ); poDS->papszSubDatasets = CSLSetNameValue( poDS->papszSubDatasets, szTemp, CPLSPrintf( "[%s] %s (%s)", pszString, pszName, poDS->GetDataTypeName(iNumType)) ); CPLFree( pszString ); SDendaccess( iSDS ); szTemp[0] = '\0'; } SDend( poDS->hSD ); poDS->hSD = 0; } /* -------------------------------------------------------------------- */ /* Build a list of raster images. Note, that HDF-EOS dataset may */ /* contain a raster image as well. */ /* -------------------------------------------------------------------- */ hHDF4 = Hopen(poOpenInfo->pszFilename, DFACC_READ, 0); poDS->hGR = GRstart( hHDF4 ); if ( poDS->hGR != -1 ) { if ( GRfileinfo( poDS->hGR, &poDS->nImages, &nAttrs ) == -1 ) { // Release mutex otherwise we will deadlock with GDALDataset own // mutex. CPLReleaseMutex(hHDF4Mutex); GRend( poDS->hGR ); poDS->hGR = 0; Hclose( hHDF4 ); delete poDS; CPLAcquireMutex(hHDF4Mutex, 1000.0); return NULL; } char szTemp[256] = {'\0'}; // TODO: Get this off the stack. for( int32 i = 0; i < poDS->nImages; i++ ) { const int32 iGR = GRselect( poDS->hGR, i ); // iRank in GR interface has another meaning. It represents number // of samples per pixel. aiDimSizes has only two dimensions. int32 iInterlaceMode = 0; if ( GRgetiminfo( iGR, szName, &iRank, &iNumType, &iInterlaceMode, aiDimSizes, &nAttrs ) != 0 ) { // Release mutex otherwise we will deadlock with GDALDataset // own mutex. CPLReleaseMutex(hHDF4Mutex); GRend( poDS->hGR ); poDS->hGR = 0; Hclose( hHDF4 ); delete poDS; CPLAcquireMutex(hHDF4Mutex, 1000.0); return NULL; } const int nCount = CSLCount( poDS->papszSubDatasets ) / 2; snprintf( szTemp, sizeof(szTemp), "SUBDATASET_%d_NAME", nCount + 1 ); poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets, szTemp,CPLSPrintf( "HDF4_GR:UNKNOWN:\"%s\":%ld", poOpenInfo->pszFilename, static_cast<long>( i ) ) ); snprintf( szTemp, sizeof(szTemp), "SUBDATASET_%d_DESC", nCount + 1 ); char *pszString = SPrintArray( GDT_UInt32, aiDimSizes, 2, "x" ); poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets, szTemp, CPLSPrintf( "[%sx%ld] %s (%s)", pszString, static_cast<long>( iRank ), szName, poDS->GetDataTypeName(iNumType)) ); CPLFree( pszString ); GRendaccess( iGR ); szTemp[0] = '\0'; } GRend( poDS->hGR ); poDS->hGR = 0; } Hclose( hHDF4 ); poDS->nRasterXSize = poDS->nRasterYSize = 512; // XXX: bogus values // Make sure we don't try to do any pam stuff with this dataset. poDS->nPamFlags |= GPF_NOSAVE; /* -------------------------------------------------------------------- */ /* If we have single subdataset only, open it immediately */ /* -------------------------------------------------------------------- */ if ( CSLCount( poDS->papszSubDatasets ) / 2 == 1 ) { char *pszSDSName = CPLStrdup( CSLFetchNameValue( poDS->papszSubDatasets, "SUBDATASET_1_NAME" )); // Release mutex otherwise we will deadlock with GDALDataset own mutex. CPLReleaseMutex(hHDF4Mutex); delete poDS; poDS = NULL; GDALDataset* poRetDS = reinterpret_cast<GDALDataset*>( GDALOpen( pszSDSName, poOpenInfo->eAccess ) ); CPLFree( pszSDSName ); CPLAcquireMutex(hHDF4Mutex, 1000.0); if (poRetDS) { poRetDS->SetDescription(poOpenInfo->pszFilename); } return poRetDS; } else { /* -------------------------------------------------------------------- */ /* Confirm the requested access is supported. */ /* -------------------------------------------------------------------- */ if( poOpenInfo->eAccess == GA_Update ) { // Release mutex otherwise we will deadlock with GDALDataset own // mutex. CPLReleaseMutex(hHDF4Mutex); delete poDS; CPLAcquireMutex(hHDF4Mutex, 1000.0); CPLError( CE_Failure, CPLE_NotSupported, "The HDF4 driver does not support update access to " "existing datasets." ); return NULL; } } return poDS; }
int main( ) { /************************* Variable declaration **************************/ intn status_n; /* returned status for functions returning an intn */ int32 status_32, /* returned status for functions returning an int32 */ file_id, vgroup_id, vgroup_ref, vdata_id, vdata_ref, num_of_records, num_of_vals_per_rec, record_pos, obj_index, /* index of an object within a vgroup */ num_of_pairs, /* number of tag/ref number pairs, i.e., objects */ obj_tag, obj_ref, /* tag/ref number of an HDF object */ vgroup_pos = 0; /* position of a vgroup in the file */ float32 databuf[N_RECORDS][N_VALS_PER_REC]; int16 rec_num; /********************** End of variable declaration ***********************/ char FIELDNAME_LIST[MAX_FIELDNAME_LIST_LENGTH]; memset(FIELDNAME_LIST, 0x00, MAX_FIELDNAME_LIST_LENGTH); int i; for (i = 0; i < N_VALS_PER_REC; i++) { char buffer[256]; if (i == 0) { sprintf(buffer, "%d", i); } else { sprintf(buffer, " %d", i); } strcat(FIELDNAME_LIST, buffer); } file_id = Hopen (FILE_NAME, DFACC_READ, 0); status_n = Vstart (file_id); vgroup_ref = -1; vgroup_ref = Vgetid (file_id, vgroup_ref); if (vgroup_ref == -1) exit(1); vgroup_ref = Vgetid (file_id, vgroup_ref); if (vgroup_ref == -1) exit(1); vgroup_id = Vattach (file_id, vgroup_ref, "r"); num_of_pairs = Vntagrefs (vgroup_id); if (num_of_pairs > 0) { printf ("\nVgroup #%d contains:\n", vgroup_pos); for (obj_index = 0; obj_index < num_of_pairs; obj_index++) { status_n = Vgettagref (vgroup_id, obj_index, &obj_tag, &obj_ref); printf ("tag = %d, ref = %d", obj_tag, obj_ref); if (Visvg (vgroup_id, obj_ref)) printf (" <-- is a vgroup\n"); else if (Visvs (vgroup_id, obj_ref)) { printf (" <-- is a vdata\n"); vdata_ref = VSfind (file_id, VDATA_NAME); vdata_id = VSattach (file_id, vdata_ref, "r"); status_n = VSsetfields (vdata_id, FIELDNAME_LIST); record_pos = VSseek (vdata_id, RECORD_INDEX); num_of_records = VSread (vdata_id, (uint8 *)databuf, N_RECORDS, FULL_INTERLACE); for (rec_num = 0; rec_num < num_of_records; rec_num++) { for (num_of_vals_per_rec = 0; num_of_vals_per_rec < N_VALS_PER_REC; num_of_vals_per_rec++) { printf ("%6.2f\n", databuf[rec_num][num_of_vals_per_rec]); } } } else { printf (" <-- neither vdata nor vgroup\n"); } } /* for */ } /* if */ else printf ("Vgroup #%d contains no HDF objects\n", vgroup_pos); /* * Terminate access to the current vgroup. */ status_32 = Vdetach (vgroup_id); /* * Move to the next vgroup position. */ vgroup_pos++; /* * Terminate access to the V interface and close the file. */ status_n = Vend (file_id); status_n = Hclose (file_id); return 0; }
static int do_groups(void) { int32 vg0_id, /* vgroup identifier */ vg1_id, /* vgroup identifier */ vg2_id, /* vgroup identifier */ file1_id; /* HDF file identifier */ /* create a HDF file */ if ((file1_id = Hopen (FILE7_NAME, DFACC_CREATE, (int16)0))<0) { printf("Error: Could not create file <%s>\n",FILE7_NAME); return FAIL; } /* initialize the V interface */ if (Vstart (file1_id)==FAIL) { printf( "Could not start VG\n"); return FAIL; } /* create a vgroup */ vg0_id = Vattach (file1_id, -1, "w"); if (Vsetname (vg0_id, "g0")==FAIL) { printf( "Could not name group\n"); goto out; } /* create the second vgroup */ vg1_id = Vattach (file1_id, -1, "w"); if (Vsetname (vg1_id, "g1")==FAIL) { printf( "Could not name group\n"); goto out; } /* create the third vgroup */ vg2_id = Vattach (file1_id, -1, "w"); if (Vsetname (vg2_id, "g1.1")==FAIL) { printf( "Could not name group\n"); goto out; } if (Vinsert (vg0_id, vg1_id)==FAIL) { printf( "Could not insert VG\n"); goto out; } if (Vinsert (vg0_id, vg2_id)==FAIL) { printf( "Could not insert VG\n"); goto out; } if (Vinsert (vg1_id, vg2_id)==FAIL) { printf( "Could not insert VG\n"); goto out; } if (Vinsert (vg2_id, vg1_id)==FAIL) { printf( "Could not insert VG\n"); goto out; } /* terminate access to the vgroup */ if (Vdetach (vg0_id)==FAIL) { printf( "Could not close group\n"); goto out; } /* terminate access to the vgroup */ if (Vdetach (vg1_id)==FAIL) { printf( "Could not close group\n"); goto out; } /* terminate access to the vgroup */ if (Vdetach (vg2_id)==FAIL) { printf( "Could not close group\n"); goto out; } /* terminate access to the V interface */ if (Vend (file1_id)==FAIL) { printf( "Could not end VG\n"); goto out; } /* close the HDF file */ if (Hclose (file1_id)==FAIL) { printf( "Could not close file\n"); return FAIL; } return SUCCEED; out: printf("Error...Exiting...\n"); return FAIL; }
int do_lone(char* file_name, int do_diffs) { char sds_name[] = "lone"; int32 rank = 1; int32 dim_sds[1] = {5}; /* dimension of the data set */ int32 data[5] = {1, 2, 3, 4, 5}; int32 start[1]; /* start position to write for each dimension */ int32 edges[1]; /* number of elements to be written along each dimension */ int32 sds_id; int32 dim_id; int32 sd_id; if ( do_diffs ) { data[1] = data[2] = 0; } sd_id = SDstart(file_name, DFACC_CREATE); /* create the SDS */ if ((sds_id = SDcreate (sd_id, sds_name, DFNT_INT32, rank, dim_sds))<0) { printf( "Could not create SDS <%s>\n",sds_name); goto fail; } dim_id = SDgetdimid(sds_id, 0); SDsetdimname(dim_id, sds_name); /* define the location and size of the data to be written to the data set */ start[0] = 0; edges[0] = 5; /* write the stored data to the data set */ if (SDwritedata (sds_id, start, NULL, edges, (VOIDP)data)==FAIL) { printf( "Failed to set write for SDS <%s>\n", sds_name); goto fail; } SDendaccess(sds_id); /* create the SDS */ if ((sds_id = SDcreate (sd_id, "sds", DFNT_INT32, rank, dim_sds))<0) { printf( "Could not create SDS <%s>\n"); goto fail; } if (SDwritedata (sds_id, start, NULL, edges, (VOIDP)data)==FAIL) { printf( "Failed to set write for SDS <%s>\n"); goto fail; } SDendaccess(sds_id); SDend(sd_id); { int32 file1_id; /* HDF file identifier */ int32 an_id; /* AN interface identifier */ int32 file_label_id; /* file label identifier */ /* open file */ if ((file1_id = Hopen (file_name, DFACC_WRITE, (int16)0))<0) { printf("Error: Could not open file <%s>\n",file_name); return FAIL; } /* Initialize the AN interface */ an_id = ANstart (file1_id); /* Create the file label */ file_label_id = ANcreatef (an_id, AN_FILE_LABEL); /* Write the annotations to the file label */ if (ANwriteann (file_label_id,FILE_LABEL_TXT,strlen (FILE_LABEL_TXT))==FAIL) { printf( "Could not write AN\n"); return FAIL; } /* Terminate access to annotation */ if (ANendaccess (file_label_id)==FAIL) { printf( "Could not end AN\n"); return FAIL; } /* Terminate access to the AN interface */ if (ANend (an_id)==FAIL) { printf( "Could not end AN\n"); return FAIL; } /* close the HDF file */ if (Hclose (file1_id)==FAIL) { printf( "Could not close file\n"); return FAIL; } } return SUCCEED; fail: SDend(sd_id); return FAIL; }
//// [[Rcpp::export]] int binlist(int x) { int numbins = 0, *binnums = NULL; int i; int file_id,vdata_ref, vdata_id,numrecs,pvd_id; char PARAM[] = "chlor_a"; initbin(); /* Open the HDF file. */ file_id = Hopen("S1998001.L3b_DAY_CHL.main", DFACC_READ, 0); if(file_id == FAIL){ fprintf(stderr,"-E- %s line %d: Hopen(%s,DFACC_READ,0) failed.\n", __FILE__,__LINE__,"S1998001.L3b_DAY_CHL.main"); return(EXIT_FAILURE); } /* Initialize the Vdata interface. */ if(Vstart(file_id) == FAIL){ fprintf(stderr,"-E- %s line %d: Vstart(%d) failed.\n", __FILE__,__LINE__,file_id); return(EXIT_FAILURE); } /* Open the "BinList" Vdata. */ vdata_ref = VSfind(file_id,"BinList"); if(vdata_ref == FAIL){ fprintf(stderr,"-E- %s line %d: VSfind(%d,\"BinList\") failed.\n", __FILE__,__LINE__,file_id); return(EXIT_FAILURE); } vdata_id = VSattach(file_id, vdata_ref, "r"); if(vdata_id == FAIL){ fprintf(stderr,"-E- %s line %d: VSattach(%d,%d,\"r\") failed.\n", __FILE__,__LINE__,file_id,vdata_ref); return(EXIT_FAILURE); } /* Find out how many bins are stored in this file. */ numrecs = VSelts(vdata_id); if(numrecs == FAIL){ fprintf(stderr,"-E- %s line %d: VSelts(%d) failed.\n", __FILE__,__LINE__,vdata_id); return(EXIT_FAILURE); } // this doesn't seem to be necessary? /* Set up to read the fields in the BinList Vdata records. */ // if(VSsetfields(vdata_id,BLIST_FIELDS) == FAIL){ // fprintf(stderr,"-E- %s line %d: VSsetfields(%d,%s) failed.\n", // __FILE__,__LINE__,vdata_id,BLIST_FIELDS); // return(EXIT_FAILURE); // } /* Open the parameter-specific Vdata. */ vdata_ref = VSfind(file_id,PARAM); if(vdata_ref == 0){ fprintf(stderr,"-E- %s line %d: VSfind(%d,\"%s\") failed.\n", __FILE__,__LINE__,file_id,PARAM); return(EXIT_FAILURE); } pvd_id = VSattach(file_id, vdata_ref, "r"); if(pvd_id == FAIL){ fprintf(stderr,"-E- %s line %d: VSattach(%d,%d,\"r\") failed.\n", __FILE__,__LINE__,file_id,vdata_ref); return(EXIT_FAILURE); } /* Set up to read the fields in the parameter-specific Vdata records. */ { int len; len = 2*strlen(PARAM) + strlen("_sum,") + strlen("_sum_sq") + 1; param_fields = (char *)malloc(len); if(param_fields == NULL){ fprintf(stderr,"-E- %s line %d: Memory allocation failed.\n", __FILE__,__LINE__); return(EXIT_FAILURE); } strcpy(param_fields,PARAM); strcat(param_fields,"_sum,"); strcat(param_fields,PARAM); strcat(param_fields,"_sum_sq"); } if(VSsetfields(pvd_id,param_fields) == FAIL){ fprintf(stderr,"-E- %s line %d: VSsetfields(%d,%s) failed.\n", __FILE__,__LINE__,pvd_id,param_fields); return(EXIT_FAILURE); } printf(param_fields); printf("\n"); /* Output a header record to identify the fields written out below. */ printf("%80s%15.15s %15.15s\n"," ",PARAM,PARAM); printf(" bin centerlat centerlon"); printf(" north south west east"); printf(" n N sum_obs sum_squared_obs weight"); printf(" time_trend_bits l2_flag_bits sel\n"); printf("------- --------- ----------"); printf(" --------- --------- ---------- ----------"); printf(" ---- --- --------------- --------------- ---------------"); printf(" ---------------- -------------------------------- ---\n"); // for(i = 0; i < numbins; i++){ for(i = 0; i < 10; i++){ int recno; // recno = binsearch(binnums[i],vdata_id,numrecs); recno = i; if(recno >= 0){ double n,s,w,e,clat,clon; /* Read the sum and sum-of-squares for the the specified parameter for this bin. */ if(VSseek(pvd_id,recno) == FAIL){ fprintf(stderr,"-E- %s line %d: VSseek(%d,%d) failed.\n", __FILE__,__LINE__,pvd_id,recno); return(EXIT_FAILURE); } if(VSread(pvd_id,paramrec,1,FULL_INTERLACE) != 1){ fprintf(stderr,"-E- %s line %d: ",__FILE__,__LINE__); fprintf(stderr,"VSread(%d,paramrec,1,FULL_INTERLACE) failed.\n", pvd_id); return(EXIT_FAILURE); } /* VSfpack() sets the global sum and sum_sq variables via the paramptrs pointer array. */ if( VSfpack( pvd_id,_HDF_VSUNPACK,param_fields,paramrec,PREC_SIZE,1,NULL,paramptrs ) == FAIL){ fprintf(stderr,"-E- %s line %d: ",__FILE__,__LINE__); fprintf(stderr,"VSfpack(%d, ...) failed.\n", pvd_id); return(EXIT_FAILURE); } /* Get the geographical coordinates associated with this bin. */ // bin2latlon(binnums[i],&clat,&clon); // bin2bounds(binnums[i],&n,&s,&w,&e); /* Output the results. */ // printf("%7d %9.5f %10.5f %9.5f %9.5f %10.5f %10.5f ", // binnums[i],clat,clon,n,s,w,e); // printf("%4d %3d ",nobs,nscenes); // printf("% .8e % .8e % .8e ",sum,sum_sq,weights); printf("% .8e % .8e % .8e ",sum,sum_sq,0.0); // printf("%.16s %.32s ",bitstr16(time_rec),bitstr32(flags_set)); // printf("%3d",sel_cat); printf("\n"); } } if(VSdetach(pvd_id) == FAIL){ fprintf(stderr,"-E- %s line %d: VSdetach(%d) failed.\n", __FILE__,__LINE__,pvd_id); return(EXIT_FAILURE); } if(VSdetach(vdata_id) == FAIL){ fprintf(stderr,"-E- %s line %d: VSdetach(%d) failed.\n", __FILE__,__LINE__,vdata_id); return(EXIT_FAILURE); } if(Vend(file_id) == FAIL){ fprintf(stderr,"-E- %s line %d: Vend(%d) failed.\n", __FILE__,__LINE__,file_id); return(EXIT_FAILURE); } if(Hclose(file_id) == FAIL){ fprintf(stderr,"-E- %s line %d: Hclose(%d) failed.\n", __FILE__,__LINE__,file_id); return(EXIT_FAILURE); } free(param_fields); free(binnums); return 2; }
int main(void) { int32 sd1_id; /* SD interface identifier */ int32 sd2_id; /* SD interface identifier */ int32 sds1_id; /* SDS identifier */ int32 sds2_id; /* SDS identifier */ int32 dim_sizes[2]; /* sizes of the SDS dimensions */ int32 start[2]; /* start location to write */ int32 edges[2]; /* number of elements to write */ int32 n_values; int32 buf1a[Y_LENGTH][X_LENGTH] = {{1,1},{1,1},{5,6}}; int32 buf1b[Y_LENGTH][X_LENGTH] = {{1,2},{3,4},{5,6}}; /* percent test: compare divide by zero, both zero */ int32 buf2a[Y_LENGTH][X_LENGTH] = {{100,100},{100,0},{0,100}}; int32 buf2b[Y_LENGTH][X_LENGTH] = {{120,80},{0,100},{0,50}}; /* global attributes */ char8 bufga1[] = "Storm_track_data1"; char8 bufga2[] = "Storm_track_data2"; float32 bufa1[2] = {1., 1.}; float32 bufa2[2] = {1., 2.}; /*vdata*/ int32 file1_id; int32 file2_id; int32 vdata1_id; int32 vdata2_id; char8 vdata1_buf1 [N_RECORDS_1] = {'V', 'D', 'A', 'T', 'A'}; char8 vdata1_buf2 [N_RECORDS_1] = {'X', 'D', 'A', 'T', 'A'}; int32 vdata2_buf1 [N_RECORDS_2][ORDER_2] = {{1, 2, 3, 4}, {5, 6, 7, 8}}; int32 vdata2_buf2 [N_RECORDS_2][ORDER_2] = {{1, 1, 1, 1}, {5, 6, 7, 8}}; float32 vdata3_buf1[N_RECORDS_2][N_VALS_PER_REC]={{1,2,3,4,5,6},{7,8,9,10,11,12}}; float32 vdata3_buf2[N_RECORDS_2][N_VALS_PER_REC]={{1,1,1,1,1,1},{7,8,9,10,11,12}}; /* Define the location and size of the data to be written to the data set*/ start[0] = 0; start[1] = 0; edges[0] = Y_LENGTH; edges[1] = X_LENGTH; /* Define the dimensions of the array to be created */ dim_sizes[0] = Y_LENGTH; dim_sizes[1] = X_LENGTH; /*------------------------------------------------------------------------- * SD data *------------------------------------------------------------------------- */ /* Create the files and initialize the SD interface */ if ((sd1_id = SDstart (FILE1_NAME, DFACC_CREATE))==FAIL) goto error; if ((sd2_id = SDstart (FILE2_NAME, DFACC_CREATE))==FAIL) goto error; /* Set a global attribute */ n_values = sizeof(bufga1); if ( SDsetattr (sd1_id, FILE_ATTR_NAME, DFNT_CHAR8, n_values, (VOIDP)bufga1)==FAIL) goto error; if ( SDsetattr (sd2_id, FILE_ATTR_NAME, DFNT_CHAR8, n_values, (VOIDP)bufga2)==FAIL) goto error; /* Create the data sets */ if ((sds1_id = SDcreate (sd1_id, "dset1", DFNT_INT32, RANK, dim_sizes))==FAIL) goto error; if ((sds2_id = SDcreate (sd2_id, "dset1", DFNT_INT32, RANK, dim_sizes))==FAIL) goto error; /* Assign attribute */ n_values = 2; if ( SDsetattr (sds1_id, SDS_ATTR_NAME, DFNT_FLOAT32, n_values, (VOIDP)bufa1)==FAIL) goto error; if ( SDsetattr (sds2_id, SDS_ATTR_NAME, DFNT_FLOAT32, n_values, (VOIDP)bufa2)==FAIL) goto error; /* Write the stored data to the data set */ if ( SDwritedata (sds1_id, start, NULL, edges, (VOIDP)buf1a)==FAIL) goto error; if ( SDwritedata (sds2_id, start, NULL, edges, (VOIDP)buf1b)==FAIL) goto error; /* Terminate access to the data set */ if ( SDendaccess (sds1_id)==FAIL) goto error; if ( SDendaccess (sds2_id)==FAIL) goto error; /* Create another data set */ if (( sds1_id = SDcreate (sd1_id, "dset2", DFNT_INT32, RANK, dim_sizes))==FAIL) goto error; if (( sds2_id = SDcreate (sd2_id, "dset2", DFNT_INT32, RANK, dim_sizes))==FAIL) goto error; if ( SDwritedata (sds1_id, start, NULL, edges, (VOIDP)buf1a)==FAIL) goto error; if ( SDwritedata (sds2_id, start, NULL, edges, (VOIDP)buf1b)==FAIL) goto error; if ( SDendaccess (sds1_id)==FAIL) goto error; if ( SDendaccess (sds2_id)==FAIL) goto error; /* data sets for -p test */ if (( sds1_id = SDcreate (sd1_id, "dset3", DFNT_INT32, RANK, dim_sizes))==FAIL) goto error; if (( sds2_id = SDcreate (sd2_id, "dset3", DFNT_INT32, RANK, dim_sizes))==FAIL) goto error; if ( SDwritedata (sds1_id, start, NULL, edges, (VOIDP)buf2a)==FAIL) goto error; if ( SDwritedata (sds2_id, start, NULL, edges, (VOIDP)buf2b)==FAIL) goto error; if ( SDendaccess (sds1_id)==FAIL) goto error; if ( SDendaccess (sds2_id)==FAIL) goto error; /*------------------------------------------------------------------------- * end SD *------------------------------------------------------------------------- */ /* Terminate access to the SD interface and close the file */ if ( SDend (sd1_id)==FAIL) goto error; if ( SDend (sd2_id)==FAIL) goto error; /*------------------------------------------------------------------------- * VD data *------------------------------------------------------------------------- */ /* Open the HDF file for writing */ if ((file1_id = Hopen (FILE1_NAME, DFACC_WRITE, 0))==FAIL) goto error; if ((file2_id = Hopen (FILE2_NAME, DFACC_WRITE, 0))==FAIL) goto error; /* Initialize the VS interface */ if ( Vstart (file1_id)==FAIL) goto error; if ( Vstart (file2_id)==FAIL) goto error; /*------------------------------------------------------------------------- * VD data one field *------------------------------------------------------------------------- */ /* Create the first vdata and populate it with data from vdata1_buf */ if (VHstoredata (file1_id, FIELD1_NAME, (uint8 *)vdata1_buf1, N_RECORDS_1, DFNT_CHAR8, VDATA1_NAME, CLASS1_NAME)==FAIL) goto error; if (VHstoredata (file2_id, FIELD1_NAME, (uint8 *)vdata1_buf2, N_RECORDS_1, DFNT_CHAR8, VDATA1_NAME, CLASS1_NAME)==FAIL) goto error; /*------------------------------------------------------------------------- * VD data one field, order 4 *------------------------------------------------------------------------- */ /* Create the second vdata and populate it with data from vdata2_buf */ if ( VHstoredatam (file1_id, FIELD2_NAME, (uint8 *)vdata2_buf1, N_RECORDS_2, DFNT_INT32, VDATA2_NAME, CLASS2_NAME, ORDER_2)==FAIL) goto error; if ( VHstoredatam (file2_id, FIELD2_NAME, (uint8 *)vdata2_buf2, N_RECORDS_2, DFNT_INT32, VDATA2_NAME, CLASS2_NAME, ORDER_2)==FAIL) goto error; /*------------------------------------------------------------------------- * VD data several fields *------------------------------------------------------------------------- */ /* Create a new vdata */ if ((vdata1_id = VSattach (file1_id, -1, "w"))==FAIL) goto error; if ((vdata2_id = VSattach (file2_id, -1, "w"))==FAIL) goto error; /* Set name and class name of the vdata */ if ( VSsetname (vdata1_id, VDATA3_NAME)==FAIL) goto error; if ( VSsetclass (vdata1_id, CLASS3_NAME)==FAIL) goto error; if ( VSsetname (vdata2_id, VDATA3_NAME)==FAIL) goto error; if ( VSsetclass (vdata2_id, CLASS3_NAME)==FAIL) goto error; /* Define fields */ if ( VSfdefine (vdata1_id, FIELD3_NAME1, DFNT_FLOAT32, ORDER3_1 )==FAIL) goto error; if ( VSfdefine (vdata1_id, FIELD3_NAME2, DFNT_FLOAT32, ORDER3_2 )==FAIL) goto error; if ( VSfdefine (vdata1_id, FIELD3_NAME3, DFNT_FLOAT32, ORDER3_3 )==FAIL) goto error; if ( VSsetfields (vdata1_id, FIELDNAME3_LIST )==FAIL) goto error; if ( VSfdefine (vdata2_id, FIELD3_NAME1, DFNT_FLOAT32, ORDER3_1 )==FAIL) goto error; if ( VSfdefine (vdata2_id, FIELD3_NAME2, DFNT_FLOAT32, ORDER3_2 )==FAIL) goto error; if ( VSfdefine (vdata2_id, FIELD3_NAME3, DFNT_FLOAT32, ORDER3_3 )==FAIL) goto error; if ( VSsetfields (vdata2_id, FIELDNAME3_LIST)==FAIL) goto error; /* Write the data with full interlacing mode */ if ( VSwrite (vdata1_id, (uint8 *)vdata3_buf1, N_RECORDS_2, FULL_INTERLACE)==FAIL) goto error; if ( VSwrite (vdata2_id, (uint8 *)vdata3_buf2, N_RECORDS_2, FULL_INTERLACE)==FAIL) goto error; if ( VSdetach (vdata1_id)==FAIL) goto error; if ( VSdetach (vdata2_id)==FAIL) goto error; /*------------------------------------------------------------------------- * end VD data *------------------------------------------------------------------------- */ /* Terminate access to the VS interface and close the HDF file */ if ( Vend (file1_id)==FAIL) goto error; if ( Vend (file2_id)==FAIL) goto error; if ( Hclose (file1_id)==FAIL) goto error; if ( Hclose (file2_id)==FAIL) goto error; /*------------------------------------------------------------------------- * write 2 big files for hyperslab reading *------------------------------------------------------------------------- */ if (do_big_file()==FAIL) goto error; /*------------------------------------------------------------------------- * groups *------------------------------------------------------------------------- */ if (do_groups()==FAIL) goto error; return 0; error: printf("Error...Exiting...\n"); return 1; }
int coda_hdf4_reopen(coda_product **product) { coda_hdf4_product *product_file; product_file = (coda_hdf4_product *)malloc(sizeof(coda_hdf4_product)); if (product_file == NULL) { coda_set_error(CODA_ERROR_OUT_OF_MEMORY, "out of memory (could not allocate %lu bytes) (%s:%u)", sizeof(coda_hdf4_product), __FILE__, __LINE__); coda_close(*product); return -1; } product_file->filename = NULL; product_file->file_size = (*product)->file_size; product_file->format = coda_format_hdf4; product_file->root_type = NULL; product_file->product_definition = NULL; product_file->product_variable_size = NULL; product_file->product_variable = NULL; product_file->mem_size = 0; product_file->mem_ptr = NULL; product_file->is_hdf = 0; product_file->file_id = -1; product_file->gr_id = -1; product_file->sd_id = -1; product_file->an_id = -1; product_file->num_gr_file_attributes = 0; product_file->num_sd_file_attributes = 0; product_file->num_sds = 0; product_file->sds = NULL; product_file->num_images = 0; product_file->gri = NULL; product_file->num_vgroup = 0; product_file->vgroup = NULL; product_file->num_vdata = 0; product_file->vdata = NULL; product_file->filename = strdup((*product)->filename); if (product_file->filename == NULL) { coda_set_error(CODA_ERROR_OUT_OF_MEMORY, "out of memory (could not duplicate filename string) (%s:%u)", __FILE__, __LINE__); coda_hdf4_close((coda_product *)product_file); coda_close(*product); return -1; } coda_close(*product); product_file->is_hdf = Hishdf(product_file->filename); /* is this a real HDF4 file or a (net)CDF file */ if (product_file->is_hdf) { product_file->file_id = Hopen(product_file->filename, DFACC_READ, 0); if (product_file->file_id == -1) { coda_set_error(CODA_ERROR_HDF4, NULL); coda_hdf4_close((coda_product *)product_file); return -1; } if (Vstart(product_file->file_id) != 0) { coda_set_error(CODA_ERROR_HDF4, NULL); coda_hdf4_close((coda_product *)product_file); return -1; } product_file->gr_id = GRstart(product_file->file_id); if (product_file->gr_id == -1) { coda_set_error(CODA_ERROR_HDF4, NULL); coda_hdf4_close((coda_product *)product_file); return -1; } product_file->an_id = ANstart(product_file->file_id); if (product_file->an_id == -1) { coda_set_error(CODA_ERROR_HDF4, NULL); coda_hdf4_close((coda_product *)product_file); return -1; } } product_file->sd_id = SDstart(product_file->filename, DFACC_READ); if (product_file->sd_id == -1) { coda_set_error(CODA_ERROR_HDF4, NULL); coda_hdf4_close((coda_product *)product_file); return -1; } product_file->root_type = NULL; if (init_SDSs(product_file) != 0) { coda_hdf4_close((coda_product *)product_file); return -1; } if (product_file->is_hdf) { if (init_GRImages(product_file) != 0) { coda_hdf4_close((coda_product *)product_file); return -1; } if (init_Vdatas(product_file) != 0) { coda_hdf4_close((coda_product *)product_file); return -1; } /* initialization of Vgroup entries should happen last, so we can build the structural tree */ if (init_Vgroups(product_file) != 0) { coda_hdf4_close((coda_product *)product_file); return -1; } } if (coda_hdf4_create_root(product_file) != 0) { coda_hdf4_close((coda_product *)product_file); return -1; } *product = (coda_product *)product_file; return 0; }
int main( ) { /************************* Variable declaration **************************/ intn status_n; /* returned status for functions returning an intn */ int32 status_32, /* returned status for functions returning an int32 */ file_id, vdata_id, vdata_ref, index = 0; /* index of the vdata in the file - manually kept */ int8 found_fields; /* TRUE if the specified fields exist in the vdata */ /********************** End of variable declaration **********************/ /* * Open the HDF file for reading. */ file_id = Hopen (FILE_NAME, DFACC_READ, 0); /* * Initialize the VS interface. */ status_n = Vstart (file_id); /* * Set the reference number to -1 to start the search from * the beginning of file. */ vdata_ref = -1; /* * Assume that the specified fields are not found in the current vdata. */ found_fields = FALSE; /* * Use VSgetid to obtain each vdata by its reference number then * attach to the vdata and search for the fields. The loop * terminates when the last vdata is reached or when a vdata which * contains the fields listed in SEARCHED_FIELDS is found. */ while ((vdata_ref = VSgetid (file_id, vdata_ref)) != FAIL) { vdata_id = VSattach (file_id, vdata_ref, "r"); if ((status_n = VSfexist (vdata_id, SEARCHED_FIELDS)) != FAIL) { found_fields = TRUE; break; } /* * Detach from the current vdata before continuing searching. */ status_32 = VSdetach (vdata_id); index++; /* advance the index by 1 for the next vdata */ } /* * Print the index of the vdata containing the fields or a "not found" * message if no such vdata is found. Also detach from the vdata found. */ if (!found_fields) printf ("Fields Position and Temperature were not found.\n"); else { printf ("Fields Position and Temperature found in the vdata at position %d\n", index); status_32 = VSdetach (vdata_id); } /* * Terminate access to the VS interface and close the HDF file. */ status_n = Vend (file_id); status_32 = Hclose (file_id); return 0; }
int main( ) { /************************* Variable declaration **************************/ intn status_n; /* returned status for functions returning an intn */ int32 status_32, /* returned status for functions returning an int32 */ file_id, vdata_ref, vdata_id, field_index, /* index of a field within the vdata */ n_vdattrs, /* number of vdata attributes */ n_fldattrs, /* number of field attributes */ vdata_type, /* to hold the type of vdata's attribute */ vdata_n_values,/* to hold the number of vdata's attribute values */ vdata_size, /* to hold the size of vdata's attribute values */ field_type, /* to hold the type of field's attribute */ field_n_values,/* to hold the number of field's attribute values */ field_size; /* to hold the size of field's attribute values */ char vd_attr[VATTR_N_VALUES] = {'A', 'B', 'C'};/* vdata attribute values*/ int32 fld_attr[FATTR_N_VALUES] = {2, 4, 6, 8}; /* field attribute values*/ char vattr_buf[VATTR_N_VALUES]; /* to hold vdata attribute's values */ int32 fattr_buf[FATTR_N_VALUES]; /* to hold field attribute's values */ char vattr_name[30], /* name of vdata attribute */ fattr_name[30]; /* name of field attribute */ /********************** End of variable declaration **********************/ /* * Open the HDF file for writing. */ file_id = Hopen (FILE_NAME, DFACC_WRITE, 0); /* * Initialize the VS interface. */ status_n = Vstart (file_id); /* * Get the reference number of the vdata named VDATA_NAME. */ vdata_ref = VSfind (file_id, VDATA_NAME); /* * Attach to the vdata for writing. */ vdata_id = VSattach (file_id, vdata_ref, "w"); /* * Attach an attribute to the vdata, i.e., indicated by the second parameter. */ status_n = VSsetattr (vdata_id, _HDF_VDATA, VATTR_NAME, DFNT_CHAR, VATTR_N_VALUES, vd_attr); /* * Get the index of the field FIELD_NAME within the vdata. */ status_n = VSfindex (vdata_id, FIELD_NAME, &field_index); /* * Attach an attribute to the field field_index. */ status_n = VSsetattr (vdata_id, field_index, FATTR_NAME, DFNT_INT32, FATTR_N_VALUES, fld_attr); /* * Get the number of attributes attached to the vdata's first * field - should be 0. */ n_fldattrs = VSfnattrs (vdata_id, 0); printf ( "Number of attributes of the first field of the vdata: %d\n", n_fldattrs); /* * Get the number of attributes attached to the field specified by * field_index - should be 1. */ n_fldattrs = VSfnattrs (vdata_id, field_index); printf ( "Number of attributes of field %s: %d\n", FIELD_NAME, n_fldattrs); /* * Get the total number of the field's and vdata's attributes - should be 2. */ n_vdattrs = VSnattrs (vdata_id); printf ( "Number of attributes of the vdata and its fields: %d\n", n_vdattrs); /* * Get information about the vdata's first attribute, indicated * by the third parameter which is the index of the attribute. */ status_n = VSattrinfo (vdata_id, _HDF_VDATA, 0, vattr_name, &vdata_type, &vdata_n_values, &vdata_size); /* * Get information about the first attribute of the field specified by * field_index. */ status_n = VSattrinfo (vdata_id, field_index, 0, fattr_name, &field_type, &field_n_values, &field_size); /* * Get the vdata's first attribute. */ status_n = VSgetattr (vdata_id, _HDF_VDATA, 0, vattr_buf); printf("Values of the vdata attribute = %c %c %c\n", vattr_buf[0], vattr_buf[1], vattr_buf[2]); /* * Get the first attribute of the field specified by field_index. */ status_n = VSgetattr (vdata_id, field_index, 0, fattr_buf); printf("Values of the field attribute = %d %d %d %d\n", fattr_buf[0], fattr_buf[1], fattr_buf[2], fattr_buf[3]); /* * Terminate access to the vdata and to the VS interface, then close * the HDF file. */ status_32 = VSdetach (vdata_id); status_n = Vend (file_id); status_32 = Hclose (file_id); return 0; }
static void test_undefined(void) { int32 status; /* Status values from routines */ int32 file_id; /* File ID */ int32 vg1; /* Vdata ID */ int32 ref; /* Vdata ref */ intn is_internal; /* to test Vgisinternal */ uint16 name_len; /* Length of a vgroup's name or class name */ /* to simulate calls to Vgetclass/Vgetname in older applications */ char vgname[VGNAMELENMAX+1], vgclass[VGNAMELENMAX+1]; /* Open the HDF file. */ file_id = Hopen(NONAMECLASS, DFACC_CREATE, 0); CHECK_VOID(file_id,FAIL,"Hopen"); /* Initialize HDF for subsequent vgroup/vdata access. */ status = Vstart(file_id); CHECK_VOID(status,FAIL,"Vstart"); /* Create a vgroup which will have name set but not class */ vg1 = Vattach(file_id, -1, "w"); CHECK_VOID(vg1,FAIL,"VSattach"); status=Vsetname(vg1, VG_LONGNAME); CHECK_VOID(status,FAIL,"VSsetname"); status = Vdetach(vg1); CHECK_VOID(status,FAIL,"Vdetach"); /* Create another vgroup which will have class but not name */ vg1 = Vattach(file_id, -1, "w"); CHECK_VOID(vg1,FAIL,"VSattach"); status=Vsetclass(vg1, VG_LONGCLASS); CHECK_VOID(status,FAIL,"VSsetname"); status = Vdetach(vg1); CHECK_VOID(status,FAIL,"Vdetach"); status = Vend(file_id); CHECK_VOID(status,FAIL,"Vend"); status = Hclose(file_id); CHECK_VOID(status,FAIL,"Hclose"); /* Re-open the HDF file. */ file_id = Hopen(NONAMECLASS, DFACC_RDWR, 0); CHECK_VOID(file_id,FAIL,"Hopen"); /* Initialize HDF for subsequent vgroup/vdata access. */ status = Vstart(file_id); CHECK_VOID(status,FAIL,"Vstart"); /* Find the long name vgroup. */ ref=Vfind(file_id,VG_LONGNAME); CHECK_VOID(ref,FAIL,"VSfind"); vg1 = Vattach(file_id, ref, "r"); CHECK_VOID(vg1,FAIL,"VSattach"); /* Test Vgisinternal */ is_internal = Vgisinternal(vg1); CHECK_VOID(is_internal, FAIL, "Vgisinternal"); VERIFY_VOID(is_internal, FALSE, "Vgisinternal"); /* Try getting the vgroup's class without calling first Vgetclassnamelen. This shows that bug HDFFR-1288 is fixed. */ status=Vgetclass(vg1, vgclass); CHECK_VOID(status,FAIL,"Vgetclass"); VERIFY_VOID(HDstrlen(vgclass), 0, "VSgetclass"); /* The length of the class name should be 0 */ status = Vgetclassnamelen(vg1, &name_len); CHECK_VOID(status,FAIL,"Vgetclassnamelen"); VERIFY_VOID(name_len, 0, "VSgetclassnamelen"); status = Vdetach(vg1); CHECK_VOID(status,FAIL,"Vdetach"); /* Find the vgroup with class VG_LONGCLASS. This vgroup doesn't have a name */ ref=Vfindclass(file_id, VG_LONGCLASS); CHECK_VOID(ref,FAIL,"VSfindclass"); vg1 = Vattach(file_id, ref, "r"); CHECK_VOID(vg1,FAIL,"VSattach"); /* Try getting the vgroup's name without calling first Vgetclassnamelen. Similar to class name in bug HDFFR-1288. */ status=Vgetname(vg1, vgname); CHECK_VOID(status,FAIL,"Vgetname"); VERIFY_VOID(HDstrlen(vgname), 0, "VSgetname"); /* The length of the name should be 0 */ status = Vgetnamelen(vg1, &name_len); CHECK_VOID(status,FAIL,"Vgetnamelen"); VERIFY_VOID(name_len, 0, "VSgetnamelen"); status = Vdetach(vg1); CHECK_VOID(status,FAIL,"Vdetach"); status = Vend(file_id); CHECK_VOID(status,FAIL,"Vend"); status = Hclose(file_id); CHECK_VOID(status,FAIL,"Hclose"); } /* test_undefined() */
static void test_vglongnames(void) { int32 file_id; /* File ID */ int32 vg1; /* Vdata ID */ int32 ref; /* Vdata ref */ uint16 name_len; /* Length of a vgroup's name or class name */ char *vgname, *vgclass; intn is_internal; int32 status; /* Status values from routines */ /* Open the HDF file. */ file_id = Hopen(LONGNAMES, DFACC_CREATE, 0); CHECK_VOID(file_id,FAIL,"Hopen"); /* Initialize HDF for subsequent vgroup/vdata access. */ status = Vstart(file_id); CHECK_VOID(status,FAIL,"Vstart"); /* Create a new vgroup. */ vg1 = Vattach(file_id, -1, "w"); CHECK_VOID(vg1,FAIL,"VSattach"); status=Vsetname(vg1, VG_LONGNAME); CHECK_VOID(status,FAIL,"VSsetname"); status=Vsetclass(vg1, VG_LONGCLASS); CHECK_VOID(status,FAIL,"VSsetname"); status = Vdetach(vg1); CHECK_VOID(status,FAIL,"Vdetach"); /* Create another vgroup of the same class. */ vg1 = Vattach(file_id, -1, "w"); CHECK_VOID(vg1,FAIL,"VSattach"); status=Vsetname(vg1, VGROUP1); CHECK_VOID(status,FAIL,"VSsetname"); status=Vsetclass(vg1, VG_LONGCLASS); CHECK_VOID(status,FAIL,"VSsetname"); status = Vdetach(vg1); CHECK_VOID(status,FAIL,"Vdetach"); status = Vend(file_id); CHECK_VOID(status,FAIL,"Vend"); status = Hclose(file_id); CHECK_VOID(status,FAIL,"Hclose"); /* Re-open the HDF file. */ file_id = Hopen(LONGNAMES, DFACC_RDWR, 0); CHECK_VOID(file_id,FAIL,"Hopen"); /* Initialize HDF for subsequent vgroup/vdata access. */ status = Vstart(file_id); CHECK_VOID(status,FAIL,"Vstart"); /* Find the long name vgroup. */ ref=Vfind(file_id,VG_LONGNAME); CHECK_VOID(ref,FAIL,"VSfind"); vg1 = Vattach(file_id, ref, "r"); CHECK_VOID(vg1,FAIL,"VSattach"); /* Test Vgisinternal */ is_internal = Vgisinternal(vg1); CHECK_VOID(is_internal, FAIL, "Vgisinternal"); VERIFY_VOID(is_internal, FALSE, "Vgisinternal"); /* get the vgroup's name */ status = Vgetnamelen(vg1, &name_len); CHECK_VOID(status,FAIL,"Vgetnamelen"); vgname = (char *) HDmalloc(sizeof(char *) * (name_len+1)); CHECK_ALLOC(vgname, "vgname", "test_vglongnames" ); status=Vgetname(vg1, vgname); CHECK_VOID(status,FAIL,"VSgetname"); VERIFY_CHAR_VOID(vgname, VG_LONGNAME, "Vgetname"); if (vgname != NULL) HDfree(vgname); /* get the vgroup's class */ status = Vgetclassnamelen(vg1, &name_len); CHECK_VOID(status,FAIL,"Vgetnamelen"); vgclass = (char *) HDmalloc(sizeof(char *) * (name_len+1)); CHECK_ALLOC(vgclass, "vgclass", "test_vglongnames" ); status=Vgetclass(vg1, vgclass); CHECK_VOID(status,FAIL,"VSgetclass"); VERIFY_CHAR_VOID(vgclass, VG_LONGCLASS, "Vgetclass"); if (vgclass != NULL) HDfree(vgclass); status = Vdetach(vg1); CHECK_VOID(status,FAIL,"Vdetach"); /* Find the vgroup VGROUP1. */ ref=Vfind(file_id,VGROUP1); CHECK_VOID(ref,FAIL,"VSfind"); vg1 = Vattach(file_id, ref, "r"); CHECK_VOID(vg1,FAIL,"VSattach"); /* get the vgroup's name */ status = Vgetnamelen(vg1, &name_len); CHECK_VOID(status,FAIL,"Vgetnamelen"); vgname = (char *) HDmalloc(sizeof(char *) * (name_len+1)); CHECK_ALLOC(vgname, "vgname", "test_vglongnames" ); status=Vgetname(vg1, vgname); CHECK_VOID(status,FAIL,"VSgetname"); if (HDstrcmp(vgname, VGROUP1)) { num_errs++; printf(">>> Got bogus Vgroup name : %s\n", vgname); } if (vgname != NULL) HDfree(vgname); /* get the vgroup's class */ status = Vgetclassnamelen(vg1, &name_len); CHECK_VOID(status,FAIL,"Vgetnamelen"); vgclass = (char *) HDmalloc(sizeof(char *) * (name_len+1)); CHECK_ALLOC(vgclass, "vgclass", "test_vglongnames" ); status=Vgetclass(vg1, vgclass); CHECK_VOID(status,FAIL,"VSgetclass"); if (HDstrcmp(vgclass, VG_LONGCLASS)) { num_errs++; printf(">>> Got bogus Vgroup class : %s\n", vgclass); } if (vgclass != NULL) HDfree(vgclass); status = Vdetach(vg1); CHECK_VOID(status,FAIL,"Vdetach"); status = Vend(file_id); CHECK_VOID(status,FAIL,"Vend"); status = Hclose(file_id); CHECK_VOID(status,FAIL,"Hclose"); } /* test_vglongnames() */
GDALDataset *HDF4Dataset::Open( GDALOpenInfo * poOpenInfo ) { int32 i; if( !Identify( poOpenInfo ) ) return NULL; /* -------------------------------------------------------------------- */ /* Try opening the dataset. */ /* -------------------------------------------------------------------- */ int32 hHDF4; hHDF4 = Hopen(poOpenInfo->pszFilename, DFACC_READ, 0); if( hHDF4 <= 0 ) return( NULL ); Hclose( hHDF4 ); /* -------------------------------------------------------------------- */ /* Create a corresponding GDALDataset. */ /* -------------------------------------------------------------------- */ HDF4Dataset *poDS; poDS = new HDF4Dataset(); poDS->fp = poOpenInfo->fp; poOpenInfo->fp = NULL; /* -------------------------------------------------------------------- */ /* Open HDF SDS Interface. */ /* -------------------------------------------------------------------- */ poDS->hSD = SDstart( poOpenInfo->pszFilename, DFACC_READ ); if ( poDS->hSD == -1 ) { delete poDS; return NULL; } /* -------------------------------------------------------------------- */ /* Now read Global Attributes. */ /* -------------------------------------------------------------------- */ if ( poDS->ReadGlobalAttributes( poDS->hSD ) != CE_None ) { delete poDS; return NULL; } poDS->SetMetadata( poDS->papszGlobalMetadata, "" ); /* -------------------------------------------------------------------- */ /* Determine type of file we read. */ /* -------------------------------------------------------------------- */ const char *pszValue; if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "Signature")) && EQUAL( pszValue, pszGDALSignature ) ) { poDS->iSubdatasetType = H4ST_GDAL; poDS->pszSubdatasetType = "GDAL_HDF4"; } else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "Title")) && EQUAL( pszValue, "SeaWiFS Level-1A Data" ) ) { poDS->iSubdatasetType = H4ST_SEAWIFS_L1A; poDS->pszSubdatasetType = "SEAWIFS_L1A"; } else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "Title")) && EQUAL( pszValue, "SeaWiFS Level-2 Data" ) ) { poDS->iSubdatasetType = H4ST_SEAWIFS_L2; poDS->pszSubdatasetType = "SEAWIFS_L2"; } else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "Title")) && EQUAL( pszValue, "SeaWiFS Level-3 Standard Mapped Image" ) ) { poDS->iSubdatasetType = H4ST_SEAWIFS_L3; poDS->pszSubdatasetType = "SEAWIFS_L3"; } else if ( (pszValue = CSLFetchNameValue(poDS->papszGlobalMetadata, "L1 File Generated By")) && EQUALN( pszValue, "HYP version ", 12 ) ) { poDS->iSubdatasetType = H4ST_HYPERION_L1; poDS->pszSubdatasetType = "HYPERION_L1"; } else { poDS->iSubdatasetType = H4ST_UNKNOWN; poDS->pszSubdatasetType = "UNKNOWN"; } /* -------------------------------------------------------------------- */ /* If we have HDF-EOS dataset, process it here. */ /* -------------------------------------------------------------------- */ char szName[VSNAMELENMAX + 1], szTemp[8192]; char *pszString; const char *pszName; int nCount; int32 aiDimSizes[H4_MAX_VAR_DIMS]; int32 iRank, iNumType, nAttrs; bool bIsHDF = true; // Sometimes "HDFEOSVersion" attribute is not defined and we will // determine HDF-EOS datasets using other records // (see ReadGlobalAttributes() method). if ( poDS->bIsHDFEOS || CSLFetchNameValue(poDS->papszGlobalMetadata, "HDFEOSVersion") ) { bIsHDF = false; int32 nSubDatasets, nStrBufSize; /* -------------------------------------------------------------------- */ /* Process swath layers. */ /* -------------------------------------------------------------------- */ hHDF4 = SWopen( poOpenInfo->pszFilename, DFACC_READ ); if( hHDF4 < 0) { delete poDS; CPLError( CE_Failure, CPLE_OpenFailed, "Failed to open HDF4 `%s'.\n", poOpenInfo->pszFilename ); return NULL; } nSubDatasets = SWinqswath(poOpenInfo->pszFilename, NULL, &nStrBufSize); #if DEBUG CPLDebug( "HDF4", "Number of HDF-EOS swaths: %d", (int)nSubDatasets ); #endif if ( nSubDatasets > 0 && nStrBufSize > 0 ) { char *pszSwathList; char **papszSwaths; pszSwathList = (char *)CPLMalloc( nStrBufSize + 1 ); SWinqswath( poOpenInfo->pszFilename, pszSwathList, &nStrBufSize ); pszSwathList[nStrBufSize] = '\0'; #if DEBUG CPLDebug( "HDF4", "List of HDF-EOS swaths: %s", pszSwathList ); #endif papszSwaths = CSLTokenizeString2( pszSwathList, ",", CSLT_HONOURSTRINGS ); CPLFree( pszSwathList ); if ( nSubDatasets != CSLCount(papszSwaths) ) { CSLDestroy( papszSwaths ); delete poDS; CPLDebug( "HDF4", "Can not parse list of HDF-EOS grids." ); return NULL; } for ( i = 0; i < nSubDatasets; i++) { char *pszFieldList; char **papszFields; int32 *paiRank, *paiNumType; int32 hSW, nFields, j; hSW = SWattach( hHDF4, papszSwaths[i] ); nFields = SWnentries( hSW, HDFE_NENTDFLD, &nStrBufSize ); pszFieldList = (char *)CPLMalloc( nStrBufSize + 1 ); paiRank = (int32 *)CPLMalloc( nFields * sizeof(int32) ); paiNumType = (int32 *)CPLMalloc( nFields * sizeof(int32) ); SWinqdatafields( hSW, pszFieldList, paiRank, paiNumType ); #if DEBUG { char *pszTmp = SPrintArray( GDT_UInt32, paiRank, nFields, "," ); CPLDebug( "HDF4", "Number of data fields in swath %d: %d", (int) i, (int) nFields ); CPLDebug( "HDF4", "List of data fields in swath %d: %s", (int) i, pszFieldList ); CPLDebug( "HDF4", "Data fields ranks: %s", pszTmp ); CPLFree( pszTmp ); } #endif papszFields = CSLTokenizeString2( pszFieldList, ",", CSLT_HONOURSTRINGS ); for ( j = 0; j < nFields; j++ ) { SWfieldinfo( hSW, papszFields[j], &iRank, aiDimSizes, &iNumType, NULL ); if ( iRank < 2 ) continue; // Add field to the list of GDAL subdatasets nCount = CSLCount( poDS->papszSubDatasets ) / 2; sprintf( szTemp, "SUBDATASET_%d_NAME", nCount + 1 ); // We will use the field index as an identificator. poDS->papszSubDatasets = CSLSetNameValue( poDS->papszSubDatasets, szTemp, CPLSPrintf("HDF4_EOS:EOS_SWATH:\"%s\":%s:%s", poOpenInfo->pszFilename, papszSwaths[i], papszFields[j]) ); sprintf( szTemp, "SUBDATASET_%d_DESC", nCount + 1 ); pszString = SPrintArray( GDT_UInt32, aiDimSizes, iRank, "x" ); poDS->papszSubDatasets = CSLSetNameValue( poDS->papszSubDatasets, szTemp, CPLSPrintf( "[%s] %s %s (%s)", pszString, papszFields[j], papszSwaths[i], poDS->GetDataTypeName(iNumType) ) ); CPLFree( pszString ); } CSLDestroy( papszFields ); CPLFree( paiNumType ); CPLFree( paiRank ); CPLFree( pszFieldList ); SWdetach( hSW ); } CSLDestroy( papszSwaths ); } SWclose( hHDF4 ); /* -------------------------------------------------------------------- */ /* Process grid layers. */ /* -------------------------------------------------------------------- */ hHDF4 = GDopen( poOpenInfo->pszFilename, DFACC_READ ); nSubDatasets = GDinqgrid( poOpenInfo->pszFilename, NULL, &nStrBufSize ); #if DEBUG CPLDebug( "HDF4", "Number of HDF-EOS grids: %d", (int)nSubDatasets ); #endif if ( nSubDatasets > 0 && nStrBufSize > 0 ) { char *pszGridList; char **papszGrids; pszGridList = (char *)CPLMalloc( nStrBufSize + 1 ); GDinqgrid( poOpenInfo->pszFilename, pszGridList, &nStrBufSize ); #if DEBUG CPLDebug( "HDF4", "List of HDF-EOS grids: %s", pszGridList ); #endif papszGrids = CSLTokenizeString2( pszGridList, ",", CSLT_HONOURSTRINGS ); CPLFree( pszGridList ); if ( nSubDatasets != CSLCount(papszGrids) ) { CSLDestroy( papszGrids ); delete poDS; CPLDebug( "HDF4", "Can not parse list of HDF-EOS grids." ); return NULL; } for ( i = 0; i < nSubDatasets; i++) { char *pszFieldList; char **papszFields; int32 *paiRank, *paiNumType; int32 hGD, nFields, j; hGD = GDattach( hHDF4, papszGrids[i] ); nFields = GDnentries( hGD, HDFE_NENTDFLD, &nStrBufSize ); pszFieldList = (char *)CPLMalloc( nStrBufSize + 1 ); paiRank = (int32 *)CPLMalloc( nFields * sizeof(int32) ); paiNumType = (int32 *)CPLMalloc( nFields * sizeof(int32) ); GDinqfields( hGD, pszFieldList, paiRank, paiNumType ); #if DEBUG { char* pszTmp = SPrintArray( GDT_UInt32, paiRank, nFields, "," ); CPLDebug( "HDF4", "Number of fields in grid %d: %d", (int) i, (int) nFields ); CPLDebug( "HDF4", "List of fields in grid %d: %s", (int) i, pszFieldList ); CPLDebug( "HDF4", "Fields ranks: %s", pszTmp ); CPLFree( pszTmp ); } #endif papszFields = CSLTokenizeString2( pszFieldList, ",", CSLT_HONOURSTRINGS ); for ( j = 0; j < nFields; j++ ) { GDfieldinfo( hGD, papszFields[j], &iRank, aiDimSizes, &iNumType, NULL ); if ( iRank < 2 ) continue; // Add field to the list of GDAL subdatasets nCount = CSLCount( poDS->papszSubDatasets ) / 2; sprintf( szTemp, "SUBDATASET_%d_NAME", nCount + 1 ); // We will use the field index as an identificator. poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets, szTemp, CPLSPrintf( "HDF4_EOS:EOS_GRID:\"%s\":%s:%s", poOpenInfo->pszFilename, papszGrids[i], papszFields[j])); sprintf( szTemp, "SUBDATASET_%d_DESC", nCount + 1 ); pszString = SPrintArray( GDT_UInt32, aiDimSizes, iRank, "x" ); poDS->papszSubDatasets = CSLSetNameValue( poDS->papszSubDatasets, szTemp, CPLSPrintf("[%s] %s %s (%s)", pszString, papszFields[j], papszGrids[i], poDS->GetDataTypeName(iNumType)) ); CPLFree( pszString ); } CSLDestroy( papszFields ); CPLFree( paiNumType ); CPLFree( paiRank ); CPLFree( pszFieldList ); GDdetach( hGD ); } CSLDestroy( papszGrids ); GDclose( hHDF4 ); } GDclose( hHDF4 ); bIsHDF = ( nSubDatasets == 0 ); // Try to read as HDF } if( bIsHDF ) { /* -------------------------------------------------------------------- */ /* Make a list of subdatasets from SDSs contained in input HDF file. */ /* -------------------------------------------------------------------- */ int32 nDatasets; if ( SDfileinfo( poDS->hSD, &nDatasets, &nAttrs ) != 0 ) return NULL; for ( i = 0; i < nDatasets; i++ ) { int32 iSDS; iSDS = SDselect( poDS->hSD, i ); if ( SDgetinfo( iSDS, szName, &iRank, aiDimSizes, &iNumType, &nAttrs) != 0 ) return NULL; if ( iRank == 1 ) // Skip 1D datsets continue; // Do sort of known datasets. We will display only image bands if ( (poDS->iSubdatasetType == H4ST_SEAWIFS_L1A ) && !EQUALN( szName, "l1a_data", 8 ) ) continue; else pszName = szName; // Add datasets with multiple dimensions to the list of GDAL subdatasets nCount = CSLCount( poDS->papszSubDatasets ) / 2; sprintf( szTemp, "SUBDATASET_%d_NAME", nCount + 1 ); // We will use SDS index as an identificator, because SDS names // are not unique. Filename also needed for further file opening poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets, szTemp, CPLSPrintf( "HDF4_SDS:%s:\"%s\":%ld", poDS->pszSubdatasetType, poOpenInfo->pszFilename, (long)i) ); sprintf( szTemp, "SUBDATASET_%d_DESC", nCount + 1 ); pszString = SPrintArray( GDT_UInt32, aiDimSizes, iRank, "x" ); poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets, szTemp, CPLSPrintf( "[%s] %s (%s)", pszString, pszName, poDS->GetDataTypeName(iNumType)) ); CPLFree( pszString ); SDendaccess( iSDS ); } SDend( poDS->hSD ); poDS->hSD = 0; } /* -------------------------------------------------------------------- */ /* Build a list of raster images. Note, that HDF-EOS dataset may */ /* contain a raster image as well. */ /* -------------------------------------------------------------------- */ hHDF4 = Hopen(poOpenInfo->pszFilename, DFACC_READ, 0); poDS->hGR = GRstart( hHDF4 ); if ( poDS->hGR != -1 ) { if ( GRfileinfo( poDS->hGR, &poDS->nImages, &nAttrs ) == -1 ) return NULL; for ( i = 0; i < poDS->nImages; i++ ) { int32 iInterlaceMode; int32 iGR = GRselect( poDS->hGR, i ); // iRank in GR interface has another meaning. It represents number // of samples per pixel. aiDimSizes has only two dimensions. if ( GRgetiminfo( iGR, szName, &iRank, &iNumType, &iInterlaceMode, aiDimSizes, &nAttrs ) != 0 ) return NULL; nCount = CSLCount( poDS->papszSubDatasets ) / 2; sprintf( szTemp, "SUBDATASET_%d_NAME", nCount + 1 ); poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets, szTemp,CPLSPrintf( "HDF4_GR:UNKNOWN:\"%s\":%ld", poOpenInfo->pszFilename, (long)i)); sprintf( szTemp, "SUBDATASET_%d_DESC", nCount + 1 ); pszString = SPrintArray( GDT_UInt32, aiDimSizes, 2, "x" ); poDS->papszSubDatasets = CSLSetNameValue(poDS->papszSubDatasets, szTemp, CPLSPrintf( "[%sx%ld] %s (%s)", pszString, (long)iRank, szName, poDS->GetDataTypeName(iNumType)) ); CPLFree( pszString ); GRendaccess( iGR ); } GRend( poDS->hGR ); poDS->hGR = 0; } Hclose( hHDF4 ); poDS->nRasterXSize = poDS->nRasterYSize = 512; // XXX: bogus values // Make sure we don't try to do any pam stuff with this dataset. poDS->nPamFlags |= GPF_NOSAVE; /* -------------------------------------------------------------------- */ /* If we have single subdataset only, open it immediately */ /* -------------------------------------------------------------------- */ if ( CSLCount( poDS->papszSubDatasets ) / 2 == 1 ) { char *pszSDSName; pszSDSName = CPLStrdup( CSLFetchNameValue( poDS->papszSubDatasets, "SUBDATASET_1_NAME" )); delete poDS; poDS = NULL; GDALDataset* poRetDS = (GDALDataset*) GDALOpen( pszSDSName, poOpenInfo->eAccess ); CPLFree( pszSDSName ); if (poRetDS) { poRetDS->SetDescription(poOpenInfo->pszFilename); } return poRetDS; } else { /* -------------------------------------------------------------------- */ /* Confirm the requested access is supported. */ /* -------------------------------------------------------------------- */ if( poOpenInfo->eAccess == GA_Update ) { delete poDS; CPLError( CE_Failure, CPLE_NotSupported, "The HDF4 driver does not support update access to existing" " datasets.\n" ); return NULL; } } return( poDS ); }
int32 fid, fid1; int32 aid1, aid2; int32 fileid, length, offset, posn; uint16 tag, ref; int16 acc_mode, special; int32 ret; int i; intn errors = 0; intn ret_bool; for (i = 0; i < BUF_SIZE; i++) outbuf[i] = (char) (i % 256); MESSAGE(5, printf("Creating a file %s\n", TESTFILE_NAME); ); fid = Hopen(TESTFILE_NAME, DFACC_CREATE, 0); CHECK_VOID(fid, FAIL, "Hopen"); ret_bool = (intn) Hishdf(TESTFILE_NAME); CHECK_VOID(ret_bool, FALSE, "Hishdf"); ret = (int32)Hnewref(fid); CHECK_VOID(ret, FAIL, "Hnewref"); MESSAGE(5, printf("Reading / Writing to file\n"); ); ret = Hputelement(fid, (uint16) 100, 1, (const uint8 *) "testing 100 1", (int32)HDstrlen("testing 100 1") + 1); CHECK_VOID(ret, FAIL, "Hputelement"); ret = Hputelement(fid, (uint16) 100, (uint16) 4, outbuf, 2000);