unichrome.cc

Linux下比较早的基于命令行的DVD播放器

void Unichrome::init3D()
{
    io.reg(Register::TRANSET) = 0x00010000;
    for(size_t i = 0; i<=0x7d; ++i) {
        io.reg(Register::TRANSPACE) = i<<24;
    }

    io.reg(Register::TRANSET) = 0x00020000;
    for(size_t i = 0; i<=0x94; ++i) {
        io.reg(Register::TRANSPACE) = i<<24;
    }
    io.reg(Register::TRANSPACE) = 0x82400000;

    io.reg(Register::TRANSET) = 0x01020000;
    for(size_t i = 0; i<=0x94; ++i) {
        io.reg(Register::TRANSPACE) = i<<24;
    }
    io.reg(Register::TRANSPACE) = 0x82400000;

    io.reg(Register::TRANSET) = 0xfe020000;
    for(size_t i = 0; i<=0x03; ++i) {
        io.reg(Register::TRANSPACE) = i<<24;
    }

    io.reg(Register::TRANSET) = 0x00030000;
    for(size_t i = 0; i<=0xff; ++i) {
        io.reg(Register::TRANSPACE) = 0;
    }

    io.reg(Register::TRANSET) = 0x00100000;
    io.reg(Register::TRANSPACE) = 0x00333004;
    io.reg(Register::TRANSPACE) = 0x10000002;
    io.reg(Register::TRANSPACE) = 0x60000000;
    io.reg(Register::TRANSPACE) = 0x61000000;
    io.reg(Register::TRANSPACE) = 0x62000000;
    io.reg(Register::TRANSPACE) = 0x63000000;
    io.reg(Register::TRANSPACE) = 0x64000000;
    
    io.reg(Register::TRANSET) = 0x00fe0000;
    io.reg(Register::TRANSPACE) = 0x40008c0f;

    io.reg(Register::TRANSPACE) = 0x44000000;
    io.reg(Register::TRANSPACE) = 0x45080c04;
    io.reg(Register::TRANSPACE) = 0x46800408;
    io.reg(Register::TRANSPACE) = 0x50000000;
    io.reg(Register::TRANSPACE) = 0x51000000;
    io.reg(Register::TRANSPACE) = 0x52000000;
    io.reg(Register::TRANSPACE) = 0x53000000;


    io.reg(Register::TRANSET) = 0x00fe0000;
    io.reg(Register::TRANSPACE) = 0x08000001;
    io.reg(Register::TRANSPACE) = 0x0a000183;
    io.reg(Register::TRANSPACE) = 0x0b00019f;
    io.reg(Register::TRANSPACE) = 0x0c00018b;
    io.reg(Register::TRANSPACE) = 0x0d00019b;
    io.reg(Register::TRANSPACE) = 0x0e000000;
    io.reg(Register::TRANSPACE) = 0x0f000000;
    io.reg(Register::TRANSPACE) = 0x10000000;
    io.reg(Register::TRANSPACE) = 0x11000000;
    io.reg(Register::TRANSPACE) = 0x20000000;
}

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

size_t Unichrome::setupV1(ssize_t sourceWidth, ssize_t sourceHeight, 
                          ssize_t realSourceWidth, ssize_t realSourceHeight,
                          ssize_t destX, ssize_t destY,
                          ssize_t destWidth, ssize_t destHeight)
{
//     Log::debug("sourceWidth=%d, realSourceWidth=%d, destWidth=%d\n", 
//                sourceWidth, realSourceWidth, destWidth);

    size_t baseOffset = 2 * getFrameBufferSize();
    
    io.reg(Register::HQV_CONTROL) = io.reg(Register::HQV_CONTROL) & ~Constant::HQV_ENABLE;

    size_t pitch = (sourceWidth + 15) & ~15;
    
    if (io.getRevision()>=0x10) {
        io.reg(Register::V_FIFO_CONTROL) = 
            //(32-1) | (28<<8) | (28<<24);
            (32-1) | (16<<8) | (29<<24);
    } else {
        io.reg(Register::V_FIFO_CONTROL) = 
            (16-1) | (12<<8) | (8<<24);
    }

    io.reg(Register::V1_WIN_START_Y) =
        (max(destX, 0)<<16) |
        (max(destY, 0));

    io.reg(Register::V1_WIN_END_Y) =
        ((min(destX + destWidth, sourceWidth)-1)<<16) |
        (min(destY + destHeight, sourceHeight)-1);
    
    if (useHQV) {
        io.reg(Register::V1_CONTROL) = 
            Constant::V1_EXPIRE_NUM |
            Constant::V1_COLORSPACE_SIGN |
            Constant::V1_ENABLE;

        if (!usingHWFlipping()) {
            io.reg(Register::V1_CONTROL) |= Constant::V1_SWAP_HW_HQV;
        }

        io.reg(Register::V12_QWORD_PER_LINE) = ((pitch*2)>>4)<<20;

        io.reg(Register::V1_STRIDE) = pitch*2;
    } else {
        io.reg(Register::V1_CONTROL) = 
            Constant::V1_EXPIRE_NUM |
            Constant::V1_BOB_ENABLE |
            Constant::V1_COLORSPACE_SIGN |
            Constant::V1_YUV_420 |
            Constant::V1_ENABLE;

        io.reg(Register::V12_QWORD_PER_LINE) = (pitch>>4)<<20;

        io.reg(Register::V1_STRIDE) = 
            ((pitch>>1)<<16) | pitch;
    }
        
    uint32_t mini = 0;
    uint32_t zoom = 0;
    uint32_t hqvFilter = 0;
    uint32_t hqvMinify = 0;
    uint32_t displayCount = 0;

    calculateHorizontalZoom(realSourceWidth, destWidth,
                            mini, displayCount, zoom, hqvFilter, hqvMinify);
    calculateVerticalZoom(realSourceHeight, destHeight,
                          mini, zoom, hqvFilter, hqvMinify);

//     Log::debug("unichrome::Unichrome: mini=0x%08x, zoom=0x%08x, hqvFilter=0x%08x, hqvMinify=0x%08x\n",
//                mini, zoom, hqvFilter, hqvMinify);
    
    io.reg(Register::V1_MINI_CONTROL) = mini;
    io.reg(Register::V1_ZOOM_CONTROL) = zoom;
    io.reg(Register::V_COLOR_KEY) = 0;
    
    io.reg(Register::V_ALPHA_CONTROL) = 0x00080000 | Constant::ALPHA_WIN_BLENDING_GRAPHIC;

    io.reg(Register::V1_COLORSPACE1) = 0x13000ded;
    io.reg(Register::V1_COLORSPACE2) = 0x13171000;

    io.reg(Register::V1_SOURCE_HEIGHT) = (sourceHeight<<16) | (sourceWidth-displayCount);

    if (useHQV) {
        size_t bufferSize = sourceWidth * 2 * sourceHeight;

        v1BufferOffsets[0] = baseOffset;

        io.reg(Register::V1_STARTADDR_Y0) = baseOffset;
        io.reg(Register::HQV_DST_STARTADDR0) = baseOffset;
        
        for(size_t i = 0; i<bufferSize; i+=2) {
            io.getFrameBuffer()[baseOffset+i+0] = 0x00;
            io.getFrameBuffer()[baseOffset+i+1] = 0x80;
        }

        baseOffset += bufferSize;

        v1BufferOffsets[1] = baseOffset;

        io.reg(Register::V1_STARTADDR_Y1) = baseOffset;
        io.reg(Register::HQV_DST_STARTADDR1) = baseOffset;

        for(size_t i = 0; i<bufferSize; i+=2) {
            io.getFrameBuffer()[baseOffset+i+0] = 0x00;
            io.getFrameBuffer()[baseOffset+i+1] = 0x80;
        }

        baseOffset += bufferSize;

        nextV1Buffer = 0;
    }

    io.reg(Register::V_COMPOSE_MODE) = Constant::V1_COMMAND_FIRE;

    if (useHQV) {
        io.reg(Register::HQV_SRC_STRIDE) = ((pitch>>1)<<16) | pitch;
        io.reg(Register::HQV_DST_STRIDE) = pitch<<1;
        io.reg(Register::HQV_SRC_FETCH_LINE) = (pitch<<16) | (sourceHeight-1);
        io.reg(Register::HQV_FILTER_CONTROL) = hqvFilter;
        io.reg(Register::HQV_MINIFY_CONTROL) = hqvMinify;
        
        io.reg(Register::HQV_CONTROL) = 
            Constant::HQV_ENABLE | Constant::HQV_YUV_420;

        spuWidth = sourceWidth;
        spuHeight = sourceHeight;
        
        size_t spuSize = spuWidth * spuHeight;

        spuOffset = baseOffset; baseOffset += spuSize;

        for(size_t i = 0; i<spuSize; ++i) {
            io.getFrameBuffer()[spuOffset+i] = 0x00;
        }

        io.reg(Register::SUBP_STARTADDR) = spuOffset;
        io.reg(Register::SUBP_CONTROL) = spuWidth;
    } else {
        spuOffset = (size_t)-1;;
        spuWidth = 0;
        spuHeight = 0;
    }

    return baseOffset;
}

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

void Unichrome::setV1Buffer(size_t yOffset, size_t cbOffset, size_t crOffset)
{
    if (useHQV) {
        io.reg(Register::HQV_SRC_STARTADDR_Y) = yOffset;
        io.reg(Register::HQV_SRC_STARTADDR_CB) = cbOffset;
        io.reg(Register::HQV_SRC_STARTADDR_CR) = crOffset;

        io.reg(Register::HQV_CONTROL) = 
            (io.reg(Register::HQV_CONTROL) & 0xffffffdf) |
            Constant::HQV_SW_FLIP | Constant::HQV_SUBPIC_FLIP | Constant::HQV_FLIP_STATUS;

        size_t numCycles = 0;
        while(isHQVFlipping() && (!Scheduler::isInterrupted() || numCycles<10))
        {
            Scheduler::sleep("unichrome::Unichrome::setV1Buffer",
                             Util::currentTimeMillis() + 10);
            ++numCycles;
        }

        if (isHQVFlipping()) {
            Log::debug("unichrome::Unichrome::setV1Buffer: HQV flipping not finished!!!!\n");
        } else {
            if (Scheduler::isInterrupted()) {
                Log::debug("unichrome::Unichrome::setV1Buffer: HQV flipping was interrupted!!!!\n");
            }
        }
    } else {
        io.reg(Register::V1_STARTADDR_Y0) = yOffset;
        io.reg(Register::V1_STARTADDR_CB0) = cbOffset;
        io.reg(Register::V1_STARTADDR_CR0) = crOffset;

        io.reg(Register::V_COMPOSE_MODE) = Constant::V1_COMMAND_FIRE;
    }
}

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

int Unichrome::findDividerAndZoom(ssize_t& source, ssize_t dest,
                                  ssize_t& zoom, ssize_t zoomFactor)
{
    int d = 0;
    zoom = 0;
    
    ssize_t s = source;
    for(; d<5 && s>dest; ++d) {
        s>>=1;
    }

    if (d>=5) return -1;
    
    if (s<dest) {
        zoom = (s*zoomFactor/dest)&(zoomFactor-1);
    }

    source = s; return d;
}

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

void Unichrome::calculateHorizontalZoom(size_t sourceSize, size_t destSize,
                                        uint32_t& mini, uint32_t& displayCount,
                                        uint32_t& zoom,
                                        uint32_t& hqvFilter, uint32_t& hqvMinify)
{
    uint32_t horizontalMini = 0;
    uint32_t horizontalZoom = 0;
    uint32_t horizontalHQVFilter = 0;
    uint32_t horizontalHQVMinify = 0;

    calculateZoom(sourceSize, destSize,
                  horizontalMini, horizontalZoom, 
                  horizontalHQVFilter, horizontalHQVMinify,
                  0x800);

    displayCount = (mini==0) ? 0 : (mini + 1);
    
    if (horizontalMini>0) {
        mini |= horizontalMini<<24;
        mini |= Constant::V1_X_INTERPOLY | Constant::V1_YCBCR_INTERPOLY;
    }
    if (horizontalZoom>0) zoom |= (horizontalZoom<<16) | Constant::V1_X_ZOOM_ENABLE;
    
    hqvFilter |= horizontalHQVFilter;
    hqvMinify |= horizontalHQVMinify;

}

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

void Unichrome::calculateVerticalZoom(size_t sourceSize, size_t destSize,
                                      uint32_t& mini, uint32_t& zoom,
                                      uint32_t& hqvFilter, uint32_t& hqvMinify)
{
    uint32_t verticalMini = 0;
    uint32_t verticalZoom = 0;
    uint32_t verticalHQVFilter = 0;
    uint32_t verticalHQVMinify = 0;
    
    calculateZoom(sourceSize, destSize,
                  verticalMini, verticalZoom, 
                  verticalHQVFilter, verticalHQVMinify,
                  0x400);
    
    if (verticalZoom>0) zoom |= verticalZoom | Constant::V1_Y_ZOOM_ENABLE;
    if (verticalMini>0) {
        mini |= verticalMini<<16;
        mini |= Constant::V1_Y_INTERPOLY | Constant::V1_YCBCR_INTERPOLY;
    }
    
    hqvFilter |= verticalHQVFilter<<16;
    hqvMinify |= verticalHQVMinify<<16;
}

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

void Unichrome::calculateZoom(size_t sourceSize, size_t destSize,
                              uint32_t& mini, uint32_t& zoom,
                              uint32_t& hqvFilter, uint32_t& hqvMinify,
                              size_t zoomFactor)
{
    static const uint32_t hqvFilterBits[] = {
        Constant::HQV_FILTER_H_TAP4_121,
        Constant::HQV_FILTER_H_TAP4_121,
        Constant::HQV_FILTER_H_TAP8_122221,
        Constant::HQV_FILTER_H_TAP8_122221,
        Constant::HQV_FILTER_H_TAP8_122221
    };

    mini = 0;
    zoom = 0;
    hqvFilter = Constant::HQV_FILTER_H_DEFAULT;
    hqvMinify = 0;

    if (sourceSize<destSize) {
        if (zoomFactor==0x800) {
            sourceSize -= 2;
        }
        zoom = (sourceSize * zoomFactor / destSize) & (zoomFactor-1);
    } else if (sourceSize>destSize) {
        size_t sourceSize1 = sourceSize;

        size_t divider = 0;
        for(; divider<5 && sourceSize1>destSize; ++divider) {
            sourceSize1>>=1;
        }
        
        if (divider>=5) {
            Log::debug("unichrome::Unichrome::calculateZoom: too much minification is requested!\n");
            divider = 4;
        }

        if (useHQV) {
            hqvFilter = hqvFilterBits[divider];
            hqvMinify = destSize * 0x800 * 0x400 / sourceSize;
            hqvMinify = (hqvMinify/0x400) + ((hqvMinify&0x3ff) ? 1 : 0);
            hqvMinify |= Constant::HQV_MINIFY_H_ENABLE | Constant::HQV_MINIFY_H_DEBLOCK_FILTER;
        } else {
            mini = (divider<<1)-1;
            if (sourceSize1<destSize) {
                if (zoomFactor==0x800) {
                    sourceSize1 -= 2;
                }
                zoom = ((sourceSize1*zoomFactor)/destSize) & (zoomFactor-1);
            }
        }

    }
}

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

void Unichrome::deallocateMemoryBlock(MemoryBlock* memoryBlock)
{
    assert(memoryBlock==lastMemoryBlock);

    lastMemoryBlock = memoryBlock->getPrevious();
}

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