/*

 * This file is part of libbluray

 * Copyright (C) 2014  VideoLAN

 *

 * This library 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.

 *

 * This library 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 this library. If not, see

 * <http://www.gnu.org/licenses/>.

 */

#if HAVE_CONFIG_H

#include "config.h"

#endif

#include "dec.h"

#include "enc_info.h"

#include "aacs.h"

#include "bdplus.h"

#include "file/file.h"

#include "util/logging.h"

#include "util/macro.h"

#include "util/strutl.h"

#include <string.h>

struct bd_dec {

    int        use_menus;

    BD_AACS   *aacs;

    BD_BDPLUS *bdplus;

};

/*

 * stream

 */

typedef struct {

    BD_FILE_H    *fp;

    BD_AACS      *aacs;

    BD_BDPLUS_ST *bdplus;

} DEC_STREAM;

static int64_t _stream_read(BD_FILE_H *fp, uint8_t *buf, int64_t size)

{

    DEC_STREAM *st = (DEC_STREAM *)fp->internal;

    int64_t     result;

    if (size != 6144) {

        BD_DEBUG(DBG_CRIT, "read size != unit size\n");

        return 0;

    }

    result = st->fp->read(st->fp, buf, size);

    if (result <= 0) {

        return result;

    }

    if (st->aacs) {

        if (libaacs_decrypt_unit(st->aacs, buf)) {

            /* failure is detected from TP header */

        }

    }

    if (st->bdplus) {

        if (libbdplus_fixup(st->bdplus, buf, (int)size) < 0) {

          /* there's no way to verify if the stream was decoded correctly */

        }

    }

    return result;

}

static int64_t _stream_seek(BD_FILE_H *fp, int64_t offset, int32_t origin)

{

    DEC_STREAM *st = (DEC_STREAM *)fp->internal;

    int64_t result = st->fp->seek(st->fp, offset, origin);

    if (result >= 0 && st->bdplus) {

        libbdplus_seek(st->bdplus, st->fp->tell(st->fp));

    }

    return result;

}

static int64_t _stream_tell(BD_FILE_H *fp)

{

    DEC_STREAM *st = (DEC_STREAM *)fp->internal;

    return st->fp->tell(st->fp);

}

static void _stream_close(BD_FILE_H *fp)

{

    DEC_STREAM *st = (DEC_STREAM *)fp->internal;

    if (st->bdplus) {

        libbdplus_m2ts_close(&st->bdplus);

    }

    st->fp->close(st->fp);

    X_FREE(fp->internal);

    X_FREE(fp);

}

BD_FILE_H *dec_open_stream(BD_DEC *dec, BD_FILE_H *fp, uint32_t clip_id)

{

    DEC_STREAM *st;

    BD_FILE_H  *p = calloc(1, sizeof(BD_FILE_H));

    if (!p) {

        return NULL;

    }

    st = calloc(1, sizeof(DEC_STREAM));

    if (!st) {

        X_FREE(p);

        return NULL;

    }

    st->fp = fp;

    if (dec->bdplus) {

        st->bdplus = libbdplus_m2ts(dec->bdplus, clip_id, 0);

    }

    if (dec->aacs) {

        st->aacs = dec->aacs;

        if (!dec->use_menus) {

            /* There won't be title events --> need to manually reset AACS CPS */

            libaacs_select_title(dec->aacs, 0xffff);

        }

    }

    p->internal = st;

    p->read  = _stream_read;

    p->seek  = _stream_seek;

    p->tell  = _stream_tell;

    p->close = _stream_close;

    return p;

}

/*

 *

 */

/*

 *

 */

static int _bdrom_have_file(void *p, const char *dir, const char *file)

{

    struct dec_dev *dev = (struct dec_dev *)p;

    BD_FILE_H *fp;

    char *path;

    path = str_printf("%s" DIR_SEP "%s", dir, file);

    if (!path) {

        return 0;

    }

    fp = dev->pf_file_open_bdrom(dev->file_open_bdrom_handle, path);

    X_FREE(path);

    if (fp) {

        file_close(fp);

        return 1;

    }

    return 0;

}

static int _libaacs_init(BD_DEC *dec, struct dec_dev *dev,

                         BD_ENC_INFO *i, const char *keyfile_path)

{

    int result;

    const uint8_t *disc_id;

    if (!dec->aacs) {

        return 0;

    }

    result = libaacs_open(dec->aacs, dev->device, dev->file_open_vfs_handle, (void*)dev->pf_file_open_vfs, keyfile_path);

    i->aacs_error_code = result;

    i->aacs_handled    = !result;

    i->aacs_mkbv       = libaacs_get_mkbv(dec->aacs);

    disc_id = libaacs_get_aacs_data(dec->aacs, BD_AACS_DISC_ID);

    if (disc_id) {

        memcpy(i->disc_id, disc_id, 20);

    }

    if (result) {

        BD_DEBUG(DBG_BLURAY | DBG_CRIT, "aacs_open() failed: %d!\n", result);

        libaacs_unload(&dec->aacs);

        return 0;

    }

    BD_DEBUG(DBG_BLURAY, "Opened libaacs\n");

    return 1;

}

static int _libbdplus_init(BD_DEC *dec, struct dec_dev *dev,

                           BD_ENC_INFO *i,

                           void *regs, void *psr_read, void *psr_write)

{

    if (!dec->bdplus) {

        return 0;

    }

    const uint8_t *vid = libaacs_get_aacs_data(dec->aacs, BD_AACS_MEDIA_VID);

    const uint8_t *mk  = libaacs_get_aacs_data(dec->aacs, BD_AACS_MEDIA_KEY);

    if (!vid) {

        BD_DEBUG(DBG_BLURAY | DBG_CRIT, "BD+ initialization failed (no AACS ?)\n");

        libbdplus_unload(&dec->bdplus);

        return 0;

    }

    if (libbdplus_init(dec->bdplus, dev->root, dev->device, dev->file_open_bdrom_handle, (void*)dev->pf_file_open_bdrom, vid, mk)) {

        BD_DEBUG(DBG_BLURAY | DBG_CRIT, "bdplus_init() failed\n");

        i->bdplus_handled = 0;

        libbdplus_unload(&dec->bdplus);

        return 0;

    }

    BD_DEBUG(DBG_BLURAY, "libbdplus initialized\n");

    /* map player memory regions */

    libbdplus_mmap(dec->bdplus, 0, regs);

    libbdplus_mmap(dec->bdplus, 1, (void*)((uint8_t *)regs + sizeof(uint32_t) * 128));

    /* connect registers */

    libbdplus_psr(dec->bdplus, regs, psr_read, psr_write);

    i->bdplus_gen     = libbdplus_get_gen(dec->bdplus);

    i->bdplus_date    = libbdplus_get_date(dec->bdplus);

    i->bdplus_handled = 1;

    if (i->bdplus_date == 0) {

        // libmmbd -> no menu support

        BD_DEBUG(DBG_BLURAY | DBG_CRIT, "WARNING: using libmmbd for BD+. On-disc menus will not work.\n");

        //i->no_menu_support = 1;

    }

    return 1;

}

static int _dec_detect(struct dec_dev *dev, BD_ENC_INFO *i)

{

    /* Check for AACS */

    i->aacs_detected = libaacs_required((void*)dev, _bdrom_have_file);

    if (!i->aacs_detected) {

        /* No AACS (=> no BD+) */

        return 0;

    }

    /* check for BD+ */

    i->bdplus_detected = libbdplus_required((void*)dev, _bdrom_have_file);

    return 1;

}

static void _dec_load(BD_DEC *dec, BD_ENC_INFO *i)

{

    int force_mmbd_aacs = 0;

    if (i->bdplus_detected) {

        /* load BD+ library and check BD+ library type. libmmbd doesn't work with libaacs */

        dec->bdplus = libbdplus_load();

        force_mmbd_aacs = dec->bdplus && libbdplus_is_mmbd(dec->bdplus);

    }

    /* load AACS library */

    dec->aacs = libaacs_load(force_mmbd_aacs);

    i->libaacs_detected   = !!dec->aacs;

    i->libbdplus_detected = !!dec->bdplus;

}

/*

 *

 */

BD_DEC *dec_init(struct dec_dev *dev, BD_ENC_INFO *enc_info,

                 const char *keyfile_path,

                 void *regs, void *psr_read, void *psr_write)

{

    BD_DEC *dec = NULL;

    memset(enc_info, 0, sizeof(*enc_info));

    /* detect AACS/BD+ */

    if (!_dec_detect(dev, enc_info)) {

        return NULL;

    }

    dec = calloc(1, sizeof(BD_DEC));

    if (!dec) {

        return NULL;

    }

    /* load compatible libraries */

    _dec_load(dec, enc_info);

    /* init decoding libraries */

    /* BD+ won't help unless AACS works ... */

    if (_libaacs_init(dec, dev, enc_info, keyfile_path)) {

        _libbdplus_init(dec, dev, enc_info, regs, psr_read, psr_write);

    }

    if (!enc_info->aacs_handled) {

        /* AACS failed, clean up */

        dec_close(&dec;;

    }

    /* BD+ failure may be non-fatal (not all titles in disc use BD+).

     * Keep working AACS decoder even if BD+ init failed

     */

    return dec;

}

void dec_close(BD_DEC **pp)

{

    if (pp && *pp) {

        BD_DEC *p = *pp;

        libaacs_unload(&p->aacs);

        libbdplus_unload(&p->bdplus);

        X_FREE(*pp);

    }

}

/*

 *

 */

const uint8_t *dec_data(BD_DEC *dec, int type)

{

    const uint8_t *ret = NULL;

    if (type >= 0x1000) {

        if (dec->bdplus) {

            ret = libbdplus_get_data(dec->bdplus, type);

        }

    } else {

        if (dec->aacs) {

            ret = libaacs_get_aacs_data(dec->aacs, type);

        }

    }

    return ret;

}

const uint8_t *dec_disc_id(BD_DEC *dec)

{

    return dec_data(dec, BD_AACS_DISC_ID);

}

void dec_start(BD_DEC *dec, uint32_t num_titles)

{

    if (num_titles == 0) {

        dec->use_menus = 1;

        if (dec->bdplus) {

            libbdplus_start(dec->bdplus);

            libbdplus_event(dec->bdplus, 0x110, 0xffff, 0);

        }

    } else {

        if (dec->bdplus) {

            libbdplus_event(dec->bdplus, 0xffffffff, num_titles, 0);

        }

    }

}

void dec_title(BD_DEC *dec, uint32_t title)

{

    if (dec->aacs) {

        libaacs_select_title(dec->aacs, title);

    }

    if (dec->bdplus) {

        libbdplus_event(dec->bdplus, 0x110, title, 0);

    }

}

void dec_application(BD_DEC *dec, uint32_t data)

{

    if (dec->bdplus) {

        libbdplus_event(dec->bdplus, 0x210, data, 0);

    }

}