#include "mpu.h"

#include "mbuf.h"

#include "media_buffer.h"

#include "my_errno.h"

#include "mem.h"

#include "silk.h"

#include "interface/SKP_Silk_SDK_API.h"

struct silk_codec {

    void* obj;

    SKP_SILK_SDK_DecControlStruct control;

    uint64_t seq[2], pts;

    audio_format* fmt_out;

    intptr_t mbuf_handle;

    uint32_t bytes;

};

static void* silk_open(fourcc** in, fourcc** out)

{

    SKP_int32 size;

    SKP_int n = SKP_Silk_SDK_Get_Decoder_Size(&size);

    if (n != 0) {

        errno = EFAULT;

        return NULL;

    }

    struct silk_codec* codec = (struct silk_codec *) my_malloc(size + sizeof(struct silk_codec));

    if (codec == NULL) {

        errno = ENOMEM;

        return NULL;

    }

    codec->obj = (void *) (codec + 1);

    n = SKP_Silk_SDK_InitDecoder(codec->obj);

    if (n != 0) {

        my_free(codec);

        errno = EFAULT;

        return NULL;

    }

    codec->seq[0] = codec->seq[1] = codec->pts = 0;

    codec->fmt_out = to_audio_format(out);

    codec->control.API_sampleRate = codec->fmt_out->pcm->samrate;

    fraction frac = pcm_bytes_from_ms(codec->fmt_out->pcm, 1);

    codec->bytes = silk_mpf * frac.num / frac.den;

    codec->mbuf_handle = mbuf_hget(sizeof(media_buffer) + codec->bytes, 8, 1);

    return codec;

}

static struct my_buffer* pcm_buffer_alloc(struct my_buffer* mbuf,

                                          uint32_t ms, media_buffer* stream, struct silk_codec* codec)

{

    if (mbuf == NULL) {

        if (__builtin_expect(codec->mbuf_handle == -1, 0)) {

            uint32_t bytes = sizeof(media_buffer) + codec->bytes;

            codec->mbuf_handle = mbuf_hget(bytes, 8, 1);

            if (codec->mbuf_handle == -1) {

                mbuf = mbuf_alloc_2(bytes);

            }

        } else {

            mbuf = mbuf_alloc_1(codec->mbuf_handle);

        }

        if (mbuf == NULL) {

            return NULL;

        }

        mbuf->length = codec->bytes;

        mbuf->ptr[1] = mbuf->ptr[0] + sizeof(media_buffer);

    }

    media_buffer* media = (media_buffer *) mbuf->ptr[0];

    memset(media->vp, 0, sizeof(media->vp));

    media->frametype = 0;

    media->angle = 0;

    media->fragment[0] = 0;

    media->fragment[1] = 1;

    media->pptr_cc = &codec->fmt_out->cc;

    media->pts = stream->pts + ms;

    media->iden = stream->iden;

    media->seq = codec->seq[0]++;

    media->vp[0].ptr = mbuf->ptr[1];

    media->vp[0].stride = (uint32_t) mbuf->length;

    media->vp[0].height = 1;

    return mbuf;

}

static uint32_t silk_muted(struct my_buffer* mbuf, uint32_t bytes)

{

    uintptr_t nb = mbuf->length;

    mbuf->length = bytes;

    uint32_t muted = silk_frame_muted(mbuf);

    mbuf->length = nb;

    return muted;

}

static int32_t conceal_lost(media_buffer* stream, struct silk_codec* codec, struct list_head* head)

{

    int32_t nr = (int32_t) (stream->seq - codec->seq[1]);

    if (codec->seq[1] == 0 || __builtin_expect(nr <= 0 || nr > 24, 1)) {

        return 0;

    }

    SKP_int16 nr_samples;

    uint64_t pts = stream->pts;

    stream->pts = codec->pts;

    uint32_t ms = 0, bytes = 0;

    for (int32_t i = 0; i < nr; ++i) {

        struct my_buffer* buffer = pcm_buffer_alloc(NULL, ms, stream, codec);

        if (buffer == NULL) {

            break;

        }

        SKP_Silk_SDK_Decode(codec->obj, &codec->control, 1,

                            NULL, 0, (SKP_int16 *) buffer->ptr[1], &nr_samples);

        my_assert(nr_samples * 2 == buffer->length);

        bytes += buffer->length;

        list_add_tail(&buffer->head, head);

        ms += silk_mpf;

    }

    stream->pts = pts;

    return bytes;

}

static int32_t silk_write(void* handle, struct my_buffer* mbuf, struct list_head* head, int32_t* delay)

{

    (void) delay;

    if (__builtin_expect(mbuf == NULL, 0)) {

        return 0;

    }

    struct silk_codec* codec = (struct silk_codec *) handle;

    media_buffer* stream = (media_buffer *) mbuf->ptr[0];

    uint32_t ms = 0;

    SKP_int16 nr_samples;

    int32_t bytes = conceal_lost(stream, codec, head);

    while (mbuf->length > 0) {

        struct my_buffer* buffer = NULL;

        uint32_t muted = silk_muted(mbuf, silk_frame_leading);

        uint16_t len = silk_read_frame_bytes(mbuf->ptr[1]);

        mbuf->ptr[1] += silk_frame_leading;

        if (muted) {

            buffer = codec->fmt_out->ops->muted_frame_get(codec->fmt_out, silk_mpf);

            if (__builtin_expect(buffer != NULL, 1)) {

                my_assert(buffer->length == codec->bytes);

                bytes += buffer->length;

                buffer = pcm_buffer_alloc(buffer, ms, stream, codec);

                list_add_tail(&buffer->head, head);

            }

        } else {

            buffer = pcm_buffer_alloc(buffer, ms, stream, codec);

            if (__builtin_expect(buffer != NULL, 1)) {

                SKP_Silk_SDK_Decode(codec->obj, &codec->control, 0,

                                    (const SKP_uint8 *) mbuf->ptr[1], (const SKP_int) len,

                                    (SKP_int16 *) buffer->ptr[1], &nr_samples);

                bytes += nr_samples * 2;

                list_add_tail(&buffer->head, head);

            }

        }

        mbuf->ptr[1] += len;

        mbuf->length -= (len + silk_frame_leading);

        ms += silk_mpf;

    }

    codec->seq[1] = stream->seq + 1;

    codec->pts = stream->pts + ms;

    my_assert(mbuf->length == 0);

    mbuf->mop->free(mbuf);

    return bytes;

}

static void silk_close(void* handle)

{

    struct silk_codec* codec = (struct silk_codec *) handle;

    if (codec->mbuf_handle != -1) {

        mbuf_reap(codec->mbuf_handle);

    }

    my_free(codec);

}

static mpu_operation silk_ops = {

    silk_open,

    silk_write,

    silk_close

};

media_process_unit silk_dec_16k16b1 = {

    &silk_16k16b1.cc,

    &pcm_16k16b1.cc,

    &silk_ops,

    1,

    mpu_decoder,

    "silk_dec_16k16b1"

};

media_process_unit silk_dec_8k16b1 = {

    &silk_8k16b1.cc,

    &pcm_8k16b1.cc,

    &silk_ops,

    1,

    mpu_decoder,

    "silk_dec_8k16b1"

};