HEIC and AVIF decoding on Android

Direct API decoding

The library exposes three native methods:

The following example reads test.heic from the assets directory and displays it in an ImageView:

val image = findViewById<ImageView>(R.id.image)

// Step 1: Read the file into a byte array
val inputStream = assets.open("test.heic")
val buffer = ByteArray(8192)
var bytesRead: Int
val output = ByteArrayOutputStream()
while (inputStream.read(buffer).also { bytesRead = it } != -1) {
    output.write(buffer, 0, bytesRead)
}
val fileBuffer: ByteArray = output.toByteArray()

// Step 2: Get image dimensions
val heifInfo = HeifInfo()
HeifNative.getInfo(heifInfo, fileBuffer.size.toLong(), fileBuffer)
val heifSize = heifInfo.frameList.first()

// Step 3: Create a Bitmap and decode
val bitmap = Bitmap.createBitmap(heifSize.width, heifSize.height, Bitmap.Config.ARGB_8888)
HeifNative.toRgba(fileBuffer.size.toLong(), fileBuffer, bitmap)

// Step 4: Display
image.setImageBitmap(bitmap)

Integrate with Glide

Glide is an open-source Android image loading and caching library.

1. Add the dependencies to build.gradle:

      implementation 'com.aliyun:libheif:1.0.0'
      implementation 'com.github.bumptech.glide:glide:4.13.2'
      implementation 'com.github.bumptech.glide:compiler:4.13.2'

2. Implement a custom ResourceDecoder that routes HEIC buffers to the Alibaba Cloud library:

      class HeifByteBufferBitmapDecoder(bitmapPool: BitmapPool) : ResourceDecoder<ByteBuffer, Bitmap> {
   
          private val bitmapPool: BitmapPool
   
          init {
              this.bitmapPool = Preconditions.checkNotNull(bitmapPool)
          }
   
          override fun handles(source: ByteBuffer, options: Options): Boolean {
              val buffer = ByteBufferUtil.toBytes(source)
              return HeifNative.isHeic(buffer.size.toLong(), buffer)
          }
   
          override fun decode(
              source: ByteBuffer,
              width: Int,
              height: Int,
              options: Options
          ): Resource<Bitmap>? {
              val buffer = ByteBufferUtil.toBytes(source)
              val heifInfo = HeifInfo()
              HeifNative.getInfo(heifInfo, buffer.size.toLong(), buffer)
              val heifSize = heifInfo.frameList[0]
              val bitmap = Bitmap.createBitmap(heifSize.width, heifSize.height, Bitmap.Config.ARGB_8888)
              HeifNative.toRgba(buffer.size.toLong(), buffer, bitmap)
              return BitmapResource.obtain(bitmap, bitmapPool)
          }
      }

3. Register the decoder in a Glide module. For details on creating a custom Glide module, see Custom module of Glide.

      @GlideModule(glideName = "HeifGlide")
      open class HeifGlideModule : LibraryGlideModule() {
          override fun registerComponents(context: Context, glide: Glide, registry: Registry) {
              val byteBufferBitmapDecoder = HeifByteBufferBitmapDecoder(glide.bitmapPool)
              registry.prepend(ByteBuffer::class.java, Bitmap::class.java, byteBufferBitmapDecoder)
          }
      }

4. Load and display the HEIC image:

      fun loadHeif(context: Context, imageView: ImageView, file: File) {
          Glide.with(context).asBitmap().load(file).into(imageView)
      }

Integrate with Fresco

Fresco is an open-source Android image caching library developed by Facebook.

1. Add the dependencies to build.gradle:

      implementation 'com.aliyun:libheif:1.0.0'
      implementation 'com.facebook.fresco:fresco:2.6.0'

2. Implement a custom ImageDecoder that uses the Alibaba Cloud library. All examples use ByteBufferUtil to convert file data into a byte array before calling HeifNative.

      class FrescoHeifDecoder : ImageDecoder {
   
          private var mFile: File? = null
          private var mUri: Uri? = null
   
          constructor(file: File) { mFile = file }
          constructor(uri: Uri) { mUri = uri }
   
          override fun decode(
              encodedImage: EncodedImage,
              length: Int,
              qualityInfo: QualityInfo,
              options: ImageDecodeOptions
          ): CloseableImage? {
              var imageRequest: ImageRequest? = null
              if (mFile != null) imageRequest = ImageRequest.fromFile(mFile)
              if (mUri != null) imageRequest = ImageRequest.fromUri(mUri)
              try {
                  val cacheKey = DefaultCacheKeyFactory.getInstance()
                      .getEncodedCacheKey(imageRequest, null)
                  val fileCache = ImagePipelineFactory.getInstance().mainFileCache
                  val resource = fileCache.getResource(cacheKey)
                  val file: File = if (resource == null) mFile!! else (resource as FileBinaryResource).file
   
                  val bufferFromFile = ByteBufferUtil.fromFile(file)
                  val bytes = ByteBufferUtil.toBytes(bufferFromFile)
                  val heifInfo = HeifInfo()
                  HeifNative.getInfo(heifInfo, file.length(), bytes)
                  val heifSize = heifInfo.frameList[0]
                  val bitmap = Bitmap.createBitmap(heifSize.width, heifSize.height, Bitmap.Config.ARGB_8888)
                  HeifNative.toRgba(file.length(), bytes, bitmap)
   
                  return CloseableStaticBitmap(
                      pinBitmap(bitmap),
                      qualityInfo,
                      encodedImage.rotationAngle,
                      encodedImage.exifOrientation
                  )
              } catch (e: Exception) {
              }
              return null
          }
   
          private fun pinBitmap(bitmap: Bitmap?): CloseableReference<Bitmap>? {
              return CloseableReference.of(
                  Preconditions.checkNotNull(bitmap),
                  BitmapCounterProvider.get().releaser
              )
          }
      }

   The ByteBufferUtil helper class reads a file into a memory-mapped ByteBuffer and converts it to a byte array:

      object ByteBufferUtil {
   
          @Throws(IOException::class)
          fun fromFile(file: File): ByteBuffer {
              var raf: RandomAccessFile? = null
              var channel: FileChannel? = null
              return try {
                  val fileLength = file.length()
                  if (fileLength > Int.MAX_VALUE) throw IOException("File too large to map into memory")
                  if (fileLength == 0L) throw IOException("File unsuitable for memory mapping")
                  raf = RandomAccessFile(file, "r")
                  channel = raf.channel
                  channel.map(FileChannel.MapMode.READ_ONLY, 0, fileLength).load()
              } finally {
                  try { channel?.close() } catch (e: IOException) {}
                  try { raf?.close() } catch (e: IOException) {}
              }
          }
   
          fun toBytes(byteBuffer: ByteBuffer): ByteArray {
              val safeArray = getSafeArray(byteBuffer)
              return if (safeArray != null && safeArray.offset == 0 && safeArray.limit == safeArray.data.size) {
                  byteBuffer.array()
              } else {
                  val toCopy = byteBuffer.asReadOnlyBuffer()
                  val result = ByteArray(toCopy.limit())
                  rewind(toCopy)
                  toCopy[result]
                  result
              }
          }
   
          private fun rewind(buffer: ByteBuffer): ByteBuffer = buffer.position(0) as ByteBuffer
   
          private fun getSafeArray(byteBuffer: ByteBuffer): SafeArray? {
              return if (!byteBuffer.isReadOnly && byteBuffer.hasArray()) {
                  SafeArray(byteBuffer.array(), byteBuffer.arrayOffset(), byteBuffer.limit())
              } else null
          }
   
          internal class SafeArray(val data: ByteArray, val offset: Int, val limit: Int)
      }

3. Load the HEIC image using Fresco:

      fun loadHeif(simpleDraweeView: SimpleDraweeView, file: File) {
          val request = ImageRequestBuilder.newBuilderWithSource(Uri.fromFile(file))
              .setImageDecodeOptions(
                  ImageDecodeOptions.newBuilder()
                      .setCustomImageDecoder(FrescoHeifDecoder(file))
                      .build()
              ).build()
          val controller = Fresco.newDraweeControllerBuilder()
              .setImageRequest(request).build()
          simpleDraweeView.controller = controller
      }