testoutputprocessor.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 "TestOutputProcessor.h"

#include "dvd/packet/PacketQueue.h"
#include "dvd/packet/TimedDataBlockPacket.h"

#include "sched/Scheduler.h"

#include "util/Log.h"
#include "util/POSIX.h"

#include <linux/soundcard.h>

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

using output::TestOutputProcessor;
using output::OutputProcessor;

using dvd::packet::PacketQueue;
using dvd::packet::TimedDataBlockPacket;

using dvd::vm::State;

using sched::Scheduler;

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

TestOutputProcessor::TestOutputProcessor(PacketQueue& inputQueue) :
    OutputProcessor("output::TestOutputProcessor"),
    inputQueue(inputQueue),
    dsp(POSIX::open("/dev/dsp", O_NONBLOCK|O_RDWR)),
    dspAvailable("output::TestOutputProcessor", "dspAvailable", dsp)
{
    int speed = 48000;
    int stereo = 1;
    int format = AFMT_S16_LE;

    POSIX::ioctl(dsp, SNDCTL_DSP_SPEED, &speed);
    POSIX::ioctl(dsp, SNDCTL_DSP_STEREO, &stereo);
    POSIX::ioctl(dsp, SNDCTL_DSP_SETFMT, &format);
}

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

TestOutputProcessor::~TestOutputProcessor()
{
    POSIX::close(dsp);
}

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

void TestOutputProcessor::run()
{
    while(!shouldQuit()) {
        clearInterrupt();

        Reference<TimedDataBlockPacket> packet = 
            TimedDataBlockPacket::convert(inputQueue.get());
        if (!packet.isValid()) continue;

        decodeAudio(packet);
    }
}

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

void TestOutputProcessor::reset()
{
//     decoder.reset();

    interrupt();
}

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

unsigned TestOutputProcessor::volumeReset()
{
//     decoder.setOutputLevel(AC3Decoder::defaultOutputLevel);
//     return AC3Decoder::defaultOutputLevel;
    return 0;
}

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

unsigned TestOutputProcessor::volumeUp()
{
//     unsigned level = decoder.getOutputLevel() ;
//     if (level<=95) level += 5; else level = 100;
    
//     decoder.setOutputLevel(level);

//     return level;
    return 0;
}

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

unsigned TestOutputProcessor::volumeDown()
{
//     unsigned level = decoder.getOutputLevel();
//     if (level>=5) level -= 5; else level = 0;
    
//     decoder.setOutputLevel(level);

//     return level;
    return 0;
}

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

bool TestOutputProcessor::toggleAudio()
{
    return 0;
}

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

void TestOutputProcessor::decodeAudio(Reference<TimedDataBlockPacket> packet)
{
    const unsigned char* data = packet->getData();
    size_t length = packet->getLength();

//     const unsigned char* end = data + length;

    size_t offset = 0;
    while(!isInterrupted() && offset<length) {
        const unsigned char* start = data + offset;
        
//         bool hasFrame = decoder.decode(start, end);
        
        offset = start - data;
        
//         if (hasFrame) {
// //             write(reinterpret_cast<const char*>(decoder.getOutput()), 
// //                   decoder.getOutputLength());
//         }
    }
}

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

void TestOutputProcessor::write(const char* data, size_t length)
{
    size_t offset = 0;
    while(!isInterrupted() && offset<length) {
        offset += POSIX::write(dsp, data + offset, length - offset);
        Scheduler::waitInterruptible(dspAvailable);
    }
}

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

OutputProcessor::processorChange_t 
TestOutputProcessor::handleOperation(input::InputListener::operation_t /*operation*/,
                                     dvd::vm::State& /*processorState*/)
{
    return NONE;
}

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

const State& TestOutputProcessor::getVMState()
{
    return *(State*)0;
}

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

void TestOutputProcessor::toggleOutput()
{
}

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