[ossim-video] 01/02: Imported Upstream version 1.8.20.3+ds
Sebastiaan Couwenberg
sebastic at moszumanska.debian.org
Sat Jun 4 09:21:36 UTC 2016
This is an automated email from the git hooks/post-receive script.
sebastic pushed a commit to branch master
in repository ossim-video.
commit e0ef63860d6d926b1ec869351d081cf175914631
Author: Bas Couwenberg <sebastic at xs4all.nl>
Date: Sat Jun 4 10:58:48 2016 +0200
Imported Upstream version 1.8.20.3+ds
---
ossimPredator/CMakeLists.txt | 103 +
ossimPredator/include/ossimPredator/ffmpegApi.h | 25 +
.../include/ossimPredator/ossimPredatorApi.h | 9 +
.../include/ossimPredator/ossimPredatorExport.h | 48 +
.../include/ossimPredator/ossimPredatorInit.h | 22 +
.../include/ossimPredator/ossimPredatorKlvTable.h | 210 ++
.../include/ossimPredator/ossimPredatorLoader.h | 13 +
.../ossimPredator/ossimPredatorProjectionFactory.h | 83 +
.../include/ossimPredator/ossimPredatorThread.h | 61 +
.../ossimPredator/ossimPredatorUavProjection.h | 74 +
.../include/ossimPredator/ossimPredatorVideo.h | 274 +++
ossimPredator/projects/vs2005/ossimPredator.vcproj | 261 ++
ossimPredator/src/GNUmakefile | 119 +
ossimPredator/src/ossimPredatorInit.cpp | 67 +
ossimPredator/src/ossimPredatorKlvTable.cpp | 2537 ++++++++++++++++++++
ossimPredator/src/ossimPredatorThread.cpp | 105 +
ossimPredator/src/ossimPredatorUavProjection.cpp | 289 +++
ossimPredator/src/ossimPredatorVideo.cpp | 717 ++++++
ossimPredator/test/mutiThreadedTest.cpp | 56 +
.../ossimPredator/English.lproj/InfoPlist.strings | Bin 0 -> 152 bytes
ossimPredator/xcode/ossimPredator/Info.plist | 26 +
.../ossimPredator.xcodeproj/project.pbxproj | 1270 ++++++++++
22 files changed, 6369 insertions(+)
diff --git a/ossimPredator/CMakeLists.txt b/ossimPredator/CMakeLists.txt
new file mode 100644
index 0000000..cd72e35
--- /dev/null
+++ b/ossimPredator/CMakeLists.txt
@@ -0,0 +1,103 @@
+PROJECT(ossimPredator)
+Message("################## Setting up ossimPredator library #########################")
+
+INCLUDE(OssimVersion)
+INCLUDE(OssimUtilities)
+INCLUDE(OssimCommonVariables)
+
+IF(NOT APPLE)
+ cmake_minimum_required(VERSION 2.6)
+ELSE(NOT APPLE)
+ cmake_minimum_required(VERSION 2.8)
+ENDIF(NOT APPLE)
+
+INCLUDE_DIRECTORIES(${${PROJECT_NAME}_SOURCE_DIR}/include)
+
+# Stores list of libs to link with. Initialized throughout.
+set( dependentLibs )
+
+# FFMPEG - Required:
+find_package( FFmpeg )
+if( FFMPEG_FOUND )
+ include_directories( ${FFMPEG_INCLUDE_DIRS} )
+ set( dependentLibs ${dependentLibs} ${FFMPEG_LIBRARIES} )
+else( FFMPEG_FOUND )
+ message( FATAL_ERROR "Could not find required ffmpeg package!" )
+endif( FFMPEG_FOUND )
+
+# OpenThreads - Required:
+find_package( OpenThreads )
+if( OPENTHREADS_FOUND )
+ include_directories( ${OPENTHREADS_INCLUDE_DIR} )
+ set( dependentLibs ${dependentLibs} ${OPENTHREADS_LIBRARY} )
+else( OPENTHREADS_FOUND )
+ message( FATAL_ERROR "Could not find required OpenThreads package!" )
+endif( OPENTHREADS_FOUND )
+
+# Ossim - Required:
+find_package( ossim )
+if( OSSIM_FOUND )
+ include_directories( ${OSSIM_INCLUDE_DIR} )
+ set( dependentLibs ${dependentLibs} ${OSSIM_LIBRARY} )
+else( OSSIM_FOUND )
+ message( FATAL_ERROR "Could not find required Ossim package!" )
+endif( OSSIM_FOUND )
+
+# Zlib - Required:
+find_package( ZLIB )
+if( ZLIB_FOUND )
+ include_directories( ${ZLIB_INCLUDE_DIR} )
+ set( dependentLibs ${dependentLibs} ${ZLIB_LIBRARY} )
+else( ZLIB_FOUND )
+ message( FATAL_ERROR "Could not find required Zlib package!" )
+endif( ZLIB_FOUND )
+
+# bzip2 - Optional
+find_package( BZIP2 )
+if( BZIP2_FOUND )
+ include_directories( ${BZIP2_INCLUDE_DIR} )
+ set( dependentLibs ${dependentLibs} ${BZIP2_LIBRARY} )
+else( BZIP2_FOUND )
+ message( WARNING "Could not find bzip2 package! Consider installing this as it will soon become a required package." )
+endif( BZIP2_FOUND )
+
+MESSAGE( STATUS "OSSIM_INCLUDE_DIR=${OSSIM_INCLUDE_DIR}")
+MESSAGE( STATUS "OSSIM_LIBRARIES =${OSSIM_LIBRARIES}")
+MESSAGE( STATUS "FFMPEG_LIBRARIES = ${FFMPEG_LIBRARIES}")
+MESSAGE( STATUS "FFMPEG_INCLUDE_DIRS = ${FFMPEG_INCLUDE_DIRS}")
+MESSAGE( STATUS "OPENTHREADS_LIBRARY = ${OPENTHREADS_LIBRARY}")
+MESSAGE( STATUS "OPENTHREADS_INCLUDE_DIR = ${OPENTHREADS_INCLUDE_DIR}")
+MESSAGE( STATUS "ZLIB_LIBRARY = ${ZLIB_LIBRARY}" )
+MESSAGE( STATUS "ZLIB_INCLUDE = ${ZLIB_INCLUDE_DIR}" )
+MESSAGE( STATUS "BZIP2_LIBRARY = ${BZIP2_LIBRARY}" )
+MESSAGE( STATUS "BZIP2_INCLUDE = ${BZIP2_INCLUDE_DIR}" )
+MESSAGE( STATUS "dependent libraries= ${dependentLibraries}" )
+
+################################################## BUILD THE LIBRARY #######################################
+SET(LIB_NAME ossimPredator)
+
+
+INCLUDE_DIRECTORIES(${${PROJECT_NAME}_BINARY_DIR}/include)
+INCLUDE_DIRECTORIES(${FFMPEG_INCLUDE_DIRS})
+INCLUDE_DIRECTORIES(${OPENTHREADS_INCLUDE_DIR})
+INCLUDE_DIRECTORIES(${OSSIM_INCLUDE_DIR})
+
+IF(BZIP2_FOUND)
+ INCLUDE_DIRECTORIES(${BZIP2_INCLUDE_DIR})
+ELSE(BZIP2_FOUND)
+ SET(BZIP2_LIBRARIES "")
+ENDIF(BZIP2_FOUND)
+
+FILE(GLOB OSSIMPREDATOR_SRCS RELATIVE_PATH ${CMAKE_CURRENT_SOURCE_DIR} "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp")
+FILE(GLOB OSSIMPREDATOR_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/include/ossimPredator/*.h")
+
+set(INSTALL_INCLUDE_DIR "include/ossimPredator")
+OSSIM_LINK_LIBRARY(${LIB_NAME} COMPONENT_NAME ossim TYPE "${OSSIM_USER_DEFINED_DYNAMIC_OR_STATIC}" HEADERS ${OSSIMPREDATOR_HEADERS} SOURCE_FILES ${OSSIMPREDATOR_SRCS}
+ LIBRARIES ${dependentLibs}
+ INSTALL_LIB INSTALL_HEADERS VERSION_SYMLINKS ADDITIONAL_COMPILE_FLAGS "-DOSSIMPREDATOR_LIBRARY")
+set(INCLUDE_DIR "include")
+
+####################################### SETUP THE UNINSTALL #################################
+OSSIM_ADD_COMMON_MAKE_UNINSTALL()
+
+message("################## end of ossimPredator library setup #########################")
diff --git a/ossimPredator/include/ossimPredator/ffmpegApi.h b/ossimPredator/include/ossimPredator/ffmpegApi.h
new file mode 100644
index 0000000..e35f598
--- /dev/null
+++ b/ossimPredator/include/ossimPredator/ffmpegApi.h
@@ -0,0 +1,25 @@
+#ifndef ffmpegApi_HEADER
+#define ffmpegApi_HEADER
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+#include <stdio.h>
+#if defined(FMPEG_SINGLE_INCLUDE)
+#include <ffmpeg/avcodec.h>
+#include <ffmpeg/avformat.h>
+#include <ffmpeg/avdevice.h>
+#include <ffmpeg/swscale.h>
+#else
+#include <libavcodec/avcodec.h>
+#include <libavdevice/avdevice.h>
+#include <libavformat/avformat.h>
+#include <libswscale/swscale.h>
+#endif
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
diff --git a/ossimPredator/include/ossimPredator/ossimPredatorApi.h b/ossimPredator/include/ossimPredator/ossimPredatorApi.h
new file mode 100644
index 0000000..72eb695
--- /dev/null
+++ b/ossimPredator/include/ossimPredator/ossimPredatorApi.h
@@ -0,0 +1,9 @@
+#ifndef ossimPredatorApi_HEADER
+#define ossimPredatorApi_HEADER
+
+#include "ffmpegApi.h"
+#include "ossimPredatorVideo.h"
+#include "ossimPredatorThread.h"
+
+
+#endif
diff --git a/ossimPredator/include/ossimPredator/ossimPredatorExport.h b/ossimPredator/include/ossimPredator/ossimPredatorExport.h
new file mode 100644
index 0000000..a901038
--- /dev/null
+++ b/ossimPredator/include/ossimPredator/ossimPredatorExport.h
@@ -0,0 +1,48 @@
+#ifndef ossimPredatorExport_HEADER
+#define ossimPredatorExport_HEADER
+// define used to include in API which is being fazed out
+// if you can compile your apps with this turned off you are
+// well placed for compatablity with future versions.
+#define USE_DEPRECATED_API
+
+#if defined(_MSC_VER)
+ #pragma warning( disable : 4244 )
+ #pragma warning( disable : 4251 )
+ #pragma warning( disable : 4267 )
+ #pragma warning( disable : 4275 )
+ #pragma warning( disable : 4290 )
+ #pragma warning( disable : 4786 )
+ #pragma warning( disable : 4305 )
+#endif
+
+#if defined(_MSC_VER) || defined(__MINGW32__) || defined( __BCPLUSPLUS__) || defined( __MWERKS__)
+# ifdef OSSIMPREDATOR_LIBRARY
+# define OSSIMPREDATOR_EXPORT __declspec(dllexport)
+# define OSSIMPREDATOR_DLL OSSIMPREDATOR_EXPORT
+# else
+# define OSSIMPREDATOR_EXPORT __declspec(dllimport)
+# define OSSIMPREDATOR_DLL OSSIMPREDATOR_EXPORT
+# endif /* OSSIMPREDATOR_LIBRARY */
+#else
+# define OSSIMPREDATOR_EXPORT
+# define OSSIMPREDATOR_DLL OSSIMPREDATOR_EXPORT
+#endif
+
+// set up define for whether member templates are supported by VisualStudio compilers.
+#ifdef _MSC_VER
+# if (_MSC_VER >= 1300)
+# define __STL_MEMBER_TEMPLATES
+# endif
+#endif
+
+/* Define NULL pointer value */
+
+#ifndef NULL
+ #ifdef __cplusplus
+ #define NULL 0
+ #else
+ #define NULL ((void *)0)
+ #endif
+#endif
+
+#endif
diff --git a/ossimPredator/include/ossimPredator/ossimPredatorInit.h b/ossimPredator/include/ossimPredator/ossimPredatorInit.h
new file mode 100644
index 0000000..18e17e8
--- /dev/null
+++ b/ossimPredator/include/ossimPredator/ossimPredatorInit.h
@@ -0,0 +1,22 @@
+#ifndef ossimPredatorInit_HEADER
+#define ossimPredatorInit_HEADER
+#include <ossimPredator/ossimPredatorExport.h>
+#include <OpenThreads/Mutex>
+class OSSIMPREDATOR_DLL ossimPredatorInit
+{
+public:
+ static ossimPredatorInit* instance();
+ OpenThreads::Mutex& criticalSectionMutex()
+ {
+ return theCriticalSectionMutex;
+ }
+
+protected:
+ ossimPredatorInit();
+ ossimPredatorInit(const ossimPredatorInit& src);
+
+ OpenThreads::Mutex theCriticalSectionMutex;
+ static ossimPredatorInit* theInstance;
+};
+
+#endif
diff --git a/ossimPredator/include/ossimPredator/ossimPredatorKlvTable.h b/ossimPredator/include/ossimPredator/ossimPredatorKlvTable.h
new file mode 100644
index 0000000..24072f9
--- /dev/null
+++ b/ossimPredator/include/ossimPredator/ossimPredatorKlvTable.h
@@ -0,0 +1,210 @@
+#ifndef ossimPredatorKlvTable_HEADER
+#define ossimPredatorKlvTable_HEADER
+#include <ossim/base/ossimConstants.h>
+#include <ossim/base/ossimString.h>
+#include <ossim/base/ossimFilename.h>
+#include <ossim/base/ossimReferenced.h>
+#include <ossim/base/ossimGpt.h>
+#include <ossim/base/ossimDpt.h>
+#include <ossim/base/ossimDrect.h>
+#include <ossim/base/ossimIrect.h>
+#include <ossim/base/ossimDate.h>
+#include <ossim/base/ossimEndian.h>
+#include <map>
+#include <ossimPredator/ossimPredatorExport.h>
+
+typedef ossim_uint8 OSSIM_PREDATOR_UDS[16];
+
+enum ossimPredatorKlvIndex
+{
+ KLV_KEY_INVALID = -1,
+ KLV_KEY_STREAM_ID = 0,
+ KLV_KEY_ORGANIZATIONAL_PROGRAM_NUMBER,
+ KLV_KEY_UNIX_TIMESTAMP,
+ KLV_KEY_USER_DEFINED_UTC_TIMESTAMP,
+ KLV_KEY_USER_DEFINED_TIMESTAMP_MICROSECONDS_1970,
+ KLV_KEY_VIDEO_START_DATE_TIME_UTC, //Video time stamp
+ KLV_TIMESYSTEM_OFFSET,
+ KLV_UAS_DATALINK_LOCAL_DATASET,
+ KLV_BASIC_UNIVERSAL_METADATA_SET,
+ KLV_URL_STRING,
+ KLV_KEY_OBJECT_COUNTRY_CODES,
+ KLV_KEY_SECURITY_CLASSIFICATION_SET,
+ KLV_KEY_BYTE_ORDER, /* MM=Big Endian ll=Little Endian */
+ KLV_KEY_MISSION_NUMBER,
+ KLV_KEY_SECURITY_CLASSIFICATION,
+ KLV_KEY_SECURITY_RELEASE_INSTRUCTIONS,
+ KLV_KEY_SECURITY_CAVEATS,
+ KLV_KEY_CLASSIFICATION_COMMENT,
+ KLV_KEY_ORIGINAL_PRODUCER_NAME,
+ KLV_KEY_PLATFORM_GROUND_SPEED,
+ KLV_KEY_PLATFORM_MAGNETIC_HEADING_ANGLE,
+ KLV_KEY_PLATFORM_HEADING_ANGLE,
+ KLV_KEY_PLATFORM_PITCH_ANGLE,
+ KLV_KEY_PLATFORM_ROLL_ANGLE,
+ KLV_KEY_PLATFORM_DESIGNATION,
+ KLV_KEY_PLATFORM_DESIGNATION2,
+ KLV_KEY_INDICATED_AIR_SPEED,
+ KLV_KEY_IMAGE_SOURCE_SENSOR,
+ KLV_KEY_IMAGE_COORDINATE_SYSTEM,
+ KLV_KEY_SENSOR_RELATIVE_ELEVATION_ANGLE,
+ KLV_KEY_SENSOR_RELATIVE_AZIMUTH_ANGLE,
+ KLV_KEY_SENSOR_RELATIVE_ROLL_ANGLE,
+ KLV_KEY_SENSOR_LATITUDE,
+ KLV_KEY_SENSOR_LONGITUDE,
+ KLV_KEY_SENSOR_TRUE_ALTITUDE,
+ KLV_KEY_SENSOR_HORIZONTAL_FOV,
+ KLV_KEY_SENSOR_VERTICAL_FOV1, // this is to the SPEC
+ KLV_KEY_SENSOR_VERTICAL_FOV2, // this is not to SPEC but have found undefined key that looks like it should be vertical field of view
+ KLV_KEY_SLANT_RANGE,
+ KLV_KEY_OBLIQUITY_ANGLE,
+ KLV_KEY_ANGLE_TO_NORTH,
+ KLV_KEY_TARGET_WIDTH,
+ KLV_KEY_FRAME_CENTER_LATITUDE,
+ KLV_KEY_FRAME_CENTER_LONGITUDE,
+ KLV_KEY_FRAME_CENTER_ELEVATION,
+ KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_1,
+ KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_1,
+ KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_2,
+ KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_2,
+ KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_3,
+ KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_3,
+ KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_4,
+ KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_4,
+
+ KLV_KEY_CORNER_LATITUDE_POINT_1,
+ KLV_KEY_CORNER_LONGITUDE_POINT_1,
+ KLV_KEY_CORNER_LATITUDE_POINT_2,
+ KLV_KEY_CORNER_LONGITUDE_POINT_2,
+ KLV_KEY_CORNER_LATITUDE_POINT_3,
+ KLV_KEY_CORNER_LONGITUDE_POINT_3,
+ KLV_KEY_CORNER_LATITUDE_POINT_4,
+ KLV_KEY_CORNER_LONGITUDE_POINT_4,
+ KLV_KEY_DEVICE_ABSOLUTE_SPEED,
+ KLV_KEY_DEVICE_ABSOLUTE_HEADING,
+ KLV_KEY_ABSOLUTE_EVENT_START_DATE,
+ KLV_KEY_SENSOR_ROLL_ANGLE,
+ KLV_KEY_PLATFORM_TAIL_NUMBER,
+ KLV_KEY_GENERIC_FLAG_DATA_01,
+ KLV_KEY_UAS_LDS_VERSION_NUMBER,
+ KLV_KEY_STATIC_PRESSURE,
+ KLV_SECURITY_METADATA_UNIVERSAL_SET,
+ KLV_KEY_TOTAL
+};
+
+class OSSIMPREDATOR_EXPORT ossimPredatorKlvInfoType
+{
+public:
+ ossimPredatorKlvIndex theId; // my ID as defined in the KlvIndex enumeration
+ const char* theName;
+ OSSIM_PREDATOR_UDS theKey;
+};
+
+
+class OSSIMPREDATOR_EXPORT ossimPredatorKlvTable : public ossimReferenced
+{
+public:
+ struct Node
+ {
+ Node(int id=0,
+ const std::vector<ossim_uint8>& value=std::vector<ossim_uint8>())
+ :theId(id),
+ theValue(value)
+ {
+
+ }
+ int theId;
+
+ std::vector<ossim_uint8> theValue;
+ };
+ typedef std::map<ossimPredatorKlvIndex, ossimPredatorKlvTable::Node> klvMapType;
+ ossimPredatorKlvTable();
+ ossimPredatorKlvTable(const ossimPredatorKlvTable& src)
+ :theNeedToParseBuffer(src.theNeedToParseBuffer),
+ theKlvParameters(src.theKlvParameters),
+ theNeedToSwapFlag(src.theNeedToSwapFlag)
+ {
+ }
+ ossimPredatorKlvTable* dup()const
+ {
+ return new ossimPredatorKlvTable(*this);
+ }
+ bool addKeys(const std::vector<ossim_uint8>& buffer);
+ bool addKeys(const ossim_uint8* buffer, ossim_uint32 length);
+ void clear();
+ //ossimString getValueAsString(ossimPredatorKlvIndex id)const;
+ bool valueAsString(ossimString& result,
+ ossimPredatorKlvIndex id)const;
+ ossimString valueAsString(ossimPredatorKlvIndex id)const;
+
+ bool getCornerPoints(ossimGpt& pt1,
+ ossimGpt& pt2,
+ ossimGpt& pt3,
+ ossimGpt& pt4)const;
+ bool getFrameCenterOffsets(ossimDpt& pt1Offset,
+ ossimDpt& pt2Offset,
+ ossimDpt& pt3Offset,
+ ossimDpt& pt4Offset)const;
+ /**
+ * Nothing has been shifted. The Elevation is still relative to mean sea level.
+ */
+ bool getFrameCenter(ossim_float64& lat,
+ ossim_float64& lon,
+ ossim_float64& elevation)const;
+
+ bool getSensorPosition(ossim_float64& lat,
+ ossim_float64& lon,
+ ossim_float64& elev)const;
+ bool getPlatformOrientation(ossim_float32& heading,
+ ossim_float32& pitch,
+ ossim_float32& roll)const;
+ bool getSensorRollAngle(ossim_float32& angle)const;
+ bool getObliquityAngle(ossim_float32& angle)const;
+ bool getSlantRange(ossim_float32& range)const;
+ bool getHorizontalFieldOfView(ossim_float32& hfov)const;
+ bool getVerticalFieldOfView(ossim_float32& hfov)const;
+ bool getAngleToNorth(ossim_float32& angleToNorth)const;
+ bool getTargetWidthInMeters(ossim_float32& targetWidth)const;
+ ossimString getUtcTimestamp()const;
+
+ /**
+ * This is defined to be in microseconds
+ */
+ bool getUnixEpocTimestamp(ossim_int64& timestamp)const;
+
+ /**
+ * Converts the microseconds to be a decmail seconds and it's fractional part
+ */
+ bool getUnixEpocTimestampInSeconds(ossim_int64& seconds,
+ ossim_float64& fractionalPart)const;
+
+ /**
+ * Converts the microseconds past to be in a decimal seconds
+ */
+ bool getUnixEpocTimestampInFractionalSeconds(ossim_float64& fractionalSeconds)const;
+
+ bool getDate(ossimDate& d, bool shiftToGmtZero = false)const;
+ bool getDateUsingEpoc(ossimDate& d)const;
+ bool getDateUsingUtc(ossimDate& d, bool shiftToGmtZero = false)const;
+
+ virtual std::ostream& print(std::ostream& out)const;
+protected:
+ ossimPredatorKlvTable::Node convertValue(int id, const std::vector<ossim_uint8>& bufferValue);
+ int findPredatorKlvIndex(const ossim_uint8* buf)const;
+ int findPredatorKlvIndexByKey(ossim_uint32 key)const;
+ void addAbsoluteKeyDefinitions(const std::vector<ossim_uint8>& buffer, bool& needMore);
+
+ void addSecurityMetadataLocalSetElements(const std::vector<ossim_uint8>& buffer, klvMapType& tempTable);
+ void addUasDatalinkLocalDataSet(const std::vector<ossim_uint8>& buffer, klvMapType& tempTable, ossim_uint16& checksum);
+ void loadVariableDataNullTerminated(std::vector<ossim_uint8>& result,
+ const std::vector<ossim_uint8>& buf,
+ ossim_uint32& idx)const;
+ ossim_uint16 compute16BitChecksum(const std::vector<ossim_uint8>& checksumBuffer)const;
+ std::vector<ossim_uint8> theNeedToParseBuffer;
+ static const ossim_uint8 theKlvKey[4];//{ 0x06,0x0e,0x2b,0x34 }
+ klvMapType theKlvParameters;
+ ossimEndian theEndian;
+ bool theNeedToSwapFlag;
+};
+
+#endif
diff --git a/ossimPredator/include/ossimPredator/ossimPredatorLoader.h b/ossimPredator/include/ossimPredator/ossimPredatorLoader.h
new file mode 100644
index 0000000..af10623
--- /dev/null
+++ b/ossimPredator/include/ossimPredator/ossimPredatorLoader.h
@@ -0,0 +1,13 @@
+#ifndef ossimPredatorLoader_HEADER
+#define ossimPredatorLoader_HEADER
+#include "ossimPredatorApi.h"
+#include <ossimPredator/ossimPredatorExport.h>
+
+class OSSIMPREDATOR_DLL ossimPredatorLoader : public OpenThreads::Thread
+{
+public:
+
+protected:
+
+};
+#endif
diff --git a/ossimPredator/include/ossimPredator/ossimPredatorProjectionFactory.h b/ossimPredator/include/ossimPredator/ossimPredatorProjectionFactory.h
new file mode 100644
index 0000000..1500e38
--- /dev/null
+++ b/ossimPredator/include/ossimPredator/ossimPredatorProjectionFactory.h
@@ -0,0 +1,83 @@
+#ifndef ossimPredatorProjectionFactory_HEADER
+#define ossimPredatorProjectionFactory_HEADER
+#include <ossim/projection/ossimProjectionFactoryBase.h>
+#include <ossimPredator/ossimPredatorExport.h>
+
+class OSSIMPREDATOR_DLL ossimPredatorProjectionFactory : public ossimProjectionFactoryBase
+{
+public:
+ static ossimPredatorProjectionFactory* instance()
+ {
+ if(!theInstance)
+ {
+ theInstance = new ossimPredatorProjectionFactory;
+ ossimProjectionFactoryRegistry::instance()->registerFactory(theInstance);
+ }
+ }
+ /**
+ * takes a filename. This filename can be an image file or
+ * it can also be a ossim .geom file. It could be other
+ * forms of geom files as well. The factories job will be to
+ * determine what parser to use and return a projection if
+ * successful.
+ */
+ virtual ossimProjection* createProjection(const ossimFilename& filename,
+ ossim_uint32 entryIdx)const
+ {
+ return 0;
+ }
+ virtual ossimObject* createObject(const ossimString& typeName)const
+ {
+ return createProjection(typeName);
+ }
+
+ /*!
+ * Creates and object given a keyword list.
+ */
+ virtual ossimObject* createObject(const ossimKeywordlist& kwl,
+ const char* prefix=0)const
+ {
+ return createProjection(kwl, prefix);
+ }
+
+
+ /**
+ * Take a projection type name.
+ */
+ virtual ossimProjection* createProjection(const ossimString& name)const
+ {
+ if(name == "ossimUavProjection")
+ {
+ return new ossimUavProjection();
+ }
+
+ return 0;
+ }
+
+ /**
+ * Take a keywordlist.
+ */
+ virtual ossimProjection* createProjection(const ossimKeywordlist& kwl,
+ const char* prefix)const
+ {
+ const char* type = kwl.find(prefix, ossimKeywordNames::TYPE_KW);
+ ossimProjection* result = createProjection(ossimString(type));
+ if(result)
+ {
+ if(result->loadState(kwl, prefix))
+ {
+ return result;
+ }
+ delete result;
+ result = 0;
+ }
+ return result;
+ }
+ virtual void getTypeNameList(std::vector<ossimString>& typeList)const
+ {
+ typeList.push_back("ossimUavProjection");
+ }
+protected:
+ static ossimPredatorProjectionFactory* theInstance;
+};
+#endif //ossimPredatorProjectionFactory_HEADER
diff --git a/ossimPredator/include/ossimPredator/ossimPredatorThread.h b/ossimPredator/include/ossimPredator/ossimPredatorThread.h
new file mode 100644
index 0000000..aacdab2
--- /dev/null
+++ b/ossimPredator/include/ossimPredator/ossimPredatorThread.h
@@ -0,0 +1,61 @@
+#ifndef ossimPredatorThread_HEADER
+#define ossimPredatorThread_HEADER
+
+#include <OpenThreads/Thread>
+#include <OpenThreads/Mutex>
+#include <OpenThreads/ScopedLock>
+#include <OpenThreads/Block>
+#include "ossimPredatorApi.h"
+#include <ossimPredator/ossimPredatorExport.h>
+class OSSIMPREDATOR_DLL ossimPredatorRefBlock : virtual public ossimReferenced,
+ public OpenThreads::Block
+{
+public:
+ ossimPredatorRefBlock()
+ {}
+};
+
+class OSSIMPREDATOR_DLL ossimPredatorThread : public OpenThreads::Thread
+{
+public:
+ ossimPredatorThread()
+ {
+ theBlock = new ossimPredatorRefBlock;
+ theStartThreadCalledFlag = false;
+ theDoneFlag = false;
+ theBlock->set(true);
+ theNumberOfFramesToBuffer = 1;
+ }
+ void setNumberOfFramesToBuffer(ossim_uint32 framesToBuffer)
+ {
+ theNumberOfFramesToBuffer = framesToBuffer;
+ }
+ virtual void run();
+ virtual int cancel();
+
+ ossimRefPtr<ossimPredatorVideo::FrameInfo> nextFrame();
+
+ bool openPredator(const ossimFilename& file);
+ void setVideo(ossimPredatorVideo* video);
+
+ void updateThreadBlock()
+ {
+ OpenThreads::ScopedLock<OpenThreads::Mutex> lock(theFrameBufferMutex);
+
+ // set true if we need to fill the frame buffer
+ theBlock->set( (theFrameBuffer.size() < theNumberOfFramesToBuffer));
+ // will update the block
+ }
+
+protected:
+
+ ossimRefPtr<ossimPredatorRefBlock> theBlock;
+ bool theDoneFlag;
+ bool theStartThreadCalledFlag;
+ ossimRefPtr<ossimPredatorVideo> theVideo;
+ OpenThreads::Mutex theFrameBufferMutex;
+ ossim_uint32 theNumberOfFramesToBuffer;
+ std::deque<ossimRefPtr<ossimPredatorVideo::FrameInfo> > theFrameBuffer;
+};
+
+#endif
diff --git a/ossimPredator/include/ossimPredator/ossimPredatorUavProjection.h b/ossimPredator/include/ossimPredator/ossimPredatorUavProjection.h
new file mode 100644
index 0000000..b123a61
--- /dev/null
+++ b/ossimPredator/include/ossimPredator/ossimPredatorUavProjection.h
@@ -0,0 +1,74 @@
+#ifndef ossimPredatorUavProjection_HEADER
+#define ossimPredatorUavProjection_HEADER
+#include <ossim/base/ossimMatrix4x4.h>
+#include <ossim/base/ossimLsrSpace.h>
+#include <ossim/base/ossimEllipsoid.h>
+#include <ossim/elevation/ossimElevManager.h>
+#include <ossim/projection/ossimSensorModel.h>
+#include <ossimPredator/ossimPredatorExport.h>
+
+class OSSIMPREDATOR_DLL ossimPredatorUavProjection : public ossimSensorModel
+{
+public:
+ ossimPredatorUavProjection();
+ virtual ~ossimPredatorUavProjection();
+ void setParameters(ossim_uint32 imageWidth,
+ ossim_uint32 imageHeight,
+ const ossimGpt& sensorPosition,
+ const ossimGpt& frameCenter,
+ const ossim_float64 platformHeading,
+ const ossim_float64 platformPitch,
+ const ossim_float64 platformRoll,
+ ossim_float64 hfov,
+ ossim_float64 vfov,
+ ossim_float64 obliquityAngle,
+ ossim_float64 angleToNorth,
+ ossim_float64 targetWidthInMeters,
+ ossim_float64 slantRange
+ );
+
+ virtual void updateModel();
+ virtual ossimObject* dup()const;
+ virtual void imagingRay(const ossimDpt& image_point,
+ ossimEcefRay& image_ray) const;
+ virtual bool useForward()const;
+ void lineSampleToWorld(const ossimDpt& image_point,
+ ossimGpt& gpt) const;
+ virtual void lineSampleHeightToWorld(const ossimDpt& image_point,
+ const double& heightEllipsoid,
+ ossimGpt& worldPoint) const;
+ virtual ossimGpt origin()const;
+
+ virtual bool saveState(ossimKeywordlist& kwl,
+ const char* prefix = 0)const;
+ virtual bool loadState(const ossimKeywordlist& kwl,
+ const char* prefix = 0);
+protected:
+ ossim_float32 theWidth;
+ ossim_float32 theHeight;
+ ossimGpt theSensorPosition;
+ ossimEcefPoint theSensorEcefPosition;
+ ossimEcefPoint theAdjNadirSensorEcefPosition;
+ ossimGpt theFrameCenter;
+ ossimEcefPoint theFrameCenterEcef;
+ ossim_float64 thePlatformHeading;
+ ossim_float64 thePlatformPitch;
+ ossim_float64 thePlatformRoll;
+ ossim_float64 theHorizontalFieldOfView;
+ ossim_float64 theVerticalFieldOfView;
+ ossim_float64 theObliquityAngle;
+ ossim_float64 theAngleToNorth;
+ ossim_float64 theTargetWidthInMeters;
+ ossim_float64 theSlantRange;
+ NEWMAT::Matrix theProjectionMatrix;
+ NEWMAT::Matrix theOrientationMatrix;
+ NEWMAT::Matrix theOrientationMatrixInverse;
+
+
+ NEWMAT::Matrix m_air2Ned;
+ NEWMAT::Matrix m_ecef2Ned;
+ NEWMAT::Matrix m_ecef2NedInverse;
+
+};
+
+#endif //ossimPredatorUavProjection_HEADER
diff --git a/ossimPredator/include/ossimPredator/ossimPredatorVideo.h b/ossimPredator/include/ossimPredator/ossimPredatorVideo.h
new file mode 100644
index 0000000..133d674
--- /dev/null
+++ b/ossimPredator/include/ossimPredator/ossimPredatorVideo.h
@@ -0,0 +1,274 @@
+#ifndef ossimPredatorVideo_HEADER
+#define ossimPredatorVideo_HEADER
+#include "ffmpegApi.h"
+#include <ossim/base/ossimConstants.h>
+#include <ossim/base/ossimReferenced.h>
+#include <ossim/base/ossimRefPtr.h>
+#include <OpenThreads/Mutex>
+#include <OpenThreads/ScopedLock>
+#include <queue>
+#include <iostream>
+#include <ossimPredator/ossimPredatorExport.h>
+#include <ossimPredator/ossimPredatorKlvTable.h>
+
+
+class OSSIMPREDATOR_DLL ossimPredatorVideo : public ossimReferenced
+{
+public:
+ enum SeekType
+ {
+ SEEK_NONE = 0,
+ SEEK_RELATIVE = 1,
+ SEEK_ABSOLUTE = 2
+ };
+ class KlvInfo : public ossimReferenced
+ {
+ public:
+ KlvInfo()
+ :theTime(0.0)
+ {
+
+ }
+ KlvInfo(const KlvInfo& src)
+ :theTime(0.0),
+ theTable(src.theTable.valid()?src.theTable->dup():0)
+ {
+
+ }
+ ~KlvInfo()
+ {
+ theTable = 0;
+ }
+ KlvInfo* dup()const
+ {
+ return new KlvInfo(*this);
+ }
+ void setTable(ossimPredatorKlvTable* value)
+ {
+ theTable = value;
+ }
+ void setTime(ossim_float64 t)
+ {
+ theTime = t;
+ }
+ const ossimPredatorKlvTable* table()const
+ {
+ return theTable.get();
+ }
+ ossimPredatorKlvTable* table()
+ {
+ return theTable.get();
+ }
+ ossim_float64 time()const
+ {
+ return theTime;
+ }
+ protected:
+ ossim_float64 theTime; // seconds since first Klv
+ ossimRefPtr<ossimPredatorKlvTable> theTable;
+ };
+ class FrameInfo : public ossimReferenced
+ {
+ public:
+ FrameInfo()
+ :theVideoFrameTime(0.0),
+ theKlvInfo(new KlvInfo())
+ {
+ }
+ FrameInfo(const FrameInfo& src)
+ :theRgbBuffer(src.theRgbBuffer),
+ theVideoFrameTime(src.theVideoFrameTime),
+ theImageRect(src.theImageRect),
+ theKlvInfo(src.theKlvInfo->dup())
+ {
+ }
+ ~FrameInfo()
+ {
+ }
+ FrameInfo* dup()const
+ {
+ return new FrameInfo(*this);
+ }
+ ossimIrect imageRect()const
+ {
+ return theImageRect;
+ }
+ void setImageRect(const ossimIrect& rect)
+ {
+ theImageRect = rect;
+ }
+ void allocate()
+ {
+ ossim_uint32 size = theImageRect.width()*theImageRect.height()*3;
+
+ theRgbBuffer.resize(size);
+ }
+ void setKlvTable(ossimPredatorKlvTable* table)
+ {
+ theKlvInfo->setTable(table);
+ }
+ ossimPredatorKlvTable* klvTable()
+ {
+ return theKlvInfo->table();
+ }
+ const ossimPredatorKlvTable* klvTable()const
+ {
+ return theKlvInfo->table();
+ }
+ ossim_uint8* rgbBuffer()
+ {
+ return &theRgbBuffer.front();
+ }
+ const ossim_uint8* rgbBuffer()const
+ {
+ return &theRgbBuffer.front();
+ }
+ ossim_uint32 rgbBufferSizeInBytes()const
+ {
+ return theRgbBuffer.size();
+ }
+ void setVideoFrameTime(ossim_float64 t)
+ {
+ theVideoFrameTime = t;
+ }
+ ossim_float64 videoTime()const
+ {
+ return theVideoFrameTime;
+ }
+ void setKlvTime(ossim_float64 t)
+ {
+ theKlvInfo->setTime(t);
+ }
+ ossim_float64 klvTime()const
+ {
+ return theKlvInfo->time();
+ }
+ ossimRefPtr<KlvInfo> klvInfo()
+ {
+ return theKlvInfo.get();
+ }
+
+
+ protected:
+ std::vector<ossim_uint8> theRgbBuffer;
+ ossim_float64 theVideoFrameTime;// seconds sice first frame
+ ossimIrect theImageRect;
+ ossimRefPtr<KlvInfo> theKlvInfo;
+ };
+ ossimPredatorVideo();
+ ~ossimPredatorVideo();
+
+ bool open(const ossimFilename& videoFile);
+ void close();
+ bool isOpen()const;
+
+ /**
+ * This will cycle and read the first KLV. Sense we have to incorporate time we will
+ * have to look at the video frame to do a clock time. If no time is set then we do
+ * not need to.
+ *
+ * @param maxTimeToSearchInSeconds The maximum time to search in seconds. If this is
+ * larger then 0.0 then it will tell the method
+ * to use the timing in the video packet. If not set
+ * it will search until it hits the first klv or end of file
+ *
+ * @return The first valid klv in the sequence
+ */
+ ossimRefPtr<ossimPredatorVideo::KlvInfo> firstKlv(double maxTimeToSearchInSeconds=0);
+
+ /**
+ * This allows you to seq1uence to the next klv only. If you want vide info and klv
+ * information then you should use the nextFrame call.
+ */
+ ossimRefPtr<ossimPredatorVideo::KlvInfo> nextKlv();
+
+ ossimRefPtr<ossimPredatorVideo::FrameInfo> nextFrame();
+
+ /**
+ * Will rewind all active streams
+ */
+ void rewind();
+
+ /**
+ *
+ */
+ void seek(ossim_float64 reference, ossimPredatorVideo::SeekType seekType);
+ ossim_float64 duration()const
+ {
+ return theDurationInSeconds;
+ }
+ ossim_float64 referenceTime()const;
+/* void seek(ossim_float64 timeInSeconds, */
+/* ossimPredatorVideo::SeekType seekType=CURRENT_POSITION); */
+
+/* void seek(ossim_int64 */
+/* ossimRefPtr<ossimPredatorVideo::GeometryInfo> currentGeometry(); */
+/* const ossimRefPtr<ossimPredatorVideo::GeometryInfo> currentGeometry()const; */
+
+ ossimFilename filename()const;
+ ossim_float64 videoFrameRate()const;
+ ossim_float64 videoClock()const;
+
+ ossim_uint32 imageWidth()const
+ {
+ return theImageWidth;
+ }
+ ossim_uint32 imageHeight()const
+ {
+ return theImageHeight;
+ }
+ bool seekingFlag()const;
+ void setFirstFrameFlag(bool flag);
+ bool firstFrameFlag()const;
+ /**
+ * Will scan the current stream and print out meta information
+ * such as timing, ... etc.
+ */
+ void debugScan();
+
+ static ossim_int64 MY_NOPTS_VALUE;
+
+protected:
+ void adjustSeek();
+ ossim_float64 synchronizeVideo(AVFrame *src_frame, ossim_float64 pts);
+ void flushQueues();
+
+ class TimestampKlv : public ossimReferenced
+ {
+ public:
+ ossim_float64 theOffsetInSeconds; // offset in seconds from the first time stamp
+ ossimRefPtr<ossimPredatorKlvTable> theKlvInfo; // geometry information
+ };
+ ossimFilename theFilename;
+ AVFormatContext *theFormatCtx;
+ ossim_int32 theVideoStreamIndex;
+ ossim_int32 theKlvStreamIndex;
+ ossim_uint32 theImageWidth;
+ ossim_uint32 theImageHeight;
+ AVFrame *theVideoFrame;
+ AVFrame *theRgbFrame;
+ AVCodecContext *theVideoCodecCtx;
+ AVCodec *theVideoDecoder;
+ ossim_uint8 *theBuffer;
+ ossim_uint32 theBufferSizeInBytes;
+ ossim_float64 theVideoFrameRate;
+ ossim_float64 theVideoClock;
+ ossim_uint64 theKlvTimestamp;
+
+ bool theFirstFrameFlag;
+ bool theFirstKlvTimeSetFlag;
+ ossim_float64 theFirstFrameTime; // seconds
+ ossim_float64 theFirstKlvTime; // seconds
+
+ ossim_float64 theDurationInSeconds;
+ std::queue<ossimRefPtr<ossimPredatorVideo::TimestampKlv> > theKlvQueue;
+ ossimRefPtr<ossimPredatorVideo::FrameInfo> theCurrentFrameInfo;
+
+ mutable OpenThreads::Mutex theSeekMutex;
+ ossim_float64 theSeekTarget;
+ ossimPredatorVideo::SeekType theSeekTargetType;
+ bool theSeekingFlag;
+
+ struct SwsContext *theImageConvertContext;
+};
+#endif // ossimPredatorVideo_HEADER
diff --git a/ossimPredator/projects/vs2005/ossimPredator.vcproj b/ossimPredator/projects/vs2005/ossimPredator.vcproj
new file mode 100644
index 0000000..ec23025
--- /dev/null
+++ b/ossimPredator/projects/vs2005/ossimPredator.vcproj
@@ -0,0 +1,261 @@
+<?xml version="1.0" encoding="Windows-1252"?>
+<VisualStudioProject
+ ProjectType="Visual C++"
+ Version="9.00"
+ Name="ossimPredator"
+ ProjectGUID="{A1511628-E839-4EA1-8CC5-4ABE99F49527}"
+ RootNamespace="libwms"
+ Keyword="Win32Proj"
+ TargetFrameworkVersion="131072"
+ >
+ <Platforms>
+ <Platform
+ Name="Win32"
+ />
+ </Platforms>
+ <ToolFiles>
+ </ToolFiles>
+ <Configurations>
+ <Configuration
+ Name="Debug|Win32"
+ OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+ IntermediateDirectory="$(OutDir)\work\$(ProjectName)\"
+ ConfigurationType="2"
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+ CharacterSet="2"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ Optimization="0"
+ AdditionalIncludeDirectories=""$(ProjectDir)..\..\include";"$(ProjectDir)..\..\..\ossim_dependencies\src\ffmpeg\include\";"$(ProjectDir)..\..\..\ossim_dependencies\src\ffmpeg\include\ffmpeg\";"$(ProjectDir)..\..\..\ossim\include";"$(ProjectDir)..\..\..\ossim_dependencies\src\OpenSceneGraph-2.2.0\include""
+ AdditionalUsingDirectories=" "
+ PreprocessorDefinitions="OSSIMPREDATOR_LIBRARY"
+ MinimalRebuild="true"
+ BasicRuntimeChecks="3"
+ RuntimeLibrary="3"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLinkerTool"
+ OutputFile="$(OutDir)\bin\$(ProjectName)d.dll"
+ RandomizedBaseAddress="1"
+ DataExecutionPrevention="0"
+ ImportLibrary="$(SolutionDir)$(ConfigurationName)\lib\ossimPredatord.lib"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCManifestTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCAppVerifierTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ <Configuration
+ Name="Release|Win32"
+ OutputDirectory="$(SolutionDir)$(ConfigurationName)"
+ IntermediateDirectory="$(OutDir)\build\$(ProjectName)\"
+ ConfigurationType="2"
+ InheritedPropertySheets="$(VCInstallDir)VCProjectDefaults\UpgradeFromVC71.vsprops"
+ CharacterSet="2"
+ WholeProgramOptimization="1"
+ >
+ <Tool
+ Name="VCPreBuildEventTool"
+ />
+ <Tool
+ Name="VCCustomBuildTool"
+ />
+ <Tool
+ Name="VCXMLDataGeneratorTool"
+ />
+ <Tool
+ Name="VCWebServiceProxyGeneratorTool"
+ />
+ <Tool
+ Name="VCMIDLTool"
+ />
+ <Tool
+ Name="VCCLCompilerTool"
+ InlineFunctionExpansion="1"
+ AdditionalIncludeDirectories=""$(ProjectDir)..\..\..\ossim\include\";"$(ProjectDir)..\..\include";"$(ProjectDir)..\..\..\ossim_dependencies\include""
+ PreprocessorDefinitions="OSSIMPREDATOR_LIBRARY"
+ RuntimeLibrary="2"
+ UsePrecompiledHeader="0"
+ WarningLevel="3"
+ Detect64BitPortabilityProblems="true"
+ DebugInformationFormat="3"
+ />
+ <Tool
+ Name="VCManagedResourceCompilerTool"
+ />
+ <Tool
+ Name="VCResourceCompilerTool"
+ />
+ <Tool
+ Name="VCPreLinkEventTool"
+ />
+ <Tool
+ Name="VCLinkerTool"
+ AdditionalDependencies="OpenThreads.lib avdevice.lib avcodec.lib avformat.lib avutil.lib swscale.lib"
+ OutputFile="$(OutDir)\bin\$(ProjectName).dll"
+ AdditionalLibraryDirectories=""$(ProjectDir)..\..\..\ossim_dependencies\lib";"$(ProjectDir)..\..\..\ossim_dependencies\bin""
+ IgnoreAllDefaultLibraries="false"
+ GenerateDebugInformation="true"
+ RandomizedBaseAddress="1"
+ DataExecutionPrevention="0"
+ ImportLibrary="$(OutDir)\lib\$(ProjectName).lib"
+ TargetMachine="1"
+ />
+ <Tool
+ Name="VCALinkTool"
+ />
+ <Tool
+ Name="VCManifestTool"
+ />
+ <Tool
+ Name="VCXDCMakeTool"
+ />
+ <Tool
+ Name="VCBscMakeTool"
+ />
+ <Tool
+ Name="VCFxCopTool"
+ />
+ <Tool
+ Name="VCAppVerifierTool"
+ />
+ <Tool
+ Name="VCPostBuildEventTool"
+ />
+ </Configuration>
+ </Configurations>
+ <References>
+ </References>
+ <Files>
+ <Filter
+ Name="Source Files"
+ Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+ UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}"
+ >
+ <File
+ RelativePath="..\..\src\ossimPredatorInit.cpp"
+ >
+ </File>
+ <File
+ RelativePath="..\..\src\ossimPredatorKlvTable.cpp"
+ >
+ </File>
+ <File
+ RelativePath="..\..\src\ossimPredatorThread.cpp"
+ >
+ </File>
+ <File
+ RelativePath="..\..\src\ossimPredatorVideo.cpp"
+ >
+ </File>
+ </Filter>
+ <Filter
+ Name="Header Files"
+ Filter="h;hpp;hxx;hm;inl;inc;xsd"
+ UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}"
+ >
+ <File
+ RelativePath="..\..\include\ossimPredator\ffmpegApi.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\..\ossim_dependencies\src\ffmpeg\include\ffmpeg\inttypes.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\include\ossimPredator\ossimPredatorApi.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\include\ossimPredator\ossimPredatorExport.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\include\ossimPredator\ossimPredatorInit.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\include\ossimPredator\ossimPredatorKlvTable.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\include\ossimPredator\ossimPredatorLoader.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\include\ossimPredator\ossimPredatorProjectionFactory.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\include\ossimPredator\ossimPredatorThread.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\include\ossimPredator\ossimPredatorUavProjection.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\include\ossimPredator\ossimPredatorVideo.h"
+ >
+ </File>
+ <File
+ RelativePath="..\..\..\ossim_dependencies\src\ffmpeg\include\ffmpeg\stdint.h"
+ >
+ </File>
+ </Filter>
+ <Filter
+ Name="Resource Files"
+ Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx"
+ UniqueIdentifier="{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}"
+ >
+ </Filter>
+ </Files>
+ <Globals>
+ </Globals>
+</VisualStudioProject>
diff --git a/ossimPredator/src/GNUmakefile b/ossimPredator/src/GNUmakefile
new file mode 100644
index 0000000..5ec4189
--- /dev/null
+++ b/ossimPredator/src/GNUmakefile
@@ -0,0 +1,119 @@
+###
+# $Id: Makefile 10406 2007-01-30 21:55:38Z dburken $
+###
+
+###
+# Must edit OSSIM_HOME and OP_HOME:
+###
+#OSSIM_HOME=/work/drb/ossim
+
+OP_HOME=$(OSSIM_DEV_HOME)/ossimPredator
+FFMPEG_INSTALL=/usr/local
+
+include $(OSSIM_DEV_HOME)/ossim/Makefile.common
+
+OP_INCLUDE_PATH=$(OP_HOME)/include
+
+###
+# INSTALL DIRECTORY:
+# NOTE you can override at make time like this:
+# make prefix=/usr/local
+###
+# prefix=$(OMS_HOME)
+#prefix=/usr/local
+prefix=$(OSSIM_RELEASE_HOME)
+
+libdir=$(prefix)/lib
+includedir=$(prefix)/include/ossimPredator
+
+###
+# Pick up platform specific overrides.
+###
+# include ../make_platform.opt
+
+BASE_INCLUDES := -I$(OP_INCLUDE_PATH) $(BASE_INCLUDES) -I$(FFMPEG_INSTALL)/include -I$(FFMPEG_INSTALL)/include/ffmpeg -I/usr/local/include
+OSSIM_APP_LINK := $(OSSIM_APP_LINK) -L$(FFMPEG_INSTALL)/lib -lavcodec -lavformat -lavdevice -lavutil -lswscale
+
+###
+# For pattern rule to make objects.
+###
+CPPSRCS=$(wildcard *.cpp)
+CPPOBJS=$(patsubst %.cpp,%.o,$(CPPSRCS))
+OBJS=$(CPPOBJS)
+
+###
+# For pattern rule to make .d files.
+###
+DEPENDS_FILES=$(wildcard *.d)
+
+
+PLUGIN_LIB=libossimPredator
+SHARED_LIB_VERSIONLESS=$(PLUGIN_LIB).$(SO_VERSIONLESS_EXT)
+SHARED_LIB_DIR=../lib
+SHARED_LIB_TARGET=$(SHARED_LIB_DIR)/$(SHARED_LIB_VERSIONLESS)
+SHARED_OBJ_DIR=`pwd`/$(SHARED_OBJ_DIR)
+SHARED_OBJECT_FILES=*.$(OBJEXT)
+DOT_D_FILES=*.d
+INSTALL_LIB_TARGET=$(OSSIM_PLUGINS_INSTAL_LIB_DIR)/$(SHARED_LIB_VERSIONLESS)
+
+# linux stuff #
+ifeq ($(HOST_RESULT),linux)
+# Override for linux to just do a straight link.
+LD_SHARED=$(CXX) -shared
+endif
+
+# ---
+# all target:
+# 1) Make all objects.
+# 2) link objects to library.
+# ---
+all: depends $(OBJS)
+ $(LD_SHARED) -o $(SHARED_LIB_TARGET) $(SHARED_OBJECT_FILES) $(OSSIM_APP_LINK)
+
+# ---
+# install target:
+# ---
+install: all
+ if test "$(prefix)" != "$(OP_HOME)" ; then \
+ $(INSTALL) -d $(libdir); \
+ $(INSTALL) -d $(includedir); \
+ $(INSTALL) $(SHARED_LIB_TARGET) $(libdir)/$(SHARED_LIB) ; \
+ ( cd $(OP_INCLUDE_PATH)/ossimPredator; \
+ for h in `find . -name "*.h"` ; do \
+ $(INSTALL) -m 664 $$h $(includedir)/$$h; \
+ done ; \
+ ) \
+ fi
+
+# ---
+# clean target:
+# ---
+clean:
+ $(RM_NOPROMPT) $(DOT_D_FILES) $(SHARED_OBJECT_FILES) $(SHARED_LIB_TARGET) *~
+
+# ---
+# uninstall target:
+# ---
+uninstall:
+ if test -f "$(INSTALL_LIB_TARGET)" ; then $(RM_NOPROMPT) $(INSTALL_LIB_TARGET) ; fi
+
+# ---
+# depends target (for .d files):
+# ---
+depends: $(CPPSRCS:.cpp=.d)
+
+# ---
+# Pattern rule for objects from .cpp files.
+# ---
+%.$(OBJEXT): %.cpp
+ $(CXX) $(CXXFLAGS) $(PIC_FLAG) $(CDEBUGFLAGS) $(BASE_DEFINES) $(BASE_INCLUDES) -c $< -o $@
+
+###
+# Pattern rule for .d dependency file from .cpp files.
+###
+%.d: %.cpp
+ $(SHELL) -ec '$(CXX) -MM $(CXXFLAGS) $(CDEBUGFLAGS) $(BASE_DEFINES) $(BASE_INCLUDES) $< >> $@;'
+
+ifneq ( $(DEPENDS_FILES),)
+-include $(DEPENDS_FILES)
+endif
diff --git a/ossimPredator/src/ossimPredatorInit.cpp b/ossimPredator/src/ossimPredatorInit.cpp
new file mode 100644
index 0000000..b687110
--- /dev/null
+++ b/ossimPredator/src/ossimPredatorInit.cpp
@@ -0,0 +1,67 @@
+#include <ossimPredator/ossimPredatorInit.h>
+#include <ossimPredator/ossimPredatorApi.h>
+#include <OpenThreads/Mutex>
+ossimPredatorInit* ossimPredatorInit::theInstance = 0;
+
+extern "C"
+{
+int ffmpeg_lock_callback(void **mutex, enum AVLockOp op);
+}
+
+int ffmpeg_lock_callback(void **mutex, enum AVLockOp op)
+{
+ static OpenThreads::Mutex m;
+
+ switch(op)
+ {
+ case AV_LOCK_CREATE:
+ {
+ *mutex = &m;
+ break;
+ }
+ case AV_LOCK_OBTAIN:
+ {
+ ((OpenThreads::Mutex*)(*mutex))->lock();
+ break;
+ }
+ case AV_LOCK_RELEASE:
+ {
+ ((OpenThreads::Mutex*)(*mutex))->unlock();
+ break;
+ }
+ case AV_LOCK_DESTROY:
+ {
+ *mutex = 0;
+ break;
+ }
+
+ }
+
+ return 0;
+}
+
+ossimPredatorInit::ossimPredatorInit()
+{
+ theInstance = this;
+}
+
+ossimPredatorInit* ossimPredatorInit::instance()
+{
+ // synch the entry of instance
+ static OpenThreads::Mutex m;
+ OpenThreads::ScopedLock<OpenThreads::Mutex> lock(m);
+ if(!theInstance)
+ {
+ theInstance = new ossimPredatorInit;
+ av_lockmgr_register(&ffmpeg_lock_callback);
+ // now synch the critcal section
+ //
+ avcodec_register_all();
+ avdevice_register_all();
+ av_register_all();
+
+ av_log_set_level(AV_LOG_QUIET);
+ }
+
+ return theInstance;
+}
diff --git a/ossimPredator/src/ossimPredatorKlvTable.cpp b/ossimPredator/src/ossimPredatorKlvTable.cpp
new file mode 100644
index 0000000..9067f33
--- /dev/null
+++ b/ossimPredator/src/ossimPredatorKlvTable.cpp
@@ -0,0 +1,2537 @@
+#include <ossimPredator/ossimPredatorKlvTable.h>
+#include <iostream>
+#include <iomanip>
+
+#include <ossim/base/ossimTrace.h>
+static const ossimTrace traceDebug("ossimPredatorKlvTable:debug");
+static const ossimPredatorKlvInfoType OSSIM_PREDATOR_UDS_TABLE[]=
+{
+{KLV_KEY_STREAM_ID,"stream ID",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x01, 0x03, 0x04, 0x02, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_ORGANIZATIONAL_PROGRAM_NUMBER,"Organizational Program Number",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x01, 0x03, 0x05, 0x01, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_UNIX_TIMESTAMP,"UNIX Timestamp",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x04, 0x07, 0x02, 0x01, 0x01, 0x01, 0x05, 0x00, 0x00}}, // TIME STAMP
+{KLV_KEY_USER_DEFINED_UTC_TIMESTAMP, "User Defined UTC", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x02, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00}},
+{KLV_KEY_USER_DEFINED_TIMESTAMP_MICROSECONDS_1970, "User Defined Timestamp Microseconds since 1970", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x02, 0x01, 0x01, 0x01, 0x05, 0x00, 0x00}},
+{KLV_KEY_VIDEO_START_DATE_TIME_UTC, "Video Timestamp Start Date and Time",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x02, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00}},
+{KLV_TIMESYSTEM_OFFSET, "Time System Offset From UTC", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x03, 0x03, 0x01, 0x00, 0x00, 0x00}},
+{KLV_UAS_DATALINK_LOCAL_DATASET, "UAS Datalink Local Data Set",{0x06, 0x0E, 0x2B, 0x34, 0x02, 0x0B, 0x01, 0x01, 0x0E, 0x01, 0x03, 0x01, 0x01, 0x00, 0x00, 0x00}},
+{KLV_BASIC_UNIVERSAL_METADATA_SET, "Universal Metadata Set",{0x06, 0x0E, 0x2B, 0x34, 0x02, 0x01, 0x01, 0x01, 0x0E, 0x01, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00}},
+{KLV_SECURITY_METADATA_UNIVERSAL_SET, "Security metadata universal set", {0x06, 0x0E, 0x2B, 0x34, 0x02, 0x01, 0x01, 0x01, 0x02, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00}},
+{KLV_URL_STRING, "URL String", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_SECURITY_CLASSIFICATION_SET, "Security Classification Set", {0x06, 0x0E, 0x2B, 0x34, 0x02, 0x01, 0x01, 0x01, 0x02, 0x08, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_BYTE_ORDER, "Byte Order", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x03, 0x01, 0x02, 0x01, 0x02, 0x00, 0x00, 0x00}},
+{KLV_KEY_MISSION_NUMBER,"Mission Number",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x01, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_OBJECT_COUNTRY_CODES, "Object Country Codes", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x20, 0x01, 0x02, 0x01, 0x01, 0x00}},
+{KLV_KEY_SECURITY_CLASSIFICATION, "Security Classification", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02, 0x08, 0x02, 0x01, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_SECURITY_RELEASE_INSTRUCTIONS, "Release Instructions", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x20, 0x01, 0x02, 0x09, 0x00, 0x00}},
+{KLV_KEY_SECURITY_CAVEATS, "Caveats", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02, 0x08, 0x02, 0x02, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_CLASSIFICATION_COMMENT, "Classification Comment", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x02, 0x08, 0x02, 0x07, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_ORIGINAL_PRODUCER_NAME, "Original Producer Name", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x02, 0x01, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_PLATFORM_GROUND_SPEED,"Platform Ground Speed",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x0E, 0x01, 0x01, 0x01, 0x05, 0x00, 0x00, 0x00}},
+{KLV_KEY_PLATFORM_MAGNETIC_HEADING_ANGLE,"Platform Magnetic Heading Angle",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x0E, 0x01, 0x01, 0x01, 0x08, 0x00, 0x00, 0x00}},
+{KLV_KEY_PLATFORM_HEADING_ANGLE,"Platform Heading Angle",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x07, 0x07, 0x01, 0x10, 0x01, 0x06, 0x00, 0x00, 0x00}},
+{KLV_KEY_PLATFORM_PITCH_ANGLE,"Platform Pitch Angle",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x07, 0x07, 0x01, 0x10, 0x01, 0x05, 0x00, 0x00, 0x00}},
+{KLV_KEY_PLATFORM_ROLL_ANGLE, "Platform Roll Angle",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x07, 0x07, 0x01, 0x10, 0x01, 0x04, 0x00, 0x00, 0x00}},
+{KLV_KEY_INDICATED_AIR_SPEED,"Platform Indicated Air Speed",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x0E, 0x01, 0x01, 0x01, 0x0B, 0x00, 0x00, 0x00}},
+{KLV_KEY_PLATFORM_DESIGNATION,"Platform Designation",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x20, 0x01, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_PLATFORM_DESIGNATION2,"Platform Designation",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x01, 0x01, 0x21, 0x01, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_IMAGE_SOURCE_SENSOR,"Image Source Sensor",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x04, 0x20, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00}},
+{KLV_KEY_IMAGE_COORDINATE_SYSTEM,"Image Coordinate System",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00}},
+{KLV_KEY_SENSOR_LATITUDE,"Sensor Latitude",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x02, 0x01, 0x02, 0x04, 0x02, 0x00}},
+{KLV_KEY_SENSOR_LONGITUDE,"Sensor Longitude",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x02, 0x01, 0x02, 0x06, 0x02, 0x00}},
+{KLV_KEY_SENSOR_TRUE_ALTITUDE,"Sensor True Altitude",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x01, 0x02, 0x01, 0x02, 0x02, 0x00, 0x00}},
+{KLV_KEY_SENSOR_HORIZONTAL_FOV,"Sensor Horizontal Field Of View",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x02, 0x04, 0x20, 0x02, 0x01, 0x01, 0x08, 0x00, 0x00}},
+{KLV_KEY_SENSOR_VERTICAL_FOV1,"Sensor Vertical Field Of View",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x07, 0x04, 0x20, 0x02, 0x01, 0x01, 0x0A, 0x01, 0x00}},
+{KLV_KEY_SENSOR_VERTICAL_FOV2,"Sensor Vertical Field Of View",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x04, 0x20, 0x02, 0x01, 0x01, 0x0A, 0x01, 0x00}},
+{KLV_KEY_SLANT_RANGE,"Slant Range",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x01, 0x08, 0x01, 0x01, 0x00, 0x00, 0x00}},
+{KLV_KEY_OBLIQUITY_ANGLE,"Obliquity Angle",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x01, 0x10, 0x01, 0x03, 0x00, 0x00, 0x00}},
+{KLV_KEY_ANGLE_TO_NORTH, "Angle To North", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x01, 0x10, 0x01, 0x02, 0x00, 0x00, 0x00}},
+{KLV_KEY_TARGET_WIDTH,"Target Width",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x01, 0x09, 0x02, 0x01, 0x00, 0x00, 0x00}},
+{KLV_KEY_FRAME_CENTER_LATITUDE,"Frame Center Latitude",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x01, 0x02, 0x01, 0x03, 0x02, 0x00, 0x00}},
+{KLV_KEY_FRAME_CENTER_LONGITUDE,"Frame Center Longitude",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x01, 0x02, 0x01, 0x03, 0x04, 0x00, 0x00}},
+{KLV_KEY_FRAME_CENTER_ELEVATION,"Frame Center elevation",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x06, 0x07, 0x01, 0x02, 0x03, 0x10, 0x00, 0x00, 0x00}},
+{KLV_KEY_CORNER_LATITUDE_POINT_1,"Corner Latitude Point 1",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x02, 0x01, 0x03, 0x07, 0x01, 0x00}},
+{KLV_KEY_CORNER_LONGITUDE_POINT_1,"Corner Longitude Point 1",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x02, 0x01, 0x03, 0x0B, 0x01, 0x00}},
+{KLV_KEY_CORNER_LATITUDE_POINT_2,"Corner Latitude Point 2",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x02, 0x01, 0x03, 0x08, 0x01, 0x00}},
+{KLV_KEY_CORNER_LONGITUDE_POINT_2,"Corner Longitude Point 2",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x02, 0x01, 0x03, 0x0C, 0x01, 0x00}},
+{KLV_KEY_CORNER_LATITUDE_POINT_3,"Corner Latitude Point 3",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x02, 0x01, 0x03, 0x09, 0x01, 0x00}},
+{KLV_KEY_CORNER_LONGITUDE_POINT_3,"Corner Longitude Point 3",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x02, 0x01, 0x03, 0x0D, 0x01, 0x00}},
+{KLV_KEY_CORNER_LATITUDE_POINT_4,"Corner Latitude Point 4",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x02, 0x01, 0x03, 0x0A, 0x01, 0x00}},
+{KLV_KEY_CORNER_LONGITUDE_POINT_4,"Corner Longitude Point 4",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x03, 0x07, 0x01, 0x02, 0x01, 0x03, 0x0E, 0x01, 0x00}},
+{KLV_KEY_DEVICE_ABSOLUTE_SPEED,"Device Absolute Speed",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x01, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00}},
+{KLV_KEY_DEVICE_ABSOLUTE_HEADING,"Device Absolute Heading",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x01, 0x03, 0x01, 0x01, 0x02, 0x00, 0x00}},
+{KLV_KEY_ABSOLUTE_EVENT_START_DATE,"Absolute Event Start Date",{0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x02, 0x01, 0x02, 0x07, 0x01, 0x00, 0x00}},
+{KLV_KEY_SENSOR_ROLL_ANGLE,"Sensor Roll Angle", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x07, 0x01, 0x10, 0x01, 0x01, 0x00, 0x00, 0x00}},
+{KLV_KEY_SENSOR_RELATIVE_ELEVATION_ANGLE,"Sensor Relative Elevation Angle", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x0E, 0x01, 0x01, 0x02, 0x05, 0x00, 0x00, 0x00}},
+{KLV_KEY_SENSOR_RELATIVE_AZIMUTH_ANGLE,"Sensor Relative Azimuth Angle", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x0E, 0x01, 0x01, 0x02, 0x04, 0x00, 0x00, 0x00}},
+{KLV_KEY_SENSOR_RELATIVE_ROLL_ANGLE,"Sensor Relative Roll Angle", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x0E, 0x01, 0x01, 0x02, 0x06, 0x00, 0x00, 0x00}},
+{KLV_KEY_UAS_LDS_VERSION_NUMBER,"UAS LDS Version Number", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x0E, 0x01, 0x02, 0x03, 0x03, 0x00, 0x00, 0x00}},
+{KLV_KEY_GENERIC_FLAG_DATA_01,"Generic Flag Data 01", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x0E, 0x01, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00}},
+{KLV_KEY_STATIC_PRESSURE,"Static Pressure", {0x06, 0x0E, 0x2B, 0x34, 0x01, 0x01, 0x01, 0x01, 0x0E, 0x01, 0x01, 0x01, 0x0F, 0x00, 0x00, 0x00}},
+{KLV_KEY_INVALID,"Invalid Key",{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}}
+};
+
+const ossim_uint8 ossimPredatorKlvTable::theKlvKey[4] = { 0x06,0x0e,0x2b,0x34 };
+#define PRINT_KEY(x) printf("%02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X %02X\n", \
+(x)[0], (x)[1], (x)[2], (x)[3], (x)[4], (x)[5], (x)[6], (x)[7], (x)[8], (x)[9], (x)[10], (x)[11], (x)[12], (x)[13], (x)[14], (x)[15])
+
+static double mapValue(double value, double a, double b, double targetA, double targetB)
+{
+ double t = (value - a)/(b-a);
+ return (targetA + (t*(targetB-targetA)));
+}
+
+ossimPredatorKlvTable::Node ossimPredatorKlvTable::convertValue(int id, const std::vector<ossim_uint8>& bufferValue)
+{
+ ossimPredatorKlvTable::Node result;
+ result.theId = id;
+ switch(id)
+ {
+ case KLV_KEY_FRAME_CENTER_LATITUDE:
+ case KLV_KEY_SENSOR_LATITUDE:
+ {
+ ossim_int32 buf = *reinterpret_cast<const ossim_int32*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+
+ //LAT: Map -(2^31-1)..(2^31-1) to +/-90.
+ ossim_float64 value = mapValue(buf, -2147483647, 2147483647, -90, 90);//(360.0*(((double)buf + 2147483647.0)/(4294967294.0)))-180.0; //180.0*((buf)/(double)((ossim_int64)(1<<31) - 1));
+ //std::cout << "LAT == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+8);
+ // std::cout << "SENSOR LAT!!" << std::endl;
+ break;
+ }
+
+ case KLV_KEY_FRAME_CENTER_LONGITUDE:
+ case KLV_KEY_SENSOR_LONGITUDE:
+ {
+ ossim_int32 buf = *reinterpret_cast<const ossim_int32*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+
+ //LAT: Map -(2^31-1)..(2^31-1) to +/-180.
+ ossim_float64 value = mapValue(buf, -2147483647, 2147483647, -180, 180);//(360.0*(((double)buf + 2147483647.0)/(4294967294.0)))-180.0; //180.0*((buf)/(double)((ossim_int64)(1<<31) - 1));
+ //std::cout << "LAT == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+8);
+ // std::cout << "SENSOR LAT!!" << std::endl;
+ break;
+ }
+ case KLV_KEY_SENSOR_TRUE_ALTITUDE:
+ {
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 65535, -900, 19000);
+ //std::cout << "ALTITUDE == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+8);
+
+ break;
+ }
+ case KLV_KEY_SENSOR_RELATIVE_ELEVATION_ANGLE:
+ {
+ //Map -(2^31-1)..(2^31-1) to +/-180.
+ ossim_int32 buf = *reinterpret_cast<const ossim_int32*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -2147483647.0,2147483647.0,-180.0,180.0);
+ //std::cout << "REALATIVE Elevation == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+8);
+ break;
+ }
+ case KLV_KEY_SENSOR_VERTICAL_FOV1:
+ case KLV_KEY_SENSOR_VERTICAL_FOV2:
+ case KLV_KEY_SENSOR_HORIZONTAL_FOV:
+ {
+ // Map 0..(2^16-1) to 0..180.
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float32 value = mapValue(buf, 0, 65535, 0, 180);
+ //std::cout << "VFOV == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+4);
+ break;
+ }
+ case KLV_KEY_SENSOR_RELATIVE_AZIMUTH_ANGLE://KLV_KEY_SENSOR_RELATIVE_AZIMUTH_ANGLE
+ {
+ // Map 0..(2^32-1) to 0..360.
+ ossim_uint32 buf = *reinterpret_cast<const ossim_uint32*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 4294967295, 0, 360);
+ //std::cout << "REALATIVE AZIMUTH == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+8);
+ // std::cout << "SENSOR REALTIVE AZIMUTH ANGLE!!" << std::endl;
+ break;
+ }
+ case KLV_KEY_SENSOR_RELATIVE_ROLL_ANGLE: //KLV_KEY_SENSOR_RELATIVE_ROLL_ANGLE
+ {
+ //0..(2^32-1) to 0..360.
+ ossim_uint32 buf = *reinterpret_cast<const ossim_uint32*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 4294967295, 0, 360);
+ //std::cout << "REALATIVE roll == " << value << std::endl;
+ // std::cout << "SENSOR REALTIVE ROLL ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+8);
+ break;
+ }
+ case KLV_KEY_SLANT_RANGE: // KLV_KEY_SLANT_RANGE
+ {
+ // Map 0..(2^32-1) to 0..5000000
+ ossim_uint32 buf = *reinterpret_cast<const ossim_uint32*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 4294967295, 0, 5000000);
+ //std::cout << "SLANT range == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+8);
+ break;
+ }
+ case KLV_KEY_TARGET_WIDTH: //KLV_KEY_TARGET_WIDTH
+ {
+ //Map 0..(2^16-1) to 0..10000
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float32 value = mapValue(buf, 0, 65535, 0, 10000);
+ //std::cout << "TARGET width == " << value << std::endl;
+ // std::cout << "TARGET WIDTH!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+4);
+ break;
+ }
+ case KLV_KEY_FRAME_CENTER_ELEVATION:
+ {
+ // Map 0..(2^16-1) to -900..19000
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 65535, -900, 19000);
+ //std::cout << "FRAME CENTER ELEV == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+8);
+ break;
+ }
+ case KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_1:
+ case KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_1:
+ case KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_2:
+ case KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_2:
+ case KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_3:
+ case KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_3:
+ case KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_4:
+ case KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_4:
+ {
+ // Map -(2^15-1)..(2^15-1) to +/-0.075.
+ ossim_int16 buf = *reinterpret_cast<const ossim_int16*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -32767, 32767, -0.075, 0.075);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+8);
+ break;
+ }
+ case KLV_KEY_STATIC_PRESSURE:
+ {
+ // Map 0..(2^16-1) to 0..5000 mbar.
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_uint16 value = mapValue(buf, 0, 65535, 0, 5000);
+
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+2);
+ break;
+ }
+ case KLV_KEY_PLATFORM_MAGNETIC_HEADING_ANGLE:// KLV_KEY_PLATFORM_MAGNETIC_HEADING_ANGLE
+ {
+ // Map 0..(2^16-1) to 0..360.
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&bufferValue.front());
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 65535, 0, 360);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ result.theValue = std::vector<ossim_uint8>(tempBuf, tempBuf+8);
+ // std::cout << "SENSOR REALTIVE AZIMUTH ANGLE!!" << std::endl;
+ // platform magnetic heading
+ break;
+ }
+ default:
+ {
+ result.theValue = bufferValue;
+ }
+
+ }
+ return result;
+}
+
+static void printHex(const std::vector<ossim_uint8>& buf)
+{
+ ossim_uint32 idx = 0;
+ while(idx < buf.size())
+ {
+ printf("%02X ", buf[idx]);
+ if((idx%32) == 0)
+ {
+ // printf("\n");
+ }
+ ++idx;
+ }
+}
+
+bool ossimPredatorKlvTable::addKeys(const std::vector<ossim_uint8>& buffer)
+{
+ return addKeys(&buffer.front(), buffer.size());
+}
+
+ossim_int64 klv_decode_length(const ossim_uint8* buf, ossim_uint32& offset)
+{
+ ossim_int64 size = buf[offset];
+ ossim_uint8 longTest = buf[offset];
+ ++offset;
+ if (longTest & 0x80)
+ { /* long form */
+ int bytes_num = longTest & 0x7f;
+ /* SMPTE 379M 5.3.4 guarantee that bytes_num must not exceed 8 bytes */
+ if (bytes_num > 8)
+ {
+ return -1;
+ }
+ size = 0;
+
+ while (bytes_num--)
+ {
+ size = size << 8 | buf[offset];
+ ++offset;
+ }
+ }
+
+ return size;
+}
+
+ossimPredatorKlvTable::ossimPredatorKlvTable()
+{
+ theNeedToSwapFlag = theEndian.getSystemEndianType()!=OSSIM_BIG_ENDIAN;
+}
+
+bool ossimPredatorKlvTable::addKeys(const ossim_uint8* buffer, ossim_uint32 length)
+{
+ // std::cout << "addKeys---------------------------------\n";
+ // std::cout << "ADDING KEYS!!!!!!!!!!!!\n";
+ std::vector<ossim_uint8> bufferToParse;
+ bufferToParse = theNeedToParseBuffer;
+ if(buffer)
+ {
+ bufferToParse.insert(bufferToParse.end(),
+ buffer,
+ buffer + length);
+
+ }
+ theNeedToParseBuffer.clear();
+ ossim_uint32 currentIdx = 0;
+ ossim_uint32 totalLen = bufferToParse.size();
+ // std::cout << "BUFFER TOTAL SIZE: " << totalLen << std::endl;
+ if(totalLen < 1){
+ //std::cout << "FIRST RETURN!!!!!!!!\n";
+ return false;
+ }
+ const ossim_uint8* bufPtr = &bufferToParse.front();
+ //PRINT_KEY(&bufPtr[currentIdx]);
+ while(std::equal(theKlvKey,
+ theKlvKey + 4,
+ &bufPtr[currentIdx])) // while we are looking at klv keys keep parsing
+ {
+ //std::cout << "CURRENT IDX, totallength ==== " << currentIdx << "," << totalLen << std::endl;
+ //std::cout << "((currentIdx+16) >= totalLen)?" << ((currentIdx+16) >= totalLen) << std::endl;
+ if((currentIdx+16) >= totalLen)
+ {
+ theNeedToParseBuffer.clear();
+ theNeedToParseBuffer.insert(theNeedToParseBuffer.end(),
+ &bufPtr[currentIdx],
+ &bufPtr[totalLen]);
+ // std::cout << "SECOND RETURN!!!!!!!!\n";
+ return true;
+ }
+ ossimPredatorKlvTable::Node node;
+ ossim_uint32 saveIdx = currentIdx;
+ ossim_int32 indexValue = findPredatorKlvIndex(&bufPtr[currentIdx]);
+
+ if(indexValue >= 0)
+ {
+ node.theId = OSSIM_PREDATOR_UDS_TABLE[indexValue].theId;
+ }
+ else
+ {
+ node.theId = KLV_KEY_INVALID;
+ }
+ if(node.theId < 0)
+ {
+ if(traceDebug())
+ {
+ ossim_uint32 tempId = currentIdx + 16;
+ std::cout << "**************UNDEFINED KEY**************\n";
+ std::cout << "WITH SIZE === " << klv_decode_length(bufPtr, tempId) << std::endl;
+ PRINT_KEY(&bufPtr[currentIdx]);
+ }
+ //if(bufPtr[currentIdx] == 0xff) return false;
+ //ossim_uint32 tempId = currentIdx + 16;
+ //std::cout << "**************UNDEFINED KEY**************\n";
+ //std::cout << "WITH SIZE === " << klv_decode_length(bufPtr, tempId) << std::endl;
+ // PRINT_KEY(&bufPtr[currentIdx]);
+ //
+ //ossim_float32 f = *reinterpret_cast<const ossim_float32*>(&bufPtr[tempId]);
+ //theEndian.swap(f);
+ // std::cout << "POSSIBLE VALUE === " << f << std::endl;
+ }
+ // PRINT_KEY(&bufPtr[currentIdx]);
+ currentIdx += 16;
+ int klvLength = klv_decode_length(bufPtr, currentIdx);
+ //std::cout << "offsets: " << (currentIdx+klvLength) << std::endl;
+ if(klvLength > 0)
+ {
+ bool needMore = false;
+ if((currentIdx + klvLength) <= totalLen)
+ {
+ node.theValue.insert(node.theValue.end(),
+ &bufPtr[currentIdx], &bufPtr[currentIdx + klvLength]);
+ currentIdx += klvLength;
+ //std::cout << "KLV LENGTH ======= " << klvLength << std::endl;
+ if(node.theId >=0)
+ {
+ //std::cout << "node.theId? " << node.theId << std::endl;
+ if((node.theId == KLV_BASIC_UNIVERSAL_METADATA_SET)||
+ (node.theId == KLV_KEY_SECURITY_CLASSIFICATION_SET)||
+ (node.theId == KLV_SECURITY_METADATA_UNIVERSAL_SET))
+ {
+ addAbsoluteKeyDefinitions(node.theValue, needMore);
+ }
+ /*
+ if((node.theId == KLV_BASIC_UNIVERSAL_METADATA_SET)||
+ (node.theId == KLV_KEY_SECURITY_CLASSIFICATION_SET))
+ {
+ ossim_uint32 tempIdx = 0;
+ while(tempIdx < node.theValue.size())
+ {
+ if(node.theValue[tempIdx] == 0x06)
+ {
+ break;
+ }
+ ++tempIdx;
+ }
+ //addKeys(&node.theValue[tempIdx], node.theValue.size() - tempIdx);
+
+
+ if(currentIdx < totalLen)
+ {
+ theNeedToParseBuffer.insert(theNeedToParseBuffer.begin(),
+ &bufPtr[currentIdx],
+ &bufPtr[totalLen]);
+ }
+// std::cout << "??????????????";
+ if(tempIdx < node.theValue.size())
+ theNeedToParseBuffer.insert(theNeedToParseBuffer.begin(),
+ node.theValue.begin()+tempIdx,
+ node.theValue.end());
+ //node.theValue.clear();
+ //node.theId = -1;
+ //PRINT_KEY(&theNeedToParseBuffer.front());
+ ////std::cout << "CALLING RECURSIVE!!!!!!!!!!!!!!!!!!!!!!" << node.theId << std::endl;
+ return addKeys(0,0);
+
+ }
+ */
+ else if(node.theId == KLV_UAS_DATALINK_LOCAL_DATASET)
+ {
+ //std::cout << "KLV_UAS_DATALINK_LOCAL_DATASET\n";
+ klvMapType tempTable;
+ ossim_uint16 checksum;
+ // lod 16 byte key
+ std::vector<ossim_uint8> checksumBuffer(&bufPtr[saveIdx], &bufPtr[currentIdx-2]);
+ addUasDatalinkLocalDataSet(node.theValue, tempTable, checksum);
+
+ // now verify checksum
+ ossim_uint16 checksumCompare = compute16BitChecksum(checksumBuffer);
+
+ if(checksum == checksumCompare)
+ {
+ klvMapType::iterator iter = tempTable.begin();
+ while(iter != tempTable.end())
+ {
+ theKlvParameters.insert(std::make_pair(iter->first, iter->second));
+ ++iter;
+ }
+ }
+ else
+ {
+ // std::cout << "WHAT!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n";
+ }
+
+ //print(std::cout);
+ //node.theValue.clear();
+ //node.theId = -1;
+ // std::cout << "CURRENT IDX ====== " << currentIdx << ", " << totalLen << std::endl;
+ // if(currentIdx < totalLen)
+ // {
+ // theNeedToParseBuffer.insert(theNeedToParseBuffer.begin(),
+ // &bufPtr[currentIdx],
+ // &bufPtr[totalLen]);
+ // }
+ // if(currentIdx == totalLen)
+ // {
+ // return false;
+ // }
+ }
+ else
+ {
+ //if(klvLength > 16)
+ // {
+ // addAbsoluteKeyDefinitions(node.theValue, needMore);
+
+ //}
+ //else
+ // {
+// std::cout << "INSERTING THIS THING HERE!!!!\n";
+// std::cout << "KLV LENGTH ========================= " << klvLength << std::endl;
+ theKlvParameters.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(node.theId),
+ convertValue(node.theId, node.theValue)));
+ //}
+ }
+ if(needMore)
+ {
+
+// std::cout << "DOING MORE STUFFFFF!!!!!!!!!!!!" << std::endl;
+ ossim_uint32 tempIdx = currentIdx - (klvLength+16);
+ theNeedToParseBuffer.clear();
+ theNeedToParseBuffer.insert(theNeedToParseBuffer.end(),
+ &bufPtr[tempIdx],
+ &bufPtr[totalLen]);
+
+// std::cout << "THIRD RETURN!!!!!!!!\n";
+ return true;
+ }
+
+
+ }
+ }
+ else
+ {
+ theNeedToParseBuffer.clear();
+
+ theNeedToParseBuffer.insert(theNeedToParseBuffer.end(),
+ &bufPtr[saveIdx],
+ &bufPtr[totalLen]);
+// std::cout << "FOURTH RETURN!!!!!!!!\n";
+ return true;
+ }
+ }
+ }
+
+//std::cout << this->print(std::cout);
+//std::cout << "___________________________\n";
+// std::cout << "FIFTH RETURN!!!!!!!!\n";
+ return false;
+}
+
+
+void ossimPredatorKlvTable::clear()
+{
+ theKlvParameters.clear();
+}
+
+void ossimPredatorKlvTable::addAbsoluteKeyDefinitions(const std::vector<ossim_uint8>& buffer,
+ bool& needMore)
+{
+ needMore = false;
+ ossim_uint32 currentIdx = 0;
+ ossim_uint32 bufferSize = buffer.size();
+ while(currentIdx < bufferSize)
+ {
+ if(buffer[currentIdx] == 0x06)
+ {
+ break;
+ }
+ ++currentIdx;
+ }
+ const ossim_uint8* bufPtr = &buffer.front();
+
+ while((currentIdx < bufferSize)&&
+ (std::equal(theKlvKey,
+ theKlvKey + 4,
+ &bufPtr[currentIdx])))
+ {
+ if((currentIdx+16) >= bufferSize)
+ {
+ break;
+ }
+ ossimPredatorKlvTable::Node node;
+ ossim_uint32 saveIdx = currentIdx;
+ ossim_int32 klvIndex = findPredatorKlvIndex(&bufPtr[currentIdx]);
+ if(klvIndex >= 0)
+ {
+ node.theId = OSSIM_PREDATOR_UDS_TABLE[klvIndex].theId;
+ }
+ else
+ {
+ node.theId = KLV_KEY_INVALID;
+ }
+// if(node.theId < 0)
+// {
+// }
+ currentIdx += 16;
+ int klvLength = klv_decode_length(bufPtr, currentIdx);
+ //std::cout << "offsets: " << (currentIdx+klvLength) << std::endl;
+ if(klvLength > 0)
+ {
+
+ if((currentIdx + klvLength) <= bufferSize)
+ {
+ std::vector<ossim_uint8> value;
+
+ value.insert(value.end(),
+ &bufPtr[currentIdx], &bufPtr[currentIdx + klvLength]);
+ if(node.theId >=0)
+ {
+ node = convertValue(node.theId, value);
+ // switch(node.theId)
+ // {
+ // default:
+ // {
+ theKlvParameters.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(node.theId),
+ node));
+ // break;
+ // }
+ // }
+ }
+ }
+ currentIdx += klvLength;
+ }
+ }
+ if(currentIdx < bufferSize) needMore = true;
+}
+
+bool ossimPredatorKlvTable::valueAsString(ossimString& result,
+ ossimPredatorKlvIndex id)const
+{
+ bool foundFlag = false;
+ klvMapType::const_iterator i = theKlvParameters.find(id);
+ if(i != theKlvParameters.end())
+ {
+ foundFlag = true;
+ switch(i->second.theId)
+ {
+ // convert ossim_uint64 types
+ case KLV_KEY_UNIX_TIMESTAMP:
+ case KLV_KEY_USER_DEFINED_TIMESTAMP_MICROSECONDS_1970:
+ {
+// std::cout << "ossimPredatorKlvTable::valueAsString: byte size ===== " <<i->second.theValue.size() << std::endl;
+ ossim_uint64 value = *reinterpret_cast<const ossim_uint64*>(&(i->second.theValue.front()));
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ result = ossimString::toString(value);
+ break;
+ }
+ // convert uint8 values
+ case KLV_KEY_GENERIC_FLAG_DATA_01:
+ case KLV_KEY_INDICATED_AIR_SPEED:
+ case KLV_KEY_PLATFORM_GROUND_SPEED:
+ case KLV_KEY_UAS_LDS_VERSION_NUMBER:
+ {
+ ossim_uint16 value = *reinterpret_cast<const ossim_uint8*>(&(i->second.theValue.front()));
+ result = ossimString::toString(value);
+
+ break;
+ }
+ // convert uint16 values
+ case KLV_KEY_STATIC_PRESSURE:
+ {
+ ossim_uint16 value = *reinterpret_cast<const ossim_uint16*>(&(i->second.theValue.front()));
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ result = ossimString::toString(value);
+ break;
+ }
+ // convert string values
+ case KLV_KEY_OBJECT_COUNTRY_CODES:
+ case KLV_KEY_MISSION_NUMBER:
+ case KLV_KEY_ORGANIZATIONAL_PROGRAM_NUMBER:
+ case KLV_URL_STRING:
+ case KLV_KEY_CLASSIFICATION_COMMENT:
+ case KLV_KEY_SECURITY_RELEASE_INSTRUCTIONS:
+ case KLV_KEY_SECURITY_CAVEATS:
+ case KLV_KEY_SECURITY_CLASSIFICATION:
+ case KLV_KEY_ORIGINAL_PRODUCER_NAME:
+ case KLV_TIMESYSTEM_OFFSET:
+ case KLV_KEY_BYTE_ORDER:
+ case KLV_KEY_PLATFORM_DESIGNATION:
+ case KLV_KEY_PLATFORM_DESIGNATION2:
+ case KLV_KEY_IMAGE_SOURCE_SENSOR:
+ case KLV_KEY_IMAGE_COORDINATE_SYSTEM:
+ case KLV_KEY_ABSOLUTE_EVENT_START_DATE:
+ case KLV_KEY_VIDEO_START_DATE_TIME_UTC:
+ case KLV_KEY_PLATFORM_TAIL_NUMBER:
+ {
+ if(i->second.theValue.size()>0)
+ {
+ const char* bufPtr = reinterpret_cast<const char*>(&(i->second.theValue.front()));
+ result = ossimString(bufPtr,
+ bufPtr+i->second.theValue.size());
+ }
+ else
+ {
+ result = "";
+ }
+ break;
+ }
+ // convert double precision values
+ case KLV_KEY_SENSOR_RELATIVE_ELEVATION_ANGLE:
+ case KLV_KEY_PLATFORM_MAGNETIC_HEADING_ANGLE:
+ case KLV_KEY_SENSOR_RELATIVE_ROLL_ANGLE:
+ case KLV_KEY_SENSOR_RELATIVE_AZIMUTH_ANGLE:
+ case KLV_KEY_SENSOR_LATITUDE:
+ case KLV_KEY_SENSOR_LONGITUDE:
+ case KLV_KEY_FRAME_CENTER_LATITUDE:
+ case KLV_KEY_FRAME_CENTER_LONGITUDE:
+ case KLV_KEY_CORNER_LATITUDE_POINT_1:
+ case KLV_KEY_CORNER_LATITUDE_POINT_2:
+ case KLV_KEY_CORNER_LATITUDE_POINT_3:
+ case KLV_KEY_CORNER_LATITUDE_POINT_4:
+ case KLV_KEY_CORNER_LONGITUDE_POINT_1:
+ case KLV_KEY_CORNER_LONGITUDE_POINT_2:
+ case KLV_KEY_CORNER_LONGITUDE_POINT_3:
+ case KLV_KEY_CORNER_LONGITUDE_POINT_4:
+ case KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_1:
+ case KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_1:
+ case KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_2:
+ case KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_2:
+ case KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_3:
+ case KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_3:
+ case KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_4:
+ case KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_4:
+ {
+ ossim_float64 value = *reinterpret_cast<const ossim_float64*>(&(i->second.theValue.front()));
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ result = ossimString::toString(value);
+ break;
+ }
+ case KLV_KEY_SENSOR_TRUE_ALTITUDE:
+ case KLV_KEY_FRAME_CENTER_ELEVATION:
+ case KLV_KEY_SLANT_RANGE:
+ case KLV_KEY_TARGET_WIDTH:
+ case KLV_KEY_SENSOR_ROLL_ANGLE:
+ case KLV_KEY_SENSOR_HORIZONTAL_FOV:
+ case KLV_KEY_SENSOR_VERTICAL_FOV1:
+ case KLV_KEY_SENSOR_VERTICAL_FOV2:
+ case KLV_KEY_PLATFORM_HEADING_ANGLE:
+ case KLV_KEY_PLATFORM_PITCH_ANGLE:
+ case KLV_KEY_PLATFORM_ROLL_ANGLE:
+ case KLV_KEY_OBLIQUITY_ANGLE:
+ case KLV_KEY_ANGLE_TO_NORTH:
+ case KLV_KEY_DEVICE_ABSOLUTE_SPEED:
+ case KLV_KEY_DEVICE_ABSOLUTE_HEADING:
+ {
+ ossim_float32 value = *reinterpret_cast<const ossim_float32*>(&(i->second.theValue.front()));
+
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ result = ossimString::toString(value);
+ break;
+ }
+ }
+ }
+ return foundFlag;
+}
+
+ossimString ossimPredatorKlvTable::valueAsString(ossimPredatorKlvIndex id)const
+
+{
+ ossimString result;
+ if(valueAsString(result, id))
+ {
+ return result;
+ }
+
+ return ossimString("");
+}
+
+bool ossimPredatorKlvTable::getCornerPoints(ossimGpt& pt1,
+ ossimGpt& pt2,
+ ossimGpt& pt3,
+ ossimGpt& pt4)const
+{
+ bool result = false;
+ klvMapType::const_iterator endIter = theKlvParameters.end();
+ klvMapType::const_iterator lat1i = theKlvParameters.find(KLV_KEY_CORNER_LATITUDE_POINT_1);
+ klvMapType::const_iterator lat2i = theKlvParameters.find(KLV_KEY_CORNER_LATITUDE_POINT_2);
+ klvMapType::const_iterator lat3i = theKlvParameters.find(KLV_KEY_CORNER_LATITUDE_POINT_3);
+ klvMapType::const_iterator lat4i = theKlvParameters.find(KLV_KEY_CORNER_LATITUDE_POINT_4);
+ klvMapType::const_iterator lon1i = theKlvParameters.find(KLV_KEY_CORNER_LONGITUDE_POINT_1);
+ klvMapType::const_iterator lon2i = theKlvParameters.find(KLV_KEY_CORNER_LONGITUDE_POINT_2);
+ klvMapType::const_iterator lon3i = theKlvParameters.find(KLV_KEY_CORNER_LONGITUDE_POINT_3);
+ klvMapType::const_iterator lon4i = theKlvParameters.find(KLV_KEY_CORNER_LONGITUDE_POINT_4);
+
+
+//std::cout << "TRIED FRO KEY: " << KLV_KEY_CORNER_LATITUDE_POINT_1 << std::endl;
+// std::cout << "END ITER? " << (lat1i==endIter) << std::endl;
+ if((lat1i!=endIter)&&
+ (lat2i!=endIter)&&
+ (lat3i!=endIter)&&
+ (lat4i!=endIter)&&
+ (lon1i!=endIter)&&
+ (lon2i!=endIter)&&
+ (lon3i!=endIter)&&
+ (lon4i!=endIter))
+ {
+
+ ossim_float64 lat1 = *reinterpret_cast<const ossim_float64*>(&(lat1i->second.theValue.front()));
+ ossim_float64 lat2 = *reinterpret_cast<const ossim_float64*>(&(lat2i->second.theValue.front()));
+ ossim_float64 lat3 = *reinterpret_cast<const ossim_float64*>(&(lat3i->second.theValue.front()));
+ ossim_float64 lat4 = *reinterpret_cast<const ossim_float64*>(&(lat4i->second.theValue.front()));
+ ossim_float64 lon1 = *reinterpret_cast<const ossim_float64*>(&(lon1i->second.theValue.front()));
+ ossim_float64 lon2 = *reinterpret_cast<const ossim_float64*>(&(lon2i->second.theValue.front()));
+ ossim_float64 lon3 = *reinterpret_cast<const ossim_float64*>(&(lon3i->second.theValue.front()));
+ ossim_float64 lon4 = *reinterpret_cast<const ossim_float64*>(&(lon4i->second.theValue.front()));
+
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(lat1);
+ theEndian.swap(lat2);
+ theEndian.swap(lat3);
+ theEndian.swap(lat4);
+ theEndian.swap(lon1);
+ theEndian.swap(lon2);
+ theEndian.swap(lon3);
+ theEndian.swap(lon4);
+
+ }
+ pt1 = ossimGpt(lat1, lon1);
+ pt2 = ossimGpt(lat2, lon2);
+ pt3 = ossimGpt(lat3, lon3);
+ pt4 = ossimGpt(lat4, lon4);
+
+ result = true;
+ }
+ else
+ {
+ ossimDpt p1,p2,p3,p4;
+
+ if(getFrameCenterOffsets(p1,p2,p3,p4))
+ {
+ ossim_float64 lat,lon,elevation;
+ if(getFrameCenter(lat, lon, elevation))
+ {
+ pt1 = ossimGpt(lat+p1.lat, lon+p1.lon);
+ pt2 = ossimGpt(lat+p2.lat, lon+p2.lon);
+ pt3 = ossimGpt(lat+p3.lat, lon+p3.lon);
+ pt4 = ossimGpt(lat+p4.lat, lon+p4.lon);
+ result = true;
+ }
+ }
+ }
+
+ return result;
+
+}
+
+bool ossimPredatorKlvTable::getFrameCenterOffsets(ossimDpt& pt1Offset,
+ ossimDpt& pt2Offset,
+ ossimDpt& pt3Offset,
+ ossimDpt& pt4Offset)const
+{
+ bool result = false;
+ klvMapType::const_iterator lat1i = theKlvParameters.find(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_1);
+ klvMapType::const_iterator lat2i = theKlvParameters.find(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_2);
+ klvMapType::const_iterator lat3i = theKlvParameters.find(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_3);
+ klvMapType::const_iterator lat4i = theKlvParameters.find(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_4);
+ klvMapType::const_iterator lon1i = theKlvParameters.find(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_1);
+ klvMapType::const_iterator lon2i = theKlvParameters.find(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_2);
+ klvMapType::const_iterator lon3i = theKlvParameters.find(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_3);
+ klvMapType::const_iterator lon4i = theKlvParameters.find(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_4);
+
+ if((lat1i!=theKlvParameters.end())&&
+ (lat2i!=theKlvParameters.end())&&
+ (lat3i!=theKlvParameters.end())&&
+ (lat4i!=theKlvParameters.end())&&
+ (lon1i!=theKlvParameters.end())&&
+ (lon2i!=theKlvParameters.end())&&
+ (lon3i!=theKlvParameters.end())&&
+ (lon4i!=theKlvParameters.end()))
+ {
+ ossim_float64 lat1 = *reinterpret_cast<const ossim_float64*>(&(lat1i->second.theValue.front()));
+ ossim_float64 lat2 = *reinterpret_cast<const ossim_float64*>(&(lat2i->second.theValue.front()));
+ ossim_float64 lat3 = *reinterpret_cast<const ossim_float64*>(&(lat3i->second.theValue.front()));
+ ossim_float64 lat4 = *reinterpret_cast<const ossim_float64*>(&(lat4i->second.theValue.front()));
+ ossim_float64 lon1 = *reinterpret_cast<const ossim_float64*>(&(lon1i->second.theValue.front()));
+ ossim_float64 lon2 = *reinterpret_cast<const ossim_float64*>(&(lon2i->second.theValue.front()));
+ ossim_float64 lon3 = *reinterpret_cast<const ossim_float64*>(&(lon3i->second.theValue.front()));
+ ossim_float64 lon4 = *reinterpret_cast<const ossim_float64*>(&(lon4i->second.theValue.front()));
+
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(lat1);
+ theEndian.swap(lat2);
+ theEndian.swap(lat3);
+ theEndian.swap(lat4);
+ theEndian.swap(lon1);
+ theEndian.swap(lon2);
+ theEndian.swap(lon3);
+ theEndian.swap(lon4);
+ }
+ pt1Offset.lat = lat1;
+ pt2Offset.lat = lat2;
+ pt3Offset.lat = lat3;
+ pt4Offset.lat = lat4;
+ pt1Offset.lon = lon1;
+ pt2Offset.lon = lon2;
+ pt3Offset.lon = lon3;
+ pt4Offset.lon = lon4;
+ result = true;
+ }
+
+ return result;
+}
+
+
+bool ossimPredatorKlvTable::getFrameCenter(ossim_float64& lat,
+ ossim_float64& lon,
+ ossim_float64& elevation)const
+{
+ klvMapType::const_iterator lati = theKlvParameters.find(KLV_KEY_FRAME_CENTER_LATITUDE);
+ klvMapType::const_iterator loni = theKlvParameters.find(KLV_KEY_FRAME_CENTER_LONGITUDE);
+ klvMapType::const_iterator elevi = theKlvParameters.find(KLV_KEY_FRAME_CENTER_ELEVATION);
+
+ if((lati != theKlvParameters.end())&&
+ (loni != theKlvParameters.end()))
+ {
+ lat = *reinterpret_cast<const ossim_float64*>(&(lati->second.theValue.front()));
+ lon = *reinterpret_cast<const ossim_float64*>(&(loni->second.theValue.front()));
+ ossim_float32 elev = 0;
+ if(elevi != theKlvParameters.end())
+ {
+ elev = *reinterpret_cast<const ossim_float32*>(&(elevi->second.theValue.front()));
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(elev);
+ }
+ }
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(lat);
+ theEndian.swap(lon);
+ }
+ elevation = elev;
+ return true;
+ }
+
+ return false;
+}
+
+bool ossimPredatorKlvTable::getSensorPosition(ossim_float64& lat,
+ ossim_float64& lon,
+ ossim_float64& elevation)const
+{
+ klvMapType::const_iterator lati = theKlvParameters.find(KLV_KEY_SENSOR_LATITUDE);
+ klvMapType::const_iterator loni = theKlvParameters.find(KLV_KEY_SENSOR_LONGITUDE);
+ klvMapType::const_iterator elevi = theKlvParameters.find(KLV_KEY_SENSOR_TRUE_ALTITUDE);
+
+ if((lati != theKlvParameters.end())&&
+ (loni != theKlvParameters.end())&&
+ (elevi != theKlvParameters.end()))
+ {
+ lat = *reinterpret_cast<const ossim_float64*>(&(lati->second.theValue.front()));
+ lon = *reinterpret_cast<const ossim_float64*>(&(loni->second.theValue.front()));
+ ossim_float32 elev = *reinterpret_cast<const ossim_float32*>(&(elevi->second.theValue.front()));
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(lat);
+ theEndian.swap(lon);
+ theEndian.swap(elev);
+ }
+ elevation = elev;//*0.304801;
+ return true;
+ }
+
+ return false;
+}
+
+bool ossimPredatorKlvTable::getPlatformOrientation(ossim_float32& heading,
+ ossim_float32& pitch,
+ ossim_float32& roll)const
+{
+ heading = valueAsString(KLV_KEY_PLATFORM_HEADING_ANGLE).toFloat32();
+ pitch = valueAsString(KLV_KEY_PLATFORM_PITCH_ANGLE).toFloat32();
+ roll = valueAsString(KLV_KEY_PLATFORM_ROLL_ANGLE).toFloat32();
+
+ return true;
+}
+
+bool ossimPredatorKlvTable::getSensorRollAngle(ossim_float32& angle)const
+{
+ ossimString value = valueAsString(KLV_KEY_SENSOR_ROLL_ANGLE);
+ if(!value.empty())
+ {
+ angle = value.toFloat32();
+ }
+
+ return !value.empty();
+}
+
+bool ossimPredatorKlvTable::getObliquityAngle(ossim_float32& angle)const
+{
+ klvMapType::const_iterator value = theKlvParameters.find(KLV_KEY_OBLIQUITY_ANGLE);
+ angle = 0.0;
+ if(value!=theKlvParameters.end())
+ {
+ angle = *reinterpret_cast<const ossim_float32*>(&(value->second.theValue.front()));
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(angle);
+ }
+ }
+
+ return (value!=theKlvParameters.end());
+}
+
+bool ossimPredatorKlvTable::getSlantRange(ossim_float32& range)const
+{
+ klvMapType::const_iterator value = theKlvParameters.find(KLV_KEY_SLANT_RANGE);
+ range = 0.0;
+ if(value!=theKlvParameters.end())
+ {
+ range = *reinterpret_cast<const ossim_float32*>(&(value->second.theValue.front()));
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(range);
+ }
+ }
+
+ return (value!=theKlvParameters.end());
+
+}
+bool ossimPredatorKlvTable::getHorizontalFieldOfView(ossim_float32& hfov)const
+{
+ klvMapType::const_iterator value = theKlvParameters.find(KLV_KEY_SENSOR_HORIZONTAL_FOV);
+ hfov = 0.0;
+ if(value!=theKlvParameters.end())
+ {
+ hfov = *reinterpret_cast<const ossim_float32*>(&(value->second.theValue.front()));
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(hfov);
+ }
+ }
+
+ return (value!=theKlvParameters.end());
+}
+
+bool ossimPredatorKlvTable::getVerticalFieldOfView(ossim_float32& vfov)const
+{
+ klvMapType::const_iterator value = theKlvParameters.find(KLV_KEY_SENSOR_VERTICAL_FOV1);
+ if(value == theKlvParameters.end())
+ {
+ value = theKlvParameters.find(KLV_KEY_SENSOR_VERTICAL_FOV2);
+ }
+ vfov = 0.0;
+ if(value!=theKlvParameters.end())
+ {
+ vfov = *reinterpret_cast<const ossim_float32*>(&(value->second.theValue.front()));
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(vfov);
+ }
+ }
+
+ return (value!=theKlvParameters.end());
+}
+
+bool ossimPredatorKlvTable::getAngleToNorth(ossim_float32& angleToNorth)const
+{
+ klvMapType::const_iterator value = theKlvParameters.find(KLV_KEY_ANGLE_TO_NORTH);
+ angleToNorth = 0.0;
+ if(value!=theKlvParameters.end())
+ {
+ angleToNorth = *reinterpret_cast<const ossim_float32*>(&(value->second.theValue.front()));
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(angleToNorth);
+ }
+ }
+
+ return (value!=theKlvParameters.end());
+
+}
+
+bool ossimPredatorKlvTable::getTargetWidthInMeters(ossim_float32& targetWidth)const
+{
+ ossimString value = valueAsString(KLV_KEY_TARGET_WIDTH);
+
+ targetWidth = value.toFloat32();
+
+ return !value.empty();
+}
+
+ossimString ossimPredatorKlvTable::getUtcTimestamp()const
+{
+ return valueAsString(KLV_KEY_VIDEO_START_DATE_TIME_UTC);
+}
+
+
+bool ossimPredatorKlvTable::getUnixEpocTimestamp(ossim_int64& timestamp)const
+{
+ klvMapType::const_iterator timei = theKlvParameters.end();//theKlvParameters.find(KLV_KEY_USER_DEFINED_TIMESTAMP_MICROSECONDS_1970);
+ if(timei == theKlvParameters.end())
+ {
+ timei = theKlvParameters.find(KLV_KEY_UNIX_TIMESTAMP);
+ }
+ if(timei == theKlvParameters.end())
+ {
+ timei = theKlvParameters.find(KLV_KEY_USER_DEFINED_TIMESTAMP_MICROSECONDS_1970);
+ }
+ if(timei != theKlvParameters.end())
+ {
+ timestamp = *reinterpret_cast<const ossim_uint64*>(&(timei->second.theValue.front()));
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(timestamp);
+ }
+ return true;
+ }
+
+ return false;
+}
+
+bool ossimPredatorKlvTable::getUnixEpocTimestampInSeconds(ossim_int64& seconds,
+ ossim_float64& fractionalPart)const
+{
+ ossim_int64 epocInMicroseconds;
+ bool result = getUnixEpocTimestamp(epocInMicroseconds);
+ ossim_float64 fractionalSeconds = static_cast<ossim_float64>(epocInMicroseconds*1e-6);
+ seconds = static_cast<ossim_uint64>(fractionalSeconds);
+ fractionalPart = fractionalSeconds - seconds;
+
+ return result;
+}
+
+bool ossimPredatorKlvTable::getUnixEpocTimestampInFractionalSeconds(ossim_float64& fractionalSeconds)const
+{
+ ossim_int64 epocInMicroseconds;
+ bool result = getUnixEpocTimestamp(epocInMicroseconds);
+ fractionalSeconds = static_cast<ossim_float64>(epocInMicroseconds/10e-6);
+
+ return result;
+}
+
+bool ossimPredatorKlvTable::getDate(ossimDate& d, bool shiftToGmtZero)const
+{
+ bool result = getDateUsingUtc(d, shiftToGmtZero);
+
+ if(!result)
+ {
+ result = getDateUsingEpoc(d);
+ }
+ return result;
+}
+
+bool ossimPredatorKlvTable::getDateUsingEpoc(ossimDate& d)const
+{
+ bool result = false;
+ ossim_int64 t;
+ ossim_float64 fraction=0;
+
+ if(getUnixEpocTimestampInSeconds(t, fraction))
+ {
+ result = true;
+ d.setTimeNoAdjustmentGivenEpoc(t);
+ d.setFractionalSecond(fraction);
+ }
+
+ return result;
+}
+
+bool ossimPredatorKlvTable::getDateUsingUtc(ossimDate& d, bool shiftToGmtZero)const
+{
+ bool result = false;
+ ossimString utc = getUtcTimestamp();
+ if(utc.size() > 0)
+ {
+ result = d.setIso8601(utc, shiftToGmtZero);
+ }
+ return result;
+}
+
+int ossimPredatorKlvTable::findPredatorKlvIndex(const ossim_uint8* buf)const
+{
+ ossim_int32 idx = 0;
+
+
+ while(OSSIM_PREDATOR_UDS_TABLE[idx].theId != -1)
+ {
+ if(std::equal(buf,
+ buf+16,
+ OSSIM_PREDATOR_UDS_TABLE[idx].theKey))
+ {
+ return idx;
+ }
+ ++idx;
+ }
+
+ return -1;
+}
+
+int ossimPredatorKlvTable::findPredatorKlvIndexByKey(ossim_uint32 key)const
+{
+ ossim_int32 idx = 0;
+
+
+ while(OSSIM_PREDATOR_UDS_TABLE[idx].theId != -1)
+ {
+ if(key == OSSIM_PREDATOR_UDS_TABLE[idx].theId)
+ {
+ return idx;
+ }
+ ++idx;
+ }
+
+ return -1;
+}
+
+void ossimPredatorKlvTable::loadVariableDataNullTerminated(std::vector<ossim_uint8>& result,
+ const std::vector<ossim_uint8>& buf,
+ ossim_uint32& idx)const
+{
+ while((idx < buf.size())&&(buf[idx] != '\0'))
+ {
+ result.push_back(buf[idx]);
+ ++idx;
+ }
+ if(idx < buf.size())
+ {
+ ++idx;
+ }
+}
+
+
+void ossimPredatorKlvTable::addSecurityMetadataLocalSetElements(const std::vector<ossim_uint8>& buffer, klvMapType& tempTable)
+{
+ //std::cout << "addSecurityMetadataLocalSetElements: ....................... entered\n";
+ if(buffer.size() == 0) return;
+ ossim_uint32 idx = 0;
+ bool done = false;
+ while(!done&&((idx+2) < buffer.size()))
+ {
+ ossim_uint32 key = buffer[idx++];
+ ossim_uint32 length = buffer[idx++];
+ if(length > 0)
+ {
+ switch(key)
+ {
+ case 1://Security Classification
+ {
+ ossim_uint16 classification = (ossim_uint16)(*(buffer.begin()+idx));
+ ossimString value;
+ switch(classification)
+ {
+ case 0x01:
+ {
+ value = "UNCLASSIFIED";
+ break;
+ }
+ case 0x02:
+ {
+ value = "RESTRICTED";
+ break;
+ }
+ case 0x03:
+ {
+ value = "CONFIDENTIAL";
+ break;
+ }
+ case 0x04:
+ {
+ value = "SECRET";
+ break;
+ }
+ case 0x05:
+ {
+ value = "TOP SECRET";
+ break;
+ }
+
+ }
+ //UNCLASSIFIED (0x01) RESTRICTED (0x02) CONFIDENTIAL (0x03) SECRET (0x04) TOPSECRET(0x05)
+ //std::cout << "SECURITY CLASS: " << value << std::endl;
+
+ Node n(KLV_KEY_SECURITY_CLASSIFICATION,
+ std::vector<ossim_uint8>(value.begin(), value.end()));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 2://Classifying Country and Releasing Instructions Country Coding Method
+ {
+ ossim_uint16 classifyingCountry = (*(buffer.begin()+idx));
+ // ISO-3166 Two Letter (0x01) ISO-3166 Three Letter (0x02) FIPS 10-4 Two Letter (0x03) FIPS 10-4 Four Letter (0x04)
+ if(traceDebug()) std::cout << "Classifying Country and Releasing Instructions Country Coding Method Not Handled: " << std::endl;
+ //ossim_uint8 value = (*(buffer.begin()+idx));
+
+ break;
+ }
+ case 3://Classifying Country
+ {
+ if(traceDebug()) std::cout << "Classifying Country Not Handled: " << std::endl;
+ break;
+ }
+ case 12://Object Country Coding Method
+ {
+ //std::cout << "Object Country Coding Method: " << (int)(*(buffer.begin()+idx)) << std::endl;
+ //ossim_uint8 value = (*(buffer.begin()+idx));
+ break;
+ }
+ case 13://Object Country Codes
+ {
+ Node n(KLV_KEY_OBJECT_COUNTRY_CODES,
+ std::vector<ossim_uint8>(buffer.begin()+idx, buffer.begin()+(idx+length)));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ //std::cout << "Object Country Codes: " << ossimString(buffer.begin() +idx, buffer.begin()+(idx+length)) << std::endl;
+ break;
+ }
+ case 4://Security-SCI information
+ case 5://Caveats
+ case 6://Releasing Instructions
+ case 7://Classified By
+ case 8://Derived From
+ case 9://Classification Reason
+ case 10://Declassification Date
+ case 11://Classification and Marking System
+ case 14://Classification Comments
+ case 15://UMID Video
+ case 16://UMID Audio
+ case 17://UMID Data
+ case 18://UMID System
+ case 19://Stream ID
+ case 20://Transport Stream ID
+ case 21://Item Designator ID
+ default:
+ {
+ if(traceDebug()) std::cout << "SECURITY KEY " << key << " Not handled\n";
+ break;
+ }
+ }
+ }
+ idx +=length;
+ }
+}
+
+//#include <ossim/base/ossimTraceManager.h>
+void ossimPredatorKlvTable::addUasDatalinkLocalDataSet(const std::vector<ossim_uint8>& buffer, klvMapType& tempTable, ossim_uint16& checksum)
+{
+
+
+// ossimTraceManager::instance()->setTracePattern("ossimPredatorKlvTable.*");
+// if (traceDebug()) std::cout << "ossimPredatorKlvTable::addUasDatalinkLocalDataSet: entered....................\n";
+ if(buffer.size() == 0) return;
+ ossim_uint32 idx = 0;
+ bool done = false;
+ while(!done&&((idx+2) < buffer.size()))
+ {
+ ossim_uint32 key= buffer[idx++];
+ ossim_uint32 length= buffer[idx++];
+ //std::cout << "KEY ====================== " << key << std::endl;
+ //std::cout << "LENGTH ====================== " << length << std::endl;
+ if(length > 0)
+ {
+ switch(key)
+ {
+ case 1: // checksum
+ {
+ //std::cout << "CHECKSUM\n";
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ checksum = buf;
+ break;
+ }
+ case 2: // unix timestamp
+ {
+ ossim_uint64 value = *reinterpret_cast<const ossim_uint64*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_UNIX_TIMESTAMP,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+
+ break;
+ }
+ case 3:
+ {
+ Node n(KLV_KEY_MISSION_NUMBER,
+ std::vector<ossim_uint8>(buffer.begin()+idx,
+ buffer.begin()+idx+length));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+
+ //std::cout << "MISSION ID!!" << std::endl;
+ break;
+ }
+ case 4:
+ {
+ Node n(KLV_KEY_PLATFORM_TAIL_NUMBER,
+ std::vector<ossim_uint8>(buffer.begin()+idx,
+ buffer.begin()+idx+length));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+
+ //std::cout << "PLATFORM TAIL!! " << valueAsString(KLV_KEY_PLATFORM_TAIL_NUMBER) << std::endl;
+ break;
+ }
+ case 5:
+ {
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 heading = mapValue(buf, 0.0, (1<<16) - 1, 0.0, 360.0);
+ //std::cout << "HEADING == " << heading << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(heading);
+ }
+
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&heading);
+ Node n(KLV_KEY_PLATFORM_HEADING_ANGLE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),n));
+ // std::cout << "PLATFORM HEADING!!" << std::endl;
+ break;
+ }
+ case 6:
+ {
+ ossim_int16 buf = *reinterpret_cast<const ossim_int16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -((1<<15)-1), ((1<<15)-1), -20,20);//20.0*(buf)/(double)((1<<15) - 1);
+ //std::cout << "PITCH == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_PLATFORM_PITCH_ANGLE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),n));
+ // std::cout << "PLATFORM PITCH!!" << std::endl;
+ break;
+ }
+ case 7:
+ {
+ ossim_int16 buf = *reinterpret_cast<const ossim_int16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ double value = mapValue(buf, -((1<<15)-1), ((1<<15)-1), -50,50);
+ //std::cout << "ROLL == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_PLATFORM_ROLL_ANGLE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),n));
+ // std::cout << "PLATFORM ROLL!!" << std::endl;
+ break;
+ }
+ case 8:
+ {
+ //ossim_uint8 buf = *reinterpret_cast<const ossim_uint8*>(&buffer.front()+idx);
+
+ if(traceDebug()) std::cout << "PLATFORM TRUE AIRSPEED not handled!!" << std::endl;
+ break;
+ }
+ case 9:
+ {
+ Node n(KLV_KEY_INDICATED_AIR_SPEED,
+ std::vector<ossim_uint8>(buffer.begin()+idx,
+ buffer.begin()+idx+length));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+
+ //if(traceDebug()) std::cout << "PLATFORM INDICATED AIRSPEED!!" << std::endl;
+ break;
+ }
+ case 10:
+ {
+ Node n(KLV_KEY_PLATFORM_DESIGNATION,
+ std::vector<ossim_uint8>(buffer.begin()+idx,
+ buffer.begin()+idx+length));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ //std::cout << "PLATFORM DESIGNATION: " << valueAsString(KLV_KEY_PLATFORM_DESIGNATION) << std::endl;
+ //if(traceDebug()) std::cout << "PLATFORM DESIGNATION not handled!!" << std::endl;
+ break;
+ }
+ case 11: // KLV_KEY_IMAGE_SOURCE_SENSOR
+ {
+ Node n(KLV_KEY_IMAGE_SOURCE_SENSOR,
+ std::vector<ossim_uint8>(buffer.begin()+idx,
+ buffer.begin()+idx+length));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ // std::cout << "IMAGE SOURCE SENSOR!!" << valueAsString(KLV_KEY_IMAGE_SOURCE_SENSOR).trim()<< std::endl;
+ break;
+ }
+ case 12:
+ {
+ Node n(KLV_KEY_IMAGE_COORDINATE_SYSTEM,
+ std::vector<ossim_uint8>(buffer.begin()+idx,
+ buffer.begin()+idx+length));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+
+ //std::cout << "IMAGE COORDINATE SYSTEM!!" << std::endl;
+ break;
+ }
+ case 13://KLV_KEY_SENSOR_LATITUDE
+ {
+ ossim_int32 buf = *reinterpret_cast<const ossim_int32*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+
+ // Map -(2^31-1)..(2^31-1) to +/-90.
+ ossim_float64 value = mapValue(buf, -2147483647, 2147483647, -90, 90);//(360.0*(((double)buf + 2147483647.0)/(4294967294.0)))-180.0; //180.0*((buf)/(double)((ossim_int64)(1<<31) - 1));
+ //std::cout << "LAT == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_SENSOR_LATITUDE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ // std::cout << "SENSOR LAT!!" << std::endl;
+ break;
+ }
+ case 14://KLV_KEY_SENSOR_LONGITUDE
+ {
+ ossim_int32 buf = *reinterpret_cast<const ossim_int32*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ //KLV_KEY_SENSOR_LONGITUDE
+ // Map -(2^31-1)..(2^31-1) to +/-180.
+ ossim_float64 value = mapValue(buf, -2147483647, 2147483647, -180, 180); //180.0*((buf)/(double)((ossim_int64)(1<<31) - 1));
+ //std::cout << "LON == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_SENSOR_LONGITUDE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+
+ // std::cout << "SENSOR LON!!" << std::endl;
+ break;
+ }
+ case 15://KLV_KEY_SENSOR_TRUE_ALTITUDE
+ {
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 65535, -900, 19000);
+ //std::cout << "ALTITUDE == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_SENSOR_TRUE_ALTITUDE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ // std::cout << "SENSOR TRUE ALTITUDE!!" << std::endl;
+ break;
+ }
+ case 16://KLV_KEY_SENSOR_HORIZONTAL_FOV
+ {
+ // map -2^16-1..2^16-1 to 0..180
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float32 value = mapValue(buf, 0, 65535, 0, 180);
+ //std::cout << "HFOV == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_SENSOR_HORIZONTAL_FOV,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+4));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ // std::cout << "SENSOR HORIZONTAL FOV!!" << std::endl;
+ break;
+ }
+ case 17://KLV_KEY_SENSOR_VERTICAL_FOV1
+ {
+ // Map 0..(2^16-1) to 0..180.
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float32 value = mapValue(buf, 0, 65535, 0, 180);
+ //std::cout << "VFOV == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_SENSOR_VERTICAL_FOV1,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+4));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 18://KLV_KEY_SENSOR_RELATIVE_AZIMUTH_ANGLE
+ {
+ // Map 0..(2^32-1) to 0..360.
+ ossim_uint32 buf = *reinterpret_cast<const ossim_uint32*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 4294967295, 0, 360);
+ //std::cout << "REALATIVE AZIMUTH == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_SENSOR_RELATIVE_AZIMUTH_ANGLE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ // std::cout << "SENSOR REALTIVE AZIMUTH ANGLE!!" << std::endl;
+ break;
+ }
+ case 19://KLV_KEY_SENSOR_RELATIVE_ELEVATION_ANGLE
+ {
+ //Map -(2^31-1)..(2^31-1) to +/-180.
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -2147483647.0,2147483647.0,-180.0,180.0);
+ //std::cout << "REALATIVE Elevation == " << value << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_SENSOR_RELATIVE_ELEVATION_ANGLE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 20: //KLV_KEY_SENSOR_RELATIVE_ROLL_ANGLE
+ {
+ //0..(2^32-1) to 0..360.
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 4294967295, 0, 360);
+ //std::cout << "REALATIVE roll == " << value << std::endl;
+ // std::cout << "SENSOR REALTIVE ROLL ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_SENSOR_RELATIVE_ROLL_ANGLE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 21: // KLV_KEY_SLANT_RANGE
+ {
+ // Map 0..(2^32-1) to 0..5000000
+ ossim_uint32 buf = *reinterpret_cast<const ossim_uint32*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 4294967295, 0, 5000000);
+ //std::cout << "SLANT range == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_SLANT_RANGE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 22: //KLV_KEY_TARGET_WIDTH
+ {
+ //Map 0..(2^16-1) to 0..10000
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float32 value = mapValue(buf, 0, 65535, 0, 10000);
+ //std::cout << "TARGET width == " << value << std::endl;
+ // std::cout << "TARGET WIDTH!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_TARGET_WIDTH,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+4));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 23:
+ {
+ // Map -(2^31-1)..(2^31-1) to +/-90
+ ossim_int32 buf = *reinterpret_cast<const ossim_int32*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -2147483647, 2147483647, -90.0, 90.0);
+ //std::cout << "FRAME CENTER LAT == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_FRAME_CENTER_LATITUDE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 24:
+ {
+ // Map -(2^31-1)..(2^31-1) to +/-180
+ ossim_int32 buf = *reinterpret_cast<const ossim_int32*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -2147483647, 2147483647, -180.0, 180.0);
+ //std::cout << "FRAME CENTER LON == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_FRAME_CENTER_LONGITUDE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 25:
+ {
+ // Map 0..(2^16-1) to -900..19000
+ ossim_uint16 buf = *reinterpret_cast<const ossim_int16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 65535, -900, 19000);
+ //std::cout << "FRAME CENTER ELEV == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_FRAME_CENTER_ELEVATION,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 26:
+ {
+ // Map -(2^15-1)..(2^15-1) to +/-0.075.
+ ossim_int16 buf = *reinterpret_cast<const ossim_int16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -32767, 32767, -0.075, 0.075);
+ //std::cout << "offset corner lat 1 == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_1,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 27:
+ {
+ // Map -(2^15-1)..(2^15-1) to +/-0.075.
+ ossim_int16 buf = *reinterpret_cast<const ossim_int16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -32767, 32767, -0.075, 0.075);
+ //std::cout << "offset corner lon 1 == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_1,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 28:
+ {
+ // Map -(2^15-1)..(2^15-1) to +/-0.075.
+ ossim_int16 buf = *reinterpret_cast<const ossim_int16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -32767, 32767, -0.075, 0.075);
+ //std::cout << "offset corner lat 2 == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_2,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 29:
+ {
+ // Map -(2^15-1)..(2^15-1) to +/-0.075.
+ ossim_int16 buf = *reinterpret_cast<const ossim_int16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -32767, 32767, -0.075, 0.075);
+ //std::cout << "offset corner lon 2 == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_2,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 30:
+ {
+ // Map -(2^15-1)..(2^15-1) to +/-0.075.
+ ossim_int16 buf = *reinterpret_cast<const ossim_int16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -32767, 32767, -0.075, 0.075);
+ //std::cout << "offset corner lat 3 == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_3,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 31:
+ {
+ // Map -(2^15-1)..(2^15-1) to +/-0.075.
+ ossim_int16 buf = *reinterpret_cast<const ossim_int16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -32767, 32767, -0.075, 0.075);
+ //std::cout << "offset corner lon 3 == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_3,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 32:
+ {
+ // Map -(2^15-1)..(2^15-1) to +/-0.075.
+ ossim_int16 buf = *reinterpret_cast<const ossim_int16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -32767, 32767, -0.075, 0.075);
+ //std::cout << "offset corner lat 4 == " << value << std::endl;
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_4,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 33:
+ {
+ // Map -(2^15-1)..(2^15-1) to +/-0.075.
+ ossim_int16 buf = *reinterpret_cast<const ossim_int16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, -32767, 32767, -0.075, 0.075);
+ // std::cout << "SENSOR SLANT ANGLE!!" << std::endl;
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_4,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ break;
+ }
+ case 34:
+ {
+ if(traceDebug()) std::cout << "ICING DETECTED Not Handled!!" << std::endl;
+ break;
+ }
+ case 35:
+ {
+ if(traceDebug()) std::cout << "WIND DIRECTION Not Handled!!" << std::endl;
+ break;
+ }
+ case 36:
+ {
+ if(traceDebug()) std::cout << "WIND SPEED not handled!!" << std::endl;
+ break;
+ }
+ case 37://KLV_KEY_STATIC_PRESSURE
+ {
+ // Map 0..(2^16-1) to 0..5000 mbar.
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_uint16 value = mapValue(buf, 0, 65535, 0, 5000);
+
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_STATIC_PRESSURE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+2));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+
+
+ // if(traceDebug()) std::cout << "Static Pressure not handled!!" << std::endl;
+ break;
+ }
+ case 38:
+ {
+ if(traceDebug()) std::cout << "DENSITY ALTITUDE not handled!!" << std::endl;
+ break;
+ }
+ case 39:
+ {
+ if(traceDebug()) std::cout << "OUTSIDE AIR TEMP not handled!!" << std::endl;
+ break;
+ }
+ case 40:
+ {
+ if(traceDebug()) std::cout << "Target Location Latitude not handled!!" << std::endl;
+ break;
+ }
+ case 41:
+ {
+ if(traceDebug()) std::cout << "Target Location Longitude not handled!!" << std::endl;
+ break;
+ }
+ case 42:
+ {
+ if(traceDebug()) std::cout << "Target Location Elevation not handled!!" << std::endl;
+ break;
+ }
+ case 43:
+ {
+ if(traceDebug()) std::cout << "Target track gate width not handled!!" << std::endl;
+ break;
+ }
+ case 44:
+ {
+ if(traceDebug()) std::cout << "Target track gate height not handled!!" << std::endl;
+ break;
+ }
+ case 45:
+ {
+ if(traceDebug()) std::cout << "Target Error esitimate CE90 not handled!!" << std::endl;
+ break;
+ }
+ case 46:
+ {
+ if(traceDebug())
+ {
+ std::cout << "Target Error esitimate LE90!!" << std::endl;
+ }
+ break;
+ }
+ case 47:
+ {
+ Node n(KLV_KEY_GENERIC_FLAG_DATA_01,
+ std::vector<ossim_uint8>(buffer.begin()+idx,
+ buffer.begin()+idx+length));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+
+ //std::cout << "Generic Flag Data 01!!" << (int)((buffer.front()+idx)) << std::endl;
+ break;
+ }
+ case 48:
+ {
+
+ //if(traceDebug())
+ //{
+ std::vector<ossim_uint8> tempBuf(buffer.begin()+idx, buffer.begin()+idx+length);
+ addSecurityMetadataLocalSetElements(tempBuf, tempTable);
+ // std::cout << "Security Local Dataset Not Handled!! ADDED KEYS?: " << std::endl;
+ //}
+ break;
+ }
+ case 49:
+ {
+ if(traceDebug())
+ {
+ std::cout << "Differential pressure!!" << std::endl;
+ }
+ break;
+ }
+ case 50:
+ {
+ if(traceDebug())
+ {
+ std::cout << "Platform angle of attack!!" << std::endl;
+ }
+ break;
+ }
+ case 51:
+ {
+ if(traceDebug())
+ {
+ std::cout << "Platform vertical speed!!" << std::endl;
+ }
+ break;
+ }
+ case 52:
+ {
+ if(traceDebug())
+ {
+ std::cout << "Platform side slip angle!!" << std::endl;
+ }
+ break;
+ }
+ case 53:
+ {
+ if(traceDebug())
+ {
+ std::cout << "airfilled barometrc pressure!!" << std::endl;
+ }
+ // airfiled barometrc pressure
+ break;
+ }
+ case 54:
+ {
+ if(traceDebug())
+ {
+ std::cout << "airfiled elevation!! Not handled" << std::endl;
+ }
+ // airfiled elevation
+ break;
+ }
+ case 55:
+ {
+ if(traceDebug())
+ {
+ std::cout << "relative humidity!! Not handled" << std::endl;
+ }
+ // relative humidity
+ break;
+ }
+ case 56://KLV_KEY_PLATFORM_GROUND_SPEED
+ {
+ Node n(KLV_KEY_PLATFORM_GROUND_SPEED,
+ std::vector<ossim_uint8>(buffer.begin()+idx,
+ buffer.begin()+idx+length));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ // platform ground speed
+ break;
+ }
+ case 57:
+ {
+ if(traceDebug())
+ {
+ std::cout << "ground range!! Not handled" << std::endl;
+ }
+ // ground range
+ break;
+ }
+ case 58:
+ {
+ if(traceDebug())
+ {
+ std::cout << " platform fuel remaining! Not handled" << std::endl;
+ }
+ // platform fuel remaining
+ break;
+ }
+ case 59:
+ {
+ if(traceDebug())
+ {
+ std::cout << "platform call sign! Not handled" << std::endl;
+ }
+ // platform call sign
+ break;
+ }
+ case 60:
+ {
+ if(traceDebug())
+ {
+ std::cout << "weapon load! Not handled" << std::endl;
+ }
+ // weapon load
+ break;
+ }
+ case 61:
+ {
+ if(traceDebug())
+ {
+ std::cout << "weapon fired Not Handled!" << std::endl;
+ }
+ // weapon fired
+ break;
+ }
+ case 62:
+ {
+ if(traceDebug())
+ {
+ std::cout << "Laser PRF Code Not handled" << std::endl;
+ }
+ // Laser PRF Code
+ break;
+ }
+ case 63:
+ {
+ if(traceDebug())
+ {
+ std::cout << "Sensor Field of View Name Not handled" << std::endl;
+ }
+ //Sensor Field of View Name
+ break;
+ }
+ case 64:// KLV_KEY_PLATFORM_MAGNETIC_HEADING_ANGLE
+ {
+ // Map 0..(2^16-1) to 0..360.
+ ossim_uint16 buf = *reinterpret_cast<const ossim_uint16*>(&buffer.front()+idx);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(buf);
+ }
+ ossim_float64 value = mapValue(buf, 0, 65535, 0, 360);
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(value);
+ }
+ ossim_uint8* tempBuf = reinterpret_cast<ossim_uint8*>(&value);
+ Node n(KLV_KEY_PLATFORM_MAGNETIC_HEADING_ANGLE,
+ std::vector<ossim_uint8>(tempBuf,
+ tempBuf+8));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ // std::cout << "SENSOR REALTIVE AZIMUTH ANGLE!!" << std::endl;
+ // platform magnetic heading
+ break;
+ }
+ case 65:// KLV_KEY_UAS_LDS_VERSION_NUMBER
+ {
+ Node n(KLV_KEY_UAS_LDS_VERSION_NUMBER,
+ std::vector<ossim_uint8>(buffer.begin()+idx,
+ buffer.begin()+idx+length));
+ tempTable.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(n.theId),
+ n));
+ //std::cout << "KLV_KEY_UAS_LDS_VERSION_NUMBER: " << valueAsString(KLV_KEY_UAS_LDS_VERSION_NUMBER) <<std::endl;
+ // UAS LDS Version Number
+ break;
+ }
+ case 66:
+ {
+ if(traceDebug()) std::cout << "target location covariance matrix Not handled" << std::endl;
+ // target locatio covariance matrix
+ break;
+ }
+ case 67:
+ {
+ // alternate platform latitude
+ if(traceDebug()) std::cout << " alternate platform latitude No Handled!" << std::endl;
+ break;
+ }
+ case 68:
+ {
+ if(traceDebug()) std::cout << "alternate platform longitude Not Handled! " <<key << std::endl;
+ // alternate platform longitude
+ break;
+ }
+ case 69:
+ {
+ // alternate platform altitude
+ if(traceDebug()) std::cout << "alternate platform altitude Not handled " <<key << std::endl;
+ break;
+ }
+ case 70:
+ {
+ // alternate platform name
+ if(traceDebug()) std::cout << "alternate platform name Not handled " <<key << std::endl;
+ break;
+ }
+ case 71:
+ {
+ // alternate platform heading
+ if(traceDebug()) std::cout << "alternate platform heading Not handled " <<key << std::endl;
+ break;
+ }
+ case 72:
+ {
+ if(traceDebug()) std::cout << "EVENT START TIME Not handled " <<key << std::endl;
+ // std::cout << "EVENT START TIME!!" << std::endl;
+ break;
+ }
+ default:
+ {
+ if(traceDebug() ) std::cout << "KEY NOT HANDLED " <<key << std::endl;
+ break;
+ }
+ }
+ }
+ idx +=length;
+ }
+ /*
+ ossimDpt pt1,pt2,pt3,pt4;
+ if(getFrameCenterOffsets(pt1,pt2,pt3,pt4))
+ {
+ ossim_float64 lat,lon,elevation;
+ if(getFrameCenter(lat, lon, elevation))
+ {
+ ossim_float64 cornerLat[4];
+ ossim_float64 cornerLon[4];
+
+ cornerLat[0] = lat + pt1.lat;
+ cornerLat[1] = lat + pt2.lat;
+ cornerLat[2] = lat + pt3.lat;
+ cornerLat[3] = lat + pt4.lat;
+ cornerLon[0] = lon + pt1.lon;
+ cornerLon[1] = lon + pt2.lon;
+ cornerLon[2] = lon + pt3.lon;
+ cornerLon[3] = lon + pt4.lon;
+
+
+ if(theNeedToSwapFlag)
+ {
+ theEndian.swap(cornerLat[0]);
+ theEndian.swap(cornerLat[1]);
+ theEndian.swap(cornerLat[2]);
+ theEndian.swap(cornerLat[3]);
+ theEndian.swap(cornerLon[0]);
+ theEndian.swap(cornerLon[1]);
+ theEndian.swap(cornerLon[2]);
+ theEndian.swap(cornerLon[3]);
+ }
+
+ ossim_uint8* cornerLat1Buf = reinterpret_cast<ossim_uint8*>(&cornerLat[0]);
+ Node cornerLat1Node(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_1,
+ std::vector<ossim_uint8>(cornerLat1Buf,
+ cornerLat1Buf+8));
+ theKlvParameters.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(cornerLat1Node.theId),
+ cornerLat1Node));
+ ossim_uint8* cornerLat2Buf = reinterpret_cast<ossim_uint8*>(&cornerLat[1]);
+ Node cornerLat2Node(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_2,
+ std::vector<ossim_uint8>(cornerLat2Buf,
+ cornerLat2Buf+8));
+ theKlvParameters.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(cornerLat2Node.theId),
+ cornerLat2Node));
+ ossim_uint8* cornerLat3Buf = reinterpret_cast<ossim_uint8*>(&cornerLat[2]);
+ Node cornerLat3Node(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_3,
+ std::vector<ossim_uint8>(cornerLat3Buf,
+ cornerLat3Buf+8));
+ theKlvParameters.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(cornerLat3Node.theId),
+ cornerLat3Node));
+ ossim_uint8* cornerLat4Buf = reinterpret_cast<ossim_uint8*>(&cornerLat[3]);
+ Node cornerLat4Node(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_4,
+ std::vector<ossim_uint8>(cornerLat4Buf,
+ cornerLat4Buf+8));
+ theKlvParameters.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(cornerLat4Node.theId),
+ cornerLat4Node));
+
+
+ ossim_uint8* cornerLon1Buf = reinterpret_cast<ossim_uint8*>(&cornerLon[0]);
+ Node cornerLon1Node(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_1,
+ std::vector<ossim_uint8>(cornerLon1Buf,
+ cornerLon1Buf+8));
+ theKlvParameters.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(cornerLon1Node.theId),
+ cornerLon1Node));
+ ossim_uint8* cornerLon2Buf = reinterpret_cast<ossim_uint8*>(&cornerLon[1]);
+ Node cornerLon2Node(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_2,
+ std::vector<ossim_uint8>(cornerLon2Buf,
+ cornerLon2Buf+8));
+ theKlvParameters.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(cornerLon2Node.theId),
+ cornerLon2Node));
+ ossim_uint8* cornerLon3Buf = reinterpret_cast<ossim_uint8*>(&cornerLon[2]);
+ Node cornerLon3Node(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_3,
+ std::vector<ossim_uint8>(cornerLon3Buf,
+ cornerLon3Buf+8));
+ theKlvParameters.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(cornerLon3Node.theId),
+ cornerLon3Node));
+ ossim_uint8* cornerLon4Buf = reinterpret_cast<ossim_uint8*>(&cornerLon[3]);
+ Node cornerLon4Node(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_4,
+ std::vector<ossim_uint8>(cornerLon4Buf,
+ cornerLon4Buf+8));
+ theKlvParameters.insert(std::make_pair(static_cast<ossimPredatorKlvIndex>(cornerLon4Node.theId),
+ cornerLon4Node));
+
+ // std::cout << "corner1 = " << valueAsString(KLV_KEY_OFFSET_CORNER_LATITUDE_POINT_1) << ", "
+ // << valueAsString(KLV_KEY_OFFSET_CORNER_LONGITUDE_POINT_1) << std::endl;
+ }
+ }
+ */
+}
+
+std::ostream& ossimPredatorKlvTable::print(std::ostream& out)const
+{
+ klvMapType::const_iterator iter = theKlvParameters.begin();
+ while(iter!=theKlvParameters.end())
+ {
+ int idx = findPredatorKlvIndexByKey((*iter).second.theId);
+ if(idx >= 0)
+ {
+ out << (*iter).second.theId << "," << (*iter).first<< ", " << OSSIM_PREDATOR_UDS_TABLE[idx].theName << ": " << valueAsString((*iter).first) << "\n";
+ }
+ ++iter;
+ }
+
+ /*
+ klvMapType::const_iterator iter = theKlvParameters.begin();
+ while(iter!=theKlvParameters.end())
+ {
+ out << (*iter).second.theId << "," << (*iter).first<< ", " << OSSIM_PREDATOR_UDS_TABLE[(*iter).second.theId].theName << ": " << valueAsString((*iter).first) << "\n";
+ ++iter;
+ }
+ */
+ return out;
+}
+
+ossim_uint16 ossimPredatorKlvTable::compute16BitChecksum(const std::vector<ossim_uint8>& checksumBuffer)const
+{
+
+ const ossim_uint8* buf= &checksumBuffer.front();
+ ossim_uint16 len = checksumBuffer.size();
+ // Initialize Checksum and counter variables.
+ ossim_uint16 bcc = 0, i=0;
+
+ // Sum each 16-bit chunk within the buffer into a checksum
+ for ( i = 0 ; i < len; ++i)
+ bcc += buf[i] << (8 * ((i + 1) % 2));
+ return bcc;
+}
\ No newline at end of file
diff --git a/ossimPredator/src/ossimPredatorThread.cpp b/ossimPredator/src/ossimPredatorThread.cpp
new file mode 100644
index 0000000..c3512ea
--- /dev/null
+++ b/ossimPredator/src/ossimPredatorThread.cpp
@@ -0,0 +1,105 @@
+#include <ossimPredator/ossimPredatorThread.h>
+#include <iostream>
+
+void ossimPredatorThread::run()
+{
+ bool firstTime = true;
+ theDoneFlag = false;
+
+ if(!theVideo.valid()) return;
+ if(!theVideo->isOpen()) return;
+// int frameCount = 0;
+ do
+ {
+ theBlock->block();
+
+// std::cout << "FILLING BUFFER!!!!" << std::endl;
+ if (firstTime)
+ {
+ // do a yield to get round a peculiar thread hang when testCancel() is called
+ // in certain cirumstances - of which there is no particular pattern.
+ YieldCurrentThread();
+ firstTime = false;
+ }
+ ossimRefPtr<ossimPredatorVideo::FrameInfo> frameInfo = theVideo->nextFrame();
+
+ if(!frameInfo.valid())
+ {
+ theDoneFlag = true;
+ }
+ else
+ {
+// ossimRefPtr<ossimPredatorVideo::FrameInfo> f = frameInfo->dup();
+// ++frameCount;
+ theFrameBufferMutex.lock();
+ theFrameBuffer.push_back(frameInfo->dup());
+ theFrameBufferMutex.unlock();
+ }
+// updateThreadBlock();
+ } while (!testCancel() && !theDoneFlag);
+// std::cout << frameCount << std::endl;
+}
+
+ossimRefPtr<ossimPredatorVideo::FrameInfo> ossimPredatorThread::nextFrame()
+{
+ ossimRefPtr<ossimPredatorVideo::FrameInfo> result;
+ theFrameBufferMutex.lock();
+
+ if(!theFrameBuffer.empty())
+ {
+ result = theFrameBuffer.front();
+ theFrameBuffer.pop_front();
+ }
+ theFrameBufferMutex.unlock();
+ updateThreadBlock();
+
+ return result;
+}
+
+int ossimPredatorThread::cancel()
+{
+ int result = 0;
+
+ if( isRunning() )
+ {
+ theDoneFlag = true;
+ // release the frameBlock and _databasePagerThreadBlock incase its holding up thread cancelation.
+ theBlock->release();
+
+ // then wait for the the thread to stop running.
+ while(isRunning())
+ {
+ // commenting out debug info as it was cashing crash on exit, presumable
+ // due to osg::notify or std::cout destructing earlier than this destructor.
+ // osg::notify(osg::DEBUG_INFO)<<"Waiting for DatabasePager to cancel"<<std::endl;
+ OpenThreads::Thread::YieldCurrentThread();
+ }
+ theStartThreadCalledFlag = false;
+ }
+
+ return result;
+}
+
+bool ossimPredatorThread::openPredator(const ossimFilename& file)
+{
+ ossimRefPtr<ossimPredatorVideo> video = new ossimPredatorVideo;
+ if(video->open(file))
+ {
+ setVideo(video.get());
+
+ return true;
+ }
+ return false;
+}
+
+void ossimPredatorThread::setVideo(ossimPredatorVideo* video)
+{
+ if(isRunning())
+ {
+ cancel();
+ }
+
+ theVideo = video;
+
+ start();
+}
diff --git a/ossimPredator/src/ossimPredatorUavProjection.cpp b/ossimPredator/src/ossimPredatorUavProjection.cpp
new file mode 100644
index 0000000..e959c0c
--- /dev/null
+++ b/ossimPredator/src/ossimPredatorUavProjection.cpp
@@ -0,0 +1,289 @@
+#include <ossimPredator/ossimPredatorUavProjection.h>
+
+ossimPredatorUavProjection::ossimPredatorUavProjection()
+{
+}
+
+ossimPredatorUavProjection::~ossimPredatorUavProjection()
+{
+}
+
+void ossimPredatorUavProjection::setParameters(ossim_uint32 imageWidth,
+ ossim_uint32 imageHeight,
+ const ossimGpt& sensorPosition,
+ const ossimGpt& frameCenter,
+ const ossim_float64 platformHeading,
+ const ossim_float64 platformPitch,
+ const ossim_float64 platformRoll,
+ ossim_float64 hfov,
+ ossim_float64 vfov,
+ ossim_float64 obliquityAngle,
+ ossim_float64 angleToNorth,
+ ossim_float64 targetWidthInMeters,
+ ossim_float64 slantRange
+ )
+{
+ theWidth = imageWidth;
+ theHeight = imageHeight;
+ theSensorPosition = sensorPosition;
+ theSensorEcefPosition = theSensorPosition;
+ theFrameCenter = frameCenter;
+ theFrameCenterEcef = theFrameCenter;
+ theObliquityAngle = obliquityAngle;
+ theAngleToNorth = angleToNorth;
+ theTargetWidthInMeters = targetWidthInMeters;
+ theSlantRange = slantRange;
+ theFrameCenter = frameCenter;
+ theHorizontalFieldOfView = hfov;
+ theVerticalFieldOfView = vfov;
+ thePlatformHeading = platformHeading;
+ thePlatformPitch = platformPitch;
+ thePlatformRoll = platformRoll;
+
+
+ std::cout << "ROLL = " << thePlatformRoll << std::endl;
+ std::cout << "Pitch = " << thePlatformPitch << std::endl;
+ std::cout << "Obliq = " << theObliquityAngle << std::endl;
+ updateModel();
+}
+
+void ossimPredatorUavProjection::updateModel()
+{
+ theRefImgPt = ossimDpt(theWidth*.5,
+ theHeight*.5);
+
+#if 1
+ double r = ossim::degreesToRadians(thePlatformRoll );
+ double obliquity = ossim::degreesToRadians(theObliquityAngle );
+ double p = ossim::degreesToRadians(thePlatformPitch );
+ double y = ossim::degreesToRadians(theAngleToNorth);
+ NEWMAT::Matrix rollM = ossimMatrix3x3::create(1, 0, 0,
+ 0, cos(r), sin(r),
+ 0, -sin(r), cos(r));
+ NEWMAT::Matrix pitchM = ossimMatrix3x3::create(cos(p), 0, -sin(p),
+ 0, 1, 0,
+ sin(p), 0, cos(p));
+ NEWMAT::Matrix yawM = ossimMatrix3x3::create(cos(y), sin(y), 0,
+ -sin(y), cos(y), 0,
+ 0,0,1);
+ NEWMAT::Matrix obliquityM = ossimMatrix3x3::create(cos(obliquity), 0, -sin(obliquity),
+ 0, 1, 0,
+ sin(obliquity), 0, cos(obliquity));
+ m_air2Ned = rollM*yawM*obliquityM;
+// m_air2Ned = rollM*pitchM*yawM*obliquityM;
+ double sin_lat = ossim::sind(theSensorPosition.latd());
+ double cos_lat = ossim::cosd(theSensorPosition.latd());
+ double sin_lon = ossim::sind(theSensorPosition.lond());
+ double cos_lon = ossim::cosd(theSensorPosition.lond());
+ m_ecef2Ned = (ossimMatrix3x3::create(0,0,1,0,1,0,-1,0,0)*
+ ossimMatrix3x3::create(cos_lat, 0, sin_lat, 0,1,0, -sin_lat,0,cos_lat)*
+ ossimMatrix3x3::create(cos_lon,sin_lon,0, -sin_lon, cos_lon, 0, 0, 0, 1));
+ m_ecef2NedInverse = m_ecef2Ned.t();
+ // theOrientationMatrix = rollM*pitchM*yawM;
+#else
+ // get the Lsr matrix which is oriented nadir to the platform position
+ //
+ ossimLsrSpace lsrSpace(theSensorPosition);//, thePlatformHeading);
+ ossimMatrix4x4 lsrMatrix(lsrSpace.lsrToEcefRotMatrix());
+ theOrientationMatrix = lsrMatrix.getData()
+ // *ossimMatrix4x4::createRotationXMatrix(thePlatformPitch, OSSIM_RIGHT_HANDED)
+ // *ossimMatrix4x4::createRotationZMatrix(thePlatformHeading, OSSIM_RIGHT_HANDED)
+ *ossimMatrix4x4::createRotationZMatrix(theAngleToNorth, OSSIM_RIGHT_HANDED)
+ *ossimMatrix4x4::createRotationXMatrix(thePlatformRoll, OSSIM_RIGHT_HANDED)
+ *ossimMatrix4x4::createRotationYMatrix(theObliquityAngle, OSSIM_RIGHT_HANDED);
+#endif
+// theOrientationMatrixInverse = theOrientationMatrix.i();
+
+}
+
+ossimObject* ossimPredatorUavProjection::dup()const
+{
+ return new ossimPredatorUavProjection(*this);
+}
+
+void ossimPredatorUavProjection::imagingRay(const ossimDpt& image_point,
+ ossimEcefRay& image_ray) const
+{
+#if 1
+ ossimDpt film (image_point - theRefImgPt);
+ film.x/=(theWidth);
+ film.y/=(theHeight);
+ ossim_float64 rotX = film.y*(theVerticalFieldOfView*.5);
+ ossim_float64 rotY = film.x*(theHorizontalFieldOfView*.5);
+
+
+ ossimColumnVector3d cam_ray_dir (0.0,
+ 0.0,
+ 1.0);
+ ossimEcefVector ecf_ray_dir ( m_ecef2NedInverse*m_air2Ned*
+ ossimMatrix3x3::createRotationYMatrix(rotY, OSSIM_LEFT_HANDED)*
+ ossimMatrix3x3::createRotationXMatrix(rotX, OSSIM_LEFT_HANDED)*
+ cam_ray_dir);
+ ecf_ray_dir.normalize();
+
+ image_ray.setOrigin(theSensorPosition);
+ image_ray.setDirection(ecf_ray_dir);
+
+#else
+ ossimDpt film (image_point - theRefImgPt);
+ film.x/=(theWidth);
+ film.y/=(theHeight);
+ ossim_float64 rotX = film.y*(theVerticalFieldOfView*.5);
+ ossim_float64 rotY = film.x*(theHorizontalFieldOfView*.5);
+
+ ossimColumnVector3d cam_ray_dir (0.0,
+ 0.0,
+ -1.0);
+ ossimEcefVector ecf_ray_dir (theOrientationMatrix*
+ ossimMatrix4x4::createRotationYMatrix(rotY, OSSIM_RIGHT_HANDED)*
+ ossimMatrix4x4::createRotationXMatrix(rotX, OSSIM_RIGHT_HANDED)*
+ cam_ray_dir);
+ ecf_ray_dir.normalize();
+
+ image_ray.setOrigin(theSensorPosition);
+ image_ray.setDirection(ecf_ray_dir);
+#endif
+}
+
+bool ossimPredatorUavProjection::useForward()const
+{
+ return true;
+}
+
+void ossimPredatorUavProjection::lineSampleToWorld(const ossimDpt& image_point,
+ ossimGpt& gpt) const
+{
+ ossimEcefRay ray;
+ imagingRay(image_point, ray);
+ ossimElevManager::instance()->intersectRay(ray, gpt);
+}
+
+void ossimPredatorUavProjection::lineSampleHeightToWorld(const ossimDpt& image_point,
+ const double& heightEllipsoid,
+ ossimGpt& worldPoint) const
+{
+ ossimEcefRay ray;
+ imagingRay(image_point, ray);
+ ossimEcefPoint Pecf (ray.intersectAboveEarthEllipsoid(heightEllipsoid));
+ worldPoint = ossimGpt(Pecf);
+}
+
+ossimGpt ossimPredatorUavProjection::origin()const
+{
+ return theSensorPosition;
+}
+
+bool ossimPredatorUavProjection::saveState(ossimKeywordlist& kwl,
+ const char* prefix)const
+{
+ kwl.add(prefix,
+ "type",
+ "ossimUavProjection",
+ true);
+ kwl.add(prefix,
+ "sensor_origin",
+ theSensorPosition.toString(),
+ true);
+ kwl.add(prefix,
+ "frame_center",
+ theFrameCenter.toString(),
+ true);
+ kwl.add(prefix,
+ "image_width",
+ theWidth,
+ true);
+ kwl.add(prefix,
+ "image_height",
+ theHeight,
+ true);
+ kwl.add(prefix,
+ "hfov",
+ theHorizontalFieldOfView,
+ true);
+ kwl.add(prefix,
+ "vfov",
+ theVerticalFieldOfView,
+ true);
+ kwl.add(prefix,
+ "obliquity_angle",
+ theObliquityAngle,
+ true);
+ kwl.add(prefix,
+ "angle_to_north",
+ theAngleToNorth,
+ true);
+ kwl.add(prefix,
+ "target_width",
+ theTargetWidthInMeters,
+ true);
+ kwl.add(prefix,
+ "slant_range",
+ theSlantRange,
+ true);
+ kwl.add(prefix,
+ "platform_heading",
+ thePlatformHeading,
+ true);
+ kwl.add(prefix,
+ "platform_pitch",
+ thePlatformPitch,
+ true);
+ kwl.add(prefix,
+ "platform_roll",
+ thePlatformRoll,
+ true);
+
+ return true;
+}
+
+bool ossimPredatorUavProjection::loadState(const ossimKeywordlist& kwl,
+ const char* prefix)
+{
+ const char* sensor_origin = kwl.find(prefix, "sensor_origin");
+ const char* frame_center = kwl.find(prefix, "frame_center");
+ const char* image_width = kwl.find(prefix, "image_width");
+ const char* image_height = kwl.find(prefix, "image_height");
+ const char* hfov = kwl.find(prefix, "hfov");
+ const char* vfov = kwl.find(prefix, "vfov");
+ const char* obliquity_angle = kwl.find(prefix, "obliquity_angle");
+ const char* angle_to_north = kwl.find(prefix, "angle_to_north");
+ const char* target_width = kwl.find(prefix, "target_width");
+ const char* slant_range = kwl.find(prefix, "slant_range");
+ const char* h = kwl.find(prefix, "platform_heading");
+ const char* p = kwl.find(prefix, "platform_pitch");
+ const char* r = kwl.find(prefix, "platform_roll");
+ if(sensor_origin&&
+ image_height&&
+ image_width&&
+ hfov&&
+ vfov&&
+ obliquity_angle&&
+ angle_to_north&&
+ frame_center&&
+ slant_range&&
+ h&&
+ p&&
+ r)
+ {
+ ossimGpt origin;
+ ossimGpt frameCenter;
+ origin.toPoint(sensor_origin);
+ frameCenter.toPoint(frame_center);
+ setParameters(ossimString(image_width).toUInt32(),
+ ossimString(image_height).toUInt32(),
+ origin,
+ frameCenter,
+ ossimString(h).toFloat64(),
+ ossimString(p).toFloat64(),
+ ossimString(r).toFloat64(),
+ ossimString(hfov).toFloat64(),
+ ossimString(vfov).toFloat64(),
+ ossimString(obliquity_angle).toFloat64(),
+ ossimString(angle_to_north).toFloat64(),
+ ossimString(target_width).toFloat64(),
+ ossimString(slant_range).toFloat64()
+ );
+ return true;
+ }
+ return false;
+}
diff --git a/ossimPredator/src/ossimPredatorVideo.cpp b/ossimPredator/src/ossimPredatorVideo.cpp
new file mode 100644
index 0000000..aee292c
--- /dev/null
+++ b/ossimPredator/src/ossimPredatorVideo.cpp
@@ -0,0 +1,717 @@
+#include <ossimPredator/ossimPredatorVideo.h>
+#include <ossimPredator/ossimPredatorInit.h>
+#include <ossim/base/ossimDate.h>
+#ifndef EINVAL
+#define EINVAL 0
+#endif
+#include <libavutil/avutil.h>
+#include <libavformat/avformat.h>
+#include <libavformat/avio.h>
+#include <libavcodec/avcodec.h>
+#include <iostream>
+#include <algorithm>
+#include <iomanip>
+
+enum ossimPredatorMediaType
+{
+ ossimPredator_AVMEDIA_TYPE_UNKNOWN = -1,
+ ossimPredator_AVMEDIA_TYPE_VIDEO,
+ ossimPredator_AVMEDIA_TYPE_AUDIO,
+ ossimPredator_AVMEDIA_TYPE_DATA,
+ ossimPredator_AVMEDIA_TYPE_SUBTITLE,
+ ossimPredator_AVMEDIA_TYPE_ATTACHMENT,
+ ossimPredator_AVMEDIA_TYPE_NB
+
+};
+
+ossim_int64 ossimPredatorVideo::MY_NOPTS_VALUE = static_cast<ossim_int64>(0x8000000000000000LL);
+ossimPredatorVideo::ossimPredatorVideo()
+ :theFormatCtx(0),
+ theVideoStreamIndex(-1),
+ theKlvStreamIndex(-1),
+ theImageWidth(0),
+ theImageHeight(0),
+ theVideoFrame(0),
+ theRgbFrame(0),
+ theVideoCodecCtx(0),
+ theVideoDecoder(0),
+ theBuffer(0),
+ theBufferSizeInBytes(0),
+ theVideoFrameRate(0.0),
+ theVideoClock(0.0),
+ theKlvTimestamp(0),
+ theFirstFrameFlag(false),
+ theFirstKlvTimeSetFlag(false),
+ theFirstFrameTime(0.0),
+ theFirstKlvTime(0.0),
+ theDurationInSeconds(0.0),
+ theSeekTarget(0.0),
+ theSeekTargetType(ossimPredatorVideo::SEEK_NONE),
+theSeekingFlag(false),
+theImageConvertContext(0)
+{
+
+}
+
+ossimPredatorVideo::~ossimPredatorVideo()
+{
+ close();
+}
+
+bool ossimPredatorVideo::open(const ossimFilename& videoFile)
+{
+ // make sure the system is initialized
+ ossimPredatorInit::instance();
+ close();
+ int err = avformat_open_input(&theFormatCtx, videoFile.c_str(), NULL, NULL);
+
+
+ // open input file using the ffmpeg library
+ if(err!=0)
+ {
+
+ theFormatCtx = 0;
+ return false;
+ }
+ // now determine if we have a klv stream and video stream.
+ // if not then eturn false;
+ //
+ // Retrieve stream information
+ if(avformat_find_stream_info(theFormatCtx, NULL)<0)
+ {
+ return false; // Couldn't find stream information
+ }
+ static const int BUF_SIZE = 256;
+ ossim_int32 i = 0;
+ ossim_int32 klvStream = -1;
+ char buf[BUF_SIZE];
+ int is_output = 1;
+
+ ossim_int32 lastDataStream = -1;
+ ossim_int32 lastAudioStream = -1;
+ for(i=0; i<(ossim_int32)theFormatCtx->nb_streams; i++)
+ {
+ avcodec_string(buf, sizeof(buf), theFormatCtx->streams[i]->codec, is_output);
+
+ // std::cout << "START TIME = " << theFormatCtx->start_time << std::endl;
+ // std::cout << "CODEC TYPE === " << theFormatCtx->streams[i]->codec->codec_type << std::endl;
+ if((int)theFormatCtx->streams[i]->codec->codec_type==(int)ossimPredator_AVMEDIA_TYPE_VIDEO &&
+ theVideoStreamIndex < 0)
+ {
+ theVideoStreamIndex=i;
+ }
+ else if((static_cast<int>(theFormatCtx->streams[i]->codec->codec_type)==static_cast<int>(ossimPredator_AVMEDIA_TYPE_DATA))&&
+ (lastDataStream==-1))
+ {
+ lastDataStream = i;
+ }
+ else if((static_cast<int>(theFormatCtx->streams[i]->codec->codec_type)==static_cast<int>(ossimPredator_AVMEDIA_TYPE_AUDIO))&&
+ (lastDataStream==-1))
+ {
+ lastAudioStream = i;
+ }
+ ossimString testBuf(buf);
+ testBuf = testBuf.upcase();
+ //std::cout << "TESTING BUFFER = " << testBuf << std::endl;
+ if(testBuf.contains("KLVA"))
+ {
+ // std::cout << "*****************HERE**************\n";
+ //std::cout << testBuf << std::endl;
+ klvStream = i;
+ }
+ else if(testBuf.contains("KLV")&&(klvStream<0))
+ {
+ klvStream = i;
+ }
+#if 0
+
+ else if(theFormatCtx->streams[i]->id == 0xBD) // 0xBD is a fixed id for KLV streams in predator video
+ {
+ // disable parsing so we do our own parsing. Let it return raw data.
+ theKlvStreamIndex = i;
+ }
+ else if((static_cast<int>(theFormatCtx->streams[i]->codec->codec_type)==static_cast<int>(ossimPredator_AVMEDIA_TYPE_DATA))&&
+ (lastDataStream==-1))
+ {
+ lastDataStream = i;
+ }
+ else if((static_cast<int>(theFormatCtx->streams[i]->codec->codec_type)==static_cast<int>(ossimPredator_AVMEDIA_TYPE_AUDIO))&&
+ (lastDataStream==-1))
+ {
+ lastAudioStream = i;
+ }
+#endif
+ }
+ if(theVideoStreamIndex==-1)
+ {
+ return false; // Didn't find a video stream
+ }
+ if(klvStream < 0)
+ {
+ if(theKlvStreamIndex==-1)
+ {
+ if(lastAudioStream != -1) // try audio, older version of ffmpeg sets audio codec for klv
+ {
+ theKlvStreamIndex = lastAudioStream;
+ }
+ else if(lastDataStream != -1)
+ {
+ theKlvStreamIndex = lastDataStream;
+ }
+ }
+ }
+ else
+ {
+ theKlvStreamIndex = klvStream;
+ }
+//std::cout << "KLV STREAM IDX!!!! ===== " << theKlvStreamIndex << std::endl;
+ if(theKlvStreamIndex != -1)
+ {
+ theFormatCtx->streams[theKlvStreamIndex]->need_parsing = AVSTREAM_PARSE_NONE;
+ }
+ theImageWidth = theFormatCtx->streams[theVideoStreamIndex]->codec->width;
+ theImageHeight = theFormatCtx->streams[theVideoStreamIndex]->codec->height;
+ theVideoFrameRate = av_q2d(theFormatCtx->streams[theVideoStreamIndex]->r_frame_rate);
+ theVideoFrame = avcodec_alloc_frame();
+ theRgbFrame = avcodec_alloc_frame();
+
+ theVideoCodecCtx=theFormatCtx->streams[theVideoStreamIndex]->codec;
+ theVideoDecoder=avcodec_find_decoder(theVideoCodecCtx->codec_id);
+ if(avcodec_open2(theVideoCodecCtx, theVideoDecoder, NULL)<0)
+ {
+ close();
+ return false; // Could not open codec
+ }
+
+ theBufferSizeInBytes = avpicture_get_size(PIX_FMT_RGB24,
+ theImageWidth,
+ theImageHeight);
+ theBuffer = (ossim_uint8 *)av_malloc(theBufferSizeInBytes);
+
+ // Assign appropriate parts of buffer to image planes in theRgbFrame
+ // Note that pFrameRGB is an AVFrame, but AVFrame is a superset
+ // of AVPicture
+ avpicture_fill((AVPicture *)theRgbFrame,
+ theBuffer,
+ PIX_FMT_RGB24,
+ theImageWidth,
+ theImageHeight);
+
+ theCurrentFrameInfo = new FrameInfo;
+ theCurrentFrameInfo->setImageRect(ossimIrect(0,
+ 0,
+ theImageWidth-1,
+ theImageHeight-1));
+ theCurrentFrameInfo->allocate();
+ AVRational r = {1, AV_TIME_BASE};
+ theDurationInSeconds = av_q2d(r)*theFormatCtx->duration;
+ return true;
+}
+
+void ossimPredatorVideo::close()
+{
+
+ if(theVideoFrame)
+ {
+ av_free(theVideoFrame);
+ }
+ if(theRgbFrame)
+ {
+ av_free(theRgbFrame);
+ }
+ if(theBuffer)
+ {
+ av_free(theBuffer);
+ }
+ if(theImageConvertContext)
+ {
+ sws_freeContext(theImageConvertContext);
+ }
+ if(theVideoCodecCtx)
+ {
+ avcodec_close(theVideoCodecCtx);
+ }
+ if(theFormatCtx)
+ {
+ avformat_close_input(&theFormatCtx);
+ }
+
+ // set all values to initial state
+ theFormatCtx = 0;
+ theVideoStreamIndex = -1;
+ theKlvStreamIndex = -1;
+ theImageWidth = 0;
+ theImageHeight = 0;
+ theVideoFrame = 0;
+ theRgbFrame = 0;
+ theVideoCodecCtx = 0;
+ theVideoDecoder = 0;
+ theBuffer = 0;
+ theBufferSizeInBytes = 0;
+ theVideoFrameRate = 0.0;
+ theVideoClock = 0.0;
+ theKlvTimestamp = 0;
+ theFirstFrameFlag = false;
+ theFirstKlvTimeSetFlag = false;
+ theFirstFrameTime = 0.0;
+ theFirstKlvTime = 0.0;
+ theDurationInSeconds = 0.0;
+ theSeekTarget = 0.0;
+ theSeekTargetType = ossimPredatorVideo::SEEK_NONE;
+ theSeekingFlag = false;
+ theImageConvertContext = 0;
+
+ flushQueues();
+}
+
+bool ossimPredatorVideo::isOpen()const
+{
+ return (theFormatCtx!=0);
+}
+
+void ossimPredatorVideo::rewind()
+{
+ seek(0, SEEK_ABSOLUTE);
+}
+
+void ossimPredatorVideo::seek(ossim_float64 reference, ossimPredatorVideo::SeekType seekType)
+{
+
+ theSeekingFlag = true;
+ theSeekTargetType = seekType;
+ theSeekTarget = reference;
+}
+
+ossim_float64 ossimPredatorVideo::referenceTime()const
+{
+ if(isOpen()&&theFirstFrameFlag)
+ {
+ return (theVideoClock-theFirstFrameTime);
+ }
+
+ return 0.0;
+}
+
+// void SaveFrame(AVFrame *pFrame, int width, int height, int iFrame)
+// {
+// FILE *pFile;
+// char szFilename[32];
+// int y;
+
+// // Open file
+// sprintf(szFilename, "frame%d.ppm", iFrame);
+// pFile=fopen(szFilename, "wb");
+// if(pFile==NULL)
+// return;
+
+// // Write header
+// fprintf(pFile, "P6\n%d %d\n255\n", width, height);
+
+// // Write pixel data
+// for(y=0; y<height; y++)
+// fwrite(pFrame->data[0]+y*pFrame->linesize[0], 1, width*3, pFile);
+
+// // Close file
+// fclose(pFile);
+// }
+
+ossimRefPtr<ossimPredatorVideo::KlvInfo> ossimPredatorVideo::nextKlv()
+{
+ if(theKlvStreamIndex == -1) return 0;
+ AVPacket packet;
+ ossimRefPtr<ossimPredatorKlvTable> klvTable;
+ bool needMoreKlvPacketsFlag = false;
+ if(!isOpen()) return 0;
+ adjustSeek();
+
+ while(av_read_frame(theFormatCtx, &packet)>=0)
+ {
+ if(packet.stream_index == theKlvStreamIndex)
+ {
+ if(!klvTable.valid())
+ {
+ klvTable = new ossimPredatorKlvTable;
+ }
+ needMoreKlvPacketsFlag = klvTable->addKeys(packet.data, packet.size);
+ if(!needMoreKlvPacketsFlag)
+ {
+ // klvTable->print(std::cout) << std::endl;
+ ossim_int64 unixT = 0;
+ if(klvTable->getUnixEpocTimestamp(unixT))
+ {
+ if(!theFirstKlvTimeSetFlag)
+ {
+ theFirstKlvTimeSetFlag = true;
+ theFirstKlvTime = unixT*1e-6;
+ }
+ ossimRefPtr<KlvInfo> klvInfo = new KlvInfo;
+
+ klvInfo->setTime(unixT*1e-6 - theFirstKlvTime);
+ theVideoClock = klvInfo->time();
+ klvInfo->setTable(klvTable.get());
+ av_free_packet(&packet);
+ return klvInfo.release();
+ }
+ klvTable = 0;
+ }
+ }
+ av_free_packet(&packet);
+ }
+ return 0;
+}
+
+void ossimPredatorVideo::adjustSeek()
+{
+ //OpenThreads::ScopedLock<OpenThreads::Mutex> lock(theSeekMutex);
+ if(theSeekingFlag)
+ {
+ ossim_float64 adjustedToRelative = theSeekTarget;
+ switch(theSeekTargetType)
+ {
+ case ossimPredatorVideo::SEEK_ABSOLUTE:
+ {
+ // look at the current video clock and adjust to relative increment
+ adjustedToRelative = theSeekTarget - (theVideoClock - theFirstFrameTime);
+ break;
+ }
+ case ossimPredatorVideo::SEEK_RELATIVE:
+ {
+ break;
+ }
+ default:
+ {
+ adjustedToRelative = 0.0;
+ }
+ }
+ int seekFlag = adjustedToRelative < 0?AVSEEK_FLAG_BACKWARD : 0;
+ adjustedToRelative += theVideoClock;
+ if(adjustedToRelative < theFirstFrameTime)
+ {
+ adjustedToRelative = theFirstFrameTime;
+ }
+ ossim_int64 scaledAdjust = (ossim_int64)(adjustedToRelative*AV_TIME_BASE);
+ AVRational r = {1, AV_TIME_BASE};
+
+ ossim_int64 seekTarget = av_rescale_q(scaledAdjust,
+ r,
+ theFormatCtx->streams[theVideoStreamIndex]->time_base);
+ if(av_seek_frame(theFormatCtx, theVideoStreamIndex, seekTarget, seekFlag)<0)
+ {
+ // ERROR
+ }
+ if(theVideoStreamIndex>=0) avcodec_flush_buffers(theFormatCtx->streams[theVideoStreamIndex]->codec);
+ flushQueues();
+ }
+ theSeekingFlag = false;
+}
+
+ossimRefPtr<ossimPredatorVideo::FrameInfo> ossimPredatorVideo::nextFrame()
+{
+ AVPacket packet;
+ ossimRefPtr<ossimPredatorKlvTable> klvTable;
+// ossimRefPtr<ossimPredatorVideo::FrameInfo> frameInfo;
+ ossim_int64 firstFramePts = 0;
+ bool firstFrame = true;
+ int frameFinished = 0;
+ ossim_float64 pts = 0;
+ bool needMoreKlvPacketsFlag = false;
+ theCurrentFrameInfo->setKlvTable(0);
+ if(!isOpen()) return 0;
+ adjustSeek();
+
+// std::cout << "KLV IDX = " << theKlvStreamIndex << std::endl;
+ while(av_read_frame(theFormatCtx, &packet)>=0)
+ {
+// std::cout << "packet idx = " << packet.stream_index << std::endl;
+ /**
+ * see if the packet is a klv stream and update the geometry
+ */
+ if(packet.stream_index == theKlvStreamIndex)
+ {
+ if(!klvTable.valid())
+ {
+ klvTable = new ossimPredatorKlvTable;
+ }
+ //std::cout << "ROOT!!!!!!\n";
+ needMoreKlvPacketsFlag = klvTable->addKeys(packet.data, packet.size);
+ // new geometry detected for the next frame
+ //
+ //std::cout << "needMoreKlvPacketsFlag: " << needMoreKlvPacketsFlag << std::endl;
+ if(!needMoreKlvPacketsFlag)
+ {
+ ossim_int64 unixT = 0;
+ if(klvTable->getUnixEpocTimestamp(unixT)
+ &&(!theFirstKlvTimeSetFlag || (unixT != (ossim_int64)theKlvTimestamp)))
+ {
+ theKlvTimestamp = unixT;
+ if(!theFirstKlvTimeSetFlag)
+ {
+ theFirstKlvTimeSetFlag = true;
+ theFirstKlvTime = unixT*1e-6;
+ }
+ ossimRefPtr<ossimPredatorVideo::TimestampKlv> klvTimestamp = new ossimPredatorVideo::TimestampKlv;
+ klvTimestamp->theOffsetInSeconds = theKlvTimestamp*1e-6 - theFirstKlvTime;
+ klvTimestamp->theKlvInfo = klvTable;
+ theKlvQueue.push(klvTimestamp.get());
+ }
+ }
+ }
+ else if(packet.stream_index == theVideoStreamIndex)
+ {
+// if(avcodec_decode_video(theVideoCodecCtx,
+// theVideoFrame,
+// &frameFinished,
+// packet.data,
+// packet.size) > 0)
+ if(avcodec_decode_video2(theVideoCodecCtx,
+ theVideoFrame,
+ &frameFinished,
+ &packet) > 0)
+ {
+ if(firstFrame)
+ {
+ // grab first frame pts
+ firstFramePts = packet.pts;
+ firstFrame = false;
+ }
+ if(packet.dts == MY_NOPTS_VALUE
+ && firstFramePts != MY_NOPTS_VALUE)
+ {
+ pts = firstFramePts;
+ }
+ else if(packet.dts != MY_NOPTS_VALUE)
+ {
+ pts = packet.dts;
+ }
+ else
+ {
+ pts = 0;
+ }
+ // next frame found. Once finished then return
+ if(frameFinished)
+ {
+ if(!theImageConvertContext)
+ {
+ int dstW = theImageWidth;
+ int dstH = theImageHeight;
+ theImageConvertContext = sws_getContext(theFormatCtx->streams[theVideoStreamIndex]->codec->width,
+ theFormatCtx->streams[theVideoStreamIndex]->codec->height,
+ theFormatCtx->streams[theVideoStreamIndex]->codec->pix_fmt,
+ dstW,
+ dstH,
+ PIX_FMT_RGB24,
+ SWS_BICUBIC,
+ 0, 0, 0);
+ }
+ if(theImageConvertContext!=0)
+ {
+ sws_scale(theImageConvertContext, theVideoFrame->data,
+ theVideoFrame->linesize, 0,
+ theFormatCtx->streams[theVideoStreamIndex]->codec->height,
+ theRgbFrame->data, theRgbFrame->linesize);
+ }
+#if 0
+ img_convert((AVPicture *)theRgbFrame, PIX_FMT_RGB24,
+ (AVPicture*)theVideoFrame, theVideoCodecCtx->pix_fmt,
+ theImageWidth, theImageHeight);
+#endif
+ // let's do our own copy it's faster
+ memcpy(theCurrentFrameInfo->rgbBuffer(),
+ (ossim_uint8*)theRgbFrame->data[0],
+ theCurrentFrameInfo->rgbBufferSizeInBytes());
+
+ pts *= av_q2d(theFormatCtx->streams[theVideoStreamIndex]->time_base);
+ pts = synchronizeVideo(theVideoFrame, pts);
+ bool addKlvForFirstFrame = false;
+ if(!theFirstFrameFlag)
+ {
+ theFirstFrameTime = theVideoClock;
+ theFirstFrameFlag = true;
+ addKlvForFirstFrame = true;
+ }
+ ossim_float64 deltaTime = theVideoClock-theFirstFrameTime;
+ if(!theKlvQueue.empty())
+ {
+ if((deltaTime > theKlvQueue.front()->theOffsetInSeconds)||
+ (addKlvForFirstFrame))
+ {
+ // std::cout << "FRAME TIME OFFSET = " << deltaTime << std::endl
+ // << "KLV TIME OFFSET = " << theKlvQueue.front()->theOffsetInSeconds << std::endl;
+ theCurrentFrameInfo->setKlvTable(theKlvQueue.front()->theKlvInfo.get());
+ theCurrentFrameInfo->setKlvTime(theKlvQueue.front()->theOffsetInSeconds);
+ theKlvQueue.pop();
+ }
+ }
+ theCurrentFrameInfo->setVideoFrameTime(theVideoClock);
+ av_free_packet(&packet);
+
+ return theCurrentFrameInfo.get();
+ }
+ }
+ else
+ {
+ // std::cout << "ERROR!!!!!!!!!!!!!!!!!!" << std::endl;
+ }
+ }
+ av_free_packet(&packet);
+ }
+ return 0;
+}
+
+ossimFilename ossimPredatorVideo::filename()const
+{
+ return theFilename;
+}
+
+ossim_float64 ossimPredatorVideo::videoFrameRate()const
+{
+ return theVideoFrameRate;
+}
+
+ossim_float64 ossimPredatorVideo::videoClock()const
+{
+ return theVideoClock;
+}
+
+bool ossimPredatorVideo::seekingFlag()const
+{
+ OpenThreads::ScopedLock<OpenThreads::Mutex> lock(theSeekMutex);
+ return theSeekingFlag;
+}
+
+void ossimPredatorVideo::setFirstFrameFlag(bool flag)
+{
+ theFirstFrameFlag = flag;
+}
+
+bool ossimPredatorVideo::firstFrameFlag()const
+{
+ return theFirstFrameFlag;
+}
+
+void ossimPredatorVideo::debugScan()
+{
+ if(!isOpen()) return;
+
+ AVPacket packet;
+ ossimPredatorKlvTable klvTable;
+ bool needMoreKlvPacketsFlag = false;
+ ossim_uint64 prevT = 0;
+ int frameFinished = 0;
+ ossim_int64 firstFramePts = 0;
+ ossim_float64 pts = 0;
+ while(av_read_frame(theFormatCtx, &packet)>=0)
+ {
+ if(packet.stream_index == theKlvStreamIndex)
+ {
+ //std::cout << "KLV\n";
+ needMoreKlvPacketsFlag = klvTable.addKeys(packet.data, packet.size);
+ if(!needMoreKlvPacketsFlag)
+ {
+ ossimDate date;
+ ossim_int64 t;
+ ossim_float64 fraction=0;
+ ossim_int64 unixT;
+ klvTable.getUnixEpocTimestamp(unixT);
+
+ klvTable.getUnixEpocTimestampInSeconds(t, fraction);
+ date.setTimeNoAdjustmentGivenEpoc(t);
+ date.setFractionalSecond(fraction);
+ if(static_cast<ossim_int64>(prevT) != static_cast<ossim_int64>(unixT))
+ {
+ prevT = unixT;
+ //std::cout << "VIDEO START = " << klvTable.valueAsString(KLV_KEY_VIDEO_START_DATE_TIME_UTC) << std::endl;
+ //std::cout << "EPOC KLV = " << t << std::endl;
+ std::cout << std::setw(4) << std::setfill('0') << date.getYear()
+ << std::setw(2) << std::setfill('0') << date.getMonth()
+ << std::setw(2) << std::setfill('0') << date.getDay()
+ << " " << std::setw(2) << std::setfill('0') << date.getHour() << ":"
+ << std::setw(2) << std::setfill('0') << date.getMin() << ":"
+ << std::setprecision(20) << (date.getSec()+date.getFractionalSecond()) << std::endl;
+ }
+ klvTable.clear();
+ }
+ else
+ {
+ std::cout << "Need more" << std::endl;
+ }
+
+ }
+ else if(packet.stream_index == theVideoStreamIndex)
+ {
+ if(!frameFinished)
+ {
+ // grab first frame pts
+ firstFramePts = packet.pts;
+ }
+// avcodec_decode_video(theVideoCodecCtx, theVideoFrame, &frameFinished,
+// packet.data, packet.size);
+ avcodec_decode_video2(theVideoCodecCtx, theVideoFrame, &frameFinished,
+ &packet);
+ if(packet.dts == MY_NOPTS_VALUE
+ && firstFramePts != MY_NOPTS_VALUE)
+ {
+ pts = firstFramePts;
+ }
+ else if(packet.dts != MY_NOPTS_VALUE)
+ {
+ pts = packet.dts;
+ }
+ else
+ {
+ pts = 0;
+ }
+ if(frameFinished)
+ {
+ ossimDate date;
+
+// date.setTimeNoAdjustmentGivenEpoc(static_cast<ossim_uint64>(packet.dts));
+// std::cout << std::setw(4) << std::setfill('0') << date.getYear()
+// << std::setw(2) << std::setfill('0') << date.getMonth()
+// << std::setw(2) << std::setfill('0') << date.getDay()
+// << " " << std::setw(2) << std::setfill('0') << date.getHour() << ":"
+// << std::setw(2) << std::setfill('0') << date.getMin() << ":"
+// << std::setprecision(20) << (date.getSec()+date.getFractionalSecond()) << std::endl;
+ frameFinished = 0;
+ pts *= av_q2d(theFormatCtx->streams[theVideoStreamIndex]->time_base);
+ pts = synchronizeVideo(theVideoFrame, pts);
+ //std::cout << "pts = " << pts << std::endl;
+ }
+
+ }
+ av_free_packet(&packet);
+ }
+// std::cout << "klvCount = " << klvCount << std::endl;
+// std::cout << "videoCount = " << videoCount << std::endl;
+}
+
+ossim_float64 ossimPredatorVideo::synchronizeVideo(AVFrame *src_frame, ossim_float64 pts)
+{
+ ossim_float64 frame_delay = 0.0;
+
+ if(pts != 0)
+ {
+ /* if we have pts, set video clock to it */
+ theVideoClock = pts;
+ }
+ else
+ {
+ /* if we aren't given a pts, set it to the clock */
+ pts = theVideoClock;
+ }
+ /* update the video clock */
+ frame_delay = av_q2d(theFormatCtx->streams[theVideoStreamIndex]->codec->time_base);
+
+ /* if we are repeating a frame, adjust clock accordingly */
+ frame_delay += src_frame->repeat_pict * (frame_delay * 0.5);
+
+ theVideoClock += frame_delay;
+
+ return pts;
+}
+
+
+void ossimPredatorVideo::flushQueues()
+{
+ while(!theKlvQueue.empty())theKlvQueue.pop();
+}
diff --git a/ossimPredator/test/mutiThreadedTest.cpp b/ossimPredator/test/mutiThreadedTest.cpp
new file mode 100644
index 0000000..5571712
--- /dev/null
+++ b/ossimPredator/test/mutiThreadedTest.cpp
@@ -0,0 +1,56 @@
+#include <ossimPredator/ossimPredatorVideo.h>
+#include <ossimPredator/ossimPredatorInit.h>
+#include <ossim/base/ossimRefPtr.h>
+#include <ossim/base/ossimFilename.h>
+#include <OpenThreads/Thread>
+
+class TempThread : public OpenThreads::Thread
+{
+public:
+ bool openVideo(ossimPredatorVideo* video)
+ {
+ return video->open(file);
+ }
+ virtual void run()
+ {
+ ossimRefPtr<ossimPredatorVideo> video;
+ while(true)
+ {
+ video = new ossimPredatorVideo();
+ if(openVideo(video.get()))
+ {
+ ossimRefPtr<ossimPredatorVideo::FrameInfo> frameInfo = video->nextFrame();
+ if(!frameInfo.valid())
+ {
+ std::cout << "Unable to get the next frame!\n";
+ exit(1);
+ }
+ else
+ {
+ // std::cout << "Got it!\n";
+ }
+
+ }
+ else
+ {
+// m.unlock();
+ std::cout << "Unable to open file = " << file << "\n";
+ exit(1);
+ }
+ }
+ }
+ ossimFilename file;
+};
+
+int main(int argc, char* argv[])
+{
+ TempThread t[5];
+ for(int i = 0; i < 5; ++i)
+ {
+ t[i].file = ossimFilename(argv[1]);
+ t[i].start();
+ }
+ while(true);
+
+ return 0;
+}
\ No newline at end of file
diff --git a/ossimPredator/xcode/ossimPredator/English.lproj/InfoPlist.strings b/ossimPredator/xcode/ossimPredator/English.lproj/InfoPlist.strings
new file mode 100644
index 0000000..ce87cdb
Binary files /dev/null and b/ossimPredator/xcode/ossimPredator/English.lproj/InfoPlist.strings differ
diff --git a/ossimPredator/xcode/ossimPredator/Info.plist b/ossimPredator/xcode/ossimPredator/Info.plist
new file mode 100644
index 0000000..33e771d
--- /dev/null
+++ b/ossimPredator/xcode/ossimPredator/Info.plist
@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+ <key>CFBundleDevelopmentRegion</key>
+ <string>English</string>
+ <key>CFBundleExecutable</key>
+ <string>ossimPredator</string>
+ <key>CFBundleIconFile</key>
+ <string></string>
+ <key>CFBundleIdentifier</key>
+ <string>com.apple.carbonframeworktemplate</string>
+ <key>CFBundleInfoDictionaryVersion</key>
+ <string>6.0</string>
+ <key>CFBundlePackageType</key>
+ <string>FMWK</string>
+ <key>CFBundleSignature</key>
+ <string>????</string>
+ <key>CFBundleVersion</key>
+ <string>1.0</string>
+ <key>CFBundleShortVersionString</key>
+ <string>1.0</string>
+ <key>CSResourcesFileMapped</key>
+ <true/>
+</dict>
+</plist>
diff --git a/ossimPredator/xcode/ossimPredator/ossimPredator.xcodeproj/project.pbxproj b/ossimPredator/xcode/ossimPredator/ossimPredator.xcodeproj/project.pbxproj
new file mode 100644
index 0000000..ed77129
--- /dev/null
+++ b/ossimPredator/xcode/ossimPredator/ossimPredator.xcodeproj/project.pbxproj
@@ -0,0 +1,1270 @@
+// !$*UTF8*$!
+{
+ archiveVersion = 1;
+ classes = {
+ };
+ objectVersion = 42;
+ objects = {
+
+/* Begin PBXBuildFile section */
+ 186EF5700B1CE22D00F7886A /* ossim.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 186EF4F60B1CE11D00F7886A /* ossim.framework */; };
+ 43A9A9E20D59FCE500E97FA2 /* ossimPredatorExport.h in Headers */ = {isa = PBXBuildFile; fileRef = 43A9A9E10D59FCE500E97FA2 /* ossimPredatorExport.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ 8D07F2C00486CC7A007CD1D0 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 089C1666FE841158C02AAC07 /* InfoPlist.strings */; };
+ EE3F86980D0DBB5200DFD3DF /* ffmpegApi.h in Headers */ = {isa = PBXBuildFile; fileRef = EE3F86900D0DBB5200DFD3DF /* ffmpegApi.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ EE3F86990D0DBB5200DFD3DF /* ossimPredatorApi.h in Headers */ = {isa = PBXBuildFile; fileRef = EE3F86910D0DBB5200DFD3DF /* ossimPredatorApi.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ EE3F869A0D0DBB5200DFD3DF /* ossimPredatorKlvTable.h in Headers */ = {isa = PBXBuildFile; fileRef = EE3F86920D0DBB5200DFD3DF /* ossimPredatorKlvTable.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ EE3F869B0D0DBB5200DFD3DF /* ossimPredatorLoader.h in Headers */ = {isa = PBXBuildFile; fileRef = EE3F86930D0DBB5200DFD3DF /* ossimPredatorLoader.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ EE3F869C0D0DBB5200DFD3DF /* ossimPredatorProjectionFactory.h in Headers */ = {isa = PBXBuildFile; fileRef = EE3F86940D0DBB5200DFD3DF /* ossimPredatorProjectionFactory.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ EE3F869D0D0DBB5200DFD3DF /* ossimPredatorThread.h in Headers */ = {isa = PBXBuildFile; fileRef = EE3F86950D0DBB5200DFD3DF /* ossimPredatorThread.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ EE3F869E0D0DBB5200DFD3DF /* ossimPredatorUavProjection.h in Headers */ = {isa = PBXBuildFile; fileRef = EE3F86960D0DBB5200DFD3DF /* ossimPredatorUavProjection.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ EE3F869F0D0DBB5200DFD3DF /* ossimPredatorVideo.h in Headers */ = {isa = PBXBuildFile; fileRef = EE3F86970D0DBB5200DFD3DF /* ossimPredatorVideo.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ EE3F87A50D0DBECC00DFD3DF /* Openthreads.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = EE3F87A40D0DBECC00DFD3DF /* Openthreads.framework */; };
+ EEB5EBEB0D0DD8AB000CF6B2 /* ossimPredatorThread.cpp in Sources */ = {isa = PBXBuildFile; fileRef = EE3F86A20D0DBB9000DFD3DF /* ossimPredatorThread.cpp */; };
+ EEB5EC7B0D0F0791000CF6B2 /* ossimPredatorKlvTable.cpp in Sources */ = {isa = PBXBuildFile; fileRef = EEB5EC7A0D0F0790000CF6B2 /* ossimPredatorKlvTable.cpp */; };
+ EEB5EC8C0D0F08A0000CF6B2 /* ossimPredatorVideo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = EEB5EC8B0D0F08A0000CF6B2 /* ossimPredatorVideo.cpp */; };
+ EEB5EE290D102E08000CF6B2 /* ossimPredatorInit.h in Headers */ = {isa = PBXBuildFile; fileRef = EEB5EE280D102E08000CF6B2 /* ossimPredatorInit.h */; settings = {ATTRIBUTES = (Public, ); }; };
+ EEB5EE2B0D102E25000CF6B2 /* ossimPredatorInit.cpp in Sources */ = {isa = PBXBuildFile; fileRef = EEB5EE2A0D102E25000CF6B2 /* ossimPredatorInit.cpp */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+ 186EF4F50B1CE11D00F7886A /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 8D07F2C80486CC7A007CD1D0;
+ remoteInfo = ossim;
+ };
+ 4301391E10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433628031042E368002A87C7;
+ remoteInfo = "template-app";
+ };
+ 4301392010583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433628151042E3B0002A87C7;
+ remoteInfo = "ossim-adrg-dump";
+ };
+ 4301392210583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433628371042E3F6002A87C7;
+ remoteInfo = "ossim-applanix2ogeom";
+ };
+ 4301392410583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433628551042E461002A87C7;
+ remoteInfo = "ossim-band-merge";
+ };
+ 4301392610583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433628741042E4AC002A87C7;
+ remoteInfo = "ossim-btoa";
+ };
+ 4301392810583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433628861042E4D1002A87C7;
+ remoteInfo = "ossim-chgkwval";
+ };
+ 4301392A10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 4336289F1042E52A002A87C7;
+ remoteInfo = "ossim-cmm";
+ };
+ 4301392C10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433628B91042E560002A87C7;
+ remoteInfo = "ossim-computeSrtmStats";
+ };
+ 4301392E10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433628D61042E59C002A87C7;
+ remoteInfo = "ossim-correl";
+ };
+ 4301393010583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433628F11042E5D1002A87C7;
+ remoteInfo = "ossim-create-cg";
+ };
+ 4301393210583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 4336290B1042E607002A87C7;
+ remoteInfo = "ossim-create-histo";
+ };
+ 4301393410583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433629811042E712002A87C7;
+ remoteInfo = "ossim-dms2deg";
+ };
+ 4301393610583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 4336299D1042E759002A87C7;
+ remoteInfo = "ossim-dump-ocg";
+ };
+ 4301393810583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433629B51042E77C002A87C7;
+ remoteInfo = "ossim-ecg2ocg";
+ };
+ 4301393A10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433629D01042E7B1002A87C7;
+ remoteInfo = "ossim-extract-vertices";
+ };
+ 4301393C10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 433629E41042E807002A87C7;
+ remoteInfo = "ossim-foo";
+ };
+ 4301393E10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362A2D1042E88F002A87C7;
+ remoteInfo = "ossim-height";
+ };
+ 4301394010583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362A4B1042E8BD002A87C7;
+ remoteInfo = "ossim-icp";
+ };
+ 4301394210583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362A631042E8EE002A87C7;
+ remoteInfo = "ossim-igen";
+ };
+ 4301394410583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362A7D1042E914002A87C7;
+ remoteInfo = "ossim-img2md";
+ };
+ 4301394610583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362A9A1042E955002A87C7;
+ remoteInfo = "ossim-img2rr";
+ };
+ 4301394810583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362AB41042E981002A87C7;
+ remoteInfo = "ossim-info";
+ };
+ 4301394A10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362AD21042EA43002A87C7;
+ remoteInfo = "ossim-modopt";
+ };
+ 4301394C10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362AEF1042EA81002A87C7;
+ remoteInfo = "ossim-mosaic";
+ };
+ 4301394E10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362B471042EB45002A87C7;
+ remoteInfo = "ossim-ogeom2ogeom";
+ };
+ 4301395010583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362B641042EB70002A87C7;
+ remoteInfo = "ossim-orthoigen";
+ };
+ 4301395210583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362B801042EB9B002A87C7;
+ remoteInfo = "ossim-pixelflip";
+ };
+ 4301395410583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362B9B1042EBCE002A87C7;
+ remoteInfo = "ossim-prune";
+ };
+ 4301395610583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362BD21042EC26002A87C7;
+ remoteInfo = "ossim-rejout";
+ };
+ 4301395810583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362BEE1042EC50002A87C7;
+ remoteInfo = "ossim-senint";
+ };
+ 4301395A10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362C081042EC80002A87C7;
+ remoteInfo = "ossim-space-imaging";
+ };
+ 4301395C10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362C221042ECAF002A87C7;
+ remoteInfo = "ossim-swapbytes";
+ };
+ 4301395E10583E47009BF7EC /* PBXContainerItemProxy */ = {
+ isa = PBXContainerItemProxy;
+ containerPortal = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ proxyType = 2;
+ remoteGlobalIDString = 43362C3C1042ECD6002A87C7;
+ remoteInfo = "ossim-tfw2ogeom";
+ };
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXFileReference section */
+ 089C1667FE841158C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+ 186EECAE0B1CDEF300F7886A /* common_settings.xcconfig */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = text.xcconfig; name = common_settings.xcconfig; path = ../../../ossim/xcode/ossim/common_settings.xcconfig; sourceTree = SOURCE_ROOT; };
+ 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; name = ossim.xcodeproj; path = ../../../ossim/xcode/ossim/ossim.xcodeproj; sourceTree = SOURCE_ROOT; };
+ 43333DB310FD12E000A5B432 /* libavcodec.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libavcodec.a; path = ../../../ossim_dependencies/lib/libavcodec.a; sourceTree = SOURCE_ROOT; };
+ 43333DB410FD12E000A5B432 /* libavdevice.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libavdevice.a; path = ../../../ossim_dependencies/lib/libavdevice.a; sourceTree = SOURCE_ROOT; };
+ 43333DB510FD12E000A5B432 /* libavformat.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libavformat.a; path = ../../../ossim_dependencies/lib/libavformat.a; sourceTree = SOURCE_ROOT; };
+ 43333DB610FD12E000A5B432 /* libavutil.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libavutil.a; path = ../../../ossim_dependencies/lib/libavutil.a; sourceTree = SOURCE_ROOT; };
+ 43333DB710FD12E000A5B432 /* libswscale.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; name = libswscale.a; path = ../../../ossim_dependencies/lib/libswscale.a; sourceTree = SOURCE_ROOT; };
+ 43A9A9E10D59FCE500E97FA2 /* ossimPredatorExport.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ossimPredatorExport.h; sourceTree = "<group>"; };
+ 8D07F2C70486CC7A007CD1D0 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist; path = Info.plist; sourceTree = "<group>"; };
+ EE3F868B0D0DBB2300DFD3DF /* ossimPredator.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = ossimPredator.framework; sourceTree = BUILT_PRODUCTS_DIR; };
+ EE3F86900D0DBB5200DFD3DF /* ffmpegApi.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ffmpegApi.h; sourceTree = "<group>"; };
+ EE3F86910D0DBB5200DFD3DF /* ossimPredatorApi.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ossimPredatorApi.h; sourceTree = "<group>"; };
+ EE3F86920D0DBB5200DFD3DF /* ossimPredatorKlvTable.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ossimPredatorKlvTable.h; sourceTree = "<group>"; };
+ EE3F86930D0DBB5200DFD3DF /* ossimPredatorLoader.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ossimPredatorLoader.h; sourceTree = "<group>"; };
+ EE3F86940D0DBB5200DFD3DF /* ossimPredatorProjectionFactory.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ossimPredatorProjectionFactory.h; sourceTree = "<group>"; };
+ EE3F86950D0DBB5200DFD3DF /* ossimPredatorThread.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ossimPredatorThread.h; sourceTree = "<group>"; };
+ EE3F86960D0DBB5200DFD3DF /* ossimPredatorUavProjection.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ossimPredatorUavProjection.h; sourceTree = "<group>"; };
+ EE3F86970D0DBB5200DFD3DF /* ossimPredatorVideo.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ossimPredatorVideo.h; sourceTree = "<group>"; };
+ EE3F86A20D0DBB9000DFD3DF /* ossimPredatorThread.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = ossimPredatorThread.cpp; sourceTree = "<group>"; };
+ EE3F87A40D0DBECC00DFD3DF /* Openthreads.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Openthreads.framework; path = ../../../ossim_dependencies/Frameworks/Openthreads.framework; sourceTree = SOURCE_ROOT; };
+ EEB5EC7A0D0F0790000CF6B2 /* ossimPredatorKlvTable.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = ossimPredatorKlvTable.cpp; sourceTree = "<group>"; };
+ EEB5EC8B0D0F08A0000CF6B2 /* ossimPredatorVideo.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = ossimPredatorVideo.cpp; sourceTree = "<group>"; };
+ EEB5EE280D102E08000CF6B2 /* ossimPredatorInit.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ossimPredatorInit.h; sourceTree = "<group>"; };
+ EEB5EE2A0D102E25000CF6B2 /* ossimPredatorInit.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = ossimPredatorInit.cpp; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+ 8D07F2C30486CC7A007CD1D0 /* Frameworks */ = {
+ isa = PBXFrameworksBuildPhase;
+ buildActionMask = 2147483647;
+ files = (
+ EE3F87A50D0DBECC00DFD3DF /* Openthreads.framework in Frameworks */,
+ 186EF5700B1CE22D00F7886A /* ossim.framework in Frameworks */,
+ );
+ runOnlyForDeploymentPostprocessing = 0;
+ };
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+ 034768DDFF38A45A11DB9C8B /* Products */ = {
+ isa = PBXGroup;
+ children = (
+ EE3F868B0D0DBB2300DFD3DF /* ossimPredator.framework */,
+ );
+ name = Products;
+ sourceTree = "<group>";
+ };
+ 0867D691FE84028FC02AAC07 /* ossimPlanet */ = {
+ isa = PBXGroup;
+ children = (
+ 08FB77ACFE841707C02AAC07 /* Source */,
+ 089C1665FE841158C02AAC07 /* Resources */,
+ 1862497F0B2070A20021FDF7 /* External Projects */,
+ 0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */,
+ 034768DDFF38A45A11DB9C8B /* Products */,
+ );
+ name = ossimPlanet;
+ sourceTree = "<group>";
+ };
+ 0867D69AFE84028FC02AAC07 /* External Frameworks and Libraries */ = {
+ isa = PBXGroup;
+ children = (
+ 43333DB310FD12E000A5B432 /* libavcodec.a */,
+ 43333DB410FD12E000A5B432 /* libavdevice.a */,
+ 43333DB510FD12E000A5B432 /* libavformat.a */,
+ 43333DB610FD12E000A5B432 /* libavutil.a */,
+ 43333DB710FD12E000A5B432 /* libswscale.a */,
+ );
+ name = "External Frameworks and Libraries";
+ sourceTree = "<group>";
+ };
+ 089C1665FE841158C02AAC07 /* Resources */ = {
+ isa = PBXGroup;
+ children = (
+ 8D07F2C70486CC7A007CD1D0 /* Info.plist */,
+ 089C1666FE841158C02AAC07 /* InfoPlist.strings */,
+ );
+ name = Resources;
+ sourceTree = "<group>";
+ };
+ 08FB77ACFE841707C02AAC07 /* Source */ = {
+ isa = PBXGroup;
+ children = (
+ 186EECAE0B1CDEF300F7886A /* common_settings.xcconfig */,
+ 186EECB10B1CDF1400F7886A /* ossimPredator */,
+ );
+ name = Source;
+ sourceTree = "<group>";
+ };
+ 1862497F0B2070A20021FDF7 /* External Projects */ = {
+ isa = PBXGroup;
+ children = (
+ EE3F87A40D0DBECC00DFD3DF /* Openthreads.framework */,
+ 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */,
+ );
+ name = "External Projects";
+ sourceTree = "<group>";
+ };
+ 186EECB10B1CDF1400F7886A /* ossimPredator */ = {
+ isa = PBXGroup;
+ children = (
+ 186EECB20B1CDF1400F7886A /* include */,
+ 186EECF10B1CDF1400F7886A /* src */,
+ );
+ name = ossimPredator;
+ path = ../..;
+ sourceTree = SOURCE_ROOT;
+ };
+ 186EECB20B1CDF1400F7886A /* include */ = {
+ isa = PBXGroup;
+ children = (
+ EE3F868F0D0DBB5200DFD3DF /* ossimPredator */,
+ );
+ path = include;
+ sourceTree = "<group>";
+ };
+ 186EECF10B1CDF1400F7886A /* src */ = {
+ isa = PBXGroup;
+ children = (
+ EEB5EE2A0D102E25000CF6B2 /* ossimPredatorInit.cpp */,
+ EEB5EC8B0D0F08A0000CF6B2 /* ossimPredatorVideo.cpp */,
+ EEB5EC7A0D0F0790000CF6B2 /* ossimPredatorKlvTable.cpp */,
+ EE3F86A20D0DBB9000DFD3DF /* ossimPredatorThread.cpp */,
+ );
+ path = src;
+ sourceTree = "<group>";
+ };
+ 186EF4B50B1CE11D00F7886A /* Products */ = {
+ isa = PBXGroup;
+ children = (
+ 186EF4F60B1CE11D00F7886A /* ossim.framework */,
+ 4301391F10583E47009BF7EC /* template-app */,
+ 4301392110583E47009BF7EC /* ossim-adrg-dump */,
+ 4301392310583E47009BF7EC /* ossim-applanix2ogeom */,
+ 4301392510583E47009BF7EC /* ossim-band-merge */,
+ 4301392710583E47009BF7EC /* ossim-btoa */,
+ 4301392910583E47009BF7EC /* template-app */,
+ 4301392B10583E47009BF7EC /* ossim-cmm */,
+ 4301392D10583E47009BF7EC /* ossim-computeSrtmStats */,
+ 4301392F10583E47009BF7EC /* ossim-correl */,
+ 4301393110583E47009BF7EC /* ossim-create-cg */,
+ 4301393310583E47009BF7EC /* ossim-create-histo */,
+ 4301393510583E47009BF7EC /* ossim-dms2deg */,
+ 4301393710583E47009BF7EC /* ossim-dump-ocg */,
+ 4301393910583E47009BF7EC /* ossim-ecg2ocg */,
+ 4301393B10583E47009BF7EC /* ossim-extract-vertices */,
+ 4301393D10583E47009BF7EC /* ossim-foo */,
+ 4301393F10583E47009BF7EC /* ossim-height */,
+ 4301394110583E47009BF7EC /* ossim-icp */,
+ 4301394310583E47009BF7EC /* ossim-igen */,
+ 4301394510583E47009BF7EC /* ossim-img2md */,
+ 4301394710583E47009BF7EC /* ossim-img2rr */,
+ 4301394910583E47009BF7EC /* ossim-info */,
+ 4301394B10583E47009BF7EC /* ossim-modopt */,
+ 4301394D10583E47009BF7EC /* ossim-mosaic */,
+ 4301394F10583E47009BF7EC /* ossim-ogeom2ogeom */,
+ 4301395110583E47009BF7EC /* ossim-orthoigen */,
+ 4301395310583E47009BF7EC /* ossim-pixelflip */,
+ 4301395510583E47009BF7EC /* ossim-prune */,
+ 4301395710583E47009BF7EC /* ossim-rejout */,
+ 4301395910583E47009BF7EC /* ossim-senint */,
+ 4301395B10583E47009BF7EC /* ossim-space-imaging */,
+ 4301395D10583E47009BF7EC /* ossim-swapbytes */,
+ 4301395F10583E47009BF7EC /* ossim-tfw2ogeom */,
+ );
+ name = Products;
+ sourceTree = "<group>";
+ };
+ EE3F868F0D0DBB5200DFD3DF /* ossimPredator */ = {
+ isa = PBXGroup;
+ children = (
+ 43A9A9E10D59FCE500E97FA2 /* ossimPredatorExport.h */,
+ EEB5EE280D102E08000CF6B2 /* ossimPredatorInit.h */,
+ EE3F86900D0DBB5200DFD3DF /* ffmpegApi.h */,
+ EE3F86910D0DBB5200DFD3DF /* ossimPredatorApi.h */,
+ EE3F86920D0DBB5200DFD3DF /* ossimPredatorKlvTable.h */,
+ EE3F86930D0DBB5200DFD3DF /* ossimPredatorLoader.h */,
+ EE3F86940D0DBB5200DFD3DF /* ossimPredatorProjectionFactory.h */,
+ EE3F86950D0DBB5200DFD3DF /* ossimPredatorThread.h */,
+ EE3F86960D0DBB5200DFD3DF /* ossimPredatorUavProjection.h */,
+ EE3F86970D0DBB5200DFD3DF /* ossimPredatorVideo.h */,
+ );
+ path = ossimPredator;
+ sourceTree = "<group>";
+ };
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+ 8D07F2BD0486CC7A007CD1D0 /* Headers */ = {
+ isa = PBXHeadersBuildPhase;
+ buildActionMask = 2147483647;
+ files = (
+ EE3F86980D0DBB5200DFD3DF /* ffmpegApi.h in Headers */,
+ EE3F86990D0DBB5200DFD3DF /* ossimPredatorApi.h in Headers */,
+ EE3F869A0D0DBB5200DFD3DF /* ossimPredatorKlvTable.h in Headers */,
+ EE3F869B0D0DBB5200DFD3DF /* ossimPredatorLoader.h in Headers */,
+ EE3F869C0D0DBB5200DFD3DF /* ossimPredatorProjectionFactory.h in Headers */,
+ EE3F869D0D0DBB5200DFD3DF /* ossimPredatorThread.h in Headers */,
+ EE3F869E0D0DBB5200DFD3DF /* ossimPredatorUavProjection.h in Headers */,
+ EE3F869F0D0DBB5200DFD3DF /* ossimPredatorVideo.h in Headers */,
+ EEB5EE290D102E08000CF6B2 /* ossimPredatorInit.h in Headers */,
+ 43A9A9E20D59FCE500E97FA2 /* ossimPredatorExport.h in Headers */,
+ );
+ runOnlyForDeploymentPostprocessing = 0;
+ };
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+ 8D07F2BC0486CC7A007CD1D0 /* ossimPredator */ = {
+ isa = PBXNativeTarget;
+ buildConfigurationList = 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "ossimPredator" */;
+ buildPhases = (
+ 8D07F2BD0486CC7A007CD1D0 /* Headers */,
+ 8D07F2BF0486CC7A007CD1D0 /* Resources */,
+ 8D07F2C10486CC7A007CD1D0 /* Sources */,
+ 8D07F2C30486CC7A007CD1D0 /* Frameworks */,
+ 8D07F2C50486CC7A007CD1D0 /* Rez */,
+ );
+ buildRules = (
+ );
+ dependencies = (
+ );
+ name = ossimPredator;
+ productInstallPath = "$(HOME)/Library/Frameworks";
+ productName = ossimPlanet;
+ productReference = EE3F868B0D0DBB2300DFD3DF /* ossimPredator.framework */;
+ productType = "com.apple.product-type.framework";
+ };
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+ 0867D690FE84028FC02AAC07 /* Project object */ = {
+ isa = PBXProject;
+ buildConfigurationList = 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "ossimPredator" */;
+ compatibilityVersion = "Xcode 2.4";
+ developmentRegion = English;
+ hasScannedForEncodings = 1;
+ knownRegions = (
+ English,
+ Japanese,
+ French,
+ German,
+ da,
+ Dutch,
+ fi,
+ Italian,
+ ko,
+ no,
+ pl,
+ pt,
+ pt_PT,
+ ru,
+ Spanish,
+ sv,
+ zh_CN,
+ zh_TW,
+ de,
+ en,
+ es,
+ nl,
+ );
+ mainGroup = 0867D691FE84028FC02AAC07 /* ossimPlanet */;
+ productRefGroup = 034768DDFF38A45A11DB9C8B /* Products */;
+ projectDirPath = "";
+ projectReferences = (
+ {
+ ProductGroup = 186EF4B50B1CE11D00F7886A /* Products */;
+ ProjectRef = 186EF4B40B1CE11D00F7886A /* ossim.xcodeproj */;
+ },
+ );
+ projectRoot = "";
+ targets = (
+ 8D07F2BC0486CC7A007CD1D0 /* ossimPredator */,
+ );
+ };
+/* End PBXProject section */
+
+/* Begin PBXReferenceProxy section */
+ 186EF4F60B1CE11D00F7886A /* ossim.framework */ = {
+ isa = PBXReferenceProxy;
+ fileType = wrapper.framework;
+ path = ossim.framework;
+ remoteRef = 186EF4F50B1CE11D00F7886A /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301391F10583E47009BF7EC /* template-app */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "template-app";
+ remoteRef = 4301391E10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301392110583E47009BF7EC /* ossim-adrg-dump */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-adrg-dump";
+ remoteRef = 4301392010583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301392310583E47009BF7EC /* ossim-applanix2ogeom */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-applanix2ogeom";
+ remoteRef = 4301392210583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301392510583E47009BF7EC /* ossim-band-merge */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-band-merge";
+ remoteRef = 4301392410583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301392710583E47009BF7EC /* ossim-btoa */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-btoa";
+ remoteRef = 4301392610583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301392910583E47009BF7EC /* template-app */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "template-app";
+ remoteRef = 4301392810583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301392B10583E47009BF7EC /* ossim-cmm */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-cmm";
+ remoteRef = 4301392A10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301392D10583E47009BF7EC /* ossim-computeSrtmStats */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-computeSrtmStats";
+ remoteRef = 4301392C10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301392F10583E47009BF7EC /* ossim-correl */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-correl";
+ remoteRef = 4301392E10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301393110583E47009BF7EC /* ossim-create-cg */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-create-cg";
+ remoteRef = 4301393010583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301393310583E47009BF7EC /* ossim-create-histo */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-create-histo";
+ remoteRef = 4301393210583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301393510583E47009BF7EC /* ossim-dms2deg */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-dms2deg";
+ remoteRef = 4301393410583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301393710583E47009BF7EC /* ossim-dump-ocg */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-dump-ocg";
+ remoteRef = 4301393610583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301393910583E47009BF7EC /* ossim-ecg2ocg */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-ecg2ocg";
+ remoteRef = 4301393810583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301393B10583E47009BF7EC /* ossim-extract-vertices */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-extract-vertices";
+ remoteRef = 4301393A10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301393D10583E47009BF7EC /* ossim-foo */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-foo";
+ remoteRef = 4301393C10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301393F10583E47009BF7EC /* ossim-height */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-height";
+ remoteRef = 4301393E10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301394110583E47009BF7EC /* ossim-icp */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-icp";
+ remoteRef = 4301394010583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301394310583E47009BF7EC /* ossim-igen */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-igen";
+ remoteRef = 4301394210583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301394510583E47009BF7EC /* ossim-img2md */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-img2md";
+ remoteRef = 4301394410583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301394710583E47009BF7EC /* ossim-img2rr */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-img2rr";
+ remoteRef = 4301394610583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301394910583E47009BF7EC /* ossim-info */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-info";
+ remoteRef = 4301394810583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301394B10583E47009BF7EC /* ossim-modopt */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-modopt";
+ remoteRef = 4301394A10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301394D10583E47009BF7EC /* ossim-mosaic */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-mosaic";
+ remoteRef = 4301394C10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301394F10583E47009BF7EC /* ossim-ogeom2ogeom */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-ogeom2ogeom";
+ remoteRef = 4301394E10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301395110583E47009BF7EC /* ossim-orthoigen */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-orthoigen";
+ remoteRef = 4301395010583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301395310583E47009BF7EC /* ossim-pixelflip */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-pixelflip";
+ remoteRef = 4301395210583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301395510583E47009BF7EC /* ossim-prune */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-prune";
+ remoteRef = 4301395410583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301395710583E47009BF7EC /* ossim-rejout */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-rejout";
+ remoteRef = 4301395610583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301395910583E47009BF7EC /* ossim-senint */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-senint";
+ remoteRef = 4301395810583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301395B10583E47009BF7EC /* ossim-space-imaging */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-space-imaging";
+ remoteRef = 4301395A10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301395D10583E47009BF7EC /* ossim-swapbytes */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-swapbytes";
+ remoteRef = 4301395C10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+ 4301395F10583E47009BF7EC /* ossim-tfw2ogeom */ = {
+ isa = PBXReferenceProxy;
+ fileType = "compiled.mach-o.executable";
+ path = "ossim-tfw2ogeom";
+ remoteRef = 4301395E10583E47009BF7EC /* PBXContainerItemProxy */;
+ sourceTree = BUILT_PRODUCTS_DIR;
+ };
+/* End PBXReferenceProxy section */
+
+/* Begin PBXResourcesBuildPhase section */
+ 8D07F2BF0486CC7A007CD1D0 /* Resources */ = {
+ isa = PBXResourcesBuildPhase;
+ buildActionMask = 2147483647;
+ files = (
+ 8D07F2C00486CC7A007CD1D0 /* InfoPlist.strings in Resources */,
+ );
+ runOnlyForDeploymentPostprocessing = 0;
+ };
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXRezBuildPhase section */
+ 8D07F2C50486CC7A007CD1D0 /* Rez */ = {
+ isa = PBXRezBuildPhase;
+ buildActionMask = 2147483647;
+ files = (
+ );
+ runOnlyForDeploymentPostprocessing = 0;
+ };
+/* End PBXRezBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+ 8D07F2C10486CC7A007CD1D0 /* Sources */ = {
+ isa = PBXSourcesBuildPhase;
+ buildActionMask = 2147483647;
+ files = (
+ EEB5EBEB0D0DD8AB000CF6B2 /* ossimPredatorThread.cpp in Sources */,
+ EEB5EC7B0D0F0791000CF6B2 /* ossimPredatorKlvTable.cpp in Sources */,
+ EEB5EC8C0D0F08A0000CF6B2 /* ossimPredatorVideo.cpp in Sources */,
+ EEB5EE2B0D102E25000CF6B2 /* ossimPredatorInit.cpp in Sources */,
+ );
+ runOnlyForDeploymentPostprocessing = 0;
+ };
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+ 089C1666FE841158C02AAC07 /* InfoPlist.strings */ = {
+ isa = PBXVariantGroup;
+ children = (
+ 089C1667FE841158C02AAC07 /* English */,
+ );
+ name = InfoPlist.strings;
+ sourceTree = "<group>";
+ };
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+ 18A9BCBE0CDA158B00F4581A /* DebugNativeLeopard */ = {
+ isa = XCBuildConfiguration;
+ baseConfigurationReference = 186EECAE0B1CDEF300F7886A /* common_settings.xcconfig */;
+ buildSettings = {
+ ARCHS = "$(NATIVE_ARCH)";
+ GCC_MODEL_TUNING = "";
+ GCC_WARN_ABOUT_RETURN_TYPE = YES;
+ GCC_WARN_UNUSED_VARIABLE = YES;
+ HEADER_SEARCH_PATHS = (
+ "$(DEV_HOME_PATH)/ossim/include",
+ "$(SRCROOT)/../../include",
+ );
+ INSTALL_PATH = "@executable_path/../Frameworks";
+ OTHER_CFLAGS = "";
+ OTHER_CPLUSPLUSFLAGS = "";
+ PREBINDING = NO;
+ SDKROOT = /Developer/SDKs/MacOSX10.5.sdk;
+ };
+ name = DebugNativeLeopard;
+ };
+ 18A9BCBF0CDA158B00F4581A /* DebugNativeLeopard */ = {
+ isa = XCBuildConfiguration;
+ baseConfigurationReference = 186EECAE0B1CDEF300F7886A /* common_settings.xcconfig */;
+ buildSettings = {
+ ARCHS = "$(inherited)";
+ COPY_PHASE_STRIP = NO;
+ DYLIB_COMPATIBILITY_VERSION = 1;
+ DYLIB_CURRENT_VERSION = 1;
+ FRAMEWORK_SEARCH_PATHS = (
+ "$(inherited)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_1)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_2)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_3)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2)",
+ );
+ FRAMEWORK_SEARCH_PATHS_QUOTED_1 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_2 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_3 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2 = "\"$(SYSTEM_LIBRARY_DIR)/CoreServices/Menu Extras/TextInput.menu/Contents/SharedFrameworks\"";
+ FRAMEWORK_VERSION = A;
+ GCC_DYNAMIC_NO_PIC = NO;
+ GCC_ENABLE_FIX_AND_CONTINUE = YES;
+ GCC_MODEL_TUNING = "";
+ GCC_OPTIMIZATION_LEVEL = s;
+ GCC_PRECOMPILE_PREFIX_HEADER = YES;
+ GCC_PREFIX_HEADER = "";
+ GCC_PREPROCESSOR_DEFINITIONS = "$(inherited)";
+ GCC_PREPROCESSOR_DEFINITIONS_QUOTED_1 = "EXTRA_INFO_STRING_FOR_MENU=\\\"Version\\";
+ INFOPLIST_FILE = Info.plist;
+ INSTALL_PATH = "@executable_path/../Frameworks";
+ LIBRARY_SEARCH_PATHS = (
+ "$(UNIV_STATICLIB_DEP)",
+ "$(LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
+ );
+ LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SYSTEM_LIBRARY_DIR)/CoreServices/Encodings\"";
+ LIBRARY_STYLE = DYNAMIC;
+ MACH_O_TYPE = mh_dylib;
+ OTHER_CFLAGS = "$(inherited)";
+ OTHER_CPLUSPLUSFLAGS = "$(inherited)";
+ OTHER_LDFLAGS = (
+ /usr/lib/libz.dylib,
+ "-L$UNIV_STATICLIB_DEP",
+ "-lavformat",
+ "-lavcodec",
+ "-lavutil",
+ );
+ PRODUCT_NAME = ossimPredator;
+ REZ_SEARCH_PATHS = (
+ "$(OSSIM_HOME_PATH)/xcode/ossim/Resources",
+ "$(REZ_SEARCH_PATHS)/**",
+ );
+ USER_HEADER_SEARCH_PATHS = "$(OSSIM_HOME_PATH)/include $(DEV_HOME_PATH)/libwms/include $(DEV_HOME_PATH)/ossimPlanet/include $(UNIV_HEADER_DEP) /usr/X11R6/include/freetype2 /usr/X11R6/include";
+ WARNING_CFLAGS = "-Wall";
+ WRAPPER_EXTENSION = framework;
+ ZERO_LINK = YES;
+ };
+ name = DebugNativeLeopard;
+ };
+ 18B28C4F0CD57AB3008F45B2 /* ReleaseLeopard */ = {
+ isa = XCBuildConfiguration;
+ baseConfigurationReference = 186EECAE0B1CDEF300F7886A /* common_settings.xcconfig */;
+ buildSettings = {
+ ARCHS = (
+ i386,
+ ppc,
+ );
+ GCC_MODEL_TUNING = "";
+ GCC_WARN_ABOUT_RETURN_TYPE = YES;
+ GCC_WARN_UNUSED_VARIABLE = YES;
+ HEADER_SEARCH_PATHS = (
+ "$(DEV_HOME_PATH)/ossim/include",
+ "$(SRCROOT)/../../include",
+ );
+ INSTALL_PATH = "@executable_path/../Frameworks";
+ OTHER_CFLAGS = "";
+ OTHER_CPLUSPLUSFLAGS = "$(OTHER_CFLAGS)";
+ PREBINDING = NO;
+ SDKROOT = /Developer/SDKs/MacOSX10.5.sdk;
+ };
+ name = ReleaseLeopard;
+ };
+ 18B28C500CD57AB3008F45B2 /* ReleaseLeopard */ = {
+ isa = XCBuildConfiguration;
+ buildSettings = {
+ ARCHS = "$(inherited)";
+ DYLIB_COMPATIBILITY_VERSION = 1;
+ DYLIB_CURRENT_VERSION = 1;
+ FRAMEWORK_SEARCH_PATHS = (
+ "$(inherited)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_1)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_2)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_3)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2)",
+ );
+ FRAMEWORK_SEARCH_PATHS_QUOTED_1 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_2 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_3 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2 = "\"$(SYSTEM_LIBRARY_DIR)/CoreServices/Menu Extras/TextInput.menu/Contents/SharedFrameworks\"";
+ FRAMEWORK_VERSION = A;
+ GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
+ GCC_MODEL_TUNING = "";
+ GCC_OPTIMIZATION_LEVEL = s;
+ GCC_PRECOMPILE_PREFIX_HEADER = YES;
+ GCC_PREFIX_HEADER = "";
+ INFOPLIST_FILE = Info.plist;
+ INSTALL_PATH = "@executable_path/../Frameworks";
+ LIBRARY_SEARCH_PATHS = (
+ "$(UNIV_STATICLIB_DEP)",
+ "$(LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
+ );
+ LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SYSTEM_LIBRARY_DIR)/CoreServices/Encodings\"";
+ LIBRARY_STYLE = DYNAMIC;
+ MACH_O_TYPE = mh_dylib;
+ OTHER_CFLAGS = "$(inherited)";
+ OTHER_CPLUSPLUSFLAGS = "$(inherited)";
+ OTHER_LDFLAGS = (
+ /usr/lib/libz.dylib,
+ "-L$UNIV_STATICLIB_DEP",
+ "-lavformat",
+ "-lavcodec",
+ "-lavutil",
+ );
+ PRODUCT_NAME = ossimPredator;
+ REZ_SEARCH_PATHS = (
+ "$(OSSIM_HOME_PATH)/xcode/ossim/Resources",
+ "$(REZ_SEARCH_PATHS)/**",
+ );
+ USER_HEADER_SEARCH_PATHS = "$(DEV_HOME_PATH)/ossim/include $(DEV_HOME_PATH)/libwms/include $(DEV_HOME_PATH)/ossimPlanet/include $(UNIV_HEADER_DEP)";
+ WARNING_CFLAGS = "-Wall";
+ WRAPPER_EXTENSION = framework;
+ };
+ name = ReleaseLeopard;
+ };
+ 18E4E5560BE7802B00C8442B /* DebugNative */ = {
+ isa = XCBuildConfiguration;
+ baseConfigurationReference = 186EECAE0B1CDEF300F7886A /* common_settings.xcconfig */;
+ buildSettings = {
+ ARCHS = "$(inherited)";
+ COPY_PHASE_STRIP = NO;
+ DYLIB_COMPATIBILITY_VERSION = 1;
+ DYLIB_CURRENT_VERSION = 1;
+ FRAMEWORK_SEARCH_PATHS = (
+ "$(inherited)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_1)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_2)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_3)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2)",
+ );
+ FRAMEWORK_SEARCH_PATHS_QUOTED_1 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_2 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_3 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2 = "\"$(SYSTEM_LIBRARY_DIR)/CoreServices/Menu Extras/TextInput.menu/Contents/SharedFrameworks\"";
+ FRAMEWORK_VERSION = A;
+ GCC_DYNAMIC_NO_PIC = NO;
+ GCC_ENABLE_FIX_AND_CONTINUE = YES;
+ GCC_MODEL_TUNING = "";
+ GCC_OPTIMIZATION_LEVEL = s;
+ GCC_PRECOMPILE_PREFIX_HEADER = YES;
+ GCC_PREFIX_HEADER = "";
+ GCC_PREPROCESSOR_DEFINITIONS = "$(inherited)";
+ GCC_PREPROCESSOR_DEFINITIONS_QUOTED_1 = "EXTRA_INFO_STRING_FOR_MENU=\\\"Version\\";
+ INFOPLIST_FILE = Info.plist;
+ INSTALL_PATH = "@executable_path/../Frameworks";
+ LIBRARY_SEARCH_PATHS = (
+ "$(UNIV_STATICLIB_DEP)",
+ "$(LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
+ );
+ LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SYSTEM_LIBRARY_DIR)/CoreServices/Encodings\"";
+ LIBRARY_STYLE = DYNAMIC;
+ MACH_O_TYPE = mh_dylib;
+ OTHER_CFLAGS = "$(inherited)";
+ OTHER_CPLUSPLUSFLAGS = "$(inherited)";
+ OTHER_LDFLAGS = (
+ /usr/lib/libz.dylib,
+ "-L$UNIV_STATICLIB_DEP",
+ "-lavformat",
+ "-lavcodec",
+ "-lavutil",
+ );
+ PRODUCT_NAME = ossimPredator;
+ REZ_SEARCH_PATHS = (
+ "$(OSSIM_HOME_PATH)/xcode/ossim/Resources",
+ "$(REZ_SEARCH_PATHS)/**",
+ );
+ USER_HEADER_SEARCH_PATHS = "$(OSSIM_HOME_PATH)/include $(DEV_HOME_PATH)/libwms/include $(DEV_HOME_PATH)/ossimPlanet/include $(UNIV_HEADER_DEP) /usr/X11R6/include/freetype2 /usr/X11R6/include";
+ WARNING_CFLAGS = "-Wall";
+ WRAPPER_EXTENSION = framework;
+ ZERO_LINK = YES;
+ };
+ name = DebugNative;
+ };
+ 18E4E5570BE7802B00C8442B /* DebugNative */ = {
+ isa = XCBuildConfiguration;
+ baseConfigurationReference = 186EECAE0B1CDEF300F7886A /* common_settings.xcconfig */;
+ buildSettings = {
+ ARCHS = "$(NATIVE_ARCH)";
+ GCC_MODEL_TUNING = "";
+ GCC_WARN_ABOUT_RETURN_TYPE = YES;
+ GCC_WARN_UNUSED_VARIABLE = YES;
+ HEADER_SEARCH_PATHS = (
+ "$(DEV_HOME_PATH)/ossim/include",
+ "$(SRCROOT)/../../include",
+ );
+ INSTALL_PATH = "@executable_path/../Frameworks";
+ OTHER_CFLAGS = "";
+ OTHER_CPLUSPLUSFLAGS = "";
+ PREBINDING = NO;
+ SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
+ };
+ name = DebugNative;
+ };
+ 4FADC24308B4156D00ABE55E /* Debug */ = {
+ isa = XCBuildConfiguration;
+ baseConfigurationReference = 186EECAE0B1CDEF300F7886A /* common_settings.xcconfig */;
+ buildSettings = {
+ ARCHS = "$(inherited)";
+ COPY_PHASE_STRIP = NO;
+ DYLIB_COMPATIBILITY_VERSION = 1;
+ DYLIB_CURRENT_VERSION = 1;
+ FRAMEWORK_SEARCH_PATHS = (
+ "$(inherited)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_1)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_2)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_3)",
+ );
+ FRAMEWORK_SEARCH_PATHS_QUOTED_1 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_2 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_3 = "\"$(SYSTEM_LIBRARY_DIR)/CoreServices/Menu Extras/TextInput.menu/Contents/SharedFrameworks\"";
+ FRAMEWORK_VERSION = A;
+ GCC_DYNAMIC_NO_PIC = NO;
+ GCC_ENABLE_FIX_AND_CONTINUE = YES;
+ GCC_MODEL_TUNING = "";
+ GCC_OPTIMIZATION_LEVEL = s;
+ GCC_PRECOMPILE_PREFIX_HEADER = YES;
+ GCC_PREFIX_HEADER = "";
+ GCC_PREPROCESSOR_DEFINITIONS = (
+ "$(inherited)",
+ "$(GCC_PREPROCESSOR_DEFINITIONS_QUOTED_1)",
+ );
+ GCC_PREPROCESSOR_DEFINITIONS_QUOTED_1 = "EXTRA_INFO_STRING_FOR_MENU=\\\"Version\\";
+ INFOPLIST_FILE = Info.plist;
+ INSTALL_PATH = "@executable_path/../Frameworks";
+ LIBRARY_SEARCH_PATHS = (
+ "$(UNIV_STATICLIB_DEP)",
+ "$(LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
+ );
+ LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SYSTEM_LIBRARY_DIR)/CoreServices/Encodings\"";
+ LIBRARY_STYLE = DYNAMIC;
+ MACH_O_TYPE = mh_dylib;
+ OTHER_CFLAGS = "$(inherited)";
+ OTHER_CPLUSPLUSFLAGS = "$(inherited)";
+ OTHER_LDFLAGS = (
+ /usr/lib/libz.dylib,
+ "-L$UNIV_STATICLIB_DEP",
+ "-lavformat",
+ "-lavcodec",
+ "-lavutil",
+ );
+ PRODUCT_NAME = ossimPredator;
+ REZ_SEARCH_PATHS = (
+ "$(OSSIM_HOME_PATH)/xcode/ossim/Resources",
+ "$(REZ_SEARCH_PATHS)/**",
+ );
+ USER_HEADER_SEARCH_PATHS = "$(OSSIM_HOME_PATH)/include $(DEV_HOME_PATH)/libwms/include $(DEV_HOME_PATH)/ossimPlanet/include $(UNIV_HEADER_DEP) /usr/X11R6/include/freetype2 /usr/X11R6/include";
+ WARNING_CFLAGS = "-Wall";
+ WRAPPER_EXTENSION = framework;
+ ZERO_LINK = YES;
+ };
+ name = Debug;
+ };
+ 4FADC24408B4156D00ABE55E /* Release */ = {
+ isa = XCBuildConfiguration;
+ buildSettings = {
+ ARCHS = "$(inherited)";
+ DYLIB_COMPATIBILITY_VERSION = 1;
+ DYLIB_CURRENT_VERSION = 1;
+ FRAMEWORK_SEARCH_PATHS = (
+ "$(inherited)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_1)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_2)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2)",
+ "$(FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_3)",
+ );
+ FRAMEWORK_SEARCH_PATHS_QUOTED_1 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_2 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_2 = "\"$(SRCROOT)/../../../ossim_dependencies/Frameworks\"";
+ FRAMEWORK_SEARCH_PATHS_QUOTED_FOR_TARGET_3 = "\"$(SYSTEM_LIBRARY_DIR)/CoreServices/Menu Extras/TextInput.menu/Contents/SharedFrameworks\"";
+ FRAMEWORK_VERSION = A;
+ GCC_DYNAMIC_NO_PIC = NO;
+ GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
+ GCC_MODEL_TUNING = "";
+ GCC_OPTIMIZATION_LEVEL = s;
+ GCC_PRECOMPILE_PREFIX_HEADER = NO;
+ GCC_PREFIX_HEADER = "";
+ INFOPLIST_FILE = Info.plist;
+ INSTALL_PATH = "@executable_path/../Frameworks";
+ LIBRARY_SEARCH_PATHS = (
+ "$(UNIV_STATICLIB_DEP)",
+ "$(LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1)",
+ );
+ LIBRARY_SEARCH_PATHS_QUOTED_FOR_TARGET_1 = "\"$(SYSTEM_LIBRARY_DIR)/CoreServices/Encodings\"";
+ LIBRARY_STYLE = DYNAMIC;
+ MACH_O_TYPE = mh_dylib;
+ OTHER_CFLAGS = "$(inherited)";
+ OTHER_CPLUSPLUSFLAGS = "$(inherited)";
+ OTHER_LDFLAGS = "$(inherited)";
+ PRODUCT_NAME = ossimPredator;
+ REZ_SEARCH_PATHS = (
+ "$(OSSIM_HOME_PATH)/xcode/ossim/Resources",
+ "$(REZ_SEARCH_PATHS)/**",
+ );
+ USER_HEADER_SEARCH_PATHS = "$(DEV_HOME_PATH)/ossim/include $(DEV_HOME_PATH)/libwms/include $(DEV_HOME_PATH)/ossimPlanet/include $(UNIV_HEADER_DEP)";
+ WARNING_CFLAGS = "-Wall";
+ WRAPPER_EXTENSION = framework;
+ };
+ name = Release;
+ };
+ 4FADC24708B4156D00ABE55E /* Debug */ = {
+ isa = XCBuildConfiguration;
+ baseConfigurationReference = 186EECAE0B1CDEF300F7886A /* common_settings.xcconfig */;
+ buildSettings = {
+ ARCHS = (
+ ppc,
+ i386,
+ );
+ GCC_MODEL_TUNING = "";
+ GCC_WARN_ABOUT_RETURN_TYPE = YES;
+ GCC_WARN_UNUSED_VARIABLE = YES;
+ HEADER_SEARCH_PATHS = (
+ "$(DEV_HOME_PATH)/ossim/include",
+ "$(SRCROOT)/../../include",
+ );
+ INSTALL_PATH = "@executable_path/../Frameworks";
+ OTHER_CFLAGS = "";
+ OTHER_CPLUSPLUSFLAGS = "";
+ PREBINDING = NO;
+ SDKROOT = /Developer/SDKs/MacOSX10.4u.sdk;
+ };
+ name = Debug;
+ };
+ 4FADC24808B4156D00ABE55E /* Release */ = {
+ isa = XCBuildConfiguration;
+ baseConfigurationReference = 186EECAE0B1CDEF300F7886A /* common_settings.xcconfig */;
+ buildSettings = {
+ ARCHS = "$(inherited)";
+ GCC_MODEL_TUNING = "";
+ GCC_VERSION = "$(inherited)";
+ GCC_WARN_ABOUT_RETURN_TYPE = YES;
+ GCC_WARN_UNUSED_VARIABLE = YES;
+ HEADER_SEARCH_PATHS = (
+ "$(DEV_HOME_PATH)/ossim/include",
+ "$(SRCROOT)/../../include",
+ );
+ INSTALL_PATH = "@executable_path/../Frameworks";
+ OTHER_CFLAGS = "";
+ OTHER_CPLUSPLUSFLAGS = "";
+ OTHER_LDFLAGS = (
+ "-lavdevice",
+ "-lavformat",
+ "-lavcodec",
+ "-lavutil",
+ "-lswscale",
+ "-lz",
+ "-lbz2",
+ "-lm",
+ );
+ PREBINDING = NO;
+ SDKROOT = "$(inherited)";
+ };
+ name = Release;
+ };
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+ 4FADC24208B4156D00ABE55E /* Build configuration list for PBXNativeTarget "ossimPredator" */ = {
+ isa = XCConfigurationList;
+ buildConfigurations = (
+ 4FADC24308B4156D00ABE55E /* Debug */,
+ 18E4E5560BE7802B00C8442B /* DebugNative */,
+ 18A9BCBF0CDA158B00F4581A /* DebugNativeLeopard */,
+ 4FADC24408B4156D00ABE55E /* Release */,
+ 18B28C500CD57AB3008F45B2 /* ReleaseLeopard */,
+ );
+ defaultConfigurationIsVisible = 0;
+ defaultConfigurationName = Release;
+ };
+ 4FADC24608B4156D00ABE55E /* Build configuration list for PBXProject "ossimPredator" */ = {
+ isa = XCConfigurationList;
+ buildConfigurations = (
+ 4FADC24708B4156D00ABE55E /* Debug */,
+ 18E4E5570BE7802B00C8442B /* DebugNative */,
+ 18A9BCBE0CDA158B00F4581A /* DebugNativeLeopard */,
+ 4FADC24808B4156D00ABE55E /* Release */,
+ 18B28C4F0CD57AB3008F45B2 /* ReleaseLeopard */,
+ );
+ defaultConfigurationIsVisible = 0;
+ defaultConfigurationName = Release;
+ };
+/* End XCConfigurationList section */
+ };
+ rootObject = 0867D690FE84028FC02AAC07 /* Project object */;
+}
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-grass/ossim-video.git
More information about the Pkg-grass-devel
mailing list