0.3.0 API

.gitignore

@@ -1,3 +1,4 @@
 build
 java/target
+doc/html
 *.userprefs

.travis.yml

@@ -11,21 +11,31 @@ matrix:
       addons:
         apt:
           packages:
-            - pcre3-dev
+            - libpcre3-dev
       compiler: gcc
     - os: linux
       sudo: false
       addons:
         apt:
           packages:
-            - pcre3-dev
+            - libpcre3-dev
       compiler: clang
     - os: osx
-      osx_image: beta-xcode6.2  # Mac OS X 10.9
+      osx_image: xcode6.4  # Mac OS X 10.10
       compiler: gcc
+      before_install:
+        - brew update
+        - brew install openssl
+      env:
+        - HOMEBREW=1
     - os: osx
-      osx_image: beta-xcode6.2  # Mac OS X 10.9
+      osx_image: xcode6.4  # Mac OS X 10.10
       compiler: clang
+      before_install:
+        - brew update
+        - brew install openssl
+      env:
+        - HOMEBREW=1
 
 before_install:
   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update ; brew install swig ; fi

Makefile

@@ -117,6 +117,12 @@ endif
 LIBS=-L$(DIR_BUILD) $(shell echo $(LIBRARIES) | sed -E 's%$(DIR_BUILD)/lib([^ ]*)\.(a|$(LIBSUFFIX))%-l\1%g') -lm
 CXXLIBS=-L$(DIR_BUILD) -ljxr++ -lcrypto
 
+ifdef HOMEBREW
+CFLAGS:=$(CFLAGS) -I$(shell brew --prefix openssl)/include
+CXXFLAGS:=$(CXXFLAGS) -I$(shell brew --prefix openssl)/include
+LIBS:=$(LIBS) -L$(shell brew --prefix openssl)/lib
+endif
+
 ##--------------------------------
 ##
 ## Common files
@@ -260,6 +266,10 @@ $(DIR_BUILD)/libjxrjava.$(LIBSUFFIX): $(LIBRARIES) $(CXX_LIBRARIES)
 	@echo "JAVA_INCLUDE=$(JAVA_INCLUDE)"
 	$(CXX) -o $(DIR_BUILD)/libjxrjava.$(LIBSUFFIX) -shared -I$(JAVA_INCLUDE) -I$(JAVA_INCLUDE)/$(PLATFORM) -I$(DIR_CXX)/lib $(CXXFLAGS) $(OBJ_SYS) $(OBJ_ENC) $(OBJ_DEC) $(OBJ_GLUE) $(OBJ_TEST) $(OBJ_CXX) $(DIR_JAVA)/JXR_wrap.cxx
 
+.PHONY: doc
+doc:
+	doxygen Doxyfile
+
 ##--------------------------------
 ##
 ## Enc app files

appveyor.yml

@@ -23,6 +23,8 @@ on_success:
   - ps: (Get-Content java\settings.xml) -replace '__MAVEN_SERVER_USERNAME__', "$env:MAVEN_SERVER_USERNAME" | %{$_ -replace '__MAVEN_SERVER_PASSWORD__', "$env:MAVEN_SERVER_PASSWORD"} | Out-File -encoding ASCII C:\Users\appveyor\.m2\settings.xml
   - mvn -f java/pom.xml -DargLine="-Djava.library.path=vc14projects\Release\JXRJava\x64" test
   - IF NOT DEFINED APPVEYOR_PULL_REQUEST_NUMBER mvn -f java\native-windows_64\pom.xml deploy
+on_finish:
+  - ps: Get-ChildItem .\java\*.log | % { Push-AppveyorArtifact $_.FullName -FileName $_.Name }
 artifacts:
   - path: 'java\native-windows_64\target\*.jar'
 cache:

cpp/lib/CodecFactory.cpp

@@ -86,13 +86,13 @@ namespace jxrlib {
 #ifdef DEBUG
     printf("Advanced file...");
     printf("First couple characters: %c%c%c", std::fgetc(pStream->state.file.pFile),  std::fgetc(pStream->state.file.pFile), std::fgetc(pStream->state.file.pFile));
+    std::fseek(pStream->state.file.pFile, -3, SEEK_CUR);
 #endif
 
     // initialize the decoder with the prepared stream
     Call(decoder.pDecoder->Initialize(decoder.pDecoder, pStream));
 #ifdef DEBUG
     printf("Initialized with the stream...");
-    std::fseek(pStream->state.file.pFile, -3, SEEK_CUR);
 #endif
     decoder.pDecoder->fStreamOwner = !0;
     decoder.initialize();

cpp/lib/CodecFactory.hpp

@@ -29,27 +29,88 @@
 
 namespace jxrlib {
 
+  /**
+   *  The CodecFactory class wraps the `pCodecFactory` struct and corresponding
+   *  methods from the jxrlib C code. It contains methods to generate image
+   *  decoders and format converters.
+   */
   class CodecFactory {
     PKCodecFactory *pCodecFactory;
     ERR err;
   public:
     CodecFactory();
     ~CodecFactory();
 
+    /**
+     *  Initialize an ImageDecoder from a file.
+     *
+     *  @param decoder   A pre-instantiated ImageDecoder instance to be initialized
+     *  @param inputFile The JPEG XR file to be decoded
+     */
     void decoderFromFile(ImageDecoder &decoder, std::string inputFile);
+
+    /**
+     *  Initialize an ImageDecoder from data inside a file.
+     *
+     *  @param decoder   A pre-instantiated ImageDecoder instance to be
+     *                   initialized
+     *  @param inputFile The file containing the JPEG XR data to be decoded
+     *  @param offset    The offset within the file where image data begins
+     */
     void decoderFromFile(ImageDecoder &decoder,
                          std::string inputFile,
                          long offset);
+
+    /**
+     *  Initialize an ImageDecoder directly from JPEG XR data
+     *
+     *  @param decoder A pre-instantiated ImageDecoder instance to be
+     *                 initialized
+     *  @param data    The raw JPEG XR data
+     */
     void decoderFromBytes(ImageDecoder &decoder,
                           std::vector<unsigned char> data);
+
+    /**
+     *  Initialize an ImageDecoder directly from in-memory data containing a
+     *  JPEG XR image
+     *
+     *  @param decoder A pre-instantiated ImageDecoder instance to be
+     *                 initialized
+     *  @param data    The data containing the JPEG XR image
+     *  @param offset  Where in the `data` the JPEG XR image begins
+     *  @param length  The length of the JPEG XR image data
+     */
     void decoderFromBytes(ImageDecoder &decoder,
                           std::vector<unsigned char> data,
                           size_t offset,
                           size_t length);
+
+    /**
+     *  Initialize an ImageDecoder directly from in-memory data containing a
+     *  JPEG XR image
+     *
+     *  @param decoder A pre-instantiated ImageDecoder instance to be
+     *                 initialized
+     *  @param bytes   A pointer to the location of the data containing the JPEG
+     *                 XR image
+     *  @param offset  The offset from `bytes` where the JPEG XR image begins
+     *  @param length  The length of the JPEG XR image data
+     */
     void decoderFromBytes(ImageDecoder &decoder,
                           unsigned char *bytes,
                           size_t offset,
                           size_t length);
+
+    /**
+     *  Generate a FormatConverter from a decoder which will convert a JPEG XR
+     *  image into an image format specified by extension
+     *
+     *  @param decoder   An ImageDecoder initialized with a JPEG XR image
+     *  @param extension The file extension of the image format to convert to
+     *  @return          A FormatConverter ready to be used with an ImageEncoder
+     *                   to transcode a JPEG XR image
+     */
     FormatConverter createFormatConverter(ImageDecoder &decoder,
                                           std::string extension);
   };

cpp/lib/DecodeContext.cpp

@@ -20,25 +20,115 @@
 
 #include "CodecFactory.hpp"
 #include "DecodeContext.hpp"
+#include "Factory.hpp"
 #include "ImageDecoder.hpp"
+#include "ImageEncoder.hpp"
 
 namespace jxrlib {
 
-  signed char* DecodeContext::decodeFirstFrame(char *source,
-                                               size_t offset,
-                                               size_t length,
-                                               size_t *size) {
+  void DecodeContext::decodeFrame(int frame,
+                                  ImageDecoder &source,
+                                  unsigned char *destination) {
+    source.selectFrame(frame);
+    source.getRawBytes(destination);
+  }
+
+  void DecodeContext::decodeFrame(int frame,
+                                  std::string inputFile,
+                                  std::string outputFile,
+                                  size_t sourceOffset) {
+    Factory factory;
+    CodecFactory codecFactory;
+
+    ImageDecoder decoder;
+    codecFactory.decoderFromFile(decoder, inputFile, sourceOffset);
+    decoder.selectFrame(frame);
+
+    std::string extension = outputFile.substr(outputFile.find_last_of(".") + 1);
+    FormatConverter converter = codecFactory.createFormatConverter(decoder, extension);
+    Stream outputStream = factory.createStreamFromFilename(outputFile);
+    ImageEncoder encoder(outputStream, "." + extension);
+
+    encoder.initializeWithDecoder(decoder);
+    encoder.writeSource(converter);
+    encoder.close();
+  }
+
+  signed char* DecodeContext::decodeFrame(int frame,
+                                          std::string inputFile,
+                                          size_t *size,
+                                          size_t sourceOffset) {
     ImageDecoder decoder;
     CodecFactory codecFactory;
-    codecFactory.decoderFromBytes(
-      decoder, (unsigned char *)source, offset, length);
+    codecFactory.decoderFromFile(decoder, inputFile, sourceOffset);
+    ImageMetadata metadata = decoder.getImageMetadata();
+
+    *size = metadata.height * metadata.width * metadata.bytesPerPixel;
+    signed char *destination = new signed char[*size];
+    decodeFrame(frame, decoder, (unsigned char *)destination);
+    return destination;
+  }
+
+  void DecodeContext::decodeFrame(int frame,
+                                  std::string inputFile,
+                                  unsigned char *destination,
+                                  size_t sourceOffset) {
+    Factory factory;
+    CodecFactory codecFactory;
+
+    ImageDecoder decoder;
+    codecFactory.decoderFromFile(decoder, inputFile, sourceOffset);
+    decodeFrame(frame, decoder, destination);
+  }
+
+  signed char* DecodeContext::decodeFrame(int frame,
+                                          unsigned char *source,
+                                          size_t *size,
+                                          size_t sourceOffset,
+                                          size_t sourceLength) {
+    ImageDecoder decoder;
+    CodecFactory codecFactory;
+    codecFactory.decoderFromBytes(decoder, source,
+                                  sourceOffset, sourceLength);
 
     *size =
       decoder.getWidth() * decoder.getHeight() * decoder.getBytesPerPixel();
     signed char *destination = new signed char[*size];
-    decoder.selectFrame(0);
-    decoder.getRawBytes((unsigned char *)destination);
+    this->decodeFrame(frame, decoder, (unsigned char *)destination);
     return destination;
   }
 
+  void DecodeContext::decodeFrame(int frame,
+                                  unsigned char *source,
+                                  unsigned char *destination,
+                                  size_t sourceOffset,
+                                  size_t sourceLength,
+                                  size_t destinationOffset) {
+    ImageDecoder decoder;
+    CodecFactory codecFactory;
+    codecFactory.decoderFromBytes(
+      decoder, source, sourceOffset, sourceLength);
+
+    decodeFrame(
+      frame, decoder, destination + destinationOffset);
+  }
+
+  ImageMetadata DecodeContext::getImageMetadata(unsigned char *source,
+                                                size_t sourceOffset,
+                                                size_t sourceLength) {
+    ImageDecoder decoder;
+    CodecFactory codecFactory;
+    codecFactory.decoderFromBytes(decoder, (unsigned char *)source,
+                                  sourceOffset, sourceLength);
+    return decoder.getImageMetadata();
+  }
+
+  ImageMetadata DecodeContext::getImageMetadata(std::string inputFile,
+                                                size_t sourceOffset) {
+    ImageDecoder decoder;
+    CodecFactory codecFactory;
+    codecFactory.decoderFromFile(decoder, inputFile, sourceOffset);
+    return decoder.getImageMetadata();
+  }
+
 } // namespace jxrlib