overlay.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 "config.h"

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

#ifdef USE_OVERLAY
//------------------------------------------------------------------------------

#include "Overlay.h"
#include "DXR3.h"

#include "util/Log.h"

#include <linux/em8300.h>

#include <X11/Xlib.h>

#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <cmath>

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

using dxr3::Overlay;

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

namespace {

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

/**
 * Overlay parameters.
 */
class OverlayParameters
{
private:
    /**
     * Read an integer from the given string. It is assumed, that
     * strtok is set up correctly.
     */
    static int readInt(char*& token);

    /**
     * Read a hexadecimal integer from the given string. It is
     * assumed, that strtok is set up correctly.
     */
    static int readHexInt(char*& token);

    /**
     * Read a floating point value from the given string. It is
     * assumed, that strtok is set up correctly.
     */
    static float readFloat(char*& token);

    /**
     * Coefficient.
     */
    struct Coefficient {
        float k;
        float m;

        /**
         * Construct the coefficient.
         */
        Coefficient(float k = 0.0, float m = 0.0);

        /**
         * Read values from the given string.
         */
        void read(char*& token);

        /**
         * Interpolate the given colour.
         */
        int interpolate(float x);
    };

    friend struct Coefficient;

public:
    /**
     * Horizontal offset;
     */
    int xOffset;

    /**
     * Vertical offset;
     */
    int yOffset;

    /**
     * Horizontal correction.
     */
    int xCorrection;

    /**
     * Jitter.
     */
    int jitter;

    /**
     * Stability
     */
    int stability;

    /**
     * Key colour upper half.
     */
    int keyColourUpper;

    /**
     * Key colour lower half.
     */
    int keyColourLower;

private:    
    /**
     * Key colour.
     */
    int keyColour;

    /**
     * Key colour coefficients.
     */
    Coefficient colcal_upper[3];
    Coefficient colcal_lower[3];

    /**
     * Colour interval.
     */
    float colourInterval;

public:
    /**
     * Construct the parameters.
     */
    OverlayParameters(size_t width, size_t height, size_t depth);

private:
    /**
     * Process the given line of the parameter file.
     */
    void processLine(char* line);
    
};

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

OverlayParameters::Coefficient::Coefficient(float k, float m) :
    k(k), m(m)
{
}

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

void OverlayParameters::Coefficient::read(char*& token)
{
    k = readFloat(token);
    m = readFloat(token);
}

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

int OverlayParameters::Coefficient::interpolate(float x)
{
    float y = x * k + m;
    
    if (y>255.0) y = 255.0;
    else if (y<0.0) y = 0.0;

    return static_cast<int>(rint(y));
}

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

int OverlayParameters::readInt(char*& token)
{
    token = strtok(0, " ");
    
    int x;
    sscanf(token, "%d", &x);
    return x;
}

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

int OverlayParameters::readHexInt(char*& token)
{
    token = strtok(0, " ");
    
    int x;
    sscanf(token, "%x", &x);
    return x;
}

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

float OverlayParameters::readFloat(char*& token)
{
    token = strtok(0, " ");
    
    float x;
    sscanf(token, "%f", &x);
    return x;
}

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

OverlayParameters::OverlayParameters(size_t width, size_t height,
                                     size_t depth) :
    xOffset(0),
    yOffset(0),
    xCorrection(0),
    jitter(0),
    stability(0),
    keyColourUpper(0),
    keyColourLower(0),
    keyColour(0),
    colourInterval(10.0)
{
    char fname[256];
    snprintf(fname, sizeof(fname), 
             "%s/.overlay/res_%ux%ux%u", 
             getenv("HOME"), width, height, depth);
    
    FILE* f = fopen(fname, "rt");
    if (f!=0) {
        char line[256];

        while(fgets(line, sizeof(line), f)!=0) {
            processLine(line);
        }

        fclose(f);
    } else {
        Log::warning("Could not open overlay parameter file '%s', using default parameters.\n",
                     fname);
    }

    int red   = (keyColour>>16) & 0xff;
    int green = (keyColour>> 8) & 0xff;
    int blue  = (keyColour>> 0) & 0xff;

    float redUpper   = red + colourInterval;
    float redLower   = red - colourInterval;

    float greenUpper = green + colourInterval;
    float greenLower = green - colourInterval;

    float blueUpper  = blue + colourInterval;
    float blueLower  = blue - colourInterval;

    keyColourUpper = 
        (colcal_upper[0].interpolate(redUpper)<<16) |
        (colcal_upper[1].interpolate(greenUpper)<<8) |
        (colcal_upper[2].interpolate(blueUpper)<<0);

    keyColourLower = 
        (colcal_lower[0].interpolate(redLower)<<16) |
        (colcal_lower[1].interpolate(greenLower)<<8) |
        (colcal_lower[2].interpolate(blueLower)<<0);
}

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

void OverlayParameters::processLine(char* line)
{
    char* token = strtok(line, " ");
    if (!strcmp(token, "xoffset")) {
        xOffset = readInt(token);
    } else if (!strcmp(token, "yoffset")) {
        yOffset = readInt(token);
    } else if (!strcmp(token, "xcorr")) {
        xCorrection = readInt(token); 
    } else if (!strcmp(token, "jitter")) {
        jitter = readInt(token);
    } else if (!strcmp(token, "stability")) {
        stability = readInt(token);
    } else if (!strcmp(token, "keycolor")) {
        keyColour = readHexInt(token);
    } else if (!strcmp(token, "colcal_upper")) {
        for(size_t i = 0; i<sizeof(colcal_upper)/sizeof(Coefficient); ++i) {
            colcal_upper[i].read(token);
        }
    } else if (!strcmp(token, "colcal_lower")) {
        for(size_t i = 0; i<sizeof(colcal_lower)/sizeof(Coefficient); ++i) {
            colcal_lower[i].read(token);
        }
    } else if (!strcmp(token, "color_interval")) {
        colourInterval = readFloat(token);
    }
}

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

} /* anonymous namespace */

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

Overlay::~Overlay()
{
    setSignalMode(VGA_ONLY);
}

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

void Overlay::initialize()
{
    size_t depth = setupResolution();

    OverlayParameters parameters(width, height, depth);

    setAttribute(EM9010_ATTRIBUTE_XOFFSET, parameters.xOffset);
    setAttribute(EM9010_ATTRIBUTE_YOFFSET, parameters.yOffset);
    setAttribute(EM9010_ATTRIBUTE_XCORR, parameters.xCorrection);
    setAttribute(EM9010_ATTRIBUTE_JITTER, parameters.jitter);
    setAttribute(EM9010_ATTRIBUTE_STABILITY, parameters.stability);
    setAttribute(EM9010_ATTRIBUTE_KEYCOLOR_UPPER, parameters.keyColourUpper);
    setAttribute(EM9010_ATTRIBUTE_KEYCOLOR_LOWER, parameters.keyColourLower);

    em8300_overlay_screen_t screen;
    
    screen.xsize = width;
    screen.ysize = height;

    dxr3.dev.ioctl(EM8300_IOCTL_OVERLAY_SETSCREEN, &screen, "Error setting overlay screen");

    setSignalMode(VGA_ONLY);
}

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

void Overlay::toggleOverlayMode()
{
    setSignalMode(signalMode==VGA_ONLY ? SIGNAL_ONLY : VGA_ONLY);
}

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

size_t Overlay::setupResolution()
{
    Display* dpy = XOpenDisplay(0);

    if (dpy==0) {
        Log::warning("Could not open connection to X, using default resolution\n");
        return 8;
    }

    Screen* screen = DefaultScreenOfDisplay(dpy);

    width  = WidthOfScreen(screen);
    height = HeightOfScreen(screen);
    
    size_t depth = PlanesOfScreen(screen);
    
    XCloseDisplay(dpy);
    
    return depth;
}

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

void Overlay::setAttribute(int attribute, int value)
{
    em8300_attribute_t attr;

    attr.attribute = attribute;
    attr.value = value;
    dxr3.dev.ioctl(EM8300_IOCTL_OVERLAY_SET_ATTRIBUTE, &attr, "Error setting overlay attribute %d to %d",
                   attribute, value);
}

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

void Overlay::setSignalMode(signalMode_t mode)
{
    signalMode = mode;

    int overlayMode = 
        (signalMode==SIGNAL_ONLY) ? 
        EM8300_OVERLAY_MODE_RECTANGLE : EM8300_OVERLAY_MODE_OFF;
    dxr3.dev.ioctl(EM8300_IOCTL_OVERLAY_SETMODE, &overlayMode,
                   "Error setting overlay mode to %d", overlayMode);
   
    int m = static_cast<int>(signalMode);
    dxr3.dev.ioctl(EM8300_IOCTL_OVERLAY_SIGNALMODE, &m, 
                   "Error setting signal mode to %d", signalMode);

    if (overlayMode==EM8300_OVERLAY_MODE_RECTANGLE) {
        em8300_overlay_window_t window;
        
        window.xpos = 0;
        window.ypos = 0;
        window.width = width;
        window.height = height;

        dxr3.dev.ioctl(EM8300_IOCTL_OVERLAY_SETWINDOW, &window,
                       "Error setting overlay window");
    }
}

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

#else // USE_OVERLAY

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

#include "Overlay.h"

#include "util/Log.h"

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

using dxr3::Overlay;

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

Overlay::~Overlay()
{
}
    
//------------------------------------------------------------------------------

void Overlay::initialize()
{
}

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

void Overlay::toggleOverlayMode()
{
    Log::debug("Overlay support not enabled!\n");
}

//------------------------------------------------------------------------------
#endif // USE_OVERLAY