FFStreamInputStream.c

Go to the documentation of this file.

/*
 * =================================================
 * Copyright 2013 tagtraum industries incorporated
 * This file is part of FFSampledSP.
 *
 * FFSampledSP is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFSampledSP is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFSampledSP; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 * =================================================
 *
 * @author <a href="mailto:hs@tagtraum.com">Hendrik Schreiber</a>
 */
 
#include "FFUtils.h"
#include "com_tagtraum_ffsampledsp_FFStreamInputStream.h"
 
static jmethodID fillReadBuffer_MID = NULL;
static jfieldID readBuffer_FID = NULL;
 
static const int CALLBACK_BUFFERSIZE = 32 * 1024;

JNIEXPORT void JNICALL
Java_com_tagtraum_ffsampledsp_FFStreamInputStream_initIDs(JNIEnv *env,
                                                          jclass streamClass) {
  readBuffer_FID = (*env)->GetFieldID(env, streamClass, "readBuffer",
                                      "Ljava/nio/ByteBuffer;");
  if (!readBuffer_FID)
    return;
  fillReadBuffer_MID =
      (*env)->GetMethodID(env, streamClass, "fillReadBuffer", "()I");
}

static int read_callback(void *opaque, uint8_t *buf, int size) {
  int res = 0;
  int available_data;
  jobject read_buffer = NULL;
  uint8_t *java_buffer = NULL;
  FFAudioIO *aio = (FFAudioIO *)opaque;
 
  // FFmpeg may call us again after we reported an error (e.g. via avio_feof()
  // in a demuxer's resync loop). Don't call Java with an exception pending.
  if ((*aio->env)->ExceptionCheck(aio->env)) {
    res = AVERROR(EIO);
    goto bail;
  }
 
  // tell java to fill buffer
  available_data = (int)(*aio->env)->CallIntMethod(aio->env, aio->java_instance,
                                                   fillReadBuffer_MID);
  if ((*aio->env)->ExceptionCheck(aio->env)) {
    res = AVERROR(EIO);
    goto bail;
  }
  if (available_data > size) {
    res = -1;
    throwIOExceptionIfError(
        aio->env, 1, "Available data must not be larger than callback buffer.");
    goto bail;
  }
 
  if (available_data <= 0) {
    res = AVERROR_EOF;
    goto bail;
  }
 
  read_buffer =
      (*aio->env)->GetObjectField(aio->env, aio->java_instance, readBuffer_FID);
  if (!read_buffer) {
    res = -1;
    throwIOExceptionIfError(aio->env, 1, "Failed to get read buffer.");
    goto bail;
  }
 
  java_buffer =
      (uint8_t *)(*aio->env)->GetDirectBufferAddress(aio->env, read_buffer);
  if (!java_buffer) {
    res = -1;
    throwIOExceptionIfError(aio->env, 1,
                            "Failed to get address for read buffer.");
    goto bail;
  }
 
  // copy to c buffer
  memcpy(buf, (const uint8_t *)java_buffer, available_data);
  // return size of buffer
  res = available_data;
 
bail:
  // called many times per native call, don't accumulate local refs
  if (read_buffer)
    (*aio->env)->DeleteLocalRef(aio->env, read_buffer);
  return res;
}

JNIEXPORT void JNICALL
Java_com_tagtraum_ffsampledsp_FFStreamInputStream_fillNativeBuffer(
    JNIEnv *env, jobject stream, jlong aio_pointer) {
 
  FFAudioIO *aio = (FFAudioIO *)(intptr_t)aio_pointer;
  aio->env = env;
  aio->java_instance = stream;
  ff_fill_buffer(aio);
  // we can ignore the return value,
  // because all ff_fill_buffer already
  // throws a suitable Java exception
  // in the case of an error
}

JNIEXPORT jlong JNICALL Java_com_tagtraum_ffsampledsp_FFStreamInputStream_open(
    JNIEnv *env, jobject stream, jint streamIndex) {
 
  int res = 0;
  FFAudioIO *aio;
  AVIOContext *io_context;
  unsigned char *callback_buffer = NULL;
 
  aio = calloc(1, sizeof(FFAudioIO));
  if (!aio) {
    res = AVERROR(ENOMEM);
    throwIOExceptionIfError(env, res, "Could not allocate audio IO.");
    goto bail;
  }
  aio->env = env;
  aio->java_instance = stream;
 
  aio->format_context = avformat_alloc_context();
  if (!aio->format_context) {
    res = AVERROR(ENOMEM);
    throwIOExceptionIfError(env, res, "Could not allocate format context.");
    goto bail;
  }
 
  // limit probe to less than what we read in one chunk...
  aio->format_context->probesize = 8 * 1024;
  aio->format_context->max_analyze_duration = 5 * AV_TIME_BASE;
 
  callback_buffer =
      (unsigned char *)av_malloc(CALLBACK_BUFFERSIZE * sizeof(uint8_t));
  if (!callback_buffer) {
    res = AVERROR(ENOMEM);
    throwIOExceptionIfError(env, res, "Could not allocate callback buffer.");
    goto bail;
  }
 
  io_context = avio_alloc_context(
      callback_buffer,     // IOBuffer
      CALLBACK_BUFFERSIZE, // Buffer Size (32kb corresponds to Java code)
      0,                   // Write flag, only reading, so 0
      aio,                 // FFAudioIO pointer (opaque)
      read_callback,       // Read callback
      NULL,                // Write callback
      NULL                 // Seek callback
  );
  if (!io_context) {
    res = AVERROR(ENOMEM);
    throwIOExceptionIfError(env, res, "Could not allocate custom IO context.");
    goto bail;
  }
  // we didn't supply a seek function in avio_alloc_context,
  // so we need to make sure we don't seek...
  io_context->seekable = 0;
 
  aio->format_context->pb = io_context;
  aio->stream_index = (int)streamIndex;
 
  res = ff_open_file(env, &aio->format_context, &aio->stream,
                     &aio->decode_context, &aio->stream_index,
                     "MemoryAVIOContext", 0);
  if (res) {
    // exception is already thrown
    goto bail;
  }
 
  res = ff_init_audioio(env, aio);
  if (res) {
    // exception is already thrown
    goto bail;
  }
 
#ifdef DEBUG
  fprintf(stderr, "stream->codecpar->bits_per_coded_sample: %i\n",
          aio->stream->codecpar->bits_per_coded_sample);
  fprintf(stderr, "stream->codecpar->bits_per_raw_sample  : %i\n",
          aio->stream->codecpar->bits_per_raw_sample);
  fprintf(stderr, "stream->codecpar->bit_rate             : %lli\n",
          aio->stream->codecpar->bit_rate);
  fprintf(stderr, "frames     : %" PRId64 "\n", aio->stream->nb_frames);
  fprintf(stderr, "sample_rate: %i\n", aio->stream->codecpar->sample_rate);
  fprintf(stderr, "channels   : %i\n",
          aio->stream->codecpar->ch_layout.nb_channels);
  fprintf(stderr, "frame_size : %i\n", aio->stream->codecpar->frame_size);
  fprintf(stderr, "codec_id   : %i\n", aio->stream->codecpar->codec_id);
#endif
 
  // FFmpeg may treat a read error as end of input and still succeed,
  // but the exception thrown by the Java stream is pending.
  if (!res && (*env)->ExceptionCheck(env)) {
    res = -1;
  }
 
bail:
 
  if (res)
    ff_audioio_free(aio);
  return (jlong)(intptr_t)aio;
}

JNIEXPORT void JNICALL Java_com_tagtraum_ffsampledsp_FFStreamInputStream_close(
    JNIEnv *env, jobject stream, jlong aio_pointer) {
  ff_audioio_free((FFAudioIO *)(intptr_t)aio_pointer);
}