FFmpeg/libavcodec/dfpwmdec.c

/*
 * DFPWM decoder
 * Copyright (c) 2022 Jack Bruienne
 * Copyright (c) 2012, 2016 Ben "GreaseMonkey" Russell
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg 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.
 *
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * DFPWM1a decoder
 */

#include "libavutil/internal.h"
#include "avcodec.h"
#include "codec_id.h"
#include "codec_internal.h"
#include "decode.h"

typedef struct {
    int fq, q, s, lt;
} DFPWMState;

// DFPWM codec from https://github.com/ChenThread/dfpwm/blob/master/1a/
// Licensed in the public domain

static void au_decompress(DFPWMState *state, int fs, int len,
                          uint8_t *outbuf, const uint8_t *inbuf)
{
    unsigned d;
    for (int i = 0; i < len; i++) {
        // get bits
        d = *(inbuf++);
        for (int j = 0; j < 8; j++) {
            int nq, lq, st, ns, ov;
            // set target
            int t = ((d&1) ? 127 : -128);
            d >>= 1;

            // adjust charge
            nq = state->q + ((state->s * (t-state->q) + 512)>>10);
            if(nq == state->q && nq != t)
                nq += (t == 127 ? 1 : -1);
            lq = state->q;
            state->q = nq;

            // adjust strength
            st = (t != state->lt ? 0 : 1023);
            ns = state->s;
            if(ns != st)
                ns += (st != 0 ? 1 : -1);
            if(ns < 8) ns = 8;
            state->s = ns;

            // FILTER: perform antijerk
            ov = (t != state->lt ? (nq+lq+1)>>1 : nq);

            // FILTER: perform LPF
            state->fq += ((fs*(ov-state->fq) + 0x80)>>8);
            ov = state->fq;

            // output sample
            *(outbuf++) = ov + 128;

            state->lt = t;
        }
    }
}

static av_cold int dfpwm_dec_init(struct AVCodecContext *ctx)
{
    DFPWMState *state = ctx->priv_data;

    state->fq = 0;
    state->q = 0;
    state->s = 0;
    state->lt = -128;

    ctx->sample_fmt = AV_SAMPLE_FMT_U8;
    ctx->bits_per_raw_sample = 8;

    return 0;
}

static int dfpwm_dec_frame(struct AVCodecContext *ctx, AVFrame *frame,
                           int *got_frame, struct AVPacket *packet)
{
    DFPWMState *state = ctx->priv_data;
    int ret;

    if (packet->size * 8LL % ctx->ch_layout.nb_channels)
        return AVERROR_PATCHWELCOME;

    frame->nb_samples = packet->size * 8LL / ctx->ch_layout.nb_channels;
    if (frame->nb_samples <= 0) {
        av_log(ctx, AV_LOG_ERROR, "invalid number of samples in packet\n");
        return AVERROR_INVALIDDATA;
    }

    if ((ret = ff_get_buffer(ctx, frame, 0)) < 0)
        return ret;

    au_decompress(state, 140, packet->size, frame->data[0], packet->data);

    *got_frame = 1;
    return packet->size;
}

const FFCodec ff_dfpwm_decoder = {
    .p.name         = "dfpwm",
    CODEC_LONG_NAME("DFPWM1a audio"),
    .p.type         = AVMEDIA_TYPE_AUDIO,
    .p.id           = AV_CODEC_ID_DFPWM,
    .priv_data_size = sizeof(DFPWMState),
    .init           = dfpwm_dec_init,
    FF_CODEC_DECODE_CB(dfpwm_dec_frame),
    .p.capabilities = AV_CODEC_CAP_DR1,
};