void MatCache::set_yuv422(uint8_t *y, int rs_y,
uint8_t *u, int rs_u, uint8_t *v, int rs_v)
{
invalidate();
cv::Mat y_mat(height, width, CV_8UC1, (void*)y, rs_y);
update_image("gray_8u", y_mat);
cv::Mat u_mat(height / 2, width / 2, CV_8UC1, (void*)u, rs_u);
update_image("yuv422_u_8u", u_mat);
cv::Mat v_mat(height / 2, width / 2, CV_8UC1, (void*)v, rs_v);
update_image("yuv422_v_8u", v_mat);
}
int
main(int argc, char **argv) {
if(argc != 2)
errx(EXIT_FAILURE, "no input files");
pthread_mutex_init(&mutex_update_image, NULL);
pthread_attr_t attr;
pthread_attr_init(&attr);
pthread_t inotify_thread;
if(pthread_create(&inotify_thread, &attr, monitor_file, argv[1]))
err(EXIT_FAILURE, "pthread_create");
font_init();
screen_init();
update_image(argv[1]);
for(;;) {
handle_events();
draw();
}
SDL_Quit();
return EXIT_SUCCESS;
}
void fractFunc::draw_aa(float min_progress, float max_progress)
{
int w = im->Xres();
int h = im->Yres();
reset_counts();
float delta = (max_progress - min_progress)/2.0;
// if we have multiple threads,make sure they don't modify
// pixels the other thread will look at - that wouldn't be
// an error per se but would make drawing nondeterministic,
// which I'm trying to avoid
// We do this by drawing every even line, then every odd one.
for(int i = 0; i < 2 ; ++i)
{
set_progress_range(
min_progress + delta * i,
min_progress + delta * (i+1));
reset_progress(0.0);
last_update_y = 0;
for(int y = i; y < h ; y+= 2)
{
worker->row_aa(0,y,w);
if(update_image(y))
{
break;
}
}
reset_progress(1.0);
}
}
/////////////////////////////////////////////////////////
// get the image at <m_frame> from the buffer
// and insert it into the gemchain
/////////////////////////////////////////////////////////
void pix_buffer_read :: render(GemState*state)
{
if(m_needsupdate) {
update_image();
}
// if we don't have an image, just return
if (!m_haveImage) {
return;
}
/* push the incoming state->image into a temporary memory */
state->get(GemState::_PIX, orgPixBlock);
/*
pd_findbyclass costs at least 2 if's
if m_bindname is also used for other classes too, we get an
additional penalty for traversing the list of classes;
all in all, msp has done a good job
*/
if (NULL==pd_findbyclass(m_bindname, pix_buffer_class)) {
return;
}
state->set(GemState::_PIX, &m_pixBlock);
}
int main(int argc, char *argv[]) {
pthread_t thread;
/* init threads */
g_thread_init (NULL);
gdk_threads_init ();
gdk_threads_enter ();
gtk_init(&argc, &argv);
initApp();
appdata->program = HILDON_PROGRAM(hildon_program_get_instance());
g_set_application_name("Webview");
appdata->window = HILDON_WINDOW(hildon_window_new());
hildon_program_add_window(appdata->program, appdata->window);
create_menu(appdata->window);
build_interface(appdata->window);
/* Connect signal to X in the upper corner */
g_signal_connect(G_OBJECT(appdata->window), "delete_event", G_CALLBACK(destroy), NULL);
update_image();
load_settings();
gtk_widget_show_all(GTK_WIDGET(appdata->window));
if(! start_camera(appdata->window))
{
g_warning("Unable to start camera\n");
GtkWidget *failDialog = gtk_message_dialog_new(NULL,
GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"Unable to start camera\n");
gtk_dialog_run (GTK_DIALOG (failDialog));
gtk_widget_destroy (failDialog);
}
if(! start_webserver())
{
GtkWidget *failDialog = gtk_message_dialog_new(NULL,
GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"Unable to start web server.\nCheck server port is not already in use.\n");
gtk_dialog_run (GTK_DIALOG (failDialog));
gtk_widget_destroy (failDialog);
}
sleep(1);
pthread_create(&thread, NULL, count_down_thread, NULL);
gtk_main();
gdk_threads_leave ();
return( 0 );
}
static void *
monitor_file(void *arg) {
char *path = arg;
int fd = inotify_init1(IN_NONBLOCK);
if(fd == -1)
err(EXIT_FAILURE, "inotify_init1");
if(inotify_add_watch(fd, path, IN_CLOSE_WRITE) == -1)
err(EXIT_FAILURE, "inotify_add_watch");
for(;;) {
fd_set set;
FD_SET(fd, &set);
if(select(fd + 1, &set, NULL, NULL, NULL) == -1)
err(EXIT_FAILURE, "select");
if(!(FD_ISSET(fd, &set)))
continue;
int numbytes;
if(ioctl(fd, FIONREAD, &numbytes) == -1)
err(EXIT_FAILURE, "ioctl");
char *buf[65536];
if(read(fd, buf, sizeof(buf)) == -1)
err(EXIT_FAILURE, "read");
update_image(path);
}
return NULL;
}
static void
refresh_button_clicked(GtkWidget *button, gpointer data)
{
take_photo(config->image_file);
sleep(1);
update_image();
}
static gboolean
handle_queued_objects (APP_STATE_T * state)
{
GstMiniObject *object = NULL;
g_mutex_lock (&state->queue_lock);
if (state->flushing) {
g_cond_broadcast (&state->cond);
goto beach;
} else if (g_async_queue_length (state->queue) == 0) {
goto beach;
}
if ((object = g_async_queue_try_pop (state->queue))) {
if (GST_IS_BUFFER (object)) {
GstBuffer *buffer = GST_BUFFER_CAST (object);
update_image (state, buffer);
render_scene (state);
gst_buffer_unref (buffer);
if (!SYNC_BUFFERS) {
object = NULL;
}
} else if (GST_IS_QUERY (object)) {
GstQuery *query = GST_QUERY_CAST (object);
GstStructure *s = (GstStructure *) gst_query_get_structure (query);
if (gst_structure_has_name (s, "not-used")) {
g_assert_not_reached ();
} else {
g_assert_not_reached ();
}
} else if (GST_IS_EVENT (object)) {
GstEvent *event = GST_EVENT_CAST (object);
g_print ("\nevent %p %s\n", event,
gst_event_type_get_name (GST_EVENT_TYPE (event)));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
flush_internal (state);
break;
default:
break;
}
gst_event_unref (event);
object = NULL;
}
}
if (object) {
state->popped_obj = object;
g_cond_broadcast (&state->cond);
}
beach:
g_mutex_unlock (&state->queue_lock);
return FALSE;
}
void Image_controls::on_modulate_spin_box__valueChanged(double value)
{
int slider_value = static_cast<int>(value * 100.0);
Signal_blocker blocker(ui->modulate_spin_box_);
ui->modulate_slider_->setValue(slider_value);
update_image();
}
void MainWindow::on_pushButton_clicked()
{
if (!ui->label_6->isVisible()) {
billiard->balls[0][0] = billiard->X_size/2;
billiard->balls[0][1] = billiard->Y_size/4;
billiard->balls[0][4] = 1;
update_image();
}
}
void EtagStore::get_value_of_impl(const std::string& key,
const std::string& def) {
{
boost::mutex::scoped_lock lock(resource_->cookie_to_etag_mutex_);
resource_->cookie_to_etag_[cookie_value_].def = def;
}
key_ = key;
update_image();
}
void Image_controls::on_modulate_slider__valueChanged(int value)
{
double spin_box_value = static_cast<double>(value) / 100.0;
Signal_blocker blocker(ui->modulate_slider_);
ui->modulate_spin_box_->setValue(spin_box_value);
update_image();
}
//Handle updating the displayed image from a given midi message
static void midi_update_image(int midi_note,int velocity)
{
if(velocity > 0)
{
switch(midi_note)
{
case C4:
//printf("%c",event->keyval);
update_image("c4.jpg");
break;
case D4:
//printf("%c",event->keyval);
update_image("d4.jpg");
break;
case E4:
//printf("%c",event->keyval);
update_image("e4.jpg");
break;
case F4:
//printf("%c",event->keyval);
update_image("f4.jpg");
break;
case G4:
//printf("%c",event->keyval);
update_image("g4.jpg");
break;
case A5:
//printf("%c",event->keyval);
update_image("a5.jpg");
break;
case B5:
//printf("%c",event->keyval);
update_image("b5.jpg");
break;
case C5:
//printf("%c",event->keyval);
update_image("c5.jpg");
break;
case 96:
//printf("%c",event->keyval);
gtk_exit(0);
break;
}
}
}
void Image_controls::on_image_source_combo_box__currentIndexChanged(int index)
{
if (0 == index)
{
update_constant();
}
else
{
update_image();
}
}
void EtagStore::set_item_impl(const std::string& key,
const std::string& value) {
{
boost::mutex::scoped_lock lock(resource_->cookie_to_etag_mutex_);
typedef EtagStoreResource::Etag Etag;
Etag& etag = resource_->cookie_to_etag_[cookie_value_];
etag.to_client = value;
}
key_ = key;
update_image();
}
void MainWindow::pull(double x1, double y1, double x2, double y2, double speed_factor)
{
QString str;
if (!ui->label_6->isVisible()){
if (N_p == 0) {
ui->label_2->setText("<FONT COLOR=#FF0000>Player 1</FONT>");
ui->label_3->setText("<FONT COLOR=#000000>Player 2</FONT>");
}
if (N_p == 1) {
ui->label_2->setText("<FONT COLOR=#000000>Player 1</FONT>");
ui->label_3->setText("<FONT COLOR=#FF0000>Player 2</FONT>");
}
double sp = billiard->pull(x1, y1, x2, y2, speed_factor);
str.setNum(sp);
ui->textEdit->setText(str);
ui->label_6->setVisible(1);
while (!stop_cond() && !stop) {
QApplication::processEvents();
billiard->move();
update_image();
}
if ((balls - billiard->left_balls) > 0) {
p[N_p] += (balls - billiard->left_balls);
} else {
// N_p = ~N_p;
if (N_p == 1)
N_p = 0;
else {
if (N_p == 0)
N_p = 1;
}
}
balls = billiard->left_balls;
ui->label_6->setVisible(0);
str.setNum(p[0]);
ui->label_4->setText(str);
str.setNum(p[1]);
ui->label_5->setText(str);
if (N_p == 0) {
ui->label_2->setText("<FONT COLOR=#FF0000>Player 1</FONT>");
ui->label_3->setText("<FONT COLOR=#000000>Player 2</FONT>");
}
if (N_p == 1) {
ui->label_2->setText("<FONT COLOR=#000000>Player 1</FONT>");
ui->label_3->setText("<FONT COLOR=#FF0000>Player 2</FONT>");
}
}
}
/////////////////////////////////////////////////////////
// postrender
/////////////////////////////////////////////////////////
void pix_buffer_read :: postrender(GemState *state)
{
m_pixBlock.newimage = 0;
// auto-mode logic:
if(m_auto > 0.00001 || m_auto < -0.00001) {
m_frame+=m_auto;
update_image();
}
/* restore the original incoming image */
state->set(GemState::_PIX, orgPixBlock);
}
void MatCache::set_cv_mat(const cv::Mat &image)
{
invalidate();
af_assert(image.depth() == CV_8U);
if (image.channels() == 1)
update_image("gray_8u", image);
else if (image.channels() == 3)
{
cv::Mat mat;
cv::cvtColor(image, mat, CV_BGR2RGB);
update_image("rgb_8u", mat);
}
else if (image.channels() == 4)
{
cv::Mat mat;
cv::cvtColor(image, mat, CV_BGRA2RGB);
update_image("rgb_8u", mat);
}
else
aifil::except(false, "MatCache: incorrect input channels num: " +
std::to_string(image.channels()));
}
void dialogSourceChangedCallback(GimpIntComboBox *widget, PlugInVals *vals) {
gint value;
#ifdef DEBUG
g_warning("dialogSourceChangedCallback");
#endif
if (gimp_int_combo_box_get_active(widget,&value)) {
vals->image_drawable_id = value;
vals->output_drawable_id = value;
update_image(vals);
renderPreview(vals);
}
}
/* This is the entry point for the pcm view. Normally it just calls the
* renderer with the input data.
*/
static void blursk_render_pcm(gint16 data[2][512])
{
gint i, imin, imax, start;
gint32 loudness, delta_sum;
/* If slow motion, then ignore odd-numbered frames */
oddeven = !oddeven;
if (config.slow_motion && oddeven)
return;
#if 0
/* if not supposed to do PCM data, then do nothing */
if (blursk_vp.num_pcm_chs_wanted == 0)
return;
#endif
/* Find the maximum and minimum, with the restriction that
* the minimum must occur after the maximum.
*/
for (i = 1, imin = imax = 0, delta_sum = 0; i < 127 / 2; i++)
{
if (data[0][i] < data[0][imin])
imin = i;
if (data[0][i] > data[0][imax])
imin = imax = i;
delta_sum += abs(data[0][i] - data[0][i - i]);
}
/* Triggered sweeps start halfway between min & max */
start = (imax + imin) / 2;
/* Compute the loudness. We don't want to do a full spectrum analysis
* to do this, but we can guess the low-frequency sound is proportional
* to the maximum difference found (because loud low frequencies need
* big signal changes), and that high-frequency sound is proportional
* to the differences between adjacent samples. We want to be sensitive
* to both of those, while ignoring the mid-range sound.
*
* Because we have only one low-frequency difference, but hundreds of
* high-frequency differences, we need to give more weight to the
* low-frequency difference (even though each high-frequency difference
* is small).
*/
loudness = (((gint32)data[0][imax] - (gint32)data[0][imin]) * 60 + delta_sum) / 75;
/* Draw it */
update_image(loudness, 256, &data[0][start]);
}
void MainWindow::on_actionStart_triggered()
{
billiard = new QBilliard;
billiard->init();
update_image();
stop = 0;
ui->label_2->setVisible(1);
ui->label_3->setVisible(1);
ui->label_4->setVisible(1);
ui->label_5->setVisible(1);
ui->label->setVisible(1);
ui->textEdit->setVisible(1);
ui->pushButton->setVisible(1);
ui->label_2->setText("<FONT COLOR=#FF0000>Player 1</FONT>");
}
int key_hook(int keycode, t_env *e)
{
if (keycode == ESCAPE || keycode == ESCAPE_MAC)
{
if (e->scene)
delete_scene(e->scene);
exit(0);
}
if (e->scene->mode == MOVE_MODE)
key_hook_camera(keycode, e->scene->camera);
else
key_hook_objects(keycode, e->scene);
key_hook_light(keycode, e->scene);
key_hook_scene(keycode, e);
print_keyhook(keycode, e);
update_image(e);
return (0);
}
Gui::Gui ( int argc, char** argv, QWidget *parent ) :
QMainWindow ( parent ),
ui ( new Ui::Gui )
{
ui->setupUi ( this );
cvWindow = new CvWindow ( QString ( "cvWindow" ), CV_WINDOW_AUTOSIZE );
// set the location of 'cvWindow'
cvWindow->setParent ( ui->frame );
readSettings();
social_robot_gui = new SocialRobotGui ( argc, argv );
qRegisterMetaType< Mat > ( "Mat" );
connect ( social_robot_gui, SIGNAL ( update_image ( Mat ) ), this, SLOT ( updateImage ( Mat ) ) );
social_robot_gui->init();
// If the frame resizes, update the image size
connect ( ui->frame, SIGNAL ( resizeImage ( QSize ) ), this, SLOT ( updateImageSize ( QSize ) ) );
updateImageSize ( ui->frame->size() );
}
void *count_down_thread ()
{
gchar buf[1024];
int countdown = settings->update_interval;
for (;;)
{
sleep(1);
if(timmer_running == TRUE)
{
gdk_threads_enter ();
if(countdown == 1)
{
take_photo(config->image_file);
sleep(1);
update_image();
countdown = settings->update_interval;
} else
countdown--;
g_ascii_dtostr(buf, sizeof (buf), countdown);
gtk_label_set_label(GTK_LABEL(lblUpdate), buf );
gdk_threads_leave ();
} else {
countdown = settings->update_interval;
}
}
return NULL;
}
void PropertyDisplay::on_change() {
switch (prop_->type()) {
case TypeLong:
value_ = boost::lexical_cast<std::string>(prop_->get<long>());
break;
case TypeDouble:
value_ = boost::lexical_cast<std::string>(prop_->get<double>());
break;
case TypeString:
value_ = prop_->get<std::string>();
break;
case TypeImage:
update_image();
break;
default:
throw std::runtime_error("Unknown property type in PropertyDisplay::on_change()");
}
if (output_ != NULL) {
output_->label(value_.c_str());
output_->damage(0xff);
}
}
//dev function used to manually trigger image updates
static void button_press_callback( GtkWidget *widget, GdkEventKey *event, gpointer data )
{
switch(event->keyval)
{
case 'a':
//printf("%c",event->keyval);
update_image("a.jpg");
break;
case 'b':
//printf("%c",event->keyval);
update_image("b.jpg");
break;
case 'c':
//printf("%c",event->keyval);
update_image("c.jpg");
break;
case 'd':
//printf("%c",event->keyval);
update_image("d.jpg");
break;
case 'e':
//printf("%c",event->keyval);
update_image("e.jpg");
break;
case 'f':
//printf("%c",event->keyval);
update_image("f.jpg");
break;
}
}
void
fractFunc::draw(
int rsize, int drawsize, float min_progress, float max_progress)
{
if(debug_flags & DEBUG_QUICK_TRACE)
{
printf("drawing: %d\n", render_type);
}
reset_counts();
// init RNG based on time before generating image
time_t now;
time(&now);
srand((unsigned int)now);
int x,y;
int w = im->Xres();
int h = im->Yres();
/* reset progress indicator & clear screen */
last_update_y = 0;
reset_progress(min_progress);
float mid_progress = (max_progress + min_progress)/2.0;
set_progress_range(min_progress, mid_progress);
// first pass - big blocks and edges
for (y = 0 ; y < h - rsize ; y += rsize)
{
// main large blocks
for ( x = 0 ; x< w - rsize ; x += rsize)
{
worker->pixel ( x, y, drawsize, drawsize);
}
// extra pixels at end of lines
for(int y2 = y; y2 < y + rsize; ++y2)
{
worker->row (x, y2, w-x);
}
if(update_image(y))
{
goto done;
}
}
// remaining lines
for ( ; y < h ; y++)
{
worker->row(0,y,w);
if(update_image(y))
{
goto done;
}
}
last_update_y = 0;
reset_progress(0.0);
set_progress_range(mid_progress, max_progress);
// fill in gaps in the rsize-blocks
for ( y = 0; y < h - rsize; y += rsize) {
for(x = 0; x < w - rsize ; x += rsize) {
worker->box(x,y,rsize);
}
if(update_image(y))
{
goto done;
}
}
done:
/* refresh entire image & reset progress bar */
reset_progress(1.0);
}
int main(int argc, char *argv[])
{
char buf[256];
PALETTE pal;
BITMAP *image;
BITMAP *page[2];
BITMAP *vimage;
IMAGE images[MAX_IMAGES];
int num_images = 4;
int page_num = 1;
int done = FALSE;
int i;
if (allegro_init() != 0)
return 1;
install_keyboard();
install_timer();
/* see comments in exflip.c */
#ifdef ALLEGRO_VRAM_SINGLE_SURFACE
if (set_gfx_mode(GFX_AUTODETECT, 1024, 768, 0, 2 * 768 + 200) != 0) {
#else
if (set_gfx_mode(GFX_AUTODETECT, 1024, 768, 0, 0) != 0) {
#endif
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Error setting graphics mode\n%s\n", allegro_error);
return 1;
}
/* read in the source graphic */
replace_filename(buf, argv[0], "mysha.pcx", sizeof(buf));
image = load_bitmap(buf, pal);
if (!image) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Error reading %s!\n", buf);
return 1;
}
set_palette(pal);
/* initialise the images to random positions */
for (i=0; i<MAX_IMAGES; i++)
init_image(images+i);
/* create two video memory bitmaps for page flipping */
page[0] = create_video_bitmap(SCREEN_W, SCREEN_H);
page[1] = create_video_bitmap(SCREEN_W, SCREEN_H);
/* create a video memory bitmap to store our picture */
vimage = create_video_bitmap(image->w, image->h);
if ((!page[0]) || (!page[1]) || (!vimage)) {
set_gfx_mode(GFX_TEXT, 0, 0, 0, 0);
allegro_message("Not enough video memory (need two 1024x768 pages "
"and a 320x200 image)\n");
return 1;
}
/* copy the picture into offscreen video memory */
blit(image, vimage, 0, 0, 0, 0, image->w, image->h);
while (!done) {
acquire_bitmap(page[page_num]);
/* clear the screen */
clear_bitmap(page[page_num]);
/* draw onto it */
for (i=0; i<num_images; i++)
blit(vimage, page[page_num], 0, 0, images[i].x, images[i].y,
vimage->w, vimage->h);
textprintf_ex(page[page_num], font, 0, 0, 255, -1,
"Images: %d (arrow keys to change)", num_images);
/* tell the user which functions are being done in hardware */
if (gfx_capabilities & GFX_HW_FILL)
textout_ex(page[page_num], font, "Clear: hardware accelerated",
0, 16, 255, -1);
else
textout_ex(page[page_num], font, "Clear: software (urgh, this "
"is not good!)", 0, 16, 255, -1);
if (gfx_capabilities & GFX_HW_VRAM_BLIT)
textout_ex(page[page_num], font, "Blit: hardware accelerated",
0, 32, 255, -1);
else
textout_ex(page[page_num], font, "Blit: software (urgh, this program "
"will run too sloooooowly without hardware acceleration!)",
0, 32, 255, -1);
release_bitmap(page[page_num]);
/* page flip */
show_video_bitmap(page[page_num]);
page_num = 1-page_num;
/* deal with keyboard input */
while (keypressed()) {
switch (readkey()>>8) {
case KEY_UP:
case KEY_RIGHT:
if (num_images < MAX_IMAGES)
num_images++;
break;
case KEY_DOWN:
case KEY_LEFT:
if (num_images > 0)
num_images--;
break;
case KEY_ESC:
done = TRUE;
break;
}
}
/* bounce the images around the screen */
for (i=0; i<num_images; i++)
update_image(images+i);
}
destroy_bitmap(image);
destroy_bitmap(vimage);
destroy_bitmap(page[0]);
destroy_bitmap(page[1]);
return 0;
}
END_OF_MAIN()
static gboolean
handle_queued_objects (APP_STATE_T * state)
{
GstMiniObject *object = NULL;
g_mutex_lock (state->queue_lock);
if (state->flushing) {
g_cond_broadcast (state->cond);
goto beach;
} else if (g_async_queue_length (state->queue) == 0) {
goto beach;
}
if ((object = g_async_queue_try_pop (state->queue))) {
if (GST_IS_BUFFER (object)) {
GstBuffer *buffer = GST_BUFFER_CAST (object);
update_image (state, buffer);
render_scene (state);
gst_buffer_unref (buffer);
if (!SYNC_BUFFERS) {
object = NULL;
}
} else if (GST_IS_QUERY (object)) {
GstQuery *query = GST_QUERY_CAST (object);
GstStructure *s = (GstStructure *) gst_query_get_structure (query);
if (gst_structure_has_name (s, "eglglessink-allocate-eglimage")) {
GstBuffer *buffer;
GstVideoFormat format;
gint width, height;
GValue v = { 0, };
if (!gst_structure_get_enum (s, "format", GST_TYPE_VIDEO_FORMAT,
(gint *) & format)
|| !gst_structure_get_int (s, "width", &width)
|| !gst_structure_get_int (s, "height", &height)) {
g_assert_not_reached ();
}
buffer =
gst_egl_allocate_eglimage (state,
GST_EGL_IMAGE_BUFFER_POOL (state->pool)->allocator, format,
width, height);
g_value_init (&v, G_TYPE_POINTER);
g_value_set_pointer (&v, buffer);
gst_structure_set_value (s, "buffer", &v);
g_value_unset (&v);
} else {
g_assert_not_reached ();
}
} else if (GST_IS_EVENT (object)) {
GstEvent *event = GST_EVENT_CAST (object);
g_print ("\nevent %p %s\n", event,
gst_event_type_get_name (GST_EVENT_TYPE (event)));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_EOS:
flush_internal (state);
break;
default:
break;
}
gst_event_unref (event);
object = NULL;
}
}
if (object) {
state->popped_obj = object;
g_cond_broadcast (state->cond);
}
beach:
g_mutex_unlock (state->queue_lock);
return FALSE;
}
/////////////////////////////////////////////////////////
// startRendering
/////////////////////////////////////////////////////////
void pix_buffer_read :: startRendering()
{
update_image();
}