buffer.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 "Buffer.h"
#include "Control.h"
#include "SectorProxy.h"
#include "SectorPacket.h"

#include "sched/Scheduler.h"

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

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

using dvd::reader::Buffer;

using dvd::demux::Sector;

using dvd::packet::PacketQueue;
using dvd::packet::Packet;

using sched::Scheduler;

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

Buffer::Buffer() :
    size(Config::get().readerBufferSize),
    sectors(new Sector[size]),
    sectorDescriptors(new SectorDescriptor[size]),
    sectorProxies(new SectorProxy[size]),
    firstFreeSector(0),
    numFreeSectors(size),
    numRequestedSectors(0),
    sectorsAvailable("dvd::reader::Buffer", "sectorsAvailable")
{
    Log::debug("dvd::reader::Buffer::Buffer: size=%u\n", size);

    for(size_t i = 0; i<size; ++i) {
        sectorProxies[i].setIndex(this, i);
    }
}

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

Buffer::~Buffer() 
{
    delete[] sectorDescriptors;
    delete[] sectors;
}

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

Sector* Buffer::requestForReading(size_t& numSectors)
{
    assert(numSectors>0);
    assert(numRequestedSectors==0);
    
    size_t maxFree = size - firstFreeSector;
    if (numSectors>maxFree) numSectors = maxFree;

    if (numSectors>numFreeSectors) {
        numRequestedSectors = numSectors;
        Scheduler::waitInterruptible(sectorsAvailable);
        numRequestedSectors = 0;
    }
    
    if (!Scheduler::isInterrupted() && numSectors<=numFreeSectors) {
        return markForReading(numSectors);
    } else {
        return 0;
    }
}

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

void Buffer::discardRead(Sector* sectors, size_t numSectors)
{
    assert(numSectors>0);
    
    size_t sectorIndex = getIndexOf(sectors);

    size_t nextSector = sectorIndex + numSectors;
    
    assert( nextSector==firstFreeSector ||
            (nextSector==size && firstFreeSector==0));
        
    for(size_t i = sectorIndex; i<nextSector; ++i) {
        sectorDescriptors[i].discardRead();
    }
    
    if (nextSector==firstFreeSector) {
        nextSector = firstFreeSector + numFreeSectors;
    }
    
    firstFreeSector = sectorIndex;
    numFreeSectors  = nextSector - firstFreeSector;
}

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

void Buffer::makeAvailable(PacketQueue& queue,
                           Sector* sectors, size_t numSectors)
{
    assert(numSectors>0);

    size_t sectorIndex = getIndexOf(sectors);

    assert((sectorIndex + numSectors)<=size);

    for(size_t i = 0; i<numSectors && !Scheduler::isInterrupted(); ++i) {
        SectorDescriptor& sectorDescriptor =
            sectorDescriptors[sectorIndex+i];
        
        sectorDescriptor.markForProcessing();
        bool couldPut = 
            queue.put(new SectorPacket(sectorProxies + sectorIndex + i));
        if (!couldPut) {
            assert(0);
        }
    }
}

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

void Buffer::checkRequest()
{
    if (numRequestedSectors>0 && numRequestedSectors<=numFreeSectors) {
        sectorsAvailable.set();
    }
}

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

void Buffer::checkFreeSectors()
{
    assert(firstFreeSector<=size);

    if (firstFreeSector==size) {
        assert(numFreeSectors==0);
        firstFreeSector = 0;
    }

    size_t i = firstFreeSector + numFreeSectors;
    for(; i<size && sectorDescriptors[i].isFree(); ++i);
    numFreeSectors = i - firstFreeSector;

    checkRequest();
}

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

Sector* Buffer::markForReading(size_t n)
{
    assert(n<=numFreeSectors);

    Sector* firstSector = sectors + firstFreeSector;
    
    for(size_t i = 0; i<n; ++i, ++firstFreeSector, --numFreeSectors) {
        sectorDescriptors[firstFreeSector].markForReading();
    }

    checkFreeSectors();

    return firstSector;
}

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

void Buffer::addReference(size_t index)
{
    assert(index<size);
    
    sectorDescriptors[index].addReference();
}

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

void Buffer::removeReference(size_t index)
{
    assert(index<size);

    if (sectorDescriptors[index].removeReference()) {
        checkFreeSectors();
    }
}

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