sectordemultiplexer.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 "SectorDemultiplexer.h"

#include "Sector.h"
#include "Extension.h"
#include "StreamProcessor.h"

#include "util/Log.h"

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

using dvd::demux::SectorDemultiplexer;

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

SectorDemultiplexer::
SectorDemultiplexer(StreamProcessor& streamProcessor) :
    streamProcessor(streamProcessor)
{
}

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

void SectorDemultiplexer::demultiplex(const Sector& sector)
{
    demultiplex(sector.getData());
}

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

void SectorDemultiplexer::demultiplex(const unsigned char* data)
{
    static const unsigned char startCode[3] = { 0x00, 0x00, 0x01 };

    SectorBitReader reader(data);

    size_t startCounter = 0;
    
    while( reader.available() ) {
    
        if (startCounter==sizeof(startCode)) {
            demultiplexPESPacket(reader);
            startCounter = 0;
        } else {
            unsigned char b = reader.read();

            if (b == startCode[startCounter]) {
                ++startCounter;
            } else if (startCounter!=2 || b!=0) {
                startCounter = 0;
            }
        }
    }
}

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

void SectorDemultiplexer::demultiplexPESPacket(SectorBitReader& reader)
{
    unsigned char streamID = reader.read();

    if (streamID==PESID_PACK_HEADER) {
        demultiplexPackHeader(reader);
    } else if (streamID==PESID_SYSTEM_HEADER) {
        demultiplexSystemHeader(reader);
    } else if (streamID == PESID_PRIVATE1) {
        demultiplexPrivate1(reader);
    } else if (streamID == PESID_PADDING) {
        demultiplexPadding(reader);
    } else if (streamID == PESID_PRIVATE2) {
        demultiplexPrivate2(reader);
    } else if (streamID >= PESID_MPEG_AUDIO_FIRST &&
               streamID <= PESID_MPEG_AUDIO_LAST) {
        demultiplexMPEGAudio(reader, streamID);
    } else if (streamID >= PESID_MPEG_VIDEO_FIRST &&
               streamID <= PESID_MPEG_VIDEO_LAST) {
        demultiplexMPEGVideo(reader, streamID);
    } else {
        Log::debug("dvd::demux::SectorDemultiplexer::demultiplexPESPacket: unhandled stream ID: 0x%02x!\n", (unsigned)streamID);
        reader.skip(reader.getLength());
    }
    
}

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

void SectorDemultiplexer::demultiplexPackHeader(SectorBitReader& reader)
{
    reader.skip(10);
}
//------------------------------------------------------------------------------

void SectorDemultiplexer::
demultiplexSystemHeader(SectorBitReader& reader)
{
    size_t length = reader.read16();
    reader.skip(length);
}

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

void SectorDemultiplexer::
demultiplexPrivate1(SectorBitReader& reader)
{
    size_t length = reader.read16();
   
    Extension extension(reader);
    length -= extension.getLength();

    unsigned char subStreamID = reader.read();
    --length;
    
    if ( (subStreamID&0xe0)==0x20 ) {
        unsigned spuStreamNumber = subStreamID&0x1f;
        streamProcessor.processSPU(extension, spuStreamNumber,
                                   reader, length);
    } else if ( subStreamID>=0x80 && subStreamID<=0x87) {
        reader.skip(3); length -= 3;
        unsigned audioStreamNumber = subStreamID&0x07;
//         Log::debug("dvd::demux::SectorDemultiplexer::demultiplexPrivate1: AC-3 packet of stream #%u\n", subStreamID);
        streamProcessor.processAC3Audio(extension, audioStreamNumber,
                                        reader, length);
    } else if ( subStreamID>=0x88 && subStreamID<=0x8f) {
        unsigned audioStreamNumber = subStreamID&0x07;
//         Log::debug("dvd::demux::SectorDemultiplexer::demultiplexPrivate1: DTS packet of stream #%u\n", subStreamID);
        streamProcessor.processDTSAudio(extension, audioStreamNumber,
                                        reader, length);
    } else if (subStreamID>=0xa0 && subStreamID<0xa8) {
        unsigned audioStreamNumber = subStreamID&0x07;
//         Log::debug("dvd::demux::SectorDemultiplexer::demultiplexPrivate1: LPCM packet of stream #%u\n", subStreamID);
        streamProcessor.processLPCMAudio(extension, audioStreamNumber,
                                         reader, length);
    } else {
//         Log::debug("dvd::demux::SectorDemultiplexer::demultiplexPrivate1: unhandled substream: 0x%02x\n",
//                    subStreamID);
        reader.skip(length);
    }
}

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

void SectorDemultiplexer::
demultiplexPadding(SectorBitReader& reader)
{
    size_t length = reader.read16();
    reader.skip(length);
}

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

void SectorDemultiplexer::
demultiplexPrivate2(SectorBitReader& reader)
{
    size_t length = reader.read16();

    unsigned char subStreamID = reader.read();
    --length;

    switch(subStreamID) {
      case PRIVATE2_PCI:
        streamProcessor.processPCI(reader, length);
        break;
      case PRIVATE2_DSI:
        streamProcessor.processDSI(reader, length);
        break;
      default:
        Log::debug("dvd::demux::SectorDemultiplexer::demultiplexPrivate2: unhandled substream: 0x%02x\n",
                   subStreamID);
        reader.skip(length);
        break;
    }
}
    
//------------------------------------------------------------------------------

void SectorDemultiplexer::
demultiplexMPEGAudio(SectorBitReader& reader, unsigned char streamID)
{
    unsigned audioStreamNumber = streamID - PESID_MPEG_AUDIO_FIRST;

    size_t length = reader.read16();

    Extension extension(reader);
    length -= extension.getLength();

//     Log::debug("dvd::demux::SectorDemultiplexer::demultiplexMPEGAudio: MPEG packet of stream #%u\n", streamID);

    streamProcessor.processMPEGAudio(extension, audioStreamNumber,
                                     reader, length);
}

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

void SectorDemultiplexer::
demultiplexMPEGVideo(SectorBitReader& reader, unsigned char streamID)
{
    size_t length = reader.read16();
    
    if (streamID==PESID_MPEG_VIDEO_FIRST) {
        // FIXME: find out, which stream number should be used...
        Extension extension(reader);
        length -= extension.getLength();

        streamProcessor.processVideo(extension, reader, length);
    } else {
        reader.skip(length);
    }
}

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