control.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 "Control.h"
#include "ReaderListener.h"

#include "dvd/packet/AVAttributesPacket.h"
#include "dvd/packet/SPUPalettePacket.h"
#include "dvd/packet/DemultiplexerParameterPacket.h"
#include "dvd/packet/StillPacket.h"
#include "dvd/packet/ProcessorUpdatePacket.h"
#include "dvd/packet/PlayModePacket.h"

#include "dvd/DVD.h"

#include "sched/Scheduler.h"

#include "util/Util.h"
#include "util/Log.h"
#include "util/Config.h"

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

using dvd::reader::Control;

using dvd::demux::Sector;
using dvd::demux::GeneralHighlightInformation;
using dvd::demux::DSI;

using dvd::packet::PacketQueue;
using dvd::packet::AVAttributesPacket;
using dvd::packet::SPUPalettePacket;
using dvd::packet::DemultiplexerParameterPacket;
using dvd::packet::StillPacket;
using dvd::packet::ProcessorUpdatePacket;
using dvd::packet::PlayModePacket;
using dvd::packet::CommandExecutor;

using dvd::vm::ProcessorCommandQueue;
using dvd::vm::ProcessorCommand;
using dvd::vm::Position;
using dvd::vm::State;
using dvd::vm::SPRM;

using sched::Scheduler;

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

Control::Control(DVD& dvd, 
                 ProcessorCommandQueue& processorCommandQueue,
                 PacketQueue& outputQueue) :
    Schedulable("dvd::reader::Control"),
    thread(dvd),
    processorHandler(processorCommandQueue, &dvd),
    outputQueue(outputQueue),
    listener(0),
    playing(false),
    playMode(FORWARD),
    toPause(false),
    toBranch(false),
    toEject(false),
    stateChanged(false),
    fast2Offset(Config::get().fast2Offset),
    fast3Offset(Config::get().fast3Offset)
{
}

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

void Control::run()
{
    playing = false;
    bool toContinue = true;

    thread.start();

    while(!shouldQuit() && toContinue) {
        stateChanged = false;
        clearInterrupt();
        
        playing = false;
        openDVD();
        if (!isInterrupted()) {
            playing = true;
            toContinue = readDVD();
            if (!toContinue) {
                outputQueue.flush();
                Log::debug("dvd::reader::Control: quitting due to DVD EXIT\n");
            }
        }
        
        if (thread.getDVD().isOpen()) {
            thread.close();
        }

        if (isInterrupted()) {
            if (toEject) {

                if (playing && listener!=0) listener->ejectingDVD();

                thread.eject();
                toEject = false;
            }
        }
    }

    thread.stop();
}

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

void Control::printStatus() const
{
    Log::debug("  buffer: first free sector: %u, # of free sectors: %u\n", 
               buffer.getFirstFreeSector(), buffer.getNumFreeSectors());
    Statistics& s = Statistics::get();
    Log::debug("  number of free sectors: %u\n", s.numFreeSectors);
    Log::debug("  number of sectors being read: %u\n", s.numReadingSectors);
    Log::debug("  number of sectors being processed: %u\n", s.numProcessingSectors);
    Log::debug("  number of audio packets: %u\n", s.numAudioPackets);
    Log::debug("  number of video packets: %u\n", s.numVideoPackets);
}

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

void Control::quit()
{
    outputQueue.reset();
    processorHandler.reset();
}

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

void Control::setState(const dvd::vm::State& vmState)
{
    if (playing) {
        processorHandler.setState(vmState);
        stateChanged = true;
    }
}

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

void Control::branch(const State& vmState, playMode_t pm)
{
    if (playing) {
        outputQueue.reset();
        processorHandler.reset();

        toBranch = true;
        playMode = pm;
        processorHandler.branch(vmState);
        
        interrupt();
    }
}

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

void Control::pause(const State& vmState)
{
    if (playing) {
        outputQueue.reset();
        processorHandler.reset();

        toPause = true;
        playMode = FORWARD;
        processorHandler.branch(vmState);
        
        interrupt();
    }
}

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

void Control::resume()
{
    if (playing) {
        interrupt();
    }
}

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

void Control::eject()
{
    outputQueue.reset();
    processorHandler.reset();

    toEject = true;
    interrupt();
}

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

size_t Control::getVOBULength() const
{
    size_t length = 0;

    switch(playMode) {
      case FAST_FORWARD_1:
      case FAST_BACKWARD_1:
//         length = dsi.getVOBUThirdRefLength();
//         if (length>0) return length;
      case FAST_FORWARD_2:
      case FAST_BACKWARD_2:
//         length = dsi.getVOBUSecondRefLength();
//         if (length>0) return length;
      case FAST_FORWARD_3:
      case FAST_BACKWARD_3:
        length = dsi.getVOBUFirstRefLength();
        if (length>0) return length;
      case FORWARD:
        return dsi.getVOBULength();
      default:
        assert(0);
        return 0;
    }
}

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

bool Control::doesNextVOBUFollow() const
{
    if (playMode==FORWARD) return dsi.doesNextVOBUFollow();
    else return false;
}


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

bool Control::getNextVOBUSector(size_t& sectorNo) const
{
    unsigned angleNumber = 
        processorHandler.getSPRM().getValue(SPRM::angleNumber);
    
    switch(playMode) {
      case FORWARD:
      case FAST_FORWARD_1:
        if (pci.hasNextVOBU(angleNumber)) {
            sectorNo = pci.getNextVOBUSector(angleNumber);
        } else if (dsi.hasNextVOBU(angleNumber)) {
            sectorNo = dsi.getNextVOBUSector(angleNumber);
        } else if (dsi.hasNextVOBU()) {
            sectorNo = dsi.getNextVOBUSector();
        } else return false;
        return true;
      case FAST_FORWARD_2:
        if (!dsi.hasNextVOBU(fast2Offset)) return false;
        sectorNo = dsi.getNextVOBUSector(fast2Offset);
        return true;
      case FAST_FORWARD_3:
        if (!dsi.hasNextVOBU(fast3Offset)) return false;
        sectorNo = dsi.getNextVOBUSector(fast3Offset);
        return true;
      default:
        assert(0);
    }

    return false;
}

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

bool Control::getPreviousVOBUSector(size_t& sectorNo) const
{
    switch(playMode) {
      case FAST_BACKWARD_1:
        if (!dsi.hasPreviousVOBU()) return false;
        sectorNo = dsi.getPreviousVOBUSector();
        return true;
        break;
      case FAST_BACKWARD_2:
        if (!dsi.hasPreviousVOBU(fast2Offset)) return false;
        sectorNo = dsi.getPreviousVOBUSector(fast2Offset);
        return true;
        break;
      case FAST_BACKWARD_3:
        if (!dsi.hasPreviousVOBU(fast3Offset)) return false;
        sectorNo = dsi.getPreviousVOBUSector(fast3Offset);
        return true;
        break;
      default:
        assert(0);
    }

    return false;
}

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

void Control::insertAVAttributesPacket()
{
    if (isInterrupted()) return;

    AVAttributesPacket* avAttributesPacket = new AVAttributesPacket();

    processorHandler.
        getStreamAttributes(avAttributesPacket->getAttributes());

    outputQueue.put(avAttributesPacket);

    stateChanged = false;
}

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

void Control::insertSPUPalettePacket()
{
    if (isInterrupted()) return;

    SPUPalettePacket* spuPalettePacket = new SPUPalettePacket();

    processorHandler.getSPUPalette(spuPalettePacket->getPalette());

    outputQueue.put(spuPalettePacket);
}

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

void Control::insertDemultiplexerParameterPacket()