Logo Search packages:      
Sourcecode: timfx version File versions  Download package

kino_plugin_types.h

#ifndef KINO_PLUGIN_TYPES_H
#define KINO_PLUGIN_TYPES_H

#include "kino_plugin_utility.h"

#include <algorithm>
#include <cmath>
#include <functional>
#include <iostream>
#include <string>
#include <stdint.h>

namespace kino
{

// forward class declarations
template<typename, typename>
class basic_luma;

template<typename, typename>
class basic_rgb;

template<typename, typename>
class basic_rgba;

class basic_hsv;

/// Defines data measured in pixels
typedef unsigned long pixel_size_type;

/// Enumerates input video interlace requirements for a plugin
typedef enum
{
      INTERLACE_ALLOWED,
      INTERLACE_NOT_ALLOWED,
} interlace_requirement_type;

/// Enumerates the interlace possibilities for a video stream - none, even field dominant, or odd field dominant
typedef enum
{
      NOT_INTERLACED,
      EVEN_FIELD_DOMINANT,
      ODD_FIELD_DOMINANT
} interlace_type;

/// Defines a universally-unique plugin type identifier (compatible with libuuid)
typedef uint8_t uuid_type[16];

////////////////////////////////////////////////////////////////////////
// color_traits

/// Describes traits of a type used as a sample within a color specification
template<typename SampleType>
00054 class color_traits
{
public:
      typedef SampleType sample_type;

      /// Returns the maximum value of a sample
      static sample_type minimum();
      /// Returns the minimum value of a sample
      static sample_type maximum();
      /// Returns the sample value corresponding to transparent alpha
00064       static sample_type transparent() { return minimum(); }
      /// Returns the sample value corresponding to opaque alpha
00066       static sample_type opaque() { return maximum(); }
      /// Inverts the value of a sample
      static sample_type invert(const sample_type& Sample);
};

////////////////////////////////////////////////////////////////////////
// color_traits<unsigned char>

/// Specialization of color_traits for uint8_t samples
template<>
00076 class color_traits<uint8_t>
{
public:
      /// Defines the sample type for this specialization
00080       typedef uint8_t sample_type;

      /// Returns the minimum value of a sample
00083       static sample_type minimum() { return 0; }
      /// Returns the maximum value of a sample
00085       static sample_type maximum() { return 255; }
      /// Returns the sample value corresponding to transparent alpha
00087       static sample_type transparent() { return minimum(); }
      /// Returns the sample value corresponding to opaque alpha
00089       static sample_type opaque() { return maximum(); }
      /// Inverts the value of a sample
00091       static sample_type invert(const sample_type& Sample) { return maximum() - Sample; }

      /// Converts a sample from a uint8_t
00094       static sample_type convert(const sample_type Sample) { return Sample; }
      /// Converts a sample from a double
00096       static sample_type convert(const double Sample) { return static_cast<uint8_t>(clamp(Sample, 0.0, 1.0) * maximum()); }
};

////////////////////////////////////////////////////////////////////////
// color_traits<double>

/// Specialization of color_traits for double samples
template<>
00104 class color_traits<double>
{
public:
      /// Defines the sample type for this specialization
00108       typedef double sample_type;

      /// Returns the minimum value of a sample
00111       static sample_type minimum() { return 0; }
      /// Returns the maximum value of a sample
00113       static sample_type maximum() { return 1; }
      /// Returns the sample value corresponding to transparent alpha
00115       static sample_type transparent() { return minimum(); }
      /// Returns the sample value corresponding to opaque alpha
00117       static sample_type opaque() { return maximum(); }
      /// Inverts the value of a sample
00119       static sample_type invert(const sample_type& Sample) { return maximum() - Sample; }

      /// Converts a sample from a uint8_t
00122       static sample_type convert(const uint8_t Sample) { return static_cast<sample_type>(Sample) / 255.0; }
      /// Converts a sample from a double
00124       static sample_type convert(const sample_type Sample) { return Sample; }
};

////////////////////////////////////////////////////////////////////////
// basic_hsv

/// Encapsulates storage for an HSV color sample
00131 class basic_hsv
{
public:
      typedef double sample_type;
      typedef color_traits<sample_type> sample_traits;
      typedef basic_hsv this_type;
      
      /// Default constructor sets all samples to zero
00139       basic_hsv() :
            hue(sample_traits::minimum()),
            saturation(sample_traits::minimum()),
            value(sample_traits::minimum())
      {
      }
      
      /// Constructor that takes hue, saturation, and value samples
00147       basic_hsv(const sample_type Hue, const sample_type Saturation, const sample_type Value) :
            hue(Hue),
            saturation(Saturation),
            value(Value)
      {
      }

      template<typename ForeignType, typename ForeignTraits>
      basic_hsv(const basic_luma<ForeignType, ForeignTraits>& RHS) :
            hue(sample_traits::minimum()),
            saturation(sample_traits::minimum()),
            value(sample_traits::convert(RHS.luma))
      {
      }

      template<typename ForeignType>
      basic_hsv(const ForeignType& RHS)
      {
            const sample_type red = sample_traits::convert(RHS.red);
            const sample_type green = sample_traits::convert(RHS.green);
            const sample_type blue = sample_traits::convert(RHS.blue);
            
            const sample_type maxcomponent = std::max(std::max(red, green), blue);
            const sample_type mincomponent = std::min(std::min(red, green), blue);
            const sample_type difference = maxcomponent - mincomponent;

            value = maxcomponent;

            saturation = maxcomponent ? difference / maxcomponent : sample_traits::minimum();

            if(saturation != sample_traits::minimum())
                  {
                        const sample_type reddistance = (maxcomponent - red) / difference;
                        const sample_type greendistance = (maxcomponent - green) / difference;
                        const sample_type bluedistance = (maxcomponent - blue) / difference;

                        if(red == maxcomponent)
                              {
                                    hue = bluedistance - greendistance;
                              }
                        else if(green == maxcomponent)
                              {
                                    hue = 2 + reddistance - bluedistance;
                              }
                        else
                              {
                                    hue = 4 + greendistance - reddistance;
                              }

                        hue *= 60;
                        while(hue < 0)
                              hue += 360;
                        while(hue >= 360)
                              hue -= 360;
                  }
            else
                  {
                        hue = sample_traits::minimum();
                  }
      }

      /// Serialization
00209       friend std::ostream& operator<<(std::ostream& Stream, const basic_hsv& RHS)
      {
            Stream << RHS.hue << " " << RHS.saturation << " " << RHS.value;
            return Stream;
      }

      /// Deserialization
00216       friend std::istream& operator>>(std::istream& Stream, basic_hsv& RHS)
      {
            Stream >> RHS.hue >> RHS.saturation >> RHS.value;
            return Stream;
      }

      sample_type hue;
      sample_type saturation;
      sample_type value;
};

////////////////////////////////////////////////////////////////////////
// basic_luma

/// Encapsulates storage for a luma color sample
template<typename SampleType, typename SampleTraits = color_traits<SampleType> >
00232 class basic_luma
{
public:
      typedef SampleType sample_type;
      typedef SampleTraits sample_traits;
      typedef basic_luma<sample_type, sample_traits> this_type;
      
      /// Default constructor sets all samples to zero
00240       basic_luma() :
            luma(sample_traits::minimum()),
            alpha(sample_traits::opaque())
      {
      }

      /// Straightforward constructor that initializes samples    
00247       basic_luma(const sample_type Luma) :
            luma(Luma)
      {
      }

      template<typename ForeignType, typename ForeignTraits>
      basic_luma(const basic_luma<ForeignType, ForeignTraits>& RHS) :
            luma(sample_traits::convert(RHS.luma))
      {
      }

      template<typename ForeignType, typename ForeignTraits>
      basic_luma(const basic_rgb<ForeignType, ForeignTraits>& RHS) :
            luma(sample_traits::convert(std::max(RHS.red, std::max(RHS.green, RHS.blue))))
      {
      }

      template<typename ForeignType, typename ForeignTraits>
      basic_luma(const basic_rgba<ForeignType, ForeignTraits>& RHS) :
            luma(sample_traits::convert(std::max(RHS.red, std::max(RHS.green, RHS.blue))))
      {
      }
      
      basic_luma(const basic_hsv& RHS) :
            luma(sample_traits::convert(RHS.value))
      {
      }

      /// Serialization
00276       friend std::ostream& operator<<(std::ostream& Stream, const basic_luma<sample_type, sample_traits>& RHS)
      {
            Stream << RHS.luma;
            return Stream;
      }

      /// Deserialization
00283       friend std::istream& operator>>(std::istream& Stream, basic_luma<sample_type, sample_traits>& RHS)
      {
            Stream >> RHS.luma;
            return Stream;
      }

      sample_type luma;
      sample_type alpha;
};

////////////////////////////////////////////////////////////////////////
// basic_rgb

/// Encapsulates storage for an RGB color sample
template<typename SampleType, typename SampleTraits = color_traits<SampleType> >
00298 class basic_rgb
{
public:
      typedef SampleType sample_type;
      typedef SampleTraits sample_traits;
      typedef basic_rgb<sample_type, sample_traits> this_type;
      
      /// Default constructor sets all samples to zero
00306       basic_rgb() :
            red(sample_traits::minimum()),
            green(sample_traits::minimum()),
            blue(sample_traits::minimum())
      {
      }
      
      /// Constructor that takes red, green, and blue samples
00314       basic_rgb(const sample_type Red, const sample_type Green, const sample_type Blue) :
            red(Red),
            green(Green),
            blue(Blue)
      {
      }

      template<typename ForeignType, typename ForeignTraits>
      basic_rgb(const basic_luma<ForeignType, ForeignTraits>& RHS) :
            red(sample_traits::convert(RHS.luma)),
            green(sample_traits::convert(RHS.luma)),
            blue(sample_traits::convert(RHS.luma))
      {
      }

      template<typename ForeignType, typename ForeignTraits>
      basic_rgb(const basic_rgb<ForeignType, ForeignTraits>& RHS) :
            red(sample_traits::convert(RHS.red)),
            green(sample_traits::convert(RHS.green)),
            blue(sample_traits::convert(RHS.blue))
      {
      }

      template<typename ForeignType, typename ForeignTraits>
      basic_rgb(const basic_rgba<ForeignType, ForeignTraits>& RHS) :
            red(sample_traits::convert(RHS.red)),
            green(sample_traits::convert(RHS.green)),
            blue(sample_traits::convert(RHS.blue))
      {
      }

      basic_rgb(const basic_hsv& RHS)
      {
            // Easiest case - saturation is zero
            if(0 == RHS.saturation)
                  {
                        red = green = blue = sample_traits::convert(RHS.value);
                        return;
                  }
                  
            const double h = RHS.hue / 60;
            const double i = floor(h);
            const double f = h - i;
            const double p = RHS.value * (1 - RHS.saturation);
            const double q = RHS.value * (1 - (RHS.saturation * f));
            const double t = RHS.value * (1 - (RHS.saturation * (1 - f)));

            if(0.0 == i)
                  {
                        red = sample_traits::convert(RHS.value);
                        green = sample_traits::convert(t);
                        blue = sample_traits::convert(p);
                  }
            else if(1.0 == i)
                  {
                        red = sample_traits::convert(q);
                        green = sample_traits::convert(RHS.value);
                        blue = sample_traits::convert(p);
                  }
            else if(2.0 == i)
                  {
                        red = sample_traits::convert(p);
                        green = sample_traits::convert(RHS.value);
                        blue = sample_traits::convert(t);
                  }
            else if(3.0 == i)
                  {
                        red = sample_traits::convert(p);
                        green = sample_traits::convert(q);
                        blue = sample_traits::convert(RHS.value);
                  }
            else if(4.0 == i)
                  {
                        red = sample_traits::convert(t);
                        green = sample_traits::convert(p);
                        blue = sample_traits::convert(RHS.value);
                  }
            else if(5.0 == i)
                  {
                        red = sample_traits::convert(RHS.value);
                        green = sample_traits::convert(p);
                        blue = sample_traits::convert(q);
                  }
      }

      /// Serialization
00400       friend std::ostream& operator<<(std::ostream& Stream, const basic_rgb<sample_type, sample_traits>& RHS)
      {
            Stream << RHS.red << " " << RHS.green << " " << RHS.blue;
            return Stream;
      }

      /// Deserialization
00407       friend std::istream& operator>>(std::istream& Stream, basic_rgb<sample_type, sample_traits>& RHS)
      {
            Stream >> RHS.red >> RHS.green >> RHS.blue;
            return Stream;
      }

      sample_type red;
      sample_type green;
      sample_type blue;
};

////////////////////////////////////////////////////////////////////////
// basic_rgba

/// Encapsulates storage for an RGBA color sample
template<typename SampleType, typename SampleTraits = color_traits<SampleType> >
00423 class basic_rgba
{
public:
      typedef SampleType sample_type;
      typedef SampleTraits sample_traits;
      typedef basic_rgba<sample_type, sample_traits> this_type;
      
      /// Default constructor sets all samples to zero
00431       basic_rgba() :
            red(sample_traits::minimum()),
            green(sample_traits::minimum()),
            blue(sample_traits::minimum()),
            alpha(sample_traits::opaque())
      {
      }
      
      /// Constructor that takes red, green, and blue samples, and sets alpha opaque
00440       basic_rgba(const sample_type Red, const sample_type Green, const sample_type Blue) :
            red(Red),
            green(Green),
            blue(Blue),
            alpha(sample_traits::opaque())
      {
      }
      
      /// Constructor that takes red, green, blue, and alpha samples
00449       basic_rgba(const sample_type Red, const sample_type Green, const sample_type Blue, const sample_type Alpha) :
            red(Red),
            green(Green),
            blue(Blue),
            alpha(Alpha)
      {
      }

      template<typename ForeignType, typename ForeignTraits>
      basic_rgba(const basic_luma<ForeignType, ForeignTraits>& RHS) :
            red(sample_traits::convert(RHS.luma)),
            green(sample_traits::convert(RHS.luma)),
            blue(sample_traits::convert(RHS.luma)),
            alpha(sample_traits::opaque())
      {
      }

      template<typename ForeignType, typename ForeignTraits>
      basic_rgba(const basic_rgb<ForeignType, ForeignTraits>& RHS) :
            red(sample_traits::convert(RHS.red)),
            green(sample_traits::convert(RHS.green)),
            blue(sample_traits::convert(RHS.blue)),
            alpha(sample_traits::opaque())
      {
      }

      template<typename ForeignType, typename ForeignTraits>
      basic_rgba(const basic_rgba<ForeignType, ForeignTraits>& RHS) :
            red(sample_traits::convert(RHS.red)),
            green(sample_traits::convert(RHS.green)),
            blue(sample_traits::convert(RHS.blue)),
            alpha(sample_traits::convert(RHS.alpha))
      {
      }

      /// Serialization
00485       friend std::ostream& operator<<(std::ostream& Stream, const basic_rgba<sample_type, sample_traits>& RHS)
      {
            Stream << RHS.red << " " << RHS.green << " " << RHS.blue << " " << RHS.alpha;
            return Stream;
      }

      /// Deserialization
00492       friend std::istream& operator>>(std::istream& Stream, basic_rgba<sample_type, sample_traits>& RHS)
      {
            Stream >> RHS.red >> RHS.green >> RHS.blue >> RHS.alpha;
            return Stream;
      }

      sample_type red;
      sample_type green;
      sample_type blue;
      sample_type alpha;
};

////////////////////////////////////////////////////////////////////////
// basic_bitmap

/// Encapsulates a bitmap image
template<typename PixelType>
00509 class basic_bitmap
{
public:
      typedef PixelType pixel_type;
      typedef PixelType* iterator;
      typedef const PixelType* const_iterator;
      typedef basic_bitmap<pixel_type> this_type;

      /// Creates an empty bitmap
00518       basic_bitmap() :
            m_width(0),
            m_height(0),
            m_data(0)
      {
      }
      
      /// Creates a new bitmap with given width and height in pixels
00526       basic_bitmap(const pixel_size_type Width, const pixel_size_type Height) :
            m_width(Width),
            m_height(Height),
            m_data(static_cast<pixel_type*>(std::malloc(m_width * m_height * sizeof(pixel_type))))
      {
            // Sanity checks ...
            assert(m_width);
            assert(m_height);
            assert(m_data);
      }

      /// Creates a new bitmap, copying "old fashioned" C-style data
00538       basic_bitmap(void* Data, const pixel_size_type Width, const pixel_size_type Height) :
            m_width(Width),
            m_height(Height),
            m_data(static_cast<pixel_type*>(std::malloc(m_width * m_height * sizeof(pixel_type))))
      {
            // Sanity checks ...
            assert(m_width);
            assert(m_height);
            assert(m_data);
            assert(Data);
            
            memcpy(m_data, Data, m_width * m_height * sizeof(pixel_type));
      }

      /// Copy constructor for bitmaps of similar type
00553       basic_bitmap(this_type& RHS) :
            m_width(RHS.m_width),
            m_height(RHS.m_height),
            m_data(static_cast<pixel_type*>(std::malloc(m_width * m_height * sizeof(pixel_type))))
      {
            memcpy(m_data, RHS.m_data, m_width * m_height * sizeof(pixel_type));
      }
      /// Copy constructor for bitmaps of dissimilar type
      template<typename ForeignType>
00562       basic_bitmap(basic_bitmap<ForeignType>& RHS) :
            m_width(RHS.width()),
            m_height(RHS.height()),
            m_data(static_cast<pixel_type*>(std::malloc(m_width * m_height * sizeof(pixel_type))))
      {
            std::copy(RHS.data(), RHS.data() + m_width * m_height, m_data);
      }

      /// Destructor
00571       virtual ~basic_bitmap()
      {
            clear();
      }

      /// Returns the bitmap width in pixels
00577       pixel_size_type width() const
      {
            return m_width;
      }
      
      /// Returns the bitmap height in pixels
00583       pixel_size_type height() const
      {
            return m_height;
      }

      /// Returns the raw bitmap data array     
00589       const pixel_type* const data() const
      {
            return m_data;
      }

      /// Returns the raw bitmap data array
00595       pixel_type* const data()
      {
            return m_data;
      }

      void clear()
      {
            if(m_data)
                  std::free(m_data);
            
            m_width = 0;
            m_height = 0;
            m_data = 0;
      }
      
      void reset(const pixel_size_type Width, const pixel_size_type Height)
      {
            // Sanity checks ...
            assert(Width);
            assert(Height);
      
            pixel_type* const data = static_cast<pixel_type*>(std::malloc(Width * Height * sizeof(pixel_type)));
            assert(data);
            
            clear();
            
            m_width = Width;
            m_height = Height;
            m_data = data;
      }

      iterator begin()
      {
            return m_data;
      }
      
      const_iterator begin() const
      {
            return m_data;
      }
      
      iterator end()
      {
            return m_data + (m_width * m_height);
      }
      
      const_iterator end() const
      {
            return m_data + (m_width * m_height);
      }

private:
      /// Stores the bitmap width in pixels
00648       pixel_size_type m_width;
      /// Stores the bitmap height in pixels
00650       pixel_size_type m_height;
      /// Stores the bitmap data as a 1D array of pixels
00652       PixelType* m_data;
};

/// We define the standard pixel passed to plugins to be RGBA data with 8-bits-per-channel
typedef basic_rgba<uint8_t> pixel;
/// We define the standard frame passed to plugins to be RGBA data with 8-bits-per-channel
typedef basic_bitmap<pixel> video_frame;

/// Defines a random-access container of video frames
00661 class video_sequence
{
public:
      typedef video_frame* pointer;
      typedef const video_frame* const_pointer;
      typedef video_frame& reference;
      typedef const video_frame& const_reference;
      typedef video_frame value_type;
      typedef unsigned long size_type;
      typedef long difference_type;
      
      virtual size_type size() const;
      virtual bool empty() const;
      
      virtual reference operator[](size_type Offset);
      virtual const_reference operator[](size_type Offset) const;
      
      virtual reference front();
      virtual const_reference front() const;
      
      virtual reference back();
      virtual const_reference back() const;
      
      class iterator :
            public std::iterator<std::random_access_iterator_tag, value_type>
      {
      public:
      
      private:
            class implementation;
            implementation* const m_implementation;
      };
      
      class const_iterator :
            public std::iterator<std::random_access_iterator_tag, value_type>
      {
      public:
      
      private:
            class implementation;
            implementation* const m_implementation;
      };

      virtual iterator begin();
      virtual const_iterator begin() const;
      
      virtual iterator end();
      virtual const_iterator end() const;

protected:
      virtual ~video_sequence() {}
};

/// We define the standard audio data passed to plugins to be 16-bit integers
typedef uint16_t audio_sample;

/// Defines a random-access container of audio samples
00718 class audio_sequence 
{
public:
      typedef audio_sample* pointer;
      typedef const audio_sample* const_pointer;
      typedef audio_sample& reference;
      typedef const audio_sample& const_reference;
      typedef audio_sample value_type;
      typedef unsigned long size_type;
      typedef long difference_type;

      ~audio_sequence();
      
      size_type size() const;
      bool empty() const;
      
      reference operator[](size_type Offset);
      const_reference operator[](size_type Offset) const;
      
      reference front();
      const_reference front() const;
      
      reference back();
      const_reference back() const;
      
      void push_back(const_reference Value);
      
      class iterator :
            public std::iterator<std::random_access_iterator_tag, value_type>
      {
      public:
            iterator(const iterator& RHS);
            ~iterator();
            
            iterator& operator=(const iterator& RHS);
            
            iterator& operator++();
            iterator operator++(int);
            
            bool operator==(const iterator& RHS) const;
            
            reference operator*() const;
      
      private:
            class implementation;
            implementation* m_implementation;

      public:
            iterator(implementation* Implementation);
            
            friend class audio_sequence;
      };
      
      class const_iterator :
            public std::iterator<std::random_access_iterator_tag, value_type>
      {
      public:
            const_iterator(const const_iterator& RHS);
            ~const_iterator();
            
            const_iterator& operator=(const const_iterator& RHS);
            
            const_iterator& operator++();
            const_iterator operator++(int);
            
            bool operator==(const const_iterator& RHS) const;
            
            const reference operator*() const;
      
      private:
            class implementation;
            implementation* const m_implementation;
      
      public:
            const_iterator(implementation* Implementation);
            
            friend class audio_sequence;
      };

      iterator begin();
      const_iterator begin() const;
      
      iterator end();
      const_iterator end() const;

private:
      class implementation;
      implementation* const m_implementation;

public:
      audio_sequence(implementation* Implementation);
};

} // namespace kino

#endif // !KINO_PLUGIN_TYPES_H

Generated by  Doxygen 1.6.0   Back to index