/*
 * Direct Stream Digital (DSD) decoder
 * Copyright (c) 2014 Peter Ross
 *
 * 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
 * Direct Stream Digital (DSD) decoder
 */

#include "config.h"

#include <string.h>

#include "libavutil/avassert.h"
#include "libavutil/mem.h"
#include "libavutil/reverse.h"

#include "avcodec.h"
#include "codec_internal.h"
#include "decode.h"
#include "dsd.h"

#if CONFIG_SWRESAMPLE && FF_API_DSD_PCM
#include "libswresample/swresample.h"

typedef struct DSDDecContext {
    struct SwrContext *swr;
    uint8_t *scratch;
    unsigned scratch_size;
} DSDDecContext;

#define PRIV_DATA_SIZE sizeof(DSDDecContext)
#else
#define PRIV_DATA_SIZE 0
#endif

static av_cold int decode_init(AVCodecContext *avctx)
{
    if (!avctx->ch_layout.nb_channels)
        return AVERROR_INVALIDDATA;

    avctx->sample_fmt = AV_SAMPLE_FMT_DSD;

#if CONFIG_SWRESAMPLE && FF_API_DSD_PCM
    if (avctx->request_sample_fmt != AV_SAMPLE_FMT_DSD)
        avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;
#endif

    return 0;
}

static av_cold int decode_close(AVCodecContext *avctx)
{
#if CONFIG_SWRESAMPLE && FF_API_DSD_PCM
    DSDDecContext *s = avctx->priv_data;

    swr_free(&s->swr);
    av_freep(&s->scratch);
#endif
    return 0;
}

// repack the input to interleaved DSD bytes, most significant bit first
static void repack(AVCodecContext *avctx, uint8_t *dst, const uint8_t *src,
                   int nb_samples)
{
    const int channels = avctx->ch_layout.nb_channels;

    switch (avctx->codec_id) {
    case AV_CODEC_ID_DSD_MSBF:
        memcpy(dst, src, nb_samples * channels);
        break;
    case AV_CODEC_ID_DSD_LSBF:
        for (int i = 0; i < nb_samples * channels; i++)
            dst[i] = ff_reverse[src[i]];
        break;
    case AV_CODEC_ID_DSD_MSBF_PLANAR:
        for (int ch = 0; ch < channels; ch++) {
            const uint8_t *plane = src + ch * nb_samples;
            for (int i = 0; i < nb_samples; i++)
                dst[i * channels + ch] = plane[i];
        }
        break;
    case AV_CODEC_ID_DSD_LSBF_PLANAR:
        for (int ch = 0; ch < channels; ch++) {
            const uint8_t *plane = src + ch * nb_samples;
            for (int i = 0; i < nb_samples; i++)
                dst[i * channels + ch] = ff_reverse[plane[i]];
        }
        break;
    default:
        av_assert1(0);
    }
}

static int decode_frame(AVCodecContext *avctx, AVFrame *frame,
                        int *got_frame_ptr, AVPacket *avpkt)
{
    const int channels = avctx->ch_layout.nb_channels;
    int ret;

    frame->nb_samples = avpkt->size / channels;

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

#if CONFIG_SWRESAMPLE && FF_API_DSD_PCM
    DSDDecContext *s = avctx->priv_data;
    if (avctx->sample_fmt != AV_SAMPLE_FMT_DSD) {
        if (!s->swr && (ret = ff_dsd_to_pcm_init(avctx, &s->swr)) < 0)
            return ret;

        av_fast_malloc(&s->scratch, &s->scratch_size,
                       frame->nb_samples * channels);
        if (!s->scratch)
            return AVERROR(ENOMEM);

        repack(avctx, s->scratch, avpkt->data, frame->nb_samples);

        ret = swr_convert(s->swr, frame->extended_data, frame->nb_samples,
                          (const uint8_t *const []){ s->scratch },
                          frame->nb_samples);
        if (ret != frame->nb_samples)
            return ret < 0 ? ret : AVERROR_BUG;

        *got_frame_ptr = 1;
        return frame->nb_samples * channels;
    }
#endif

    repack(avctx, frame->data[0], avpkt->data, frame->nb_samples);

    *got_frame_ptr = 1;
    return frame->nb_samples * channels;
}

#define DSD_DECODER(id_, name_, long_name_) \
const FFCodec ff_ ## name_ ## _decoder = { \
    .p.name       = #name_, \
    CODEC_LONG_NAME(long_name_), \
    .p.type       = AVMEDIA_TYPE_AUDIO, \
    .p.id         = AV_CODEC_ID_##id_, \
    .priv_data_size = PRIV_DATA_SIZE, \
    .init         = decode_init, \
    .close        = decode_close, \
    FF_CODEC_DECODE_CB(decode_frame), \
    .p.capabilities = AV_CODEC_CAP_DR1, \
};

DSD_DECODER(DSD_LSBF, dsd_lsbf, "DSD (Direct Stream Digital), least significant bit first")
DSD_DECODER(DSD_MSBF, dsd_msbf, "DSD (Direct Stream Digital), most significant bit first")
DSD_DECODER(DSD_MSBF_PLANAR, dsd_msbf_planar, "DSD (Direct Stream Digital), most significant bit first, planar")
DSD_DECODER(DSD_LSBF_PLANAR, dsd_lsbf_planar, "DSD (Direct Stream Digital), least significant bit first, planar")