//// Copyright (c) 2002 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#ifndef DXR3PLAYER_DVD_VM_PROCESSOR_H#define DXR3PLAYER_DVD_VM_PROCESSOR_H//------------------------------------------------------------------------------#include "dvd/vm/State.h"#include "dvd/vm/Instruction.h"#include "dvd/vm/Scheduler.h"//------------------------------------------------------------------------------namespace dvd { namespace vm {class TargetPosition;//------------------------------------------------------------------------------/** * The Virtual Machine processor. */class Processor{private:    /**     * Evaluate the given comparison     */    static bool evaluateComparison(Instruction::cmpOp_t cmpOp,                                   unsigned value1, unsigned value2);private:    /**     * The state of the virtual machine.     */    State state;    /**     * The instruction scheduler.     */    Scheduler scheduler;    /**     * The number of branches since the last query of this value.     */    unsigned numberOfBranches;public:    /**     * Construct the processor.     */    Processor(DVD* dvd);    /**     * Construct a processor with the given initial state.     */    Processor(const State& state);    /**     * Copy the given processor.     */    Processor(const Processor& other);    /**     * Get the current position.     */    const Position& getPosition() const;    /**     * Get the System Parameter Register file.     */    const SPRM& getSPRM() const;    /**     * Get the state of the processor.     */    const State& getState() const;    /**     * Set the processor's state to the given state.     */    void setState(const State& s);    /**     * Get the physical audio stream number based on the current     * position and register contents. If an audio language is forced,     * a suitable stream is searched for. If not forced or found, the     * ASTN register's value will be used to find a stream.     *     * @param logicalStream will contain the logical stream number for     * the stream found.     */    unsigned getAudioStreamNumber(unsigned& logicalStream) const;    /**     * Get the physical audio stream number (see getAudioStreamNumber(unsigned)).     */    unsigned getAudioStreamNumber() const;    /**     * Get the physical SPU stream number based on the current     * position and register contents. If an SPU language is forced,     * a suitable stream is searched for. If not forced or found, the     * SPSTN register's value will be used to find a stream.     *     * @param forcedOnly will be set to indicate that only forced SPUs     * are to be shown.     */    unsigned getSPUStreamNumber(aspectRatio_t aspectRatio,                                displayFormat_t displayFormat,                                bool& forcedOnly) const;    /**     * Reset the processor.     */    void reset();    /**     * Go to the first play PGC and start that.     */    void executeFirstPlayPGC();    /**     * Set the sector number.     */    void setSectorNumber(size_t sectorNumber);    /**     * Set the highlighted button number.     */    void setHighlightedButtonNumber(size_t buttonNo);    /**     * Finish the current cell and go to the next one.     *     * @return if there was a next cell. If not, the processor jumps     * to the first play PGC     */    bool nextCell(unsigned& stillTime);    /**     * Go to the previous cell. Cell commands are not played, neither     * are PGC post and pre commands.     *     * @return if there was a previous cell. If not, the position     * remains where it was     */    bool previousCell();    /**     * Enter the next program.     *     * @return if there was a next program and it was valid.     */    bool nextProgram();    /**     * Enter the previous program.     *     * @return if there was a previous program and it was valid.     */    bool previousProgram();    /**     * Repeat the current program.     *     * @return if the current program could be repeated     */    bool repeatProgram();    /**     * Enter the menu with the given ID.     *     * @param forced if true, and the current VTS does not have a menu     *               with the given ID, it will be searched for     *     * @return if the menu exists and it was entered     */    bool enterMenu(unsigned menuID, bool forced = false);    /**     * Go to the next angle.     *     * @return if there was a next angle and it was entered     */    bool nextAngle();    /**     * "Select" the next audio stream.     *     * @param reversed if true, the previous ("next in reversed     * order") audio stream will be selected     *     * @return if there was a next stream     */    bool nextAudioStream(bool reversed);    /**     * "Select" the next subpicture stream.     *     * @param reversed if true, the previous ("next in reversed     * order") subpicture stream will be selected     *     * @return if there was a next stream     */    bool nextSPUStream(bool reversed);    /**     * Execute the given instructions and any others that follow from     * them.     *     * @return if there was some jump during the execution of the     * instruction set.     */    void execute(const Instruction* instruction, size_t length = 1);    /**     * Clear the branch counter.     */    void clearBranches();    /**     * Determine if there have been any branches since queried last     * time.     */    bool hasBranched();private:    /**     * Map the given logical audio stream number to the corresponding     * physical stream number, and check if it matches the given     * language code. If found, set <tt>candidate</tt> to the physical     * stream number, unless it is already set. If it matches the     *  language code, return it, otherwise PGC::INVALID_STREAM_NUMBER.     *      * @param languageCode the 2-byte language code. If 0xffff, the     * language will fit     * @param ifo this is passed to avoid looking it up several times     * @param pgc this is passed to avoid looking it up several times     */    unsigned mapAudioStreamNumber(unsigned streamNo, unsigned languageCode,                                  const IFO* ifo, PGC pgc,                                  unsigned& candidate) const;    /**     * Map the given logical SPU stream number to the corresponding     * physical stream number, and check if it matches the given     * language code. If found, set <tt>candidate</tt> to the physical     * stream number, unless it is already set. If it matches the     * language code, return it, otherwise PGC::INVALID_STREAM_NUMBER.     *      * @param ifo this is passed to avoid looking it up several times     * @param pgc this is passed to avoid looking it up several times     * @param languageCode the 2-byte language code. If 0xffff, the     * language will fit     */    unsigned mapSPUStreamNumber(unsigned streamNo,                                 aspectRatio_t aspectRatio,                                displayFormat_t displayFormat,                                unsigned languageCode,                                const IFO* ifo, PGC pgc,                                unsigned& candidate) const;        /**     * Set the position to the given one.     */    void setPosition(const Position& position);    /**     * Process the given instruction and determine what to do next.     */    void process(const Instruction* instruction);    /**     * Execute the given special instruction     */    void executeSpecial(const Instruction* instruction);    /**     * Execute the given branch (link, jump or call) instruction     */    void executeBranch(const Instruction* instruction);    /**     * Execute the given link instruction.     */    void executeLink(const Instruction* instruction);    /**     * Execute the given link instruction without checking the conditions.     */    void executeLinkUnconditionally(const Instruction* instruction);    /**     * Link to the previous cell, i.e. set up the given target     * position to go to the previous cell, if any     *     * This has its own method, because it is used both by     * executeLinkSubset() and previousCell().     *     * @return if there was a previous cell, i.e. either one in the     * current PGC, or in a previous PGC      */    bool linkPreviousCell(TargetPosition& targetPosition);    /**     * Execute the given instruction if it is a link subset     * instruction.     */    void executeLinkSubset(const Instruction* instruction);    /**     * Execute the given jump or call instruction.     */    void executeJumpCall(const Instruction* instruction);    /**     * Execute a JumpSS or CallSS instruction.     */    void executeJumpCallSS(const Instruction* instruction,                            bool isJump);    /**     * Execute a JumpSS instruction.     */    void executeJumpSS(const Instruction* instruction);    /**     * Execute a CallSS instruction.     */    void executeCallSS(const Instruction* instruction);    /**     * Execute the given system register setting instruction     */    void executeSetSysReg(const Instruction* instruction);    /**     * Execute the given set instruction     */    void executeSet(const Instruction* instruction);    /**     * Execute the set operation in the instruction     */    bool executeSet(const Instruction* instruction,                     GPR& destRegister,                    unsigned sourceValue, Register* sourceRegister);    /**     * Execute the given set & conditional link instruction     */    void executeSetCLnk(const Instruction* instruction);    /**     * Execute the given set instruction, which is one combined with a     * (conditional) link instruction.     */    bool executeSetWithLink(const Instruction* instruction);    /**     * Execute the given conditional set & condition link instruction     */    void executeCSetCLnk(const Instruction* instruction);    /**     * Execute the given compare & set & link instruction     */    void executeCmpSetLnk(const Instruction* instruction);    /**     * Evaluate the condition version 1. This takes register 1 from     * operand 1 and register 2/constant from operand 2.     */    bool evaluateConditionV1(const Instruction* instruction) const;    /**     * Evaluate the condition version 2. This takes register 1 and 2 from     * operand 3.     */    bool evaluateConditionV2(const Instruction* instruction) const;    /**     * Evaluate the condition version 2. This takes register 1 form     * operand 1 and register / value 2 from operand 3.     */    bool evaluateConditionV3(const Instruction* instruction) const;    /**     * Evaluate the condition version 2. This takes register 1 form     * the instruction (from the CMD field) and register / value 2 from operand 2.     */    bool evaluateConditionV4(const Instruction* instruction) const;    /**     * Evaluate the condition of a special instruction.     */    bool evaluateSpecialCondition(const Instruction* instruction) const;    /**     * Evaluate the condition of a link instruction     */    bool evaluateLinkCondition(const Instruction* instruction) const;    /**     * Evaluate the condition of a jump/call instruction     */    bool evaluateJumpCallCondition(const Instruction* instruction) const;    /**     * Evaluate the condition of a set system register instruction     */    bool evaluateSetSysRegCondition(const Instruction* instruction) const;    /**     * Evaluate the condition of a set instruction     */    bool evaluateSetCondition(const Instruction* instruction) const;    /**     * Evaluate the condition of a set with a conditional link instruction     */    bool evaluateSetCLnkCondition(const Instruction* instruction) const;    /**     * Evaluate the condition of a conditional set with a conditional     * link instruction     */    bool evaluateCSetCLnkCondition(const Instruction* instruction) const;    /**     * Evaluate the condition of a compare, set and link instruction.     */    bool evaluateCmpSetLnkCondition(const Instruction* instruction) const;    friend class Scheduler;};//------------------------------------------------------------------------------// Inline definitions//------------------------------------------------------------------------------inline Processor::Processor(const State& state) :    state(state),    scheduler(*this),    numberOfBranches(0){}//------------------------------------------------------------------------------inline Processor::Processor(const Processor& other) :    state(other.state),    scheduler(*this),    numberOfBranches(0){}//------------------------------------------------------------------------------inline unsigned Processor::getAudioStreamNumber() const{    unsigned logicalStream;    return getAudioStreamNumber(logicalStream);}//------------------------------------------------------------------------------inline const Position& Processor::getPosition() const{    return state.getPosition();}//------------------------------------------------------------------------------inline const SPRM& Processor::getSPRM() const{    return state.getSPRM();}//------------------------------------------------------------------------------inline const State& Processor::getState() const{    return state;}//------------------------------------------------------------------------------inline void Processor::setState(const State& s){    state = s;}//------------------------------------------------------------------------------inline void Processor::setSectorNumber(size_t sectorNumber){    state.setSectorNumber(sectorNumber);}//------------------------------------------------------------------------------inline void Processor::setHighlightedButtonNumber(size_t buttonNo){    state.setHighlightedButtonNumber(buttonNo);}//------------------------------------------------------------------------------} /* namespace dvd::vm */ } /* namespace dvd *///------------------------------------------------------------------------------#endif // DXR3PLAYER_DVD_VM_PROCESSOR_H// Local variables:// mode: c++// End: