phEffectsThread.cpp

Go to the documentation of this file.

#include <phEffectsThread.h>

/* ------------------------------------------------------------------------ */
phEffectsThread::phEffectsThread( phLiveObject *one, 
                                phLiveObject *two, 
                                uint32_t output_format )
{
    phFUNCTION("phEffectsThread::phEffectsThread")
    int locked = 0;

    phTHIS_LOOSE_LOCK(locked);
    
    this->setName("phEffectsThread");
    this->m_input[0] = (phImage *)one;
    this->m_input[1] = (phImage *)two;
    this->m_input_count = 2;
#if 0
    this->m_alpha = 0.00;
#endif
    this->m_output_format = output_format;

    this->m_output = new phImage();

    this->m_buf = NULL;
    this->m_buf_size = 0;

    this->m_resize_width = 90;
    this->m_resize_height = 70;
    this->m_offset_x = 5;
    this->m_offset_y = 45;
    
    phTHIS_LOOSE_UNLOCK(locked);
}

/* ------------------------------------------------------------------------ */
phEffectsThread::~phEffectsThread()
{
    phFree(this->m_buf);
    this->m_buf_size = 0;
    phDelete(this->m_output);
}

/* ------------------------------------------------------------------------ */
int phEffectsThread::mosaic_images( phImage *one, phImage *two, phImage *out )
{
    phFUNCTION("phEffectsThread::mosaic_images")
    int locked = 0;
    uint8_t *ptr[2];
    uint32_t height[2];
    uint32_t width[2];
    uint32_t offset;
    uint32_t output_height = 0;
    uint32_t output_width = 0;

    uint32_t i = 0;
    uint32_t j = 0;

    uint32_t depth = 0;

    if ((one == NULL) ||
        (two == NULL) ||
        (one->isNull()) || 
        (two->isNull()))
    {
        return phFAIL;
    }
    
    phTHIS_LOCK(locked);

    /* Convert the input images to one color space */
    rc = one->convert(this->m_output_format);
    phPRINT_RC(rc,NULL,"one->convert(%s)",
            phImageFormatToString(this->m_output_format));
    
    rc = two->convert(this->m_output_format);
    phPRINT_RC(rc,NULL,"two->convert(%s)",
            phImageFormatToString(this->m_output_format));
   
    /* Make sure our buffer is large enough */ 
    phDALLOC_RESIZE(this->m_buf,
                    this->m_buf_size,
                    one->getSize() + two->getSize(),
                    uint8_t );
    
    depth = phImageFormatToDepth(this->m_output_format);
    
    /* Get the pointers to the image only after the conversions */
    ptr[0] = (uint8_t*)one->getImage();
    ptr[1] = (uint8_t*)two->getImage();
  
    height[0] = one->getHeight();
    height[1] = two->getHeight();

    width[0] = one->getWidth();
    width[1] = two->getWidth();

    output_height = (height[0] > height[1] ? height[0] : height[1]);
    output_width = width[0] + width[1];

    offset = 0;
    for (j = 0; j < this->m_input_count; j++)
    {
        for (i = 0; i < height[j]; i++ )
        {
            phMemcpy(&(this->m_buf[((i * output_width) + offset) * depth]),
                     &(ptr[j][i * width[j] * depth]),
                     width[j] * depth);
        }
        offset += width[j];
    }

    rc = out->setImage(output_width,
                       output_height,
                       this->m_output_format,
                       this->m_buf_size,
                       this->m_buf);
    phCHECK_RC(rc,NULL,"out->setImage");
    
    phTHIS_UNLOCK(locked);

    return phSUCCESS;
error:

    phTHIS_ERROR_UNLOCK(locked);
    
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phEffectsThread::overlay_images( phImage *one, phImage *two, 
                                     phImage *out )
{
    phFUNCTION("phEffectsThread::overlay_images")
    int locked = 0;
    
    float alpha = 0.0;
    float alphainv = 0.0;
    const int32_t ai = 3;
    
    float tmp = 0;
    uint8_t *outptr         = NULL;
    uint8_t *ptr[2];
    int32_t height[2];
    int32_t width[2];
    int32_t output_width   = 0;
    int32_t output_height  = 0;
    int32_t offset_x       = 0;
    int32_t offset_y       = 0;
    int32_t offset_remainder_x[2];
    int32_t offset_remainder_y[2];
    int32_t offset_pixel_x[2];
    int32_t offset_pixel_y[2];
    int32_t move_x = 0;
    int32_t move_y = 0;

    int32_t i = 0;
    int32_t j = 0;
    int32_t d = 0;

    uint32_t depth = 0;
    int32_t width_limit = 0;
    int32_t height_limit = 0;

    if ((one == NULL) || (two == NULL) || (one->isNull()) || (two->isNull()))
    {
        return phFAIL;
    }
    
    phTHIS_LOCK(locked);

    move_x = this->m_offset_x;
    move_y = this->m_offset_y;
    
    /* Convert the input images to one color space */
    rc = one->convert(this->m_output_format);
    phPRINT_RC(rc,NULL,"one->convert(%s)",
            phImageFormatToString(this->m_output_format));
    
    two->resize(this->m_resize_width,this->m_resize_height);
    rc = two->convert(this->m_output_format);
    phPRINT_RC(rc,NULL,"two->convert(%s)",
            phImageFormatToString(this->m_output_format));
   
   /*
    rc = two->resize(one->getWidth(),one->getHeight());
    phPRINT_RC(rc,NULL,"two->resize");
   */
    /* Make sure our buffer is large enough */ 
    phDALLOC_RESIZE(this->m_buf,
                    this->m_buf_size,
                    one->getSize(),
                    uint8_t );
    
    depth = phImageFormatToDepth(this->m_output_format);
    
    outptr          = this->m_buf;
    /* Get the pointers to the image only after the conversions */
    ptr[0]          = (uint8_t*)one->getImage();
    ptr[1]          = (uint8_t*)two->getImage();
  
    height[0]       = one->getHeight();
    height[1]       = two->getHeight();

    width[0]        = one->getWidth();
    width[1]        = two->getWidth();

    output_width    = one->getWidth();
    output_height   = one->getHeight();

    /* half width diff == the offset of the X coord of the upper left 
     * corner of the smaller image within the larger image */
    offset_x = width[0] - width[1];
    if (offset_x > 0) offset_x = offset_x / 2;
   
    /* half height diff == the offset of the Y coord of the upper 
     * left corner of the smaller image within the larger image */
    offset_y = height[0] - height[1];
    if (offset_y > 0) offset_y = offset_y / 2;
    
    /* The offset pixel is the pixel within the larger image and the
     * output image where the overlayed smaller image will start */
    offset_pixel_x[0]       = offset_x + move_x;
    offset_pixel_y[0]       = offset_y + move_y;
    offset_remainder_x[0]   = offset_x - move_x;
    offset_remainder_y[0]   = offset_y - move_y;
    offset_pixel_y[1]       = 0;
    offset_pixel_x[1]       = 0;
    
    /* if the offset pixel in the larger image is less than 0, we'll
     * index into the smaller image instead of the larger image */
    width_limit  = width[1];
    if (offset_pixel_x[0] < 0)
    {
        offset_pixel_x[1] = -1 * offset_pixel_x[0];
        offset_pixel_x[0] = 0;
        width_limit -= offset_pixel_x[1];
        offset_remainder_x[1] = width_limit;
    }
    
    height_limit = height[1];
    if (offset_pixel_y[0] < 0)
    {
        offset_pixel_y[1] = -1 * offset_pixel_y[0];
        offset_pixel_y[0] = 0;
        height_limit -= offset_pixel_y[1];
    }
    
    /* Copy all the rows of the image that won't have overlayed data into the
     * output image buffer */
    phMemcpy(outptr,ptr[0],offset_pixel_y[0] * width[0] * depth);

    /* Index into the buffers.
     * Index into the larger buffer and output buffer to the row where 
     * the overlay will begin */
    ptr[0] += offset_pixel_y[0] * width[0]      * depth;
    ptr[1] += offset_pixel_y[1] * width[1]      * depth;
    outptr += offset_pixel_y[0] * output_width  * depth;

    /* This loops over the two input images and overlays them into 
     * the output image */
    /* we only need to loop through the entirety of the smaller image */
    for (j = 0; j < height_limit; j++)
    {
        phMemcpy(outptr,ptr[0],offset_pixel_x[0] * 2 * depth);
        ptr[0] += (offset_pixel_x[0] * depth);
        ptr[1] += (offset_pixel_x[1] * depth);
        outptr += (offset_pixel_x[0] * depth);
        
        for (i = 0; i < width_limit; i++ )
        {
            /* Read the alpha channel value; This was likely set up in 
             * the key matte threshold filter. */
            alpha = ((float)ptr[1][ai]) / 255.0;
            alphainv = 1.0 - alpha;
            
            for (d = 0; d < 3; d++ )
            {
                tmp = ((*ptr[0]) * alphainv) + ((*ptr[1]) * alpha);
                if (tmp < 0) tmp = 0;
                *outptr = (uint8_t)(tmp > 255 ? 255 : tmp);
                ptr[0]++; ptr[1]++; outptr++;
            }
            
            outptr++;
            ptr[0]++;
            ptr[1]++;
        }
        
        phMemcpy(outptr,ptr[0],offset_remainder_x[0] * 2 * depth);
        ptr[0] += (offset_remainder_x[0] * depth);
        outptr += (offset_remainder_x[0] * depth);
    }
    
    phMemcpy(outptr,ptr[0],offset_remainder_y[0] * width[0] * depth);

    rc = out->setImage(output_width,
                       output_height,
                       this->m_output_format,
                       this->m_buf_size,
                       this->m_buf);
    phCHECK_RC(rc,NULL,"out->setImage");
    
    phTHIS_UNLOCK(locked);

    return phSUCCESS;
error:

    phTHIS_ERROR_UNLOCK(locked);
    
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phEffectsThread::run()
{   
    phFUNCTION("phEffectsThread::run") 
    phImage local_copy[2];
    uint32_t i = 0;
#if 0
    uint32_t counter = 0;
    int32_t  direction = 1;
#endif

    for (i = 0; i < 2; i++ )
    {
        rc = local_copy[i].connect(this->m_input[i]);
        phCHECK_RC(rc,NULL,"this->local_copy[%d].connect(%p)",i,this->m_input[i]);
    }
    
    rc = this->signal_running();
    phCHECK_RC(rc,NULL,"this->signal_running");
   
    while (this->isRunning())
    {    
        for (i = 0; i < 2; i++ )
        {
            rc = local_copy[i].update();
            phPRINT_RC(rc,NULL,"this->local_copy[%d].update()",i);
        }
#if 0
        rc = this->mosaic_images(&(local_copy[0]),&(local_copy[1]),this->m_output);
        phPRINT_RC(rc,NULL,"this->mosaic_images");
#else
        rc = this->overlay_images(&(local_copy[0]),
                                  &(local_copy[1]),
                                  this->m_output );
        phPRINT_RC(rc,NULL,"this->mosaic_images");
#endif

#if 0
        if (counter == 0)
        {
            if (this->m_alpha >= 1.00)
                direction = -1;
            if (this->m_alpha <= 0.00)
                direction = 1;
                
            this->m_alpha += 0.1 * direction;
            counter = 0;
        }
        else
        {
            counter++;
        }
#endif
    }

    for (i = 0; i < 2; i++ )
    {
        rc = local_copy[i].disconnect();
        phPRINT_RC(rc,NULL,"this->local_copy[%d].disconnect()",i);
    }
    
    return phSUCCESS;
error:
    rc = this->signal_error();
    phPRINT_RC(rc,NULL,"this->signal_error");

    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phEffectsThread::wakeup()
{
    phFUNCTION("phEffectsThread::wakeup")
    uint32_t i = 0;
    
    for (i = 0; i < 2; i++ )
    {
        rc = this->m_input[i]->wakeup_clients();
        phCHECK_RC(rc,NULL,"this->m_input[%d]->wakeup_clients();",i);
    }
    
    return phSUCCESS;
error:
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phEffectsThread::setOverlay( int32_t resize_width,  int32_t resize_height, 
                                 int32_t x,             int32_t y )
{
    phFUNCTION("phEffectsThread::setOverlay")
    int locked = 0;

    phTHIS_LOCK(locked);
    
    this->m_resize_width    = resize_width;
    this->m_resize_height   = resize_height;
    this->m_offset_x        = x;
    this->m_offset_y        = y;
    
    phTHIS_UNLOCK(locked);

    return phSUCCESS;
error:

    phTHIS_ERROR_UNLOCK(locked);
    
    return phFAIL;
}

/* ------------------------------------------------------------------------ */
int phEffectsThread::getOverlay( int32_t *resize_width, int32_t *resize_height,
                                 int32_t *x,            int32_t *y )
{
    phFUNCTION("phEffectsThread::getOverlay")
    int locked = 0;

    phTHIS_LOCK(locked);
    
    if (resize_width != NULL)   *resize_width = this->m_resize_width;
    if (resize_height != NULL)  *resize_height = this->m_resize_height;
    if (x != NULL)  *x = this->m_offset_x;
    if (y != NULL)  *y = this->m_offset_y;
    
    phTHIS_UNLOCK(locked);

    return phSUCCESS;
error:

    phTHIS_ERROR_UNLOCK(locked);
    
    return phFAIL;

}

/* ------------------------------------------------------------------------ */
phLiveObject *phEffectsThread::getLiveSourceOutput() 
{
    return this->m_output; 
}
/* ------------------------------------------------------------------------ */
phLiveObject *phEffectsThread::getOutput() 
{
    return this->m_output; 
}

Copyright (C) 2002 - 2007

Philip D.S. Thoren ( pthoren@users.sourceforge.net ) University Of Massachusetts at Lowell Robotics Lab

---