Beispiel #1
0
//! \brief release pictures, release mutex
//!
//! <b>Important!</b> call stop before ende
void ende()
{
    picture_release(&g_rgbPicture);
    picture_release(&g_yuvPicture);
    printf("capture.ende: called\n");

    mutex_close(mutex);
    mutex = NULL;

}
Beispiel #2
0
glui32 win_graphics_draw_picture(window_graphics_t *dwin, glui32 image, 
  glsi32 xpos, glsi32 ypos,
  int scale, glui32 imagewidth, glui32 imageheight)
{
  picture_t *pic = picture_find(image);
  
  if (!pic) {
    return FALSE;
  }
  
  if (!scale) {
    imagewidth = pic->width;
    imageheight = pic->height;
  }
  
  if (dwin->world) {
    picture_draw(pic, dwin->world, xpos, ypos, imagewidth, imageheight, NULL);
    dirty_rect(&dwin->dirtyul, &dwin->dirtylr, 
      xpos, ypos, imagewidth, imageheight);
  }
  else {
    picture_draw(pic, xiowin, dwin->bbox.x+xpos, dwin->bbox.y+ypos, 
      imagewidth, imageheight, NULL);
  }
  
  picture_release(pic);
  return TRUE;
}
Beispiel #3
0
/*! \brief return current camera picture, as rgb or yuv picture, threadsave
 *
 * \param rgb if set to zero (default), yuv-Picture will return, <br>
 *            if set to other value, rgb-Picture will return
 * \param removeFrame if set to 1 (default) the next picture will be catch <br>
 *                    if set to zero, the last picture will be returned
 * \return SPicture pointer to lokal buffer, which didn't change until the next call from getPicture with
 *         the same rgb-parameter
 * \return NULL if any error occured
 */
SPicture* getPicture(int rgb/* = 0*/, int removeFrame/* = 1*/)
{
    if(mutex_lock(mutex))
        g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_lock</font>"));

    // if start wasn't called
    if(!g_run)
    {
        while(g_capture.isOpened())
            g_capture.release();
        printf("encoder.getPicture after call g_capture.release\n");
        g_Messages.push(string("getPicture</b> <font color='blue'>Kamera wurde geschlossen</font>"));
        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 1</font>"));
        return 0;
    }
    // try to open capture
    else if(!g_capture.isOpened())
    {
        g_Messages.push(string("getPicture</b> <font color='red'>keine Kamera geoeffnet!</font>"));
        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 2</font>"));
        return 0;
    }


    //get next or last picture
    Mat m, m2, m3;
    if(!removeFrame)
        g_capture.retrieve(m);
    else
        g_capture >> m; // get a new frame from camer

    if(!m.size().area())
    {
        g_Messages.push(string("getPicture</b> <font color='red'>picture from camera is empty</font>"));
        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 3</font>"));
        return 0;
    }

    //m = cvLoadImage("test.jpg");
    if(m.depth() != CV_8U)
    {
        g_Messages.push(string("getPicture</b> <font color='red'>depth != unsigned char</font>\n"));
        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 4</font>"));
        return 0;
    }
    //m.convertTo(m2, )
    //Scale Picture to choosen resolution (if camera didn't support it)
    Mat matrices[4];
    //IplImage src = m;
    //  IplImage* scaled = cvCreateImage(cvSize(g_cfg.width, g_cfg.height), IPL_DEPTH_8U, 3);

    //cvResize( &src, scaled, CV_INTER_LINEAR );
    m3.create(g_cfg.width, g_cfg.height, m.type());
    resize(m, m3, Size(g_cfg.width, g_cfg.height));

    char buffer[256];
    sprintf(buffer, "getPicture</b> <i>breite: %d, hoehe: %d, area: %d</i>", m.size().width, m.size().height, m.size().area());
    // g_Messages.push(string(buffer));

    //rgb-output
    if(rgb)
    {
        //imshow("LIVE", scaled);
        split(m3, matrices);
        matrices[3] = matrices[0].clone();
        matrices[3] = Scalar(255);
        merge(matrices, 4, m2);

        //get current buffer size and required buffer size
        int oldSize = picture_getSize(&g_rgbPicture);
        g_rgbPicture.width = m2.cols;
        g_rgbPicture.height = m2.rows;
        int newSize = picture_getSize(&g_rgbPicture);

        //compare buffer size and picture size, and make new buffer, if picture size differ
        if(oldSize != newSize)
        {
            picture_release(&g_rgbPicture);
            if(picture_create(&g_rgbPicture, m2.cols, m2.rows, 4))
            {
                g_Messages.push(string("getPicture</b> <font color='red'>Fehler beim speicher reservieren in getPicture rgb!</font>"));
                if(mutex_unlock(mutex))
                    g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 5</font>"));
                return NULL;
            }
        }

        //return 0;
        //copy picture to buffer
        size_t size = m2.cols*m2.rows*4;
        memcpy(g_rgbPicture.channel1, m2.data, size);

        //free scaled image
        //cvReleaseImage(&scaled);

        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 6</font>"));
        //return pointer to picture buffer
        return &g_rgbPicture;

    }
    // yuv-Output
    else
    {
        //convert and split picture
        cvtColor(m3, m2, CV_BGR2YCrCb);
        split(m2, matrices);

        IplImage* U = cvCreateImage(cvSize(m3.cols/2, m3.rows/2), IPL_DEPTH_8U, 1);
        IplImage* V = cvCreateImage(cvSize(m3.cols/2, m3.rows/2), IPL_DEPTH_8U, 1);
        IplImage uSrc = matrices[1];
        IplImage vSrc = matrices[2];
        //create resized u and v pictures (half-size)
        cvResize(&uSrc, U, CV_INTER_LINEAR);
        cvResize( &vSrc, V, CV_INTER_LINEAR );
        //  imshow("Y", matrices[0]);
        //imshow("U", U);
        //imshow("V", V);

        //get current buffer size and required buffer size
        int oldSize = picture_getSize(&g_yuvPicture);
        g_yuvPicture.width = m3.cols;
        g_yuvPicture.height = m3.rows;
        int newSize = picture_getSize(&g_yuvPicture);

        //compare buffer size and picture size, and make new buffer, if picture size differ
        if(oldSize != newSize)
        {
            picture_release(&g_yuvPicture);
            if(picture_create(&g_yuvPicture, m2.cols, m2.rows, 1))
            {
                g_Messages.push(string("getPicture</b> <font color='red'>Fehler beim speicher reservieren in getPicture yuv!</font>"));
                if(mutex_unlock(mutex))
                    g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 7</font>"));
                return 0;
            }
        }
        //return 0;
        //copy channels
        size_t size = m2.cols*m2.rows;
        memcpy(g_yuvPicture.channel1, matrices[0].data, size);
        memcpy(g_yuvPicture.channel2, V->imageData, size/4);
        memcpy(g_yuvPicture.channel3, U->imageData, size/4);

        //release u and v pictures
        cvReleaseImage(&U);
        cvReleaseImage(&V);
//       cvReleaseImage(&scaled);

        if(mutex_unlock(mutex))
            g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 8</font>"));
        //return pointer to picture buffer
        return &g_yuvPicture;
    }

    if(mutex_unlock(mutex))
        g_Messages.push(string("getPicture</b> <font color='red'>Fehler bei mutex_unlock 9</font>"));
    return NULL;
}