silk mpu

#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"
};