FFURLInputStream.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_FFURLInputStream.h"

JNIEXPORT void JNICALL
Java_com_tagtraum_ffsampledsp_FFURLInputStream_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_FFURLInputStream_open(
    JNIEnv *env, jobject stream, jstring url, jbyteArray urlBytes,
    jint streamIndex, jint fileBufferSize) {
 
  int res = 0;
  FFAudioIO *aio = NULL;
  char *input_url = NULL;
 
  {
    jsize urlLen = (*env)->GetArrayLength(env, urlBytes);
    jbyte *urlBuf = (*env)->GetByteArrayElements(env, urlBytes, NULL);
    input_url = (char *)malloc(urlLen + 1);
    if (!input_url) {
      (*env)->ReleaseByteArrayElements(env, urlBytes, urlBuf, JNI_ABORT);
      res = AVERROR(ENOMEM);
      throwIOExceptionIfError(env, res, "Failed to allocate URL buffer");
      goto bail;
    }
    memcpy(input_url, urlBuf, urlLen);
    input_url[urlLen] = '\0';
    (*env)->ReleaseByteArrayElements(env, urlBytes, urlBuf, JNI_ABORT);
  }
 
  aio = calloc(1, sizeof(FFAudioIO));
  if (!aio) {
    res = AVERROR(ENOMEM);
    throwIOExceptionIfError(env, res, "Could not allocate audio io");
    goto bail;
  }
  aio->stream_index = (int)streamIndex;
 
  res = ff_open_file(env, &(aio->format_context), &(aio->stream),
                     &(aio->decode_context), &(aio->stream_index), input_url,
                     (int)fileBufferSize);
  if (res) {
    goto bail;
  }
  res = ff_init_audioio(env, aio);
  if (res) {
    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
 
bail:
 
  if (res)
    ff_audioio_free(aio);
  free(input_url);
 
  return (jlong)(intptr_t)aio;
}

JNIEXPORT jboolean JNICALL
Java_com_tagtraum_ffsampledsp_FFURLInputStream_isSeekable(JNIEnv *env,
                                                          jobject stream,
                                                          jlong aio_pointer) {
  FFAudioIO *aio = (FFAudioIO *)(intptr_t)aio_pointer;
  jboolean seekable = JNI_FALSE;
  seekable = aio->format_context->pb->seekable != 0;
  return seekable;
}

JNIEXPORT void JNICALL Java_com_tagtraum_ffsampledsp_FFURLInputStream_seek(
    JNIEnv *env, jobject stream, jlong aio_pointer, jlong microseconds) {
  FFAudioIO *aio = (FFAudioIO *)(intptr_t)aio_pointer;
  int res = 0;
  int64_t seek_target = microseconds;
  int64_t current_timestamp = 0;
 
  current_timestamp = aio->timestamp;
  seek_target =
      av_rescale_q(seek_target, AV_TIME_BASE_Q, aio->stream->time_base);
#ifdef DEBUG
  fprintf(stderr,
          "Current Timestamp = %" PRId64 ", seek_target = %" PRId64 "\n",
          current_timestamp, seek_target);
#endif
  res =
      av_seek_frame(aio->format_context, aio->stream_index, seek_target,
                    current_timestamp > seek_target ? AVSEEK_FLAG_BACKWARD : 0);
  if (res < 0) {
    throwIOExceptionIfError(env, res, "Failed to seek.");
    goto bail;
  }
 
  // make sure everything is flushed.
  av_packet_unref(aio->decode_packet);
  // flush codec
  avcodec_flush_buffers(aio->decode_context);
  // set timestamp to seek_target, since that's hopefully now our current
  // timestamp..
  aio->timestamp = seek_target;
 
bail:
 
  return;
}

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