videomux4.cc

Go to the documentation of this file.

#include "videomux4.h"
#include <algorithm>

using namespace std;

VideoMux4::VideoMux4 (
  const Id&             n,
 
  In<VYApixel>&         CinF0,
  In<VYAimageWidth>&    imgWidthInF0,
  In<VYAimageHeight>&   imgHeightInF0,
  In<imagePosition>&    imgPosInF0,

  In<VYApixel>&         CinF1,
  In<VYAimageWidth>&    imgWidthInF1,
  In<VYAimageHeight>&   imgHeightInF1,
  In<imagePosition>&    imgPosInF1,

  In<VYApixel>&         CinF2,
  In<VYAimageWidth>&    imgWidthInF2,
  In<VYAimageHeight>&   imgHeightInF2,
  In<imagePosition>&    imgPosInF2,

  In<VYApixel>&         CinF3,
  In<VYAimageWidth>&    imgWidthInF3,
  In<VYAimageHeight>&   imgHeightInF3,
  In<imagePosition>&    imgPosInF3,

  Out<VYApixel>&        CoutF,
  Out<VYAimageWidth>&   imgWidthOutF,
  Out<VYAimageHeight>&  imgHeightOutF)
:
  Process(n),

  CinP0(id("CinP0"), CinF0),
  imgWidthInP0(id("imgWidthInP0"), imgWidthInF0),
  imgHeightInP0(id("imgHeightInP0"), imgHeightInF0),
  imgPosInP0(id("imgPosInP0"), imgPosInF0),

  CinP1(id("CinP1"), CinF1),
  imgWidthInP1(id("imgWidthInP1"), imgWidthInF1),
  imgHeightInP1(id("imgHeightInP1"), imgHeightInF1),
  imgPosInP1(id("imgPosInP1"), imgPosInF1),

  CinP2(id("CinP2"), CinF2),
  imgWidthInP2(id("imgWidthInP2"), imgWidthInF2),
  imgHeightInP2(id("imgHeightInP2"), imgHeightInF2),
  imgPosInP2(id("imgPosInP2"), imgPosInF2),

  CinP3(id("CinP3"), CinF3),
  imgWidthInP3(id("imgWidthInP3"), imgWidthInF3),
  imgHeightInP3(id("imgHeightInP3"), imgHeightInF3),
  imgPosInP3(id("imgPosInP3"), imgPosInF3),

  CoutP(id("CoutP"), CoutF),
  imgWidthOutP(id("imgWidthOutP"), imgWidthOutF),
  imgHeightOutP(id("imgHeightOutP"), imgHeightOutF)
{
}

const char* VideoMux4::type() const
{
        return "VideoMux4";
}

void VideoMux4::main()
{
  /* N is the number of input streams */
  /* Index N+1 contains the output stream dimensions */
  
  const unsigned int N = 4;
  
  imagePosition   imgPos[N];
  VYApixel*   line[N+1] = { 0, 0, 0, 0, 0 };
  VYAimageWidth   imgWidth[N+1] = { 0, 0, 0, 0, 0 };
  VYAimageHeight  imgHeight[N+1] = { 0, 0, 0, 0, 0 };

  VYAimageWidth   prevImgWidth[N+1] = { 0, 0, 0, 0, 0 };
  
  unsigned int  mapToDepth[N];
      
  while(true)
  {
    read(imgWidthInP0, imgWidth[0]);
    read(imgHeightInP0, imgHeight[0]);
    read(imgPosInP0, imgPos[0]);

    read(imgWidthInP1, imgWidth[1]);
    read(imgHeightInP1, imgHeight[1]);
    read(imgPosInP1, imgPos[1]);

    read(imgWidthInP2, imgWidth[2]);
    read(imgHeightInP2, imgHeight[2]);
    read(imgPosInP2, imgPos[2]);

    read(imgWidthInP3, imgWidth[3]);
    read(imgHeightInP3, imgHeight[3]);
    read(imgPosInP3, imgPos[3]);
        
    imgWidth[N] = 0;
    imgHeight[N] = 0;
    for(unsigned int i=0; i<N; i++)
    {
      imgWidth[N] = max(imgWidth[N], imgPos[i].x + imgWidth[i]);
      imgHeight[N] = max(imgHeight[N], imgPos[i].y + imgHeight[i]);
    }
    write(imgWidthOutP, imgWidth[N]);
    write(imgHeightOutP, imgHeight[N]);

    for(unsigned int i=0; i<=N; i++)
    {
      if (imgWidth[i] != prevImgWidth[i])
      {
        if (!line[i]) delete [] line[i];
        line[i] = new VYApixel[imgWidth[i]];
        prevImgWidth[i] = imgWidth[i];
        
      }
    }

    for(unsigned int i=0; i<N; i++)
    {
      mapToDepth[i] = i;
    }
    for(unsigned int i=0; i<N-1; i++)
    {
      for (unsigned int j=i; j<N; j++)
      {
        if (imgPos[mapToDepth[i]].z > imgPos[mapToDepth[j]].z)
        {
          mapToDepth[i] = j;
          mapToDepth[j] = i;
        }
      }
    }
    
    for(VYAimageHeight h=0; h<imgHeight[N]; h++)
    {
      /*  If we allow read with port reference, we do not need line buffers 0..N.
        Input of length imgWidth[mi] can be read immediately in line[N][imgPos[mi].x],
        i.e.,
      
        for (unsigned int i=0; i<N; i++)
        {
          unsigned int mi = mapToDepth[i];
          if ((imgPos[mi].y<=h) && (h<imgHeight[mi]+imgPos[mi].y))
          {
            read(CinP[mi], &line[N][imgPos[mi].x], imgWidth[mi]);
          } 
        }
      */
      if ((imgPos[0].y<=h) && (h<imgHeight[0]+imgPos[0].y))
      {
        read(CinP0, &line[0][0], imgWidth[0]);
      }
      if ((imgPos[1].y<=h) && (h<imgHeight[1]+imgPos[1].y))
      {
        read(CinP1, &line[1][0], imgWidth[1]);
      }
      if ((imgPos[2].y<=h) && (h<imgHeight[2]+imgPos[2].y))
      {
        read(CinP2, &line[2][0], imgWidth[2]);
      }
      if ((imgPos[3].y<=h) && (h<imgHeight[3]+imgPos[3].y))
      {
        read(CinP3, &line[3][0], imgWidth[3]);
      }

      for(unsigned int i=0; i<imgWidth[N]; i++)
      {
        line[N][i] = 0;
      }
            
      for (unsigned int i=0; i<N; i++)
      {
        unsigned int mi = mapToDepth[i];
        if ((imgPos[mi].y<=h) && (h<imgHeight[mi]+imgPos[mi].y))
        {
          for(unsigned j=0; j<imgWidth[mi]; j++)
          {
            line[N][imgPos[mi].x+j] = line[mi][j];
          }
        }
      }
      
      write(CoutP, &line[N][0], imgWidth[N]);
    }   
  }
}

---