com.facebook.imagepipeline.animated.base.AnimatedImage Java Examples

@Override
public int getLoopCount() {
  // If a GIF image has no Netscape 2.0 loop extension, it is meant to play once and then stop. A
  // loop count of 0 indicates an endless looping of the animation. Any loop count X>0 indicates
  // that the animation shall be repeated X times, resulting in the animation to play X+1 times.
  final int loopCount = nativeGetLoopCount();
  switch (loopCount) {
    case LOOP_COUNT_FOREVER:
      return AnimatedImage.LOOP_COUNT_INFINITE;

    case LOOP_COUNT_MISSING:
      return 1;

    default:
      return loopCount + 1;
  }
}
 

private CloseableImage getCloseableImage(ImageDecodeOptions options, AnimatedImage image) {
  int frameForPreview = options.useLastFrameForPreview ? image.getFrameCount() - 1 : 0;
  CloseableReference<Bitmap> previewBitmap = null;
  if (options.decodePreviewFrame) {
    previewBitmap = createPreviewBitmap(image, frameForPreview);
  }
  try {
    AnimatedImageResult animatedImageResult = AnimatedImageResult.newBuilder(image)
        .setPreviewBitmap(previewBitmap)
        .setFrameForPreview(frameForPreview)
        .build();
    return new CloseableAnimatedImage(animatedImageResult);
  } finally {
    CloseableReference.closeSafely(previewBitmap);
  }
}
 

/**
 * Decode a WebP into a CloseableImage.
 *
 * @param encodedImage encoded image (native byte array holding the encoded bytes and meta data)
 * @param options the options for the decode
 * @param bitmapConfig the Bitmap.Config used to generate the output bitmaps
 * @return a {@link CloseableImage} for the WebP image
 */
public CloseableImage decodeWebP(
    final EncodedImage encodedImage,
    final ImageDecodeOptions options,
    final Bitmap.Config bitmapConfig) {
  if (sWebpAnimatedImageDecoder == null) {
    throw new UnsupportedOperationException(
        "To encode animated webp please add the dependency " + "to the animated-webp module");
  }
  final CloseableReference<PooledByteBuffer> bytesRef = encodedImage.getByteBufferRef();
  Preconditions.checkNotNull(bytesRef);
  try {
    final PooledByteBuffer input = bytesRef.get();
    AnimatedImage webPImage;
    if (input.getByteBuffer() != null) {
      webPImage = sWebpAnimatedImageDecoder.decodeFromByteBuffer(input.getByteBuffer(), options);
    } else {
      webPImage =
          sWebpAnimatedImageDecoder.decodeFromNativeMemory(
              input.getNativePtr(), input.size(), options);
    }
    return getCloseableImage(options, webPImage, bitmapConfig);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}
 

/**
 * Decodes a GIF into a CloseableImage.
 *
 * @param encodedImage encoded image (native byte array holding the encoded bytes and meta data)
 * @param options the options for the decode
 * @param bitmapConfig the Bitmap.Config used to generate the output bitmaps
 * @return a {@link CloseableImage} for the GIF image
 */
public CloseableImage decodeGif(
    final EncodedImage encodedImage,
    final ImageDecodeOptions options,
    final Bitmap.Config bitmapConfig) {
  if (sGifAnimatedImageDecoder == null) {
    throw new UnsupportedOperationException(
        "To encode animated gif please add the dependency " + "to the animated-gif module");
  }
  final CloseableReference<PooledByteBuffer> bytesRef = encodedImage.getByteBufferRef();
  Preconditions.checkNotNull(bytesRef);
  try {
    final PooledByteBuffer input = bytesRef.get();
    AnimatedImage gifImage;
    if (input.getByteBuffer() != null) {
      gifImage = sGifAnimatedImageDecoder.decodeFromByteBuffer(input.getByteBuffer(), options);
    } else {
      gifImage =
          sGifAnimatedImageDecoder.decodeFromNativeMemory(
              input.getNativePtr(), input.size(), options);
    }
    return getCloseableImage(options, gifImage, bitmapConfig);
  } finally {
    CloseableReference.closeSafely(bytesRef);
  }
}
 

private CloseableImage getCloseableImage(
    ImageDecodeOptions options, AnimatedImage image, Bitmap.Config bitmapConfig) {
  List<CloseableReference<Bitmap>> decodedFrames = null;
  CloseableReference<Bitmap> previewBitmap = null;
  try {
    final int frameForPreview = options.useLastFrameForPreview ? image.getFrameCount() - 1 : 0;
    if (options.forceStaticImage) {
      return new CloseableStaticBitmap(
          createPreviewBitmap(image, bitmapConfig, frameForPreview),
          ImmutableQualityInfo.FULL_QUALITY,
          0);
    }

    if (options.decodeAllFrames) {
      decodedFrames = decodeAllFrames(image, bitmapConfig);
      previewBitmap = CloseableReference.cloneOrNull(decodedFrames.get(frameForPreview));
    }

    if (options.decodePreviewFrame && previewBitmap == null) {
      previewBitmap = createPreviewBitmap(image, bitmapConfig, frameForPreview);
    }
    AnimatedImageResult animatedImageResult =
        AnimatedImageResult.newBuilder(image)
            .setPreviewBitmap(previewBitmap)
            .setFrameForPreview(frameForPreview)
            .setDecodedFrames(decodedFrames)
            .setBitmapTransformation(options.bitmapTransformation)
            .build();
    return new CloseableAnimatedImage(animatedImageResult);
  } finally {
    CloseableReference.closeSafely(previewBitmap);
    CloseableReference.closeSafely(decodedFrames);
  }
}
 

private static Rect getBoundsToUse(AnimatedImage image, Rect targetBounds) {
  if (targetBounds == null) {
    return new Rect(0, 0, image.getWidth(), image.getHeight());
  }
  return new Rect(
      0,
      0,
      Math.min(targetBounds.width(), image.getWidth()),
      Math.min(targetBounds.height(), image.getHeight()));
}
 

private static Rect getBoundsToUse(AnimatedImage image, Rect targetBounds) {
  if (targetBounds == null) {
    return new Rect(0, 0, image.getWidth(), image.getHeight());
  }
  return new Rect(
      0,
      0,
      Math.min(targetBounds.width(), image.getWidth()),
      Math.min(targetBounds.height(), image.getHeight()));
}
 

/**
 * Creates an {@link AnimatedDrawable} based on an {@link AnimatedImage}.
 *
 * @param animatedImageResult the result of the code
 * @param options additional options
 * @return a newly constructed {@link AnimatedDrawable}
 */
public AnimatedDrawable create(
    AnimatedImageResult animatedImageResult,
    AnimatedDrawableOptions options) {
  AnimatedImage animatedImage = animatedImageResult.getImage();
  Rect initialBounds = new Rect(0, 0, animatedImage.getWidth(), animatedImage.getHeight());
  AnimatedDrawableBackend animatedDrawableBackend =
      mAnimatedDrawableBackendProvider.get(animatedImageResult, initialBounds);
  return createAnimatedDrawable(options, animatedDrawableBackend);
}
 

public synchronized @Nullable AnimatedImage getImage() {
  return isClosed() ? null : mImageResult.getImage();
}
 

private AnimatedDrawableBackend createAnimatedDrawableBackend(
    AnimatedImageResult animatedImageResult) {
  AnimatedImage animatedImage = animatedImageResult.getImage();
  Rect initialBounds = new Rect(0, 0, animatedImage.getWidth(), animatedImage.getHeight());
  return mAnimatedDrawableBackendProvider.get(animatedImageResult, initialBounds);
}
 

public synchronized AnimatedImage getImage() {
  return isClosed() ? null : mImageResult.getImage();
}
 

@Override
public AnimatedImage decodeFromNativeMemory(
    long nativePtr, int sizeInBytes, ImageDecodeOptions options) {
  return WebPImage.createFromNativeMemory(nativePtr, sizeInBytes);
}
 

@Override
public AnimatedImage decodeFromByteBuffer(ByteBuffer byteBuffer, ImageDecodeOptions options) {
  return WebPImage.createFromByteBuffer(byteBuffer);
}
 

@Override
public AnimatedImage decodeFromNativeMemory(
    long nativePtr, int sizeInBytes, ImageDecodeOptions options) {
  return GifImage.createFromNativeMemory(nativePtr, sizeInBytes, options);
}
 

@Override
public AnimatedImage decodeFromByteBuffer(ByteBuffer byteBuffer, ImageDecodeOptions options) {
  return GifImage.createFromByteBuffer(byteBuffer, options);
}
 

/**
 * Factory method to create the AnimatedImage from a native pointer
 *
 * @param nativePtr The native pointer
 * @param sizeInBytes The size in byte to allocate
 * @param options The options for decoding
 * @return The AnimatedImage allocation
 */
AnimatedImage decodeFromNativeMemory(long nativePtr, int sizeInBytes, ImageDecodeOptions options);
 

/**
 * Factory method to create the AnimatedImage from a ByteBuffer
 *
 * @param byteBuffer The ByteBuffer containing the image
 * @param options The options for decoding
 * @return The AnimatedImage allocation
 */
AnimatedImage decodeFromByteBuffer(ByteBuffer byteBuffer, ImageDecodeOptions options);