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 "DemultiplexerQueue.h"
#include "PCI.h"
#include "Extension.h"
#include "Sector.h"

#include "dvd/packet/DataBlockPartPacket.h"
#include "dvd/packet/TimedDataBlockPartPacket.h"
#include "dvd/packet/AVAttributesPacket.h"
#include "dvd/packet/DemultiplexerParameterPacket.h"
#include "dvd/packet/StillPacket.h"
#include "dvd/packet/TimedCommandPacket.h"
#include "dvd/packet/SPUPalettePacket.h"
#include "dvd/packet/PlayModePacket.h"
#include "dvd/packet/DataBlockTypes.h"

#include "sched/Scheduler.h"

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

using dvd::demux::Control;
using dvd::demux::PCI;

using dvd::packet::DataBlockType;
using dvd::packet::DataBlockTypes;
using dvd::packet::Packet;
using dvd::packet::DataBlockPacket;
using dvd::packet::DataBlockPartPacket;
using dvd::packet::TimedDataBlockPartPacket;
using dvd::packet::AVAttributesPacket;
using dvd::packet::DemultiplexerParameterPacket;
using dvd::packet::StillPacket;
using dvd::packet::TimedCommandPacket;
using dvd::packet::SPUPalettePacket;
using dvd::packet::PlayModePacket;
using dvd::packet::PacketQueue;
using dvd::packet::PacketProcessor;

using sched::Scheduler;

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

Control::Control(PacketQueue& inputQueue, PacketQueue& outputQueue) :
    Schedulable("dvd::demux::Control", defaultStackSize, 32),
    sectorDemultiplexer(*this),
    inputQueue(inputQueue),
    outputQueue(outputQueue),
    playMode(FORWARD)
{
}

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

void Control::reset()
{
    outputQueue.reset();
    interrupt();
}

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

void Control::run()
{
    while(!shouldQuit()) {
        clearInterrupt();
        
        Reference<Packet> packet = inputQueue.get();
        if (packet.isValid()) {
            packet->processOn(*this);
        }

        if (!isInterrupted()) {
            Scheduler::continueBurst("dvd::demux::Control::run");
        }

        if (isInterrupted()) {
            playMode = FORWARD;
        }
    }

    // This is needed to eliminate all references to buffer sectors
    outputQueue.reset();
    inputQueue.reset();
}

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

void Control::printStatus() const
{
    Log::debug("  size of inputQueue: %u\n", inputQueue.getSize());
    Log::debug("  size of outputQueue: %u\n", outputQueue.getSize());
}   

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

void Control::processPacket(Reference<DataBlockPacket> packet)
{
    assert(packet->isOfType(DataBlockTypes::sector));

    currentDataBlockPacket = packet;
    
    sectorDemultiplexer.demultiplex(packet->getData());

    currentDataBlockPacket = 0;
}

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

void Control::processPacket(Reference<AVAttributesPacket> packet)
{
//     Log::debug("dvd::demux::Control::processPacket(AVAttributesPacket): encoding: %d, sample rate: %u, # of channels: %u\n",
//                (int)packet->getAttributes().audio.encoding,
//                packet->getAttributes().audio.sampleRate,
//                packet->getAttributes().audio.numberOfChannels);
    outputQueue.put(packet);
}

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

void Control::processPacket(Reference<TimedCommandPacket> packet)
{
    outputQueue.put(packet);
}

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

void Control::processPacket(Reference<SPUPalettePacket> packet)
{
    outputQueue.put(packet);
}

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

void Control::processPacket(Reference<dvd::packet::PlayModePacket> packet)
{
    playMode=packet->getPlayMode();
    outputQueue.put(packet);
}

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

void Control::
processPacket(Reference<DemultiplexerParameterPacket> packet)
{
    parameters = packet->parameters;
//     Log::debug("dvd::demux::Control::processPacket(DemultiplexerParameterPacket): audio stream #=%u\n",
//                parameters.audioStreamNumber);
    outputQueue.put(packet);
    // FIXME: we should probably not forward the complete packet
}

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

void Control::
processPacket(Reference<StillPacket> packet)
{
    outputQueue.put(packet);
}

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

void Control::processPCI(SectorBitReader& reader, size_t length)
{
    outputQueue.put(new DataBlockPartPacket(DataBlockTypes::pci,
                                            currentDataBlockPacket,
                                            reader.getOffset(),
                                            length));

    reader.skip(length);
}

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

void Control::processAC3Audio(const Extension& extension, unsigned audioStreamNo,
                              SectorBitReader& reader, size_t length)
{
    if (audioStreamNo==parameters.audioStreamNumber &&
        playMode==FORWARD) 
    {
        processCurrentPacket(DataBlockTypes::ac3Audio, extension, reader, length);
    }
    reader.skip(length);
}

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

void Control::processMPEGAudio(const Extension& extension, unsigned audioStreamNo,
                               SectorBitReader& reader, size_t length)
{
    if (audioStreamNo==parameters.audioStreamNumber && 
        playMode == FORWARD) 
    {
        processCurrentPacket(DataBlockTypes::mpegAudio, extension, reader, length);
    }
    reader.skip(length);
}

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

void Control::processLPCMAudio(const Extension& extension, unsigned audioStreamNo,
                               SectorBitReader& reader, size_t length)
{
    if (audioStreamNo==parameters.audioStreamNumber && 
        playMode == FORWARD) 
    {
        processCurrentPacket(DataBlockTypes::lpcmAudio, extension, reader, length);
    }

    reader.skip(length);
}

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

void Control::processDTSAudio(const Extension& extension, unsigned audioStreamNo,
                              SectorBitReader& reader, size_t length)
{
    if (audioStreamNo==parameters.audioStreamNumber && 
        playMode == FORWARD) 
    {
        processCurrentPacket(DataBlockTypes::dtsAudio, extension, reader, length);
    }

    reader.skip(length);
}

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

void Control::processVideo(const Extension& extension,
                           SectorBitReader& reader, size_t length)
{
    processCurrentPacket(DataBlockTypes::video,
                         extension, reader, length);
    reader.skip(length);
}

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

void Control::processSPU(const Extension& extension, unsigned spuStreamNo,
                         SectorBitReader& reader, size_t length)
    
{
    if (spuStreamNo==parameters.spuStreamNumber && 
        playMode==FORWARD)
    {
        processCurrentPacket(DataBlockTypes::spu,
                             extension, reader, length);
    }
    reader.skip(length);
}

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

void Control::processCurrentPacket(const dvd::packet::DataBlockType& type,
                                   const Extension& extension,
                                   SectorBitReader& reader, size_t length)
{
    TimedDataBlockPartPacket* packet = 
        new TimedDataBlockPartPacket(type, currentDataBlockPacket,
                                     reader.getOffset(),
                                     length, extension.getPTS());

    outputQueue.put(packet);
}

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