vya.h

Go to the documentation of this file.

/*--------------------------------------------------------------------
 *
 * (C) Copyright Koninklijke Philips Electronics NV 2006. 
 * All rights reserved. This software is licensed under the terms of
 * version 2.1 of the GNU Lesser General Public License as published 
 * by the Free Software Foundation. For licensing and warranty
 * information, see the file COPYING in the main directory.
 *
 *------------------------------------------------------------------*/

#ifndef VYA_H
#define VYA_H

#include <stdio.h>
#include "architecture.h"
#include "yapi.h"

const unsigned short VYA_MIN_BITS   =  6; // minimum bit precision
const unsigned short VYA_MAX_BITS_U = 15; // maximum bit precision for unsigned data
const unsigned short VYA_MAX_BITS_S = 16; // maximum bit precision for signed data

typedef VYAsigned16bit   VYApixel;
typedef unsigned int     VYAlineLength;
typedef unsigned int     VYAimageWidth;
typedef unsigned int     VYAimageHeight;

class VYAfileName
{
public:
  VYAfileName()                     { sprintf(name, "%s", ""); }
  VYAfileName(const char* n)        { sprintf(name, "%s", n); }
  VYAfileName(const VYAfileName& n) { sprintf(name, "%s", n.name); }
  operator char*()                  { return name; }
private:
  char name[256];
};

enum  VYAimageType  {VYA_TOP_FIELD, VYA_BOTTOM_FIELD, VYA_FRAME};
enum  VYAimageSync  {VYA_VALID, VYA_NOT_VALID}; //not valid for suppressed frames in open gop

class VYAbitPrecision
{
public:
        VYAbitPrecision();
        VYAbitPrecision(const VYAbitPrecision&);
        VYAbitPrecision(unsigned int, bool);

        unsigned int  bits;
        bool          signbit;
};

class VYAprocess: public Process
{
public:
        VYAprocess(Id n);
        virtual ~VYAprocess();

        void VYAcheckPrecision(const char *fullName,
                                VYAbitPrecision inPrec, VYAbitPrecision outPrec,
                                unsigned int minInBits, unsigned int maxInBits,
                                bool inSigned, bool outSigned
        );

        void VYAcheckLineLength(const char *fullName,
                        VYApixel **lineBuffer,
                        VYAlineLength len,    VYAlineLength *oldLen,
                        VYAlineLength minLen, VYAlineLength maxLen
        );

        void VYAcheckImageWidth(const char *fullName,
                        VYApixel **lineBuffer,
                        VYAimageWidth width,    VYAimageWidth *oldWidth,
                        VYAimageWidth minWidth, VYAimageWidth maxWidth
        );

        void VYAcheckImageHeight(const char *fullName,
                        VYAimageHeight height,    VYAimageHeight *oldHeight,
                        VYAimageHeight minHeight, VYAimageHeight maxHeight
        );

        void VYAcheckImageSize(const char *fullName,
                        VYApixel **imageBuffer,
                        VYAimageWidth  width,     VYAimageWidth  *oldWidth,
                        VYAimageWidth  minWidth,  VYAimageWidth  maxWidth,
                        VYAimageHeight height,    VYAimageHeight *oldHeight,
                        VYAimageHeight minHeight, VYAimageHeight maxHeight
        );
};

// Clip integer data to range specified by minimum and maximum values
inline int VYAclip (int data, int min, int max) {
        return ((data < min) ? min : (data > max) ? max : data);
}

// Round and normalize integer data by n bits
// {s.31-x.x} --> {s.31-x+n.x-n}
inline int VYAroundNorm (int data, int n) {
        return ((n <= 0) ? (data << (-n)) :
                ((data < 0) ? (-((-(data) + (1 << (n - 1))) >> n)) :
                              ((data + (1 << (n - 1))) >> n)));
}

// Truncate integer data towards zero by lower n bits
// {s.31-x.x} --> {s.31-x+n.x-n}
inline int VYAtruncate (int data, int n) {
        return ((data < 0) ? ((data >> n) + 1) : (data >> n));
}

// Truncate integer data by lower n bits with sign extension
// {s.31-x.x} --> {s.31-x+n.x-n}
inline int VYAdivBinary (int data, int n) {
        return (data >> n);
}

// Truncate integer data to lower n bits with leading zeros
// {s.31-x.x} --> {s.31-n.n}
inline int VYAmodBinary (int data, int n) {
        return (data & ((1 << n) - 1));
}

#endif

---