예제 #1
0
 /**
  * Releases a eds object
  *
  * @param value
  * @return
  */
 public static void release(final EdsBaseRef.ByReference... objects) {
   for (final EdsBaseRef.ByReference obj : objects) {
     if (obj != null) {
       CanonUtils.release(obj.getValue());
     }
   }
 }
예제 #2
0
 /**
  * Set a camera property
  *
  * @param ref Reference to the camera/image/liveview object
  * @param property ID of the property
  * @param param
  * @param value New property value.
  * @return Result of the operation, normally {@link EdsError#EDS_ERR_OK}
  */
 public static EdsError setPropertyData(
     final EdsBaseRef ref,
     final EdsPropertyID property,
     final long param,
     final DescriptiveEnum<? extends Number> value) {
   return CanonUtils.setPropertyDataAdvanced(ref, property, param, value.value().longValue());
 }
예제 #3
0
 /**
  * Checks whether live view is allowed to be activated (enabled) and alternately whether the
  * camera is actively transmitting live view images.
  *
  * <p>The default result from the camera may be misleading since {@link
  * CanonConstants.EdsPropertyID#kEdsPropID_Evf_Mode kEdsPropID_Evf_Mode} only indicates whether
  * live view is allowed to be enabled or not, not whether it is currently active and transmitting
  * images.
  *
  * <p>Additionally, we cannot simply query {@link
  * CanonConstants.EdsPropertyID#kEdsPropID_Evf_OutputDevice kEdsPropID_Evf_OutputDevice} because
  * the camera seems to give inconsistent results, sometimes providing an answer but mostly
  * returning {@code 0xFFFFFFFF}.
  *
  * <p>Instead, if {@code checkLiveViewActive} is {@code true} this function will try to download a
  * live view frame and if it cannot, the function assumes that live view is off and {@code false}
  * is returned.
  *
  * @param camera the camera to query
  * @param checkLiveViewActive set {@code true} to check whether the camera is actively
  *     transmitting live view images
  * @return {@code true} if live view is allowed to be enabled, or if checkLiveViewActive, then
  *     {@code true} if the camera is actively transmitting live view images
  */
 public static boolean isLiveViewEnabled(
     final EdsCameraRef camera, final boolean checkLiveViewActive) {
   try {
     if (checkLiveViewActive) {
       final EdsBaseRef.ByReference[] references = CanonUtils.getLiveViewImageReference(camera);
       if (references != null) {
         CanonUtils.release(references);
         return true;
       }
       return false;
     }
     return 1 == CanonUtils.getPropertyData(camera, EdsPropertyID.kEdsPropID_Evf_Mode);
   } catch (final IllegalArgumentException e) {
     System.err.println("Could not check live view status: " + e.getMessage());
   }
   return false;
 }
예제 #4
0
 public static EdsError setCapacity(final EdsCameraRef ref, final int capacity) {
   final EdsCapacity.ByValue edsCapacity = new EdsCapacity.ByValue();
   edsCapacity.bytesPerSector = new NativeLong(512);
   edsCapacity.numberOfFreeClusters =
       new NativeLong(capacity / edsCapacity.bytesPerSector.intValue());
   edsCapacity.reset = 1;
   return CanonUtils.toEdsError(CanonCamera.EDSDK.EdsSetCapacity(ref, edsCapacity));
 }
예제 #5
0
  public static boolean beginLiveView(final EdsCameraRef camera) {
    EdsError err = EdsError.EDS_ERR_OK;

    NativeLongByReference number = new NativeLongByReference(new NativeLong(1));
    Pointer data = number.getPointer();
    err =
        CanonUtils.setPropertyData(
            camera, EdsPropertyID.kEdsPropID_Evf_Mode, 0, NativeLong.SIZE, data);
    if (err != EdsError.EDS_ERR_OK) {
      System.err.println(
          "Could not start live view (set image mode) (error "
              + err.value()
              + ": "
              + err.name()
              + " - "
              + err.description()
              + ")");
      return false;
    }

    number =
        new NativeLongByReference(
            new NativeLong(EdsEvfOutputDevice.kEdsEvfOutputDevice_PC.value()));
    data = number.getPointer();
    err =
        CanonUtils.setPropertyData(
            camera, EdsPropertyID.kEdsPropID_Evf_OutputDevice, 0, NativeLong.SIZE, data);
    if (err != EdsError.EDS_ERR_OK) {
      System.err.println(
          "Could not start live view (set output device) (error "
              + err.value()
              + ": "
              + err.name()
              + " - "
              + err.description()
              + ")");
      return false;
    }

    return true;
  }
예제 #6
0
 public static boolean isMirrorLockupEnabled(final EdsCameraRef camera) {
   try {
     return 1l
         == CanonUtils.getPropertyData(
             camera,
             EdsPropertyID.kEdsPropID_CFn,
             EdsCustomFunction.kEdsCustomFunction_MirrorLockup.value());
   } catch (final IllegalArgumentException e) {
     System.err.println("Could not check if mirror lockup enabled: " + e.getMessage());
   }
   return false;
 }
예제 #7
0
  /**
   * Creates a stream and corresponding live view image. Don't forget to call {@link
   * CanonUtils#release(edsdk.bindings.EdSdkLibrary.EdsBaseRef.ByReference...) release()} on the
   * returned array when you are done using it or you will cause a memory leak!
   *
   * @param camera the camera to query
   * @return EdsEvfImageRef.ByReference and EdsStreamRef.ByReference as indexes 0 and 1 respectively
   */
  public static EdsBaseRef.ByReference[] getLiveViewImageReference(final EdsCameraRef camera) {
    EdsError err = EdsError.EDS_ERR_OK;

    final EdsStreamRef.ByReference streamRef = new EdsStreamRef.ByReference();
    final EdsEvfImageRef.ByReference imageRef = new EdsEvfImageRef.ByReference();

    // Create memory stream.
    err =
        CanonUtils.toEdsError(
            CanonCamera.EDSDK.EdsCreateMemoryStream(new NativeLong(0), streamRef));
    if (err != EdsError.EDS_ERR_OK) {
      System.err.println(
          "Failed to download live view image, memory stream could not be created (error "
              + err.value()
              + ": "
              + err.name()
              + " - "
              + err.description()
              + ")");
      CanonUtils.release(imageRef, streamRef);
      return null;
    }

    err =
        CanonUtils.toEdsError(
            CanonCamera.EDSDK.EdsCreateEvfImageRef(
                new EdsStreamRef(streamRef.getPointer().getPointer(0)), imageRef));
    if (err != EdsError.EDS_ERR_OK) {
      System.err.println(
          "Failed to download live view image, image ref could not be created (error "
              + err.value()
              + ": "
              + err.name()
              + " - "
              + err.description()
              + ")");
      CanonUtils.release(imageRef, streamRef);
      return null;
    }

    // Now try to follow the guidelines from
    // http://tech.groups.yahoo.com/group/CanonSDK/message/1225
    // instead of what the edsdk example has to offer!

    // Download live view image data.
    err = CanonUtils.toEdsError(CanonCamera.EDSDK.EdsDownloadEvfImage(camera, imageRef.getValue()));
    if (err != EdsError.EDS_ERR_OK) {
      /*
       * System.err.println( "Failed to download live view image (error "
       * +
       * err.value() + ": " + err.name() + " - " +
       * err.description() + ")" );
       */
      CanonUtils.release(imageRef, streamRef);
      return null;
    }

    return new EdsBaseRef.ByReference[] {imageRef, streamRef};
  }
예제 #8
0
  /**
   * Finds the filename for a directory item
   *
   * @param directoryItem The item you want to download
   * @return Either null, or the filename of the item
   */
  public static EdsDirectoryItemInfo getDirectoryItemInfo(final EdsDirectoryItemRef directoryItem) {
    EdsError err = EdsError.EDS_ERR_OK;
    final EdsDirectoryItemInfo dirItemInfo = new EdsDirectoryItemInfo();

    try {
      err =
          CanonUtils.toEdsError(
              CanonCamera.EDSDK.EdsGetDirectoryItemInfo(directoryItem, dirItemInfo));
    } catch (final Exception e) {
      e.printStackTrace();
    }

    return err == EdsError.EDS_ERR_OK ? dirItemInfo : null;
  }
예제 #9
0
 /**
  * Query property data
  *
  * @param ref Reference to the camera/image/liveview object
  * @param property Property id
  * @param param
  * @param size Data size in bytes
  * @return Current long value of the property
  */
 public static EdsError getPropertyData(
     final EdsBaseRef ref,
     final EdsPropertyID property,
     final long param,
     final long size,
     final Pointer data) {
   return CanonUtils.toEdsError(
       CanonCamera.EDSDK.EdsGetPropertyData(
           ref,
           new NativeLong(property.value()),
           new NativeLong(param),
           new NativeLong(size),
           data));
 }
예제 #10
0
  public static boolean endLiveView(final EdsCameraRef camera) {
    EdsError err = EdsError.EDS_ERR_OK;

    NativeLongByReference number =
        new NativeLongByReference(
            new NativeLong(EdsEvfOutputDevice.kEdsEvfOutputDevice_TFT.value()));
    Pointer data = number.getPointer();
    err =
        CanonUtils.setPropertyData(
            camera, EdsPropertyID.kEdsPropID_Evf_OutputDevice, 0, NativeLong.SIZE, data);
    if (err != EdsError.EDS_ERR_OK) {
      /*
       * System.err.println( "Could not end live view (error " +
       * err.value() + ": " + err.name() + " - " +
       * err.description() + ")" );
       */
      return false;
    }

    // TODO: decide whether skip deactivating the live view system. Canon's EOS Utility leaves it
    // enabled, so should consider leaving it enabled as well.
    number = new NativeLongByReference(new NativeLong(0));
    data = number.getPointer();
    err =
        CanonUtils.setPropertyData(
            camera, EdsPropertyID.kEdsPropID_Evf_Mode, 0, NativeLong.SIZE, data);
    if (err != EdsError.EDS_ERR_OK) {
      /*
       * System.err.println( "Could not end live view (error " +
       * err.value() + ": " + err.name() + " - " +
       * err.description() + ")" );
       */
      return false;
    }

    return true;
  }
예제 #11
0
 /**
  * Get the size of a property
  *
  * @param ref Reference to the camera/image/liveview object
  * @param property the property id
  * @param param
  * @return Size in bytes
  */
 public static long getPropertySize(
     final EdsBaseRef ref, final EdsPropertyID property, final long param) {
   final int bufferSize = 1;
   final IntBuffer type = IntBuffer.allocate(bufferSize);
   final NativeLongByReference number = new NativeLongByReference(new NativeLong(bufferSize));
   final EdsError err =
       CanonUtils.toEdsError(
           CanonCamera.EDSDK.EdsGetPropertySize(
               ref, new NativeLong(property.value()), new NativeLong(param), type, number));
   if (err == EdsError.EDS_ERR_OK) {
     // System.out.println( "> property size = " + number.getValue().longValue() );
     return number.getValue().longValue();
   }
   return -1;
 }
예제 #12
0
 /**
  * @param ref The camera to get the available property settings of
  * @param property One of the supported EdsPropertyID values
  * @return The EdsPropertyDesc containing the available settings for the given property
  */
 public static EdsPropertyDesc getPropertyDesc(final EdsBaseRef ref, final EdsPropertyID property)
     throws IllegalArgumentException {
   final EdsPropertyDesc propertyDesc = new EdsPropertyDesc();
   final EdsError err =
       CanonUtils.toEdsError(
           CanonCamera.EDSDK.EdsGetPropertyDesc(
               ref, new NativeLong(property.value()), propertyDesc));
   if (err == EdsError.EDS_ERR_OK) {
     // System.out.println( "> available values = " + propertyDesc.numElements );
     return propertyDesc;
   }
   throw new IllegalArgumentException(
       "An error occurred while getting detailed "
           + property.name()
           + " data (error "
           + err.value()
           + ": "
           + err.name()
           + " - "
           + err.description()
           + ")");
 }
예제 #13
0
  /**
   * Returns the data type of a specified property
   *
   * @param ref Reference to the camera
   * @param property Property id
   * @param param Name of the parameter
   * @return The data type, or null if the parameter isn't supported, or unknown if something else
   *     goes wrong.
   */
  public static EdsDataType getPropertyType(
      final EdsBaseRef ref, final EdsPropertyID property, final long param) {
    final int bufferSize = 1;
    final IntBuffer type = IntBuffer.allocate(bufferSize);
    final NativeLongByReference number = new NativeLongByReference(new NativeLong(bufferSize));
    final EdsError err =
        CanonUtils.toEdsError(
            CanonCamera.EDSDK.EdsGetPropertySize(
                ref, new NativeLong(property.value()), new NativeLong(param), type, number));
    if (err == EdsError.EDS_ERR_OK) {
      final EdsDataType edsDataType = EdsDataType.enumOfValue(type.get(0));
      if (edsDataType != null) {
        // System.out.println( " > property type = " + edsDataType.value() + " : " +
        // edsDataType.name() + " : " + edsDataType.description() );
        return edsDataType;
      }
    } else if (err == EdsError.EDS_ERR_NOT_SUPPORTED) {
      return null;
    }

    return EdsDataType.kEdsDataType_Unknown;
  }
예제 #14
0
 /**
  * Query property data
  *
  * @param ref Reference to the camera/image/liveview object
  * @param property Property id
  * @return Current value of the property
  */
 public static <T> T getPropertyDataAdvanced(final EdsBaseRef ref, final EdsPropertyID property) {
   return CanonUtils.getPropertyDataAdvanced(ref, property, 0);
 }
예제 #15
0
 /**
  * Convert a long value to it's correspond error.
  *
  * @param value
  * @return
  */
 public static EdsError toEdsError(final NativeLong value) {
   return CanonUtils.toEdsError(value.intValue());
 }
예제 #16
0
 /**
  * Convert a long value to it's corresponding error.
  *
  * @param value
  * @return
  */
 public static EdsError toEdsError(final long value) {
   return CanonUtils.toEdsError(value);
 }
예제 #17
0
  /**
   * Downloads an image and saves it somewhere.
   *
   * @param directoryItem The item you want to download
   * @param destination A path in the filesystem where you want to save the file. Can also be null
   *     or a directory. In case of null the temp directory will be used, in case of a directory the
   *     file name of the item will be used.
   * @param appendFileExtension Adds the extension of the photo onto File to ensure that supplied
   *     File name extension matches the image being downloaded from the camera. This is especially
   *     important if the camera is set to RAW+JPEG where the order of the images is not consistent.
   * @return Either null, or the location the file was ultimately saved to on success.
   */
  public static File download(
      final EdsDirectoryItemRef directoryItem,
      File destination,
      final boolean appendFileExtension) {
    EdsError err = EdsError.EDS_ERR_OK;
    final EdsStreamRef.ByReference stream = new EdsStreamRef.ByReference();
    final EdsDirectoryItemInfo dirItemInfo = new EdsDirectoryItemInfo();

    boolean success = false;

    // final long timeStart = System.currentTimeMillis();

    try {
      err =
          CanonUtils.toEdsError(
              CanonCamera.EDSDK.EdsGetDirectoryItemInfo(directoryItem, dirItemInfo));
      if (err == EdsError.EDS_ERR_OK) {
        if (destination == null) {
          destination = new File(System.getProperty("java.io.tmpdir"));
        }
        if (destination.isDirectory()) {
          destination = new File(destination, Native.toString(dirItemInfo.szFileName));
        } else if (appendFileExtension) {
          final String sourceFileName = Native.toString(dirItemInfo.szFileName);
          final int i = sourceFileName.lastIndexOf(".");
          if (i > 0) {
            final String extension = sourceFileName.substring(i);
            if (!destination.getName().toLowerCase().endsWith(extension)) {
              destination = new File(destination.getPath() + extension);
            }
          }
        }

        if (destination.getParentFile() != null) {
          destination.getParentFile().mkdirs();
        }

        /*
         * System.out.println( "Downloading image " +
         * Native.toString( dirItemInfo.szFileName ) +
         * " to " + destination.getCanonicalPath() );
         */

        // TODO: see if using an EdsCreateMemoryStream would be faster and whether the image could
        // be read directly without saving to file first - see:
        // http://stackoverflow.com/questions/1083446/canon-edsdk-memorystream-image
        err =
            CanonUtils.toEdsError(
                CanonCamera.EDSDK.EdsCreateFileStream(
                    Native.toByteArray(destination.getCanonicalPath()),
                    EdsFileCreateDisposition.kEdsFileCreateDisposition_CreateAlways.value(),
                    EdsAccess.kEdsAccess_ReadWrite.value(),
                    stream));
      }

      if (err == EdsError.EDS_ERR_OK) {
        err =
            CanonUtils.toEdsError(
                CanonCamera.EDSDK.EdsDownload(directoryItem, dirItemInfo.size, stream.getValue()));
      }

      if (err == EdsError.EDS_ERR_OK) {
        /*
         * System.out.println( "Image downloaded in " +
         * ( System.currentTimeMillis() - timeStart ) +
         * " ms" );
         */

        err = CanonUtils.toEdsError(CanonCamera.EDSDK.EdsDownloadComplete(directoryItem));

        success = true;
      }

      if (stream != null) {
        CanonCamera.EDSDK.EdsRelease(stream.getValue());
      }
    } catch (final Exception e) {
      e.printStackTrace();
    }

    return success ? destination : null;
  }
예제 #18
0
 public static EdsError setCapacity(final EdsCameraRef ref) {
   return CanonUtils.setCapacity(ref, Integer.MAX_VALUE);
 }
예제 #19
0
  /**
   * Returns an array of DescriptiveEnum values for a given EdsPropertyID enum. Some of the
   * EdsPropertyID enums that this function is known to support are listed in the EDSDK
   * documentation, others were obtained by trial-and-error. Note that not all EdsPropertyID values
   * are supported in all camera modes or with all models.
   *
   * @param camera The camera to get the available property settings of
   * @param property {@link edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_DriveMode
   *     kEdsPropID_DriveMode} {@link edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_ISOSpeed
   *     kEdsPropID_ISOSpeed}, {@link
   *     edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_MeteringMode kEdsPropID_MeteringMode},
   *     {@link edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_AFMode kEdsPropID_AFMode},
   *     {@link edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_Av kEdsPropID_Av}, {@link
   *     edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_Tv kEdsPropID_Tv}, {@link
   *     edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_ExposureCompensation
   *     kEdsPropID_ExposureCompensation}, {@link
   *     edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_AEMode kEdsPropID_AEMode}, {@link
   *     edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_ImageQuality kEdsPropID_ImageQuality},
   *     {@link edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_WhiteBalance
   *     kEdsPropID_WhiteBalance}, {@link
   *     edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_ColorSpace kEdsPropID_ColorSpace},
   *     {@link edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_PictureStyle
   *     kEdsPropID_PictureStyle}, {@link
   *     edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_Evf_WhiteBalance
   *     kEdsPropID_Evf_WhiteBalance}, or {@link
   *     edsdk.utils.CanonConstants.EdsPropertyID#kEdsPropID_Evf_AFMode kEdsPropID_Evf_AFMode}
   * @return A DescriptiveEnum array of the available settings for the given property
   */
  public static final DescriptiveEnum<?>[] getPropertyDesc(
      final EdsCameraRef camera, final EdsPropertyID property)
      throws IllegalArgumentException, IllegalStateException {

    /*
     * System.out.println( "Getting available property values for " +
     * property.description() + " (" + property.name() +
     * ")" );
     */

    final EdsPropertyDesc propertyDesc = CanonUtils.getPropertyDesc((EdsBaseRef) camera, property);

    if (propertyDesc.numElements.intValue() > 0) {
      /*
       * System.out.println( "Number of elements: " +
       * propertyDesc.numElements );
       */

      final NativeLong[] propDesc = propertyDesc.propDesc;
      final DescriptiveEnum<?>[] properties =
          new DescriptiveEnum<?>[propertyDesc.numElements.intValue()];
      for (int i = 0; i < propertyDesc.numElements.intValue(); i++) {
        DescriptiveEnum<?> de = null;
        switch (property) {
          case kEdsPropID_DriveMode:
            de = EdsDriveMode.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_ISOSpeed:
            de = EdsISOSpeed.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_MeteringMode:
            de = EdsMeteringMode.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_AFMode:
            de = EdsAFMode.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_Av:
            de = EdsAv.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_Tv:
            de = EdsTv.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_ExposureCompensation:
            de = EdsExposureCompensation.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_AEMode:
            de = EdsAEMode.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_ImageQuality:
            de = EdsImageQuality.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_WhiteBalance:
            de = EdsWhiteBalance.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_ColorSpace:
            de = EdsColorSpace.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_PictureStyle:
            de = EdsPictureStyle.enumOfValue(propDesc[i].intValue());
            break;
            // Doesn't seem possible to query available output devices
            //                    case kEdsPropID_Evf_OutputDevice:
            //                        de = EdsEvfOutputDevice.enumOfValue( propDesc[i].intValue() );
            //                        break;
          case kEdsPropID_Evf_WhiteBalance:
            de = EdsWhiteBalance.enumOfValue(propDesc[i].intValue());
            break;
          case kEdsPropID_Evf_AFMode:
            de = EdsEvfAFMode.enumOfValue(propDesc[i].intValue());
            break;
          default:
            throw new IllegalArgumentException(
                "Property '" + property.name() + "' is not supported.");
        }
        if (de == null) {
          throw new IllegalStateException(
              "Could not find "
                  + property.name()
                  + " enum with value of: "
                  + propDesc[i].intValue());
        } else {
          // System.out.println( e.name() + " ( " + e.value() + " ) " + e.description() );
        }
        properties[i] = de;
      }
      // System.out.println( "DONE!\n" );

      return properties;
    }
    return null;
  }
예제 #20
0
 /**
  * Get the size of a property
  *
  * @param ref Reference to the camera/image/liveview object
  * @param property the property id
  * @return Size in bytes
  */
 public static long getPropertySize(final EdsBaseRef ref, final EdsPropertyID property) {
   return CanonUtils.getPropertySize(ref, property, 0);
 }
예제 #21
0
 /**
  * see {@link CanonUtils#getPropertyType(EdsBaseRef, EdsPropertyID, long)}
  *
  * @param ref
  * @param property
  * @return
  */
 public static EdsDataType getPropertyType(final EdsBaseRef ref, final EdsPropertyID property) {
   return CanonUtils.getPropertyType(ref, property, 0);
 }
예제 #22
0
 /**
  * Set a camera property
  *
  * @param ref Reference to the camera/image/liveview object
  * @param property ID of the property
  * @param param
  * @param value New property value.
  * @return Result of the operation, normally {@link EdsError#EDS_ERR_OK}
  */
 public static EdsError setPropertyData(
     final EdsBaseRef ref, final EdsPropertyID property, final long param, final long value) {
   return CanonUtils.setPropertyDataAdvanced(ref, property, param, value);
 }
예제 #23
0
 public static EdsError setPropertyDataAdvanced(
     final EdsBaseRef ref, final EdsPropertyID property, final Object value) {
   return CanonUtils.setPropertyDataAdvanced(ref, property, 0, value);
 }
예제 #24
0
  // TODO: this method isn't very safe to leave public, perhaps some
  // setPropertyData[String/UInt32/etc.] methods would be better
  public static EdsError setPropertyDataAdvanced(
      final EdsBaseRef ref, final EdsPropertyID property, final long param, final Object value)
      throws IllegalStateException {

    final EdsDataType type = CanonUtils.getPropertyType(ref, property, param);

    final Pointer pointer;
    final int size;

    switch (type) {
      case kEdsDataType_String:
        { // EdsChar[]
          final String string = (String) value;
          size = string.length() + 1;
          pointer = new Memory(size);
          pointer.setString(0, string);
          break;
        }
      case kEdsDataType_Int8: // EdsInt8
      case kEdsDataType_UInt8:
        { // EdsUInt8
          size = 1;
          pointer = new Memory(size);
          pointer.setByte(0, (Byte) value);
          break;
        }
      case kEdsDataType_Int16: // EdsInt16
      case kEdsDataType_UInt16:
        { // EdsUInt16
          size = 2;
          pointer = new Memory(size);
          pointer.setShort(0, (Short) value);
          break;
        }
      case kEdsDataType_Int32: // EdsInt32
      case kEdsDataType_UInt32:
        { // EdsUInt32
          size = 4;
          pointer = new Memory(size);
          pointer.setNativeLong(0, new NativeLong((Long) value));
          break;
        }
      case kEdsDataType_Int64: // EdsInt64
      case kEdsDataType_UInt64:
        { // EdsUInt64
          size = 8;
          pointer = new Memory(size);
          pointer.setLong(0, (Long) value);
          break;
        }
      case kEdsDataType_Float:
        { // EdsFloat
          size = 4;
          pointer = new Memory(size);
          pointer.setFloat(0, (Float) value);
          break;
        }
      case kEdsDataType_Double:
        { // EdsDouble
          size = 8;
          pointer = new Memory(size);
          pointer.setDouble(0, (Double) value);
          break;
        }
      case kEdsDataType_ByteBlock:
        { // Byte Block // TODO: According to API, is either EdsInt8[] or EdsUInt32[], but perhaps
          // former is a typo or an old value
          final int[] array = (int[]) value;
          size = 4 * array.length;
          pointer = new Memory(size);
          pointer.write(0, array, 0, array.length);
          break;
        }
      case kEdsDataType_Rational: // EdsRational
      case kEdsDataType_Point: // EdsPoint
      case kEdsDataType_Rect: // EdsRect
      case kEdsDataType_Time: // EdsTime
      case kEdsDataType_FocusInfo: // EdsFocusInfo
      case kEdsDataType_PictureStyleDesc:
        { // EdsPictureStyleDesc
          final Structure structure = (Structure) value;
          structure.write();
          pointer = structure.getPointer();
          size = structure.size();
          break;
        }
      case kEdsDataType_Int8_Array: // EdsInt8[]
      case kEdsDataType_UInt8_Array:
        { // EdsUInt8[]
          final byte[] array = (byte[]) value;
          size = array.length;
          pointer = new Memory(size);
          pointer.write(0, array, 0, array.length);
          break;
        }
      case kEdsDataType_Int16_Array: // EdsInt16[]
      case kEdsDataType_UInt16_Array:
        { // EdsUInt16[]
          final short[] array = (short[]) value;
          size = 2 * array.length;
          pointer = new Memory(size);
          pointer.write(0, array, 0, array.length);
          break;
        }
      case kEdsDataType_Int32_Array: // EdsInt32[]
      case kEdsDataType_UInt32_Array:
        { // EdsUInt32[]
          final int[] array = (int[]) value;
          size = 4 * array.length;
          pointer = new Memory(size);
          pointer.write(0, array, 0, array.length);
          break;
        }
      case kEdsDataType_Bool:
        // EdsBool // TODO: implement
      case kEdsDataType_Bool_Array: // EdsBool[] // TODO: implement
      case kEdsDataType_Rational_Array: // EdsRational[] // TODO: implement
      case kEdsDataType_Unknown: // Unknown
      default:
        throw new IllegalStateException(
            type.description()
                + " ("
                + type.name()
                + ") is not currently supported by GetPropertyCommand");
    }
    return CanonUtils.setPropertyData(ref, property, param, size, pointer);
  }
예제 #25
0
 /**
  * Query property data
  *
  * @param ref Reference to the camera/image/liveview object
  * @param property Property id
  * @param param
  * @return Current long value of the property
  */
 public static Long getPropertyData(
     final EdsBaseRef ref, final EdsPropertyID property, final long param) {
   return CanonUtils.getPropertyDataAdvanced(ref, property, param);
 }
예제 #26
0
  // TODO: this method isn't very safe to leave public, perhaps some
  // setPropertyData[String/UInt32/etc.] methods would be better
  // hansi: i like having as much as possible public. it's nice for people who know what they're
  // doing.
  @SuppressWarnings("unchecked")
  public static <T> T getPropertyDataAdvanced(
      final EdsBaseRef ref, final EdsPropertyID property, final long param)
      throws IllegalArgumentException, IllegalStateException {

    final int size = (int) CanonUtils.getPropertySize(ref, property, param);
    final EdsDataType type = CanonUtils.getPropertyType(ref, property, param);

    final Memory memory = new Memory(size > 0 ? size : 1);

    final EdsError err = CanonUtils.getPropertyData(ref, property, param, size, memory);
    if (err == EdsError.EDS_ERR_OK) {
      switch (type) {
        case kEdsDataType_Unknown: // Unknown
          return null;
        case kEdsDataType_String: // EdsChar[]
          return (T) memory.getString(0);
        case kEdsDataType_Int8: // EdsInt8
        case kEdsDataType_UInt8: // EdsUInt8
          return (T) Byte.valueOf(memory.getByte(0));
        case kEdsDataType_Int16: // EdsInt16
        case kEdsDataType_UInt16: // EdsUInt16
          return (T) Short.valueOf(memory.getShort(0));
        case kEdsDataType_Int32: // EdsInt32
        case kEdsDataType_UInt32: // EdsUInt32
          return (T) Long.valueOf(memory.getNativeLong(0).longValue());
        case kEdsDataType_Int64: // EdsInt64
        case kEdsDataType_UInt64: // EdsUInt64
          return (T) Long.valueOf(memory.getLong(0));
        case kEdsDataType_Float: // EdsFloat
          return (T) Float.valueOf(memory.getFloat(0));
        case kEdsDataType_Double: // EdsDouble
          return (T) Double.valueOf(memory.getDouble(0));
        case kEdsDataType_ByteBlock: // Byte Block // TODO: According to API, is either EdsInt8[] or
                                     // EdsUInt32[], but perhaps former is a typo or an old value
          return (T) memory.getIntArray(0, size / 4);
        case kEdsDataType_Rational: // EdsRational
          return (T) new EdsRational(memory);
        case kEdsDataType_Point: // EdsPoint
          return (T) new EdsPoint(memory);
        case kEdsDataType_Rect: // EdsRect
          return (T) new EdsRect(memory);
        case kEdsDataType_Time: // EdsTime
          return (T) new EdsTime(memory);
        case kEdsDataType_FocusInfo: // EdsFocusInfo
          return (T) new EdsFocusInfo(memory);
        case kEdsDataType_PictureStyleDesc: // EdsPictureStyleDesc
          return (T) new EdsPictureStyleDesc(memory);
        case kEdsDataType_Int8_Array: // EdsInt8[]
        case kEdsDataType_UInt8_Array: // EdsUInt8[]
          return (T) memory.getByteArray(0, size);
        case kEdsDataType_Int16_Array: // EdsInt16[]
        case kEdsDataType_UInt16_Array: // EdsUInt16[]
          return (T) memory.getShortArray(0, size / 2);
        case kEdsDataType_Int32_Array: // EdsInt32[]
        case kEdsDataType_UInt32_Array: // EdsUInt32[]
          return (T) memory.getIntArray(0, size / 4);
        case kEdsDataType_Bool: // EdsBool // TODO: implement
        case kEdsDataType_Bool_Array: // EdsBool[] // TODO: implement
        case kEdsDataType_Rational_Array: // EdsRational[] // TODO: implement
        default:
          throw new IllegalStateException(
              type.description()
                  + " ("
                  + type.name()
                  + ") is not currently supported by GetPropertyCommand");
      }
    }

    throw new IllegalArgumentException(
        "An error occurred while getting "
            + property.name()
            + " data (error "
            + err.value()
            + ": "
            + err.name()
            + " - "
            + err.description()
            + ")");
  }
예제 #27
0
  /**
   * Download a live view image from the camera and convert it directly into a bufferd image.
   *
   * @param camera
   * @return
   */
  public static BufferedImage getLiveViewImage(final EdsCameraRef camera) {
    EdsError err = EdsError.EDS_ERR_OK;

    final EdsBaseRef.ByReference[] references = CanonUtils.getLiveViewImageReference(camera);
    if (references != null) {
      final EdsStreamRef.ByReference streamRef = (EdsStreamRef.ByReference) references[1];
      final EdsEvfImageRef.ByReference imageRef = (EdsEvfImageRef.ByReference) references[0];

      //		// Get the incidental data of the image.
      //		NativeLongByReference zoom = new NativeLongByReference( new NativeLong( 0 ) );
      //		Pointer data = zoom.getPointer();
      //		err = getPropertyData( image.getValue(), EdSdkLibrary.kEdsPropID_Evf_ZoomPosition, 0,
      // NativeLong.SIZE, data );
      //		if( err != EdsError.EDS_ERR_OK ){
      //			System.err.println( "Failed to download live view image, zoom value wasn't read (error "+
      // err.value() + ": "+ err.name() + " - " + err.description() + ")" );
      //			return null;
      //		}
      //
      //		// Get the focus and zoom border position
      //		EdsPoint point = new EdsPoint();
      //		data = point.getPointer();
      //		err = getPropertyData( image.getValue(), EdSdkLibrary.kEdsPropID_Evf_ZoomPosition, 0 ,
      // sizeof( point ), data );
      //		if( err != EdsError.EDS_ERR_OK ){
      //			System.err.println( "Failed to download live view image, focus point wasn't read (error
      // "+ err.value() + ": "+ err.name() + " - " + err.description() + ")" );
      //			return null;
      //		}

      final NativeLongByReference length = new NativeLongByReference();
      err = CanonUtils.toEdsError(CanonCamera.EDSDK.EdsGetLength(streamRef.getValue(), length));
      if (err != EdsError.EDS_ERR_OK) {
        System.err.println(
            "Failed to download live view image, failed to read stream length (error "
                + err.value()
                + ": "
                + err.name()
                + " - "
                + err.description()
                + ")");
        CanonUtils.release(imageRef, streamRef);
        return null;
      }

      final PointerByReference ref = new PointerByReference();
      err = CanonUtils.toEdsError(CanonCamera.EDSDK.EdsGetPointer(streamRef.getValue(), ref));
      if (err != EdsError.EDS_ERR_OK) {
        System.err.println(
            "Failed to download live view image, failed to get reference to image in memory (error "
                + err.value()
                + ": "
                + err.name()
                + " - "
                + err.description()
                + ")");
        CanonUtils.release(imageRef, streamRef);
        return null;
      }

      final byte[] data = ref.getValue().getByteArray(0, length.getValue().intValue());
      try {
        final BufferedImage img = ImageIO.read(new ByteArrayInputStream(data));
        return img;
      } catch (final IOException e) {
        e.printStackTrace();
      } finally {
        CanonUtils.release(imageRef, streamRef);
      }
    }

    return null;
  }