diff options
| -rw-r--r-- | xine_post_atmo.c | 521 |
1 files changed, 377 insertions, 144 deletions
diff --git a/xine_post_atmo.c b/xine_post_atmo.c index 723470b..1dde883 100644 --- a/xine_post_atmo.c +++ b/xine_post_atmo.c @@ -44,11 +44,11 @@ extern long int lround(double); /* Missing in math.h? */ #define LOG_2 0 -#define OUTPUT_RATE 20 /* rate of output loop [ms] */ -#define GRAB_TIMEOUT 100 /* max. time waiting for next grab image [ms] */ -#define THREAD_TERMINATION_WAIT_TIME 150 /* time waiting for thread termination [ms] */ +#define OUTPUT_RATE 20 /* rate of output loop [ms] */ +#define GRAB_TIMEOUT 100 /* max. time waiting for next grab image [ms] */ +#define THREAD_RESPONSE_TIMEOUT 500000 /* timeout for thread state change [us] */ -#define NUM_AREAS 9 /* Number of different areas (top, bottom ...) */ +#define NUM_AREAS 9 /* Number of different areas (top, bottom ...) */ /* accuracy of color calculation */ #define h_MAX 255 @@ -185,6 +185,7 @@ typedef struct { xine_t *xine; } atmo_post_class_t; +enum { TS_STOP, TS_RUNNING, TS_SUSPEND, TS_SUSPENDED, TS_TICKET_REVOKED }; typedef struct atmo_post_plugin_s { @@ -201,10 +202,10 @@ typedef struct atmo_post_plugin_s int sum_channels; /* thread related */ - int *grab_running, *output_running; + int *grab_thread_state, *output_thread_state; pthread_t grab_thread, output_thread; pthread_mutex_t lock; - pthread_cond_t thread_started, thread_stopped; + pthread_cond_t thread_state_change; /* output related */ output_driver_t *output_driver; @@ -755,9 +756,9 @@ static void calc_rgb_values(atmo_post_plugin_t *this) static void *atmo_grab_loop (void *this_gen) { atmo_post_plugin_t *this = (atmo_post_plugin_t *) this_gen; - post_video_port_t *port = this->port; - xine_video_port_t *video_port = port->original_port; xine_ticket_t *ticket = this->post_plugin.running_ticket; + post_video_port_t *port = NULL; + xine_video_port_t *video_port = NULL; #ifdef HAVE_XINE_VO_GRAB_FRAME vo_grab_frame_t *frame = NULL; #else @@ -768,24 +769,95 @@ static void *atmo_grab_loop (void *this_gen) { int last_analyze_width = 0, last_analyze_height = 0; int alloc_img_size = 0; int edge_weighting = 0; - int running = 1; hsv_color_t *hsv_img = NULL; uint8_t *weight = NULL; - struct timeval tvnow, tvlast, tvdiff; - useconds_t analyze_rate; - - _x_post_inc_usage(port); + struct timeval tvnow, tvlast, tvdiff, tvtimeout; + struct timespec ts; + int thread_state = TS_RUNNING; pthread_mutex_lock(&this->lock); - this->grab_running = &running; - pthread_cond_broadcast(&this->thread_started); + this->grab_thread_state = &thread_state; + pthread_cond_broadcast(&this->thread_state_change); pthread_mutex_unlock(&this->lock); llprintf(LOG_1, "grab thread running\n"); ticket->acquire(ticket, 0); - while (running) { + pthread_mutex_lock(&this->lock); + + gettimeofday(&tvlast, NULL); + + for (;;) { + + /* loop with analyze rate duration */ + tvdiff.tv_sec = 0; + tvdiff.tv_usec = this->active_parm.analyze_rate * 1000; + timeradd(&tvlast, &tvdiff, &tvtimeout); + gettimeofday(&tvnow, NULL); + if (timercmp(&tvtimeout, &tvnow, >)) { + ts.tv_sec = tvtimeout.tv_sec; + ts.tv_nsec = tvtimeout.tv_usec; + ts.tv_nsec *= 1000; + pthread_cond_timedwait(&this->thread_state_change, &this->lock, &ts); + gettimeofday(&tvnow, NULL); + } + tvlast = tvnow; + + if (thread_state == TS_STOP) + break; + + if (ticket->ticket_revoked || thread_state == TS_SUSPEND) { + /* free grab frame */ + if (frame) { +#ifdef HAVE_XINE_VO_GRAB_FRAME + frame->dispose(frame); +#else + xine_port_send_gui_data(video_port, XINE_GUI_SEND_FREE_GRAB_FRAME, frame); +#endif + frame = NULL; + } + + if (ticket->ticket_revoked) { + llprintf(LOG_1, "grab thread waiting for new ticket\n"); + + thread_state = TS_TICKET_REVOKED; + pthread_cond_broadcast(&this->thread_state_change); + pthread_mutex_unlock(&this->lock); + + ticket->renew(ticket, 0); + + pthread_mutex_lock(&this->lock); + if (thread_state == TS_STOP) + break; + + thread_state = TS_RUNNING; + pthread_cond_broadcast(&this->thread_state_change); + + llprintf(LOG_1, "grab thread got new ticket (revoke=%d)\n", ticket->ticket_revoked); + + gettimeofday(&tvlast, NULL); + continue; + } + + thread_state = TS_SUSPENDED; + pthread_cond_broadcast(&this->thread_state_change); + + llprintf(LOG_1, "grab thread suspended\n"); + } + + if (thread_state == TS_SUSPENDED || !this->port) + continue; + + if (port && port != this->port) { + _x_post_dec_usage(port); + port = NULL; + } + if (!port) { + port = this->port; + video_port = port->original_port; + _x_post_inc_usage(port); + } /* allocate grab frame */ if (!frame) { @@ -801,25 +873,11 @@ static void *atmo_grab_loop (void *this_gen) { xine_log(this->post_plugin.xine, XINE_LOG_PLUGIN, "atmo: frame grabbing not supported!\n"); break; } - } - if (ticket->ticket_revoked) { - /* free grab frame */ - if (frame) { -#ifdef HAVE_XINE_VO_GRAB_FRAME - frame->dispose(frame); -#else - xine_port_send_gui_data(video_port, XINE_GUI_SEND_FREE_GRAB_FRAME, frame); -#endif - frame = NULL; - } - llprintf(LOG_1, "grab thread waiting for new ticket\n"); - ticket->renew(ticket, 0); - llprintf(LOG_1, "grab thread got new ticket\n"); - continue; + llprintf(LOG_1, "grab thread resumed\n"); } - gettimeofday(&tvlast, NULL); + pthread_mutex_unlock(&this->lock); /* get actual displayed image size */ grab_width = video_port->get_property(video_port, VO_PROP_WINDOW_WIDTH); @@ -865,8 +923,10 @@ static void *atmo_grab_loop (void *this_gen) { alloc_img_size = img_size; hsv_img = (hsv_color_t *) malloc(img_size * sizeof(hsv_color_t)); weight = (uint8_t *) malloc(img_size * this->sum_channels * sizeof(uint8_t)); - if (!hsv_img || !weight) + if (!hsv_img || !weight) { + pthread_mutex_lock(&this->lock); break; + } last_analyze_width = 0; last_analyze_height = 0; edge_weighting = 0; @@ -895,9 +955,8 @@ static void *atmo_grab_loop (void *this_gen) { calc_average_brightness(this, hsv_img, weight, img_size); pthread_mutex_lock(&this->lock); calc_rgb_values(this); - pthread_mutex_unlock(&this->lock); - llprintf(LOG_2, "grab %ld.%03ld: vpts=%ld\n", tvlast.tv_sec, tvlast.tv_usec / 1000, frame->vpts); + continue; } } else { if (rc < 0) @@ -907,12 +966,7 @@ static void *atmo_grab_loop (void *this_gen) { } } - /* loop with analyze rate duration */ - analyze_rate = this->active_parm.analyze_rate * 1000; - gettimeofday(&tvnow, NULL); - timersub(&tvnow, &tvlast, &tvdiff); - if (tvdiff.tv_sec == 0 && tvdiff.tv_usec < analyze_rate) - usleep(analyze_rate - tvdiff.tv_usec); + pthread_mutex_lock(&this->lock); #if 0 { @@ -934,6 +988,8 @@ static void *atmo_grab_loop (void *this_gen) { #endif } + llprintf(LOG_1, "grab thread terminating\n"); + /* free grab frame */ if (frame) { #ifdef HAVE_XINE_VO_GRAB_FRAME @@ -943,19 +999,21 @@ static void *atmo_grab_loop (void *this_gen) { #endif } - ticket->release(ticket, 0); + if (this->grab_thread_state == &thread_state) + this->grab_thread_state = NULL; + pthread_cond_broadcast(&this->thread_state_change); + pthread_mutex_unlock(&this->lock); free(hsv_img); free(weight); - pthread_mutex_lock(&this->lock); - this->grab_running = NULL; - pthread_cond_broadcast(&this->thread_stopped); - pthread_mutex_unlock(&this->lock); + if (port) + _x_post_dec_usage(port); - _x_post_dec_usage(port); + ticket->release(ticket, 0); llprintf(LOG_1, "grab thread terminated\n"); + return NULL; } @@ -1078,44 +1136,111 @@ static void apply_gamma_correction(atmo_post_plugin_t *this) { static void *atmo_output_loop (void *this_gen) { atmo_post_plugin_t *this = (atmo_post_plugin_t *) this_gen; - post_video_port_t *port = this->port; xine_ticket_t *ticket = this->post_plugin.running_ticket; - output_driver_t *output_driver = this->output_driver; - int colors_size = this->sum_channels * sizeof(rgb_color_t); - int running = 1; + post_video_port_t *port = NULL; + output_driver_t *output_driver = NULL; + int colors_size = 0, init = 1; int delay_filter_queue_length = 0, delay_filter_queue_pos = 0, filter_delay = 0; rgb_color_t *delay_filter_queue = NULL; - struct timeval tvnow, tvlast, tvdiff, tvfirst; - - _x_post_inc_usage(port); + struct timeval tvnow, tvlast, tvdiff, tvtimeout, tvfirst; + struct timespec ts; + int thread_state = TS_RUNNING; pthread_mutex_lock(&this->lock); - this->output_running = &running; - pthread_cond_broadcast(&this->thread_started); + this->output_thread_state = &thread_state; + pthread_cond_broadcast(&this->thread_state_change); pthread_mutex_unlock(&this->lock); llprintf(LOG_1, "output thread running\n"); ticket->acquire(ticket, 0); - reset_filters(this); - gettimeofday(&tvfirst, NULL); + pthread_mutex_lock(&this->lock); - while (running) { + gettimeofday(&tvlast, NULL); - if (ticket->ticket_revoked) { - reset_filters(this); - filter_delay = 0; - llprintf(LOG_1, "output thread waiting for new ticket\n"); - ticket->renew(ticket, 0); - llprintf(LOG_1, "output thread got new ticket\n"); + for (;;) { + + /* Loop with output rate duration */ + tvdiff.tv_sec = 0; + tvdiff.tv_usec = OUTPUT_RATE * 1000; + timeradd(&tvlast, &tvdiff, &tvtimeout); + gettimeofday(&tvnow, NULL); + if (timercmp(&tvtimeout, &tvnow, >)) { + ts.tv_sec = tvtimeout.tv_sec; + ts.tv_nsec = tvtimeout.tv_usec; + ts.tv_nsec *= 1000; + pthread_cond_timedwait(&this->thread_state_change, &this->lock, &ts); + gettimeofday(&tvnow, NULL); + } + tvlast = tvnow; + + if (thread_state == TS_STOP) + break; + + if (ticket->ticket_revoked || thread_state == TS_SUSPEND) { + /* turn lights off */ + memset(this->output_colors, 0, colors_size); + if (memcmp(this->output_colors, this->last_output_colors, colors_size)) { + this->output_driver->output_colors(this->output_driver, this->output_colors, this->last_output_colors); + memset(this->last_output_colors, 0, colors_size); + } + init = 1; + + if (ticket->ticket_revoked) { + llprintf(LOG_1, "output thread waiting for new ticket\n"); + + thread_state = TS_TICKET_REVOKED; + pthread_cond_broadcast(&this->thread_state_change); + pthread_mutex_unlock(&this->lock); + + ticket->renew(ticket, 0); + + pthread_mutex_lock(&this->lock); + if (thread_state == TS_STOP) + break; + + thread_state = TS_RUNNING; + pthread_cond_broadcast(&this->thread_state_change); + + llprintf(LOG_1, "output thread got new ticket (revoke=%d)\n", ticket->ticket_revoked); + + gettimeofday(&tvlast, NULL); + continue; + } + + thread_state = TS_SUSPENDED; + pthread_cond_broadcast(&this->thread_state_change); + + llprintf(LOG_1, "output thread suspended\n"); + } + + if (thread_state == TS_SUSPENDED || !this->port) continue; + + if (port && port != this->port) { + _x_post_dec_usage(port); + port = NULL; + } + if (!port) { + port = this->port; + _x_post_inc_usage(port); } - gettimeofday(&tvlast, NULL); + if (init) { + init = 0; + + output_driver = this->output_driver; + colors_size = this->sum_channels * sizeof(rgb_color_t); + reset_filters(this); + filter_delay = 0; + + gettimeofday(&tvfirst, NULL); + + llprintf(LOG_1, "output thread resumed\n"); + } /* Transfer analyzed colors into filtered colors */ - pthread_mutex_lock(&this->lock); switch (this->active_parm.filter) { case 1: percent_filter(this); @@ -1127,10 +1252,10 @@ static void *atmo_output_loop (void *this_gen) { /* no filtering */ memcpy(this->filtered_colors, this->analyzed_colors, colors_size); } + pthread_mutex_unlock(&this->lock); - gettimeofday(&tvnow, NULL); - timersub(&tvnow, &tvfirst, &tvdiff); + timersub(&tvlast, &tvfirst, &tvdiff); if ((tvdiff.tv_sec * 1000 + tvdiff.tv_usec / 1000) >= this->active_parm.start_delay) { /* Initialize delay filter queue */ @@ -1168,12 +1293,7 @@ static void *atmo_output_loop (void *this_gen) { } } - /* Loop with output rate duration */ - const useconds_t output_rate = OUTPUT_RATE * 1000; - gettimeofday(&tvnow, NULL); - timersub(&tvnow, &tvlast, &tvdiff); - if (tvdiff.tv_sec == 0 && tvdiff.tv_usec < output_rate) - usleep(output_rate - tvdiff.tv_usec); + pthread_mutex_lock(&this->lock); #if 0 { @@ -1195,23 +1315,19 @@ static void *atmo_output_loop (void *this_gen) { #endif } - /* Turn off Light */ - memset(this->output_colors, 0, colors_size); - if (memcmp(this->output_colors, this->last_output_colors, colors_size)) { - output_driver->output_colors(output_driver, this->output_colors, this->last_output_colors); - memset(this->last_output_colors, 0, colors_size); - } + llprintf(LOG_1, "output thread terminating\n"); - free(delay_filter_queue); + if (this->output_thread_state == &thread_state) + this->output_thread_state = NULL; + pthread_cond_broadcast(&this->thread_state_change); + pthread_mutex_unlock(&this->lock); - ticket->release(ticket, 0); + free(delay_filter_queue); - pthread_mutex_lock(&this->lock); - this->output_running = NULL; - pthread_cond_broadcast(&this->thread_stopped); - pthread_mutex_unlock(&this->lock); + if (port) + _x_post_dec_usage(port); - _x_post_dec_usage(port); + ticket->release(ticket, 0); llprintf(LOG_1, "output thread terminated\n"); @@ -1278,63 +1394,160 @@ static void free_channels(atmo_post_plugin_t *this) { } -static void start_threads(atmo_post_plugin_t *this) { - int err; - pthread_attr_t pth_attrs; +static int wait_for_thread_state_change(atmo_post_plugin_t *this) { + struct timeval tvnow, tvdiff, tvtimeout; + struct timespec ts; - pthread_attr_init(&pth_attrs); - pthread_attr_setscope(&pth_attrs, PTHREAD_SCOPE_SYSTEM); - pthread_attr_setdetachstate(&pth_attrs, PTHREAD_CREATE_DETACHED); + /* calculate absolute timeout time */ + tvdiff.tv_sec = 0; + tvdiff.tv_usec = THREAD_RESPONSE_TIMEOUT; + gettimeofday(&tvnow, NULL); + timeradd(&tvnow, &tvdiff, &tvtimeout); + ts.tv_sec = tvtimeout.tv_sec; + ts.tv_nsec = tvtimeout.tv_usec; + ts.tv_nsec *= 1000; - pthread_mutex_lock(&this->lock); - if (this->grab_running == NULL) { - if ((err = pthread_create (&this->grab_thread, &pth_attrs, atmo_grab_loop, this))) - xine_log(this->post_plugin.xine, XINE_LOG_PLUGIN, "atmo: can't create grab thread (%s)\n", strerror(err)); - else - pthread_cond_wait(&this->thread_started, &this->lock); + if (pthread_cond_timedwait(&this->thread_state_change, &this->lock, &ts) == ETIMEDOUT) { + xine_log(this->post_plugin.xine, XINE_LOG_PLUGIN, "atmo: timeout while waiting for thread state change!\n"); + return 0; } + return 1; +} - if (this->output_running == NULL) { - if ((err = pthread_create (&this->output_thread, &pth_attrs, atmo_output_loop, this))) - xine_log(this->post_plugin.xine, XINE_LOG_PLUGIN, "atmo: can't create output thread (%s)\n", strerror(err)); - else - pthread_cond_wait(&this->thread_started, &this->lock); + +static void start_threads(atmo_post_plugin_t *this) { + + pthread_mutex_lock(&this->lock); + + int grab_running = 0, output_running = 0; + if (this->grab_thread_state == NULL || this->output_thread_state == NULL) { + pthread_attr_t pth_attrs; + pthread_attr_init(&pth_attrs); + pthread_attr_setscope(&pth_attrs, PTHREAD_SCOPE_SYSTEM); + pthread_attr_setdetachstate(&pth_attrs, PTHREAD_CREATE_DETACHED); + + int err = 0; + if (this->grab_thread_state == NULL) { + if ((err = pthread_create (&this->grab_thread, &pth_attrs, atmo_grab_loop, this))) { + xine_log(this->post_plugin.xine, XINE_LOG_PLUGIN, "atmo: can't create grab thread (%s)\n", strerror(err)); + grab_running = 1; + } + } + if (!err && this->output_thread_state == NULL) { + if ((err = pthread_create (&this->output_thread, &pth_attrs, atmo_output_loop, this))) { + xine_log(this->post_plugin.xine, XINE_LOG_PLUGIN, "atmo: can't create output thread (%s)\n", strerror(err)); + output_running = 1; + } + } + + pthread_attr_destroy(&pth_attrs); } + + do { + int changed = 0; + if (!grab_running) { + if (this->grab_thread_state) { + if (*this->grab_thread_state != TS_TICKET_REVOKED && *this->grab_thread_state != TS_RUNNING) { + *this->grab_thread_state = TS_RUNNING; + changed = 1; + } + grab_running = 1; + } + } + if (!output_running) { + if (this->output_thread_state) { + if (*this->output_thread_state != TS_TICKET_REVOKED && *this->output_thread_state != TS_RUNNING) { + *this->output_thread_state = TS_RUNNING; + changed = 1; + } + output_running = 1; + } + } + if (changed) + pthread_cond_broadcast(&this->thread_state_change); + } while ((!grab_running || !output_running) && wait_for_thread_state_change(this)); + pthread_mutex_unlock(&this->lock); +} + - pthread_attr_destroy(&pth_attrs); +static void suspend_threads(atmo_post_plugin_t *this) { + + pthread_mutex_lock(&this->lock); + + int grab_suspended = 0, output_suspended = 0; + do { + int changed = 0; + if (!grab_suspended) { + if (this->grab_thread_state) { + if (*this->grab_thread_state == TS_SUSPENDED || *this->grab_thread_state == TS_TICKET_REVOKED) { + grab_suspended = 1; + } else if (*this->grab_thread_state != TS_SUSPEND) { + *this->grab_thread_state = TS_SUSPEND; + changed = 1; + } + } else { + grab_suspended = 1; + } + } + if (!output_suspended) { + if (this->output_thread_state) { + if (*this->output_thread_state == TS_SUSPENDED || *this->output_thread_state == TS_TICKET_REVOKED) { + output_suspended = 1; + } else if (*this->output_thread_state != TS_SUSPEND) { + *this->output_thread_state = TS_SUSPEND; + changed = 1; + } + } else { + output_suspended = 1; + } + } + if (changed) + pthread_cond_broadcast(&this->thread_state_change); + } while ((!grab_suspended || !output_suspended) && wait_for_thread_state_change(this)); + + pthread_mutex_unlock(&this->lock); } static void stop_threads(atmo_post_plugin_t *this) { + pthread_mutex_lock(&this->lock); - if (this->grab_running) - *this->grab_running = 0; - if (this->output_running) - *this->output_running = 0; - if (this->grab_running || this->output_running) { - struct timeval tvnow, tvdiff, tvtimeout; - struct timespec ts; - - /* calculate absolute timeout time */ - tvdiff.tv_sec = THREAD_TERMINATION_WAIT_TIME / 1000; - tvdiff.tv_usec = THREAD_TERMINATION_WAIT_TIME % 1000; - tvdiff.tv_usec *= 1000; - gettimeofday(&tvnow, NULL); - timeradd(&tvnow, &tvdiff, &tvtimeout); - ts.tv_sec = tvtimeout.tv_sec; - ts.tv_nsec = tvtimeout.tv_usec; - ts.tv_nsec *= 1000; - - while (this->grab_running || this->output_running) { - if (pthread_cond_timedwait(&this->thread_stopped, &this->lock, &ts) == ETIMEDOUT) { - xine_log(this->post_plugin.xine, XINE_LOG_PLUGIN, "atmo: timeout while waiting for thread stop!\n"); - break; + + int grab_stopped = 0, output_stopped = 0; + do { + int changed = 0; + if (!grab_stopped) { + if (this->grab_thread_state) { + if (*this->grab_thread_state == TS_TICKET_REVOKED) { + *this->grab_thread_state = TS_STOP; + grab_stopped = 1; + } else if (*this->grab_thread_state != TS_STOP) { + *this->grab_thread_state = TS_STOP; + changed = 1; + } + } else + grab_stopped = 1; + } + if (!output_stopped) { + if (this->output_thread_state) { + if (*this->output_thread_state == TS_TICKET_REVOKED) { + *this->output_thread_state = TS_STOP; + output_stopped = 1; + } else if (*this->output_thread_state != TS_STOP) { + *this->output_thread_state = TS_STOP; + changed = 1; + } + } else { + output_stopped = 1; } } - } - this->grab_running = NULL; - this->output_running = NULL; + if (changed) + pthread_cond_broadcast(&this->thread_state_change); + } while ((!grab_stopped || !output_stopped) && wait_for_thread_state_change(this)); + + this->grab_thread_state = NULL; + this->output_thread_state = NULL; pthread_mutex_unlock(&this->lock); } @@ -1342,11 +1555,13 @@ static void stop_threads(atmo_post_plugin_t *this) { static void close_output_driver(atmo_post_plugin_t *this) { if (this->driver_opened) { - /* Switch all channels off */ + /* turn lights off */ int colors_size = this->sum_channels * sizeof(rgb_color_t); memset(this->output_colors, 0, colors_size); - if (memcmp(this->output_colors, this->last_output_colors, colors_size)) + if (memcmp(this->output_colors, this->last_output_colors, colors_size)) { this->output_driver->output_colors(this->output_driver, this->output_colors, this->last_output_colors); + memset(this->last_output_colors, 0, colors_size); + } if (this->output_driver->close(this->output_driver)) xine_log(this->post_plugin.xine, XINE_LOG_PLUGIN, "atmo: output driver: %s!\n", this->output_driver->errmsg); @@ -1358,12 +1573,14 @@ static void close_output_driver(atmo_post_plugin_t *this) { static void open_output_driver(atmo_post_plugin_t *this) { - if (!this->parm.enabled || this->active_parm.driver != this->parm.driver || strcmp(this->active_parm.driver_param, this->parm.driver_param)) + if (!this->parm.enabled || this->active_parm.driver != this->parm.driver || strcmp(this->active_parm.driver_param, this->parm.driver_param)) { + stop_threads(this); close_output_driver(this); + } if (this->parm.enabled) { - int start = 1; atmo_parameters_t parm = this->parm; + int start = 1, send = 0; /* open output driver */ if (!this->driver_opened) { @@ -1375,6 +1592,7 @@ static void open_output_driver(atmo_post_plugin_t *this) { start = 0; } else { this->driver_opened = 1; + send = 1; llprintf(LOG_1, "output driver opened\n"); } } else { @@ -1401,6 +1619,7 @@ static void open_output_driver(atmo_post_plugin_t *this) { this->active_parm.bottom_right != this->parm.bottom_right) { free_channels(this); config_channels(this); + send = 1; } this->active_parm = this->parm; @@ -1410,10 +1629,12 @@ static void open_output_driver(atmo_post_plugin_t *this) { if (start) { /* send first initial color packet */ - this->output_driver->output_colors(this->output_driver, this->output_colors, NULL); + if (send) + this->output_driver->output_colors(this->output_driver, this->output_colors, NULL); start_threads(this); - } + } else + stop_threads(this); } } @@ -1426,6 +1647,7 @@ static void atmo_video_open(xine_video_port_t *port_gen, xine_stream_t *stream) post_video_port_t *port = (post_video_port_t *)port_gen; atmo_post_plugin_t *this = (atmo_post_plugin_t *) port->post; + llprintf(LOG_1, "video open\n"); _x_post_rewire(port->post); _x_post_inc_usage(port); @@ -1433,8 +1655,10 @@ static void atmo_video_open(xine_video_port_t *port_gen, xine_stream_t *stream) (port->original_port->open) (port->original_port, stream); port->stream = stream; this->port = port; + open_output_driver(this); pthread_mutex_unlock(&this->port_lock); + llprintf(LOG_1, "video opened\n"); } @@ -1442,14 +1666,17 @@ static void atmo_video_close(xine_video_port_t *port_gen, xine_stream_t *stream) post_video_port_t *port = (post_video_port_t *)port_gen; atmo_post_plugin_t *this = (atmo_post_plugin_t *) port->post; + llprintf(LOG_1, "video close\n"); pthread_mutex_lock(&this->port_lock); - stop_threads(this); + suspend_threads(this); + this->port = NULL; port->original_port->close(port->original_port, stream); port->stream = NULL; pthread_mutex_unlock(&this->port_lock); _x_post_dec_usage(port); + llprintf(LOG_1, "video closed\n"); } @@ -1535,17 +1762,21 @@ static char *atmo_get_help(void) { static void atmo_dispose(post_plugin_t *this_gen) { - if (_x_post_dispose(this_gen)) { - atmo_post_plugin_t *this = (atmo_post_plugin_t *) this_gen; + atmo_post_plugin_t *this = (atmo_post_plugin_t *) this_gen; + + llprintf(LOG_1, "dispose plugin\n"); + stop_threads(this); + if (_x_post_dispose(this_gen)) { close_output_driver(this); free_channels(this); pthread_mutex_destroy(&this->lock); pthread_mutex_destroy(&this->port_lock); - pthread_cond_destroy(&this->thread_started); - pthread_cond_destroy(&this->thread_stopped); + pthread_cond_destroy(&this->thread_state_change); free(this); + llprintf(LOG_1, "final dispose\n"); } + llprintf(LOG_1, "disposed plugin\n"); } @@ -1563,6 +1794,8 @@ static post_plugin_t *atmo_open_plugin(post_class_t *class_gen, { atmo_set_parameters, atmo_get_parameters, atmo_get_param_descr, atmo_get_help }; + llprintf(LOG_1, "open plugin\n"); + if (!video_target || !video_target[0]) return NULL; @@ -1594,8 +1827,7 @@ static post_plugin_t *atmo_open_plugin(post_class_t *class_gen, pthread_mutex_init(&this->lock, NULL); pthread_mutex_init(&this->port_lock, NULL); - pthread_cond_init(&this->thread_started, NULL); - pthread_cond_init(&this->thread_stopped, NULL); + pthread_cond_init(&this->thread_state_change, NULL); /* Set default values for parameters */ this->parm.enabled = 1; @@ -1634,6 +1866,7 @@ static post_plugin_t *atmo_open_plugin(post_class_t *class_gen, if (!param || strcmp(param, buf)) config->update_string(config, "post.atmo.parameters", buf); + llprintf(LOG_1, "plugin opened\n"); return &this->post_plugin; } |