membrane_element_lame

#include "encoder.h"

UNIFEX_TERM create_result_ok(UnifexEnv* env, UnifexNifState* state) {
  return enif_make_tuple_from_array(
    env,
    (ERL_NIF_TERM []) {
      enif_make_atom(env, "ok"),
      unifex_make_resource(env, state)
    },
    2
  );
}

UNIFEX_TERM create_result_error(UnifexEnv* env, char* reason) {
  return enif_make_tuple_from_array(
    env,
    (ERL_NIF_TERM []) {
      enif_make_atom(env, "error"),
      enif_make_atom(env, reason)
    },
    2
  );
}

UNIFEX_TERM encode_frame_result_ok(UnifexEnv* env, UnifexPayload * frame) {
  return enif_make_tuple_from_array(
    env,
    (ERL_NIF_TERM []) {
      enif_make_atom(env, "ok"),
      unifex_payload_to_term(env, frame)
    },
    2
  );
}

UNIFEX_TERM encode_frame_result_error(UnifexEnv* env, char* reason) {
  return enif_make_tuple_from_array(
    env,
    (ERL_NIF_TERM []) {
      enif_make_atom(env, "error"),
      enif_make_atom(env, reason)
    },
    2
  );
}

UNIFEX_TERM flush_result_ok(UnifexEnv* env, UnifexPayload * frame) {
  return enif_make_tuple_from_array(
    env,
    (ERL_NIF_TERM []) {
      enif_make_atom(env, "ok"),
      unifex_payload_to_term(env, frame)
    },
    2
  );
}

UNIFEX_TERM flush_result_error(UnifexEnv* env, char* reason) {
  return enif_make_tuple_from_array(
    env,
    (ERL_NIF_TERM []) {
      enif_make_atom(env, "error"),
      enif_make_atom(env, reason)
    },
    2
  );
}

ErlNifResourceType *STATE_RESOURCE_TYPE;

UnifexNifState* unifex_alloc_state(UnifexEnv* env) {
  UNIFEX_UNUSED(env);
  return enif_alloc_resource(STATE_RESOURCE_TYPE, sizeof(UnifexNifState));
}

void unifex_release_state(UnifexEnv * env, UnifexNifState* state) {
  UNIFEX_UNUSED(env);
  enif_release_resource(state);
}

void unifex_keep_state(UnifexEnv * env, UnifexNifState* state) {
  UNIFEX_UNUSED(env);
  enif_keep_resource(state);
}

static void destroy_state(ErlNifEnv* env, void* value) {
  UnifexNifState* state = (UnifexNifState*) value;
  UnifexEnv *unifex_env = env;
  handle_destroy_state(unifex_env, state);
}

static int unifex_load_nif(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
  UNIFEX_UNUSED(load_info);
  UNIFEX_UNUSED(priv_data);

  int flags = ERL_NIF_RT_CREATE | ERL_NIF_RT_TAKEOVER;
  STATE_RESOURCE_TYPE =
    enif_open_resource_type(env, NULL, "UnifexNifState", destroy_state, flags, NULL);

  UNIFEX_PAYLOAD_GUARD_RESOURCE_TYPE =
    enif_open_resource_type(env, NULL, "UnifexPayloadGuard", unifex_payload_guard_destructor, flags, NULL);

  return 0;
}

static ERL_NIF_TERM export_create(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){
  UNIFEX_UNUSED(argc);
  ERL_NIF_TERM result;

  UnifexEnv *unifex_env = env;
  int channels;
  int bitrate;
  int quality;

  if(!enif_get_int(env, argv[0], &channels)) {
    result = unifex_raise_args_error(env, "channels", "enif_get_int(env, argv[0], &channels)");
    goto exit_export_create;
  }
  if(!enif_get_int(env, argv[1], &bitrate)) {
    result = unifex_raise_args_error(env, "bitrate", "enif_get_int(env, argv[1], &bitrate)");
    goto exit_export_create;
  }
  if(!enif_get_int(env, argv[2], &quality)) {
    result = unifex_raise_args_error(env, "quality", "enif_get_int(env, argv[2], &quality)");
    goto exit_export_create;
  }

  result = create(unifex_env, channels, bitrate, quality);
  goto exit_export_create;
exit_export_create:

  return result;
}

static ERL_NIF_TERM export_encode_frame(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){
  UNIFEX_UNUSED(argc);
  ERL_NIF_TERM result;

  UnifexEnv *unifex_env = env;
  UnifexPayload * buffer;
  UnifexNifState* state;

  buffer = enif_alloc(sizeof (UnifexPayload));

  if(!unifex_payload_from_term(env, argv[0], buffer)) {
    result = unifex_raise_args_error(env, "buffer", "unifex_payload_from_term(env, argv[0], buffer)");
    goto exit_export_encode_frame;
  }
  if(!enif_get_resource(env, argv[1], STATE_RESOURCE_TYPE, (void **)&state)) {
    result = unifex_raise_args_error(env, "state", "enif_get_resource(env, argv[1], STATE_RESOURCE_TYPE, (void **)&state)");
    goto exit_export_encode_frame;
  }

  result = encode_frame(unifex_env, buffer, state);
  goto exit_export_encode_frame;
exit_export_encode_frame:
  unifex_payload_release_ptr(&buffer);
  return result;
}

static ERL_NIF_TERM export_flush(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]){
  UNIFEX_UNUSED(argc);
  ERL_NIF_TERM result;

  UnifexEnv *unifex_env = env;
  int is_gapless;
  UnifexNifState* state;

  if(!unifex_parse_bool(env, argv[0], &is_gapless)) {
    result = unifex_raise_args_error(env, "is_gapless", "unifex_parse_bool(env, argv[0], &is_gapless)");
    goto exit_export_flush;
  }
  if(!enif_get_resource(env, argv[1], STATE_RESOURCE_TYPE, (void **)&state)) {
    result = unifex_raise_args_error(env, "state", "enif_get_resource(env, argv[1], STATE_RESOURCE_TYPE, (void **)&state)");
    goto exit_export_flush;
  }

  result = flush(unifex_env, is_gapless, state);
  goto exit_export_flush;
exit_export_flush:

  return result;
}

static ErlNifFunc nif_funcs[] =
{
  {"unifex_create", 3, export_create, 0},
  {"unifex_encode_frame", 2, export_encode_frame, ERL_NIF_DIRTY_JOB_CPU_BOUND},
  {"unifex_flush", 2, export_flush, ERL_NIF_DIRTY_JOB_CPU_BOUND}
};

ERL_NIF_INIT(Elixir.Membrane.Element.Lame.Encoder.Native.Nif, nif_funcs, unifex_load_nif, NULL, NULL, NULL)