state.cc

Linux下比较早的基于命令行的DVD播放器

//
// Copyright (c) 2003 by Istv醤 V醨adi
//
// This file is part of dxr3Player, a DVD player written specifically 
// for the DXR3 (aka Hollywood+) decoder card.

// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//------------------------------------------------------------------------------

#include "State.h"

#include "util/Log.h"

//------------------------------------------------------------------------------

using dvd::vm::State;
using dvd::vm::Register;

using dvd::IFO;
using dvd::VMG;
using dvd::VTS;
using dvd::PGCTable;
using dvd::PGC;

//------------------------------------------------------------------------------

State::Saved::Saved(const State& state) :
    position(state)
{
}

//------------------------------------------------------------------------------

bool State::Saved::save(FILE* f) const
{
    bool ok = true;

    ok = ok && (fwrite(&highlightedButtonNumber, sizeof(highlightedButtonNumber),
                       1, f)==1);
    ok = ok && position.save(f);

    return ok;
}

//------------------------------------------------------------------------------

bool State::Saved::load(FILE* f)
{
    bool ok = true;

    ok = ok && (fread(&highlightedButtonNumber, sizeof(highlightedButtonNumber),
                      1, f)==1);
    ok = ok && position.load(f);

    return ok;
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

State::State(DVD* dvd) :
    dvd(dvd),
    position(*this),
    saved(*this)
{
}

//------------------------------------------------------------------------------

void State::reset()
{
    gprm.reset();
    sprm.reset();
    position.reset();
}

//------------------------------------------------------------------------------

const Register& State::getRegister(size_t registerNumber) const
{
    if (registerNumber<=GPRM::maxRegisterNumber) {
        return getGPRM().getRegister(registerNumber - GPRM::minRegisterNumber);
    } else if (registerNumber>=SPRM::minRegisterNumber &&
               registerNumber<=SPRM::maxRegisterNumber) {
        return getSPRM().getRegister(registerNumber - SPRM::minRegisterNumber);
    } else {
        Log::error("dvd::vm::State::getRegister: Invalid register number: %lu\n", registerNumber);
        return getGPRM().getRegister(registerNumber % GPRM::numRegisters);
    }
}
    
//------------------------------------------------------------------------------

Register& State::getRegister(size_t registerNumber)
{
    // FIXME: these two should be merged somehow
    if (registerNumber<=GPRM::maxRegisterNumber) {
        return getGPRM().getRegister(registerNumber - GPRM::minRegisterNumber);
    } else if (registerNumber>=SPRM::minRegisterNumber &&
               registerNumber<=SPRM::maxRegisterNumber) {
        return getSPRM().getRegister(registerNumber - SPRM::minRegisterNumber);
    } else {
        Log::error("dvd::vm::State::getRegister: Invalid register number: %lu\n", registerNumber);
        return getGPRM().getRegister(registerNumber % GPRM::numRegisters);
    }
}

//------------------------------------------------------------------------------

void State::setPosition(const Position& from)
{
    position = from;

    setPositionRegisters();
}

//------------------------------------------------------------------------------

void State::save(unsigned cell)
{
    // saved.highlightedButtonNumber = getSPRValue(SPRM::highlightedButtonNumber);
    // FIXME: do we really need to save the highlighted button number?

    saved.position.copy(position, cell);
}

//------------------------------------------------------------------------------

bool State::resume()
{
    if (saved.position.getCellNumber()==0) return false;

    position.copy(saved.position);    
    setPositionRegisters();

    // setSPRValue(SPRM::highlightedButtonNumber, saved.highlightedButtonNumber)

    return true;
}

//------------------------------------------------------------------------------

bool State::save(FILE* f) const
{
    bool ok = true;

    ok = ok && gprm.save(f);
    ok = ok && sprm.save(f);
    ok = ok && position.save(f);
    ok = ok && saved.save(f);

    return ok;
}

//------------------------------------------------------------------------------

bool State::load(FILE* f)
{
    bool ok = true;

    ok = ok && gprm.load(f);
    ok = ok && sprm.load(f);
    ok = ok && position.load(f);
    ok = ok && saved.load(f);

    return ok;
}

//------------------------------------------------------------------------------

void State::updateEssential(const State& state)
{
    assert(dvd==state.dvd);

    gprm = state.gprm;
    sprm.updateEssential(state.sprm);
    position = state.position;
    saved = state.saved;
}

//------------------------------------------------------------------------------

void State::updateNonEssential(const State& state)
{
    assert(dvd==state.dvd);

    gprm = state.gprm;
    sprm.updateNonEssential(state.sprm);
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

bool State::setPositionRegisters()
{
    if (position.isInVideoManager()) return true;

    setSPRValue(SPRM::pgcNumber, position.getPGCNumber());

    const VTS* vts = position.findVTS();

    if (vts==0) {
        Log::fatal("dvd::vm::State::setPositionRegisters: Cannot set position registers because VTS is 0\n");
        return false;
    }

    PGC pgc = position.getPGC();
    if (!pgc) {
        Log::fatal("dvd::vm::State::setPositionRegisters: Cannot set position registers because PGC is invalid\n");
        return false;
    }

    unsigned vtsTitleNumber = 0;
    unsigned partNumber = vts->getPartNumber(position.getPGCNumber(),
                                             position.getPGC().getProgramNumber(position.getCellNumber()),
                                             vtsTitleNumber);
        
    if (partNumber==0) return true;

    setSPRValue(SPRM::vtsTitleNumber, vtsTitleNumber);
    setSPRValue(SPRM::pttNumber, partNumber);
        
    unsigned titleNumber =
        position.getVMG()->getTitleNumber(position.getVTSNumber(),
                                          vtsTitleNumber);

    if (titleNumber>0) {
        setSPRValue(SPRM::volumeTitleNumber, titleNumber);
    }

    return true;
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------