cleanup CC decoder config entries: move them to the class context

CVS patchset: 6487
CVS date: 2004/05/05 17:36:48

3 files changed, 83 insertions, 113 deletions

diff --git a/src/libspucc/cc_decoder.c b/src/libspucc/cc_decoder.c
index fae09339e..ace2b8df3 100644
--- a/src/libspucc/cc_decoder.c
+++ b/src/libspucc/cc_decoder.c
@@ -20,7 +20,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  *
- * $Id: cc_decoder.c,v 1.24 2003/12/09 00:02:33 f1rmb Exp $
+ * $Id: cc_decoder.c,v 1.25 2004/05/05 17:36:48 mroi Exp $
  *
  * stuff needed to provide closed captioning decoding and display
  *
@@ -286,7 +286,7 @@ struct cc_renderer_s {
 
   metronom_t *metronom;       /* the active xine metronom */
 
-  cc_config_t *cc_cfg;        /* captioning configuration */
+  cc_state_t *cc_state;        /* captioning configuration */
 };
 
 
@@ -357,7 +357,7 @@ struct cc_decoder_s {
   int displayed;
 
   /* configuration and intrinsics of CC decoder */
-  cc_config_t *cc_cfg;
+  cc_state_t *cc_state;
 
   metronom_t *metronom;
 };
@@ -528,7 +528,7 @@ static void ccrow_set_attributes(cc_renderer_t *renderer, cc_row_t *this,
 {
   const cc_attribute_t *attr = &this->cells[pos].attributes;
   const char *fontname;
-  cc_config_t *cap_info = renderer->cc_cfg;
+  cc_config_t *cap_info = renderer->cc_state->cc_cfg;
 
   if (attr->italic)
     fontname = cap_info->italic_font;
@@ -544,7 +544,7 @@ static void ccrow_render(cc_renderer_t *renderer, cc_row_t *this, int rownum)
   char buf[CC_COLUMNS + 1];
   int base_y;
   int pos = ccrow_find_next_text_part(this, 0);
-  cc_config_t *cap_info = renderer->cc_cfg;
+  cc_config_t *cap_info = renderer->cc_state->cc_cfg;
   osd_renderer_t *osd_renderer = renderer->osd_renderer;
 
   /* find y coordinate of caption */
@@ -806,8 +806,8 @@ static void ccmem_exit(cc_memory_t *this)
 static void cc_renderer_build_palette(cc_renderer_t *this)
 {
   int i, j;
-  colorinfo_t *cc_text = cc_text_palettes[this->cc_cfg->cc_scheme];
-  uint8_t *cc_alpha = cc_alpha_palettes[this->cc_cfg->cc_scheme];
+  colorinfo_t *cc_text = cc_text_palettes[this->cc_state->cc_cfg->cc_scheme];
+  uint8_t *cc_alpha = cc_alpha_palettes[this->cc_state->cc_cfg->cc_scheme];
   
   memset(this->cc_palette, 0, sizeof (this->cc_palette));
   memset(this->cc_trans, 0, sizeof (this->cc_trans));
@@ -925,14 +925,14 @@ static void cc_renderer_adjust_osd_object(cc_renderer_t *this)
 
 
 cc_renderer_t *cc_renderer_open(osd_renderer_t *osd_renderer,
-				metronom_t *metronom, cc_config_t *cc_cfg,
+				metronom_t *metronom, cc_state_t *cc_state,
 				int video_width, int video_height)
 {
   cc_renderer_t *this = (cc_renderer_t *) xine_xmalloc(sizeof (cc_renderer_t));
 
   this->osd_renderer = osd_renderer;
   this->metronom = metronom;
-  this->cc_cfg = cc_cfg;
+  this->cc_state = cc_state;
   cc_renderer_update_cfg(this, video_width, video_height);
 #ifdef LOG_DEBUG
   printf("spucc: cc_renderer: open\n");
@@ -972,12 +972,12 @@ void cc_renderer_update_cfg(cc_renderer_t *this_obj, int video_width,
 
   /* find maximum text width and height for normal & italic captioning */
   /* font */
-  get_font_metrics(this_obj->osd_renderer, this_obj->cc_cfg->font,
-		   this_obj->cc_cfg->font_size, &fontw, &fonth);
+  get_font_metrics(this_obj->osd_renderer, this_obj->cc_state->cc_cfg->font,
+		   this_obj->cc_state->cc_cfg->font_size, &fontw, &fonth);
   this_obj->max_char_width = fontw;
   this_obj->max_char_height = fonth;
-  get_font_metrics(this_obj->osd_renderer, this_obj->cc_cfg->italic_font,
-		   this_obj->cc_cfg->font_size, &fontw, &fonth);
+  get_font_metrics(this_obj->osd_renderer, this_obj->cc_state->cc_cfg->italic_font,
+		   this_obj->cc_state->cc_cfg->font_size, &fontw, &fonth);
   this_obj->max_char_width = MAX(fontw, this_obj->max_char_width);
   this_obj->max_char_height = MAX(fonth, this_obj->max_char_height);
 #ifdef LOG_DEBUG
@@ -1007,11 +1007,11 @@ void cc_renderer_update_cfg(cc_renderer_t *this_obj, int video_width,
 
   if (required_w <= this_obj->video_width && 
       required_h <= this_obj->video_height) {
-    this_obj->cc_cfg->can_cc = 1;
+    this_obj->cc_state->can_cc = 1;
     cc_renderer_adjust_osd_object(this_obj);
   }
   else {
-    this_obj->cc_cfg->can_cc = 0;
+    this_obj->cc_state->can_cc = 0;
     cc_renderer_free_osd_object(this_obj);
     printf("spucc: required captioning area %dx%d exceeds screen %dx%d!\n"
 	   "       Captions disabled. Perhaps you should choose a smaller"
@@ -1052,13 +1052,13 @@ static void cc_hide_displayed(cc_decoder_t *this)
   printf("cc_decoder: cc_hide_displayed\n");
 #endif
 
-  if (cc_renderer_on_display(this->cc_cfg->renderer)) {
-    int64_t vpts = cc_renderer_calc_vpts(this->cc_cfg->renderer, this->pts,
+  if (cc_renderer_on_display(this->cc_state->renderer)) {
+    int64_t vpts = cc_renderer_calc_vpts(this->cc_state->renderer, this->pts,
 					  this->f_offset); 
 #ifdef LOG_DEBUG
     printf("cc_decoder: cc_hide_displayed: hiding caption %u at vpts %u\n", this->capid, vpts);
 #endif    
-    cc_renderer_hide_caption(this->cc_cfg->renderer, vpts);
+    cc_renderer_hide_caption(this->cc_state->renderer, vpts);
   }
 }
 
@@ -1070,13 +1070,13 @@ static void cc_show_displayed(cc_decoder_t *this)
 #endif
 
   if (cc_onscreen_displayable(this)) {
-    int64_t vpts = cc_renderer_calc_vpts(this->cc_cfg->renderer, this->pts,
+    int64_t vpts = cc_renderer_calc_vpts(this->cc_state->renderer, this->pts,
 					  this->f_offset);
 #ifdef LOG_DEBUG
     printf("cc_decoder: cc_show_displayed: showing caption %u at vpts %u\n", this->capid, vpts);
 #endif    
     this->capid++;
-    cc_renderer_show_caption(this->cc_cfg->renderer,
+    cc_renderer_show_caption(this->cc_state->renderer,
 			     &this->on_buf->channel[this->on_buf->channel_no],
 			     vpts);
   }
@@ -1443,11 +1443,11 @@ void decode_cc(cc_decoder_t *this, uint8_t *buffer, uint32_t buf_len,
 
 
 
-cc_decoder_t *cc_decoder_open(cc_config_t *cc_cfg)
+cc_decoder_t *cc_decoder_open(cc_state_t *cc_state)
 {
   cc_decoder_t *this = (cc_decoder_t *) xine_xmalloc(sizeof (cc_decoder_t));
   /* configfile stuff */
-  this->cc_cfg = cc_cfg;
+  this->cc_state = cc_state;
 
   ccmem_init(&this->buffer[0]);
   ccmem_init(&this->buffer[1]);
diff --git a/src/libspucc/cc_decoder.h b/src/libspucc/cc_decoder.h
index f91252769..1e298515e 100644
--- a/src/libspucc/cc_decoder.h
+++ b/src/libspucc/cc_decoder.h
@@ -20,7 +20,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  *
- * $Id: cc_decoder.h,v 1.6 2003/12/09 00:02:33 f1rmb Exp $
+ * $Id: cc_decoder.h,v 1.7 2004/05/05 17:36:48 mroi Exp $
  *
  * stuff needed to provide closed captioning decoding and display
  *
@@ -45,17 +45,26 @@ typedef struct cc_config_s {
   int center;                 /* true if captions should be centered */
                               /* according to text width */
   int cc_scheme;              /* which captioning scheme to use */
+  
+  int config_version;         /* the decoder should be updated when this is increased */
+} cc_config_t;
+
+typedef struct spucc_class_s {
+  spu_decoder_class_t spu_class;
+  cc_config_t         cc_cfg;
+} spucc_class_t;
 
+typedef struct cc_state_s {
+  cc_config_t *cc_cfg;
   /* the following variables are not controlled by configuration files; they */
   /* are intrinsic to the properties of the configuration options and the */
   /* currently played video */
-  int can_cc;                 /* true if captions can be displayed */
+  int            can_cc;      /* true if captions can be displayed */
                               /* (e.g., font fits on screen) */
-
   cc_renderer_t *renderer;    /* closed captioning renderer */
-} cc_config_t;
+} cc_state_t;
 
-cc_decoder_t *cc_decoder_open(cc_config_t *cc_cfg);
+cc_decoder_t *cc_decoder_open(cc_state_t *cc_state);
 void cc_decoder_close(cc_decoder_t *this_obj);
 void cc_decoder_init(void);
 
@@ -64,7 +73,7 @@ void decode_cc(cc_decoder_t *this, uint8_t *buffer, uint32_t buf_len,
 
 /* Instantiates a new closed captioning renderer. */
 cc_renderer_t *cc_renderer_open(osd_renderer_t *osd_renderer,
-				metronom_t *metronom, cc_config_t *cc_cfg,
+				metronom_t *metronom, cc_state_t *cc_state,
 				int video_width, int video_height);
 
 /* Destroys a closed captioning renderer. */
diff --git a/src/libspucc/xine_decoder.c b/src/libspucc/xine_decoder.c
index 467b93369..8e3f88dea 100644
--- a/src/libspucc/xine_decoder.c
+++ b/src/libspucc/xine_decoder.c
@@ -17,7 +17,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA
  *
- * $Id: xine_decoder.c,v 1.29 2004/04/26 17:50:08 mroi Exp $
+ * $Id: xine_decoder.c,v 1.30 2004/05/05 17:36:48 mroi Exp $
  *
  * closed caption spu decoder. receive data by events. 
  *
@@ -47,20 +47,14 @@ typedef struct spucc_decoder_s {
   int cc_open;
 
   /* closed captioning decoder configuration and intrinsics */
-  cc_config_t cc_cfg;
+  cc_state_t cc_state;
+  /* this is to detect configuration changes */
+  int        config_version;
 
   /* video dimensions captured in frame change events */
   int video_width;
   int video_height;
 
-  /* big lock regulating access to the CC decoder, CC renderer, and
-     configuration changes. For CC decoding, fine-grained locking is not
-     necessary. Using just  single lock for everything makes the code
-     for configuraton changes *a lot* simpler, and *much* easier to
-     debug and maintain.
-  */
-  pthread_mutex_t cc_mutex;
-  
   /* events will be sent here */
   xine_event_queue_t *queue;
   
@@ -78,7 +72,6 @@ static void copy_str(char *d, const char *s, size_t maxbytes)
 
 /*------------------- private methods --------------------------------------*/
 
-/* CAUTION: THIS FUNCTION ASSUMES THAT THE MUTEX IS ALREADY LOCKED! */
 static void spucc_update_intrinsics(spucc_decoder_t *this)
 {
 #ifdef LOG_DEBUG
@@ -86,12 +79,10 @@ static void spucc_update_intrinsics(spucc_decoder_t *this)
 #endif
 
   if (this->cc_open)
-    cc_renderer_update_cfg(this->cc_cfg.renderer, this->video_width,
+    cc_renderer_update_cfg(this->cc_state.renderer, this->video_width,
 			   this->video_height);
 }
 
-
-/* CAUTION: THIS FUNCTION ASSUMES THAT THE MUTEX IS ALREADY LOCKED! */
 static void spucc_do_close(spucc_decoder_t *this)
 {
   if (this->cc_open) {
@@ -99,13 +90,11 @@ static void spucc_do_close(spucc_decoder_t *this)
     printf("spucc: close\n");
 #endif
     cc_decoder_close(this->ccdec);
-    cc_renderer_close(this->cc_cfg.renderer);
+    cc_renderer_close(this->cc_state.renderer);
     this->cc_open = 0;
   }
 }
 
-
-/* CAUTION: THIS FUNCTION ASSUMES THAT THE MUTEX IS ALREADY LOCKED! */
 static void spucc_do_init (spucc_decoder_t *this)
 {
   if (! this->cc_open) {
@@ -113,14 +102,14 @@ static void spucc_do_init (spucc_decoder_t *this)
     printf("spucc: init\n");
 #endif
     /* initialize caption renderer */
-    this->cc_cfg.renderer = cc_renderer_open(this->stream->osd_renderer,
-					     this->stream->metronom,
-					     &this->cc_cfg,
-					     this->video_width,
-					     this->video_height);
+    this->cc_state.renderer = cc_renderer_open(this->stream->osd_renderer,
+					       this->stream->metronom,
+					       &this->cc_state,
+					       this->video_width,
+					       this->video_height);
     spucc_update_intrinsics(this);
     /* initialize CC decoder */
-    this->ccdec = cc_decoder_open(&this->cc_cfg);
+    this->ccdec = cc_decoder_open(&this->cc_state);
     this->cc_open = 1;
   }
 }
@@ -130,47 +119,35 @@ static void spucc_do_init (spucc_decoder_t *this)
 
 static void spucc_cfg_enable_change(void *this_gen, xine_cfg_entry_t *value)
 {
-  spucc_decoder_t *this = (spucc_decoder_t *) this_gen;
+  spucc_class_t *this = (spucc_class_t *) this_gen;
   cc_config_t *cc_cfg = &this->cc_cfg;
 
-  pthread_mutex_lock(&this->cc_mutex);
-
   cc_cfg->cc_enabled = value->num_value;
-  if (! cc_cfg->cc_enabled) {
-    /* captions were just disabled? */
-    spucc_do_close(this);
-  }
-  /* caption decoder is initialized on demand, so do nothing on open */
-
 #ifdef LOG_DEBUG
   printf("spucc: closed captions are now %s.\n", cc_cfg->cc_enabled?
 	 "enabled" : "disabled");
 #endif
-
-  pthread_mutex_unlock(&this->cc_mutex);
+  cc_cfg->config_version++;
 }
 
 
 static void spucc_cfg_scheme_change(void *this_gen, xine_cfg_entry_t *value)
 {
-  spucc_decoder_t *this = (spucc_decoder_t *) this_gen;
+  spucc_class_t *this = (spucc_class_t *) this_gen;
   cc_config_t *cc_cfg = &this->cc_cfg;
 
-  pthread_mutex_lock(&this->cc_mutex);
-
   cc_cfg->cc_scheme = value->num_value;
 #ifdef LOG_DEBUG
   printf("spucc: closed captioning scheme is now %s.\n",
 	 cc_schemes[cc_cfg->cc_scheme]);
 #endif
-  spucc_update_intrinsics(this);
-  pthread_mutex_unlock(&this->cc_mutex);
+  cc_cfg->config_version++;
 }
 
 
 static void spucc_font_change(void *this_gen, xine_cfg_entry_t *value)
 {
-  spucc_decoder_t *this = (spucc_decoder_t *) this_gen;
+  spucc_class_t *this = (spucc_class_t *) this_gen;
   cc_config_t *cc_cfg = &this->cc_cfg;
   char *font;
   
@@ -179,21 +156,17 @@ static void spucc_font_change(void *this_gen, xine_cfg_entry_t *value)
   else
     font = cc_cfg->italic_font;
 
-  pthread_mutex_lock(&this->cc_mutex);
-
   copy_str(font, value->str_value, CC_FONT_MAX);
-  spucc_update_intrinsics(this);
 #ifdef LOG_DEBUG
   printf("spucc: changing %s to font %s\n", value->key, font);
 #endif
-
-  pthread_mutex_unlock(&this->cc_mutex);
+  cc_cfg->config_version++;
 }
 
 
 static void spucc_num_change(void *this_gen, xine_cfg_entry_t *value)
 {
-  spucc_decoder_t *this = (spucc_decoder_t *) this_gen;
+  spucc_class_t *this = (spucc_class_t *) this_gen;
   cc_config_t *cc_cfg = &this->cc_cfg;
   int *num;
   
@@ -202,26 +175,22 @@ static void spucc_num_change(void *this_gen, xine_cfg_entry_t *value)
   else
     num = &cc_cfg->center;
 
-  pthread_mutex_lock(&this->cc_mutex);
-
   *num = value->num_value;
-  spucc_update_intrinsics(this);
 #ifdef LOG_DEBUG
   printf("spucc: changing %s to %d\n", value->key, *num);
 #endif
-
-  pthread_mutex_unlock(&this->cc_mutex);
+  cc_cfg->config_version++;
 }
 
 
-static void spucc_register_cfg_vars(spucc_decoder_t *this,
+static void spucc_register_cfg_vars(spucc_class_t *this,
 				    config_values_t *xine_cfg) {
   cc_config_t *cc_vars = &this->cc_cfg;
 
   cc_vars->cc_enabled = xine_cfg->register_bool(xine_cfg,
 						"misc.cc_enabled", 0,
 						_("display closed captions in MPEG-2 streams"),
-						_("Closed captions are subtitles mostly meant "
+						_("Closed Captions are subtitles mostly meant "
 						  "to help the hearing impaired."),
 						0, spucc_cfg_enable_change, this);
   
@@ -261,16 +230,6 @@ static void spucc_register_cfg_vars(spucc_decoder_t *this,
 }
 
 
-static void spucc_unregister_cfg_callbacks(config_values_t *xine_cfg) {
-  xine_cfg->unregister_callback(xine_cfg, "misc.cc_enabled");
-  xine_cfg->unregister_callback(xine_cfg, "misc.cc_scheme");
-  xine_cfg->unregister_callback(xine_cfg, "misc.cc_font");
-  xine_cfg->unregister_callback(xine_cfg, "misc.cc_italic_font");
-  xine_cfg->unregister_callback(xine_cfg, "misc.cc_font_size");
-  xine_cfg->unregister_callback(xine_cfg, "misc.cc_center");
-}
-
-
 /* called when the video frame size changes */
 static void spucc_notify_frame_change(spucc_decoder_t *this, 
 				      int width, int height) {
@@ -278,11 +237,9 @@ static void spucc_notify_frame_change(spucc_decoder_t *this,
   printf("spucc: new frame size: %dx%d\n", width, height);
 #endif
 
-  pthread_mutex_lock(&this->cc_mutex);
   this->video_width = width;
   this->video_height = height;
   spucc_update_intrinsics(this);
-  pthread_mutex_unlock(&this->cc_mutex);
 }
 
 
@@ -292,7 +249,7 @@ static void spudec_decode_data (spu_decoder_t *this_gen, buf_element_t *buf) {
   spucc_decoder_t *this = (spucc_decoder_t *) this_gen;
   xine_event_t *event;
   
-  if ((event = xine_event_get(this->queue))) {
+  while ((event = xine_event_get(this->queue))) {
     switch (event->type) {
     case XINE_EVENT_FRAME_FORMAT_CHANGE:
       {
@@ -304,21 +261,27 @@ static void spudec_decode_data (spu_decoder_t *this_gen, buf_element_t *buf) {
       }
       break;
     }
+    xine_event_free(event);
   }
   
   if (buf->decoder_flags & BUF_FLAG_PREVIEW) {
   } else {
-    pthread_mutex_lock(&this->cc_mutex);
-    if (this->cc_cfg.cc_enabled) {
+    
+    if (this->cc_state.cc_cfg->config_version > this->config_version) {
+      spucc_update_intrinsics(this);
+      if (!this->cc_state.cc_cfg->cc_enabled)
+	spucc_do_close(this);
+      this->config_version = this->cc_state.cc_cfg->config_version;
+    }
+    
+    if (this->cc_state.cc_cfg->cc_enabled) {
       if( !this->cc_open )
 	spucc_do_init (this);
-      
-      if(this->cc_cfg.can_cc) {
+      if(this->cc_state.can_cc) {
 	decode_cc(this->ccdec, buf->content, buf->size,
 		  buf->pts);
       }
     }
-    pthread_mutex_unlock(&this->cc_mutex);
   }
 }  
 
@@ -331,13 +294,8 @@ static void spudec_discontinuity (spu_decoder_t *this_gen) {
 static void spudec_dispose (spu_decoder_t *this_gen) {
   spucc_decoder_t *this = (spucc_decoder_t *) this_gen;
 
-  pthread_mutex_lock(&this->cc_mutex);
   spucc_do_close(this);
-  pthread_mutex_unlock(&this->cc_mutex);
-
-  spucc_unregister_cfg_callbacks(this->stream->xine->config);
   xine_event_dispose_queue(this->queue);
-  pthread_mutex_destroy (&this->cc_mutex);
   free (this);
 }
 
@@ -357,10 +315,10 @@ static spu_decoder_t *spudec_open_plugin (spu_decoder_class_t *class, xine_strea
 
   this->stream                          = stream;
   this->queue                           = xine_event_new_queue(stream);
+  this->cc_state.cc_cfg                 = &((spucc_class_t *)class)->cc_cfg;
+  this->config_version = 0;
   this->cc_open = 0;
 
-  pthread_mutex_init(&this->cc_mutex, NULL);
-  spucc_register_cfg_vars(this, stream->xine->config);
   cc_decoder_init();
    
   return &this->spu_decoder;
@@ -381,16 +339,19 @@ static void spudec_class_dispose(spu_decoder_class_t *class) {
 
 static void *init_spu_decoder_plugin (xine_t *xine, void *data) {
 
-  spu_decoder_class_t *this ;
+  spucc_class_t *this ;
 
-  this = (spu_decoder_class_t *) xine_xmalloc (sizeof (spu_decoder_class_t));
+  this = (spucc_class_t *) xine_xmalloc (sizeof (spucc_class_t));
 
-  this->open_plugin      = spudec_open_plugin;
-  this->get_identifier   = spudec_get_identifier;
-  this->get_description  = spudec_get_description;
-  this->dispose          = spudec_class_dispose;
+  this->spu_class.open_plugin      = spudec_open_plugin;
+  this->spu_class.get_identifier   = spudec_get_identifier;
+  this->spu_class.get_description  = spudec_get_description;
+  this->spu_class.dispose          = spudec_class_dispose;
 
-  return this;
+  spucc_register_cfg_vars(this, xine->config);
+  this->cc_cfg.config_version = 0;
+  
+  return &this->spu_class;
 }
 
 /* plugin catalog information */