/*

 * This file is part of libbluray

 * Copyright (C) 2010-2017  Petri Hintukainen <phintuka@users.sourceforge.net>

 *

 * 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 "hdmv_vm.h"

#include "mobj_data.h"

#include "hdmv_insn.h"

#include "mobj_parse.h"

#include "mobj_print.h"

#include "../register.h"

#include "util/macro.h"

#include "util/logging.h"

#include "util/mutex.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

typedef struct {

    time_t   time;

    uint32_t mobj_id;

} NV_TIMER;

struct hdmv_vm_s {

    BD_MUTEX       mutex;

    /* state */

    uint32_t       pc;            /* program counter */

    BD_REGISTERS  *regs;          /* player registers */

    const MOBJ_OBJECT *object;    /* currently running object code */

    HDMV_EVENT     event[5];      /* pending events to return */

    NV_TIMER       nv_timer;      /* navigation timer */

    uint64_t       rand;          /* RAND state */

    /* movie objects */

    MOBJ_OBJECTS  *movie_objects; /* disc movie objects */

    MOBJ_OBJECT   *ig_object;     /* current object from IG stream */

    /* object currently playing playlist */

    const MOBJ_OBJECT *playing_object;

    uint32_t     playing_pc;

    /* suspended object */

    const MOBJ_OBJECT *suspended_object;

    uint32_t     suspended_pc;

    /* Available titles. Used to validate CALL_TITLE/JUMP_TITLE. */

    uint8_t  have_top_menu;

    uint8_t  have_first_play;

    uint16_t num_titles;

};

/*

 * save / restore VM state

 */

static int _save_state(HDMV_VM *p, uint32_t *s)

{

    memset(s, 0, sizeof(*s) * HDMV_STATE_SIZE);

    if (p->ig_object) {

        BD_DEBUG(DBG_HDMV | DBG_CRIT, "_save_state() failed: button object running\n");

        return -1;

    }

    if (p->object) {

        BD_DEBUG(DBG_HDMV | DBG_CRIT, "_save_state() failed: movie object running\n");

        return -1;

    }

    if (p->event[0].event != HDMV_EVENT_NONE) {

        BD_DEBUG(DBG_HDMV | DBG_CRIT, "_save_state() failed: unprocessed events\n");

        return -1;

    }

    if (p->playing_object) {

        s[0] = (uint32_t)(p->playing_object - p->movie_objects->objects);

        s[1] = p->playing_pc;

    } else {

        s[0] = (uint32_t)-1;

    }

    if (p->suspended_object) {

        s[2] = (uint32_t)(p->suspended_object - p->movie_objects->objects);

        s[3] = p->suspended_pc;

    } else {

        s[2] = (uint32_t)-1;

    }

    /* nv timer ? */

    return 0;

}

static int _restore_state(HDMV_VM *p, const uint32_t *s)

{

    if (s[0] == (uint32_t)-1) {

        p->playing_object = NULL;

    } else if (s[0] >= p->movie_objects->num_objects) {

        BD_DEBUG(DBG_HDMV | DBG_CRIT, "_restore_state() failed: invalid playing object index\n");

        return -1;

    } else {

        p->playing_object = &p->movie_objects->objects[s[0]];

    }

    p->playing_pc = s[1];

    if (s[2] == (uint32_t)-1) {

        p->suspended_object = NULL;

    } else if (s[2] >= p->movie_objects->num_objects) {

        BD_DEBUG(DBG_HDMV | DBG_CRIT, "_restore_state() failed: invalid suspended object index\n");

        return -1;

    } else {

        p->suspended_object = &p->movie_objects->objects[s[2]];

    }

    p->suspended_pc = s[3];

    p->object = NULL;

    p->ig_object = NULL;

    memset(p->event, 0, sizeof(p->event));

    return 0;

}

int hdmv_vm_save_state(HDMV_VM *p, uint32_t *s)

{

    int result;

    bd_mutex_lock(&p->mutex);

    result = _save_state(p, s);

    bd_mutex_unlock(&p->mutex);

    return result;

}

void hdmv_vm_restore_state(HDMV_VM *p, const uint32_t *s)

{

    bd_mutex_lock(&p->mutex);

    _restore_state(p, s);

    bd_mutex_unlock(&p->mutex);

}

/*

 * registers: PSR and GPR access

 */

#define PSR_FLAG 0x80000000

static int _is_valid_reg(uint32_t reg)

{

    if (reg & PSR_FLAG) {

        if (reg & ~0x8000007f) {

            return 0;

        }

    }  else {

        if (reg & ~0x00000fff) {

            return 0;

        }

    }

    return 1;

}

static int _store_reg(HDMV_VM *p, uint32_t reg, uint32_t val)

{

    if (!_is_valid_reg(reg)) {

        BD_DEBUG(DBG_HDMV, "_store_reg(): invalid register 0x%x\n", reg);

        return -1;

    }

    if (reg & PSR_FLAG) {

        BD_DEBUG(DBG_HDMV, "_store_reg(): storing to PSR is not allowed\n");

        return -1;

    }  else {

        return bd_gpr_write(p->regs, reg, val);

    }

}

static uint32_t _read_reg(HDMV_VM *p, uint32_t reg)

{

    if (!_is_valid_reg(reg)) {

        BD_DEBUG(DBG_HDMV, "_read_reg(): invalid register 0x%x\n", reg);

        return 0;

    }

    if (reg & PSR_FLAG) {

        return bd_psr_read(p->regs, reg & 0x7f);

    } else {

        return bd_gpr_read(p->regs, reg);

    }

}

static uint32_t _read_setstream_regs(HDMV_VM *p, uint32_t val)

{

    uint32_t flags = val & 0xf000f000;

    uint32_t reg0 = val & 0xfff;

    uint32_t reg1 = (val >> 16) & 0xfff;

    uint32_t val0 = bd_gpr_read(p->regs, reg0) & 0x0fff;

    uint32_t val1 = bd_gpr_read(p->regs, reg1) & 0x0fff;

    return flags | val0 | (val1 << 16);

}

static uint32_t _read_setbuttonpage_reg(HDMV_VM *p, uint32_t val)

{

    uint32_t flags = val & 0xc0000000;

    uint32_t reg0  = val & 0x00000fff;

    uint32_t val0  = bd_gpr_read(p->regs, reg0) & 0x3fffffff;

    return flags | val0;

}

static int _store_result(HDMV_VM *p, MOBJ_CMD *cmd, uint32_t src, uint32_t dst, uint32_t src0, uint32_t dst0)

{

    int ret = 0;

    /* store result to destination register(s) */

    if (dst != dst0) {

        if (cmd->insn.imm_op1) {

            BD_DEBUG(DBG_HDMV|DBG_CRIT, "storing to imm !\n");

            return -1;

        }

        ret = _store_reg(p, cmd->dst, dst);

    }

    if (src != src0) {

        if (cmd->insn.imm_op1) {

            BD_DEBUG(DBG_HDMV|DBG_CRIT, "storing to imm !\n");

            return -1;

        }

        ret += _store_reg(p, cmd->src, src);

    }

    return ret;

}

static uint32_t _fetch_operand(HDMV_VM *p, int setstream, int setbuttonpage, int imm, uint32_t value)

{

    if (imm) {

        return value;

    }

    if (setstream) {

        return _read_setstream_regs(p, value);

    } else if (setbuttonpage) {

        return _read_setbuttonpage_reg(p, value);

    } else {

        return _read_reg(p, value);

    }

}

static void _fetch_operands(HDMV_VM *p, MOBJ_CMD *cmd, uint32_t *dst, uint32_t *src)

{

    HDMV_INSN *insn = &cmd->insn;

    int setstream = (insn->grp     == INSN_GROUP_SET &&

                     insn->sub_grp == SET_SETSYSTEM  &&

                     (  insn->set_opt == INSN_SET_STREAM ||

                        insn->set_opt == INSN_SET_SEC_STREAM));

    int setbuttonpage = (insn->grp     == INSN_GROUP_SET &&

                         insn->sub_grp == SET_SETSYSTEM  &&

                         insn->set_opt == INSN_SET_BUTTON_PAGE);

    *dst = *src = 0;

    if (insn->op_cnt > 0) {

        *dst = _fetch_operand(p, setstream, setbuttonpage, insn->imm_op1, cmd->dst);

    }

    if (insn->op_cnt > 1) {

        *src = _fetch_operand(p, setstream, setbuttonpage, insn->imm_op2, cmd->src);

    }

}

/*

 * event queue

 */

static int _get_event(HDMV_VM *p, HDMV_EVENT *ev)

{

    if (p->event[0].event != HDMV_EVENT_NONE) {

        *ev = p->event[0];

        memmove(p->event, p->event + 1, sizeof(p->event) - sizeof(p->event[0]));

        return 0;

    }

    ev->event = HDMV_EVENT_NONE;

    return -1;

}

static int _queue_event(HDMV_VM *p, hdmv_event_e event, uint32_t param)

{

    unsigned i;

    for (i = 0; i < sizeof(p->event) / sizeof(p->event[0]) - 1; i++) {

        if (p->event[i].event == HDMV_EVENT_NONE) {

            p->event[i].event = event;

            p->event[i].param = param;

            return 0;

        }

    }

    BD_DEBUG(DBG_HDMV|DBG_CRIT, "_queue_event(%d, %d): queue overflow !\n", event, param);

    return -1;

}

/*

 * vm init

 */

HDMV_VM *hdmv_vm_init(struct bd_disc *disc, BD_REGISTERS *regs,

                      unsigned num_titles, unsigned first_play_available, unsigned top_menu_available)

{

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

    if (!p) {

        BD_DEBUG(DBG_CRIT, "out of memory\n");

        return NULL;

    }

    /* read movie objects */

    p->movie_objects = mobj_get(disc);

    if (!p->movie_objects) {

        X_FREE(p);

        return NULL;

    }

    p->regs         = regs;

    p->num_titles      = num_titles;

    p->have_top_menu   = top_menu_available;

    p->have_first_play = first_play_available;

#ifdef DEBUG

    p->rand = 1;

#else

    p->rand = time(NULL);

#endif

    bd_mutex_init(&p->mutex);

    return  p;

}

static void _free_ig_object(HDMV_VM *p)

{

    if (p->ig_object) {

        X_FREE(p->ig_object->cmds);

        X_FREE(p->ig_object);

    }

}

void hdmv_vm_free(HDMV_VM **p)

{

    if (p && *p) {

        bd_mutex_destroy(&(*p)->mutex);

        mobj_free(&(*p)->movie_objects);

        _free_ig_object(*p);

        X_FREE(*p);

    }

}

/*

 * suspend/resume ("function call")

 */

static int _suspended_at_play_pl(HDMV_VM *p)

{

    int play_pl = 0;

    if (p && p->suspended_object) {

        MOBJ_CMD  *cmd  = &p->suspended_object->cmds[p->suspended_pc];

        HDMV_INSN *insn = &cmd->insn;

        play_pl = (insn->grp     == INSN_GROUP_BRANCH &&

                   insn->sub_grp == BRANCH_PLAY  &&

                   (  insn->branch_opt == INSN_PLAY_PL ||

                      insn->branch_opt == INSN_PLAY_PL_PI ||

                      insn->branch_opt == INSN_PLAY_PL_PM));

    }

    return play_pl;

}

static int _suspend_for_play_pl(HDMV_VM *p)

{

    if (p->playing_object) {

        BD_DEBUG(DBG_HDMV|DBG_CRIT, "_suspend_for_play_pl(): object already playing playlist !\n");

        return -1;

    }

    p->playing_object = p->object;

    p->playing_pc     = p->pc;

    p->object = NULL;

    return 0;

}

static int _resume_from_play_pl(HDMV_VM *p)

{

    if (!p->playing_object) {

        BD_DEBUG(DBG_HDMV|DBG_CRIT, "_resume_from_play_pl(): object not playing playlist !\n");

        return -1;

    }

    p->object = p->playing_object;

    p->pc     = p->playing_pc + 1;

    p->playing_object = NULL;

    _free_ig_object(p);

    return 0;

}

static void _suspend_object(HDMV_VM *p, int psr_backup)

{

    BD_DEBUG(DBG_HDMV, "_suspend_object()\n");

    if (p->suspended_object) {

        BD_DEBUG(DBG_HDMV, "_suspend_object: object already suspended !\n");

        // [execute the call, discard old suspended object (10.2.4.2.2)].

    }

    if (psr_backup) {

        bd_psr_save_state(p->regs);

    }

    if (p->ig_object) {

        if (!p->playing_object) {

            BD_DEBUG(DBG_HDMV|DBG_CRIT, "_suspend_object: IG object tries to suspend, no playing object !\n");

            return;

        }

        p->suspended_object = p->playing_object;

        p->suspended_pc     = p->playing_pc;

        p->playing_object = NULL;

    } else {

        if (p->playing_object) {

            BD_DEBUG(DBG_HDMV|DBG_CRIT, "_suspend_object: Movie object tries to suspend, also playing object present !\n");

            return;

        }

        p->suspended_object = p->object;

        p->suspended_pc     = p->pc;

    }

    p->object = NULL;

    _free_ig_object(p);

}

static int _resume_object(HDMV_VM *p, int psr_restore)

{

    if (!p->suspended_object) {

        BD_DEBUG(DBG_HDMV|DBG_CRIT, "_resume_object: no suspended object!\n");

        return -1;

    }

    p->object = NULL;

    p->playing_object = NULL;

    _free_ig_object(p);

    if (psr_restore) {

        /* check if suspended in play_pl */

        if (_suspended_at_play_pl(p)) {

            BD_DEBUG(DBG_HDMV, "resuming playlist playback\n");

            p->playing_object = p->suspended_object;

            p->playing_pc     = p->suspended_pc;

            p->suspended_object = NULL;

            bd_psr_restore_state(p->regs);

            return 0;

        }

        bd_psr_restore_state(p->regs);

    }

    p->object = p->suspended_object;

    p->pc     = p->suspended_pc + 1;

    p->suspended_object = NULL;

    BD_DEBUG(DBG_HDMV, "resuming object %ld at %d\n",

             (long)(p->object - p->movie_objects->objects),

             p->pc);

    _queue_event(p, HDMV_EVENT_PLAY_STOP, 0);

    return 0;

}

/*

 * branching

 */

static int _is_valid_title(HDMV_VM *p, uint32_t title)

{

    if (title == 0) {

        return p->have_top_menu;

    }

    if (title == 0xffff) {

        return p->have_first_play;

    }

    return title > 0 && title <= p->num_titles;

}

static int _jump_object(HDMV_VM *p, uint32_t object)

{

    if (object >= p->movie_objects->num_objects) {

        BD_DEBUG(DBG_HDMV|DBG_CRIT, "_jump_object(): invalid object %u\n", object);

        return -1;

    }

    BD_DEBUG(DBG_HDMV, "_jump_object(): jumping to object %u\n", object);

    _queue_event(p, HDMV_EVENT_PLAY_STOP, 0);

    _free_ig_object(p);

    p->playing_object = NULL;

    p->pc     = 0;

    p->object = &p->movie_objects->objects[object];

    /* suspended object is not discarded */

    return 0;

}

static int _jump_title(HDMV_VM *p, uint32_t title)

{

    if (_is_valid_title(p, title)) {

        BD_DEBUG(DBG_HDMV, "_jump_title(%u)\n", title);

        /* discard suspended object */

        p->suspended_object = NULL;

        p->playing_object = NULL;

        bd_psr_reset_backup_registers(p->regs);

        _queue_event(p, HDMV_EVENT_TITLE, title);

        return 0;

    }

    BD_DEBUG(DBG_HDMV|DBG_CRIT, "_jump_title(%u): invalid title number\n", title);

    return -1;

}

static int _call_object(HDMV_VM *p, uint32_t object)

{

    if (object >= p->movie_objects->num_objects) {

        BD_DEBUG(DBG_HDMV|DBG_CRIT, "_call_object(): invalid object %u\n", object);

        return -1;

    }

    BD_DEBUG(DBG_HDMV, "_call_object(%u)\n", object);

    _suspend_object(p, 1);

    return _jump_object(p, object);

}

static int _call_title(HDMV_VM *p, uint32_t title)

{

    if (_is_valid_title(p, title)) {

        BD_DEBUG(DBG_HDMV, "_call_title(%u)\n", title);

        _suspend_object(p, 1);

        _queue_event(p, HDMV_EVENT_TITLE, title);

        return 0;

    }

    BD_DEBUG(DBG_HDMV|DBG_CRIT, "_call_title(%u): invalid title number\n", title);

    return -1;

}

/*

 * playback control

 */

static int _play_at(HDMV_VM *p, int playlist, int playitem, int playmark)

{

    if (p->ig_object && playlist >= 0) {

        BD_DEBUG(DBG_HDMV | DBG_CRIT, "play_at(list %d, item %d, mark %d): "

              "playlist change not allowed in interactive composition\n",

              playlist, playitem, playmark);

        return -1;

    }

    if (!p->ig_object && playlist < 0) {

        BD_DEBUG(DBG_HDMV | DBG_CRIT, "play_at(list %d, item %d, mark %d): "

              "playlist not given in movie object (link commands not allowed)\n",

              playlist, playitem, playmark);

        return -1;

    }

    BD_DEBUG(DBG_HDMV, "play_at(list %d, item %d, mark %d)\n",

          playlist, playitem, playmark);

    if (playlist >= 0) {

        _queue_event(p, HDMV_EVENT_PLAY_PL, playlist);

        _suspend_for_play_pl(p);

    }

    if (playitem >= 0) {

        _queue_event(p, HDMV_EVENT_PLAY_PI, playitem);

    }

    if (playmark >= 0) {

        _queue_event(p, HDMV_EVENT_PLAY_PM, playmark);

    }

    return 0;

}

static int _play_stop(HDMV_VM *p)

{

    if (!p->ig_object) {

        BD_DEBUG(DBG_HDMV | DBG_CRIT, "_play_stop() not allowed in movie object\n");

        return -1;

    }

    BD_DEBUG(DBG_HDMV, "_play_stop()\n");

    _queue_event(p, HDMV_EVENT_PLAY_STOP, 1);

    /* terminate IG object. Continue executing movie object.  */

    if (_resume_from_play_pl(p) < 0) {

        BD_DEBUG(DBG_HDMV|DBG_CRIT, "_play_stop(): resuming movie object failed !\n");

        return -1;

    }

    return 0;

}

/*

 * SET/SYSTEM setstream

 */

static void _set_stream(HDMV_VM *p, uint32_t dst, uint32_t src)

{

    BD_DEBUG(DBG_HDMV, "_set_stream(0x%x, 0x%x)\n", dst, src);

    /* primary audio stream */

    if (dst & 0x80000000) {

        bd_psr_write(p->regs, PSR_PRIMARY_AUDIO_ID, (dst >> 16) & 0xfff);

    }

    /* IG stream */

    if (src & 0x80000000) {

        bd_psr_write(p->regs, PSR_IG_STREAM_ID, (src >> 16) & 0xff);

    }

    /* angle number */

    if (src & 0x8000) {

        bd_psr_write(p->regs, PSR_ANGLE_NUMBER, src & 0xff);

    }

    /* PSR2 */

    bd_psr_lock(p->regs);

    uint32_t psr2 = bd_psr_read(p->regs, PSR_PG_STREAM);

    /* PG TextST stream number */

    if (dst & 0x8000) {

        uint32_t text_st_num = dst & 0xfff;

        psr2 = text_st_num | (psr2 & 0xfffff000);

    }

    /* Update PG TextST stream display flag */

    uint32_t disp_s_flag = (dst & 0x4000) << 17;

    psr2 = disp_s_flag | (psr2 & 0x7fffffff);

    bd_psr_write(p->regs, PSR_PG_STREAM, psr2);

    bd_psr_unlock(p->regs);

}

static void _set_sec_stream(HDMV_VM *p, uint32_t dst, uint32_t src)

{

    BD_DEBUG(DBG_HDMV, "_set_sec_stream(0x%x, 0x%x)\n", dst, src);

    uint32_t disp_v_flag   = (dst >> 30) & 1;

    uint32_t disp_a_flag   = (src >> 30) & 1;

    uint32_t text_st_flags = (src >> 13) & 3;

    /* PSR14 */

    bd_psr_lock(p->regs);

    uint32_t psr14 = bd_psr_read(p->regs, PSR_SECONDARY_AUDIO_VIDEO);

    /* secondary video */

    if (dst & 0x80000000) {

      uint32_t sec_video = dst & 0xff;

      psr14 = (sec_video << 8) | (psr14 & 0xffff00ff);

    }

    /* secondary video size */

    if (dst & 0x00800000) {

      uint32_t video_size = (dst >> 16) & 0xf;

      psr14 = (video_size << 24) | (psr14 & 0xf0ffffff);

    }

    /* secondary audio */

    if (src & 0x80000000) {

      uint32_t sec_audio = (src >> 16) & 0xff;

      psr14 = sec_audio | (psr14 & 0xffffff00);

    }

    psr14 = (disp_v_flag << 31) | (psr14 & 0x7fffffff);

    psr14 = (disp_a_flag << 30) | (psr14 & 0xbfffffff);

    bd_psr_write(p->regs, PSR_SECONDARY_AUDIO_VIDEO, psr14);

    /* PSR2 */

    uint32_t psr2  = bd_psr_read(p->regs, PSR_PG_STREAM);

    /* PiP PG TextST stream */

    if (src & 0x8000) {

        uint32_t stream = src & 0xfff;

        psr2 = (stream << 16) | (psr2 & 0xf000ffff);

    }

    psr2 = (text_st_flags << 30) | (psr2 & 0x3fffffff);

    bd_psr_write(p->regs, PSR_PG_STREAM, psr2);

    bd_psr_unlock(p->regs);

}

static void _set_stream_ss(HDMV_VM *p, uint32_t dst, uint32_t src)

{

    BD_DEBUG(DBG_HDMV, "_set_stream_ss(0x%x, 0x%x)\n", dst, src);

    if (!(bd_psr_read(p->regs, PSR_3D_STATUS) & 1)) {

        BD_DEBUG(DBG_HDMV, "_set_stream_ss ignored (PSR22 indicates 2D mode)\n");

        return;

    }

    BD_DEBUG(DBG_HDMV, "_set_stream_ss(0x%x, 0x%x) unimplemented\n", dst, src);

}

static void _setsystem_0x10(HDMV_VM *p, uint32_t dst, uint32_t src)

{

    BD_DEBUG(DBG_HDMV, "_set_psr103(0x%x, 0x%x)\n", dst, src);

    bd_psr_lock(p->regs);

    /* just a guess ... */

    //bd_psr_write(p->regs, 104, 0);

    bd_psr_write(p->regs, 103, dst);

    bd_psr_unlock(p->regs);

}

/*

 * SET/SYSTEM navigation control

 */

static void _set_button_page(HDMV_VM *p, uint32_t dst, uint32_t src)

{

    if (p->ig_object) {

        uint32_t param;

        param =  (src & 0xc0000000) |        /* page and effects flags */

                ((dst & 0x80000000) >> 2) |  /* button flag */

                ((src & 0x000000ff) << 16) | /* page id */

                 (dst & 0x0000ffff);         /* button id */

         _queue_event(p, HDMV_EVENT_SET_BUTTON_PAGE, param);

         /* terminate */

         p->pc = 1 << 17;

        return;

    }

    /* selected button */

    if (dst & 0x80000000) {

        bd_psr_write(p->regs, PSR_SELECTED_BUTTON_ID, dst & 0xffff);

    }

    /* active page */

    if (src & 0x80000000) {

        bd_psr_write(p->regs, PSR_MENU_PAGE_ID, src & 0xff);

    }

}

static void _enable_button(HDMV_VM *p, uint32_t dst, int enable)

{

    /* not valid in movie objects */

    if (p->ig_object) {

        if (enable) {

            _queue_event(p, HDMV_EVENT_ENABLE_BUTTON,  dst);

        } else {

            _queue_event(p, HDMV_EVENT_DISABLE_BUTTON, dst);

        }

    }

}

static void _set_still_mode(HDMV_VM *p, int enable)

{

    /* not valid in movie objects */

    if (p->ig_object) {

        _queue_event(p, HDMV_EVENT_STILL, enable);

    }

}

static void _popup_off(HDMV_VM *p)

{

    /* not valid in movie objects */

    if (p->ig_object) {

        _queue_event(p, HDMV_EVENT_POPUP_OFF, 1);

    }

}

/*

 * SET/SYSTEM 3D mode

 */

static void _set_output_mode(HDMV_VM *p, uint32_t dst)

{

    if ((bd_psr_read(p->regs, PSR_PROFILE_VERSION) & 0x130240) != 0x130240) {

        BD_DEBUG(DBG_HDMV, "_set_output_mode ignored (not running as profile 5 player)\n");

        return;

    }

    bd_psr_lock(p->regs);

    uint32_t psr22 = bd_psr_read(p->regs, PSR_3D_STATUS);

    /* update output mode (bit 0). PSR22 bits 1 and 2 are subtitle alignment (_set_stream_ss()) */

    if (dst & 1) {

      psr22 |= 1;

    } else {

      psr22 &= ~1;

    }

    bd_psr_write(p->regs, PSR_3D_STATUS, psr22);

    bd_psr_unlock(p->regs);

}

/*