lqt_gtk.c

这个库实现了录象功能

void lqtgtk_codec_config_window_apply(LqtGtkCodecConfigWindow *w)
  {
  int i, index;

  /*
   *  First, all parameter widgets transfer their values to the
   *  lqt_parameter_t structures
   */

  if(w->encode_widget)
    {
    index = 0;
    for(i = 0; i < w->codec_info->num_encoding_parameters; i++)
      {
      if(w->codec_info->encoding_parameters[i].type == LQT_PARAMETER_SECTION)
        continue;
      parameter_widget_apply(w->encode_widget->parameter_widgets[index]);
      lqt_set_default_parameter(w->codec_info->type,
                                1, w->codec_info->name,
                                w->codec_info->encoding_parameters[i].name,
                                &(w->encode_widget->parameter_info[i].val_default));
      index++;
      }
    }
  if(w->decode_widget)
    {
    index = 0;
    for(i = 0; i < w->codec_info->num_decoding_parameters; i++)
      {
      if(w->codec_info->decoding_parameters[i].type == LQT_PARAMETER_SECTION)
        continue;
      parameter_widget_apply(w->decode_widget->parameter_widgets[index]);
      lqt_set_default_parameter(w->codec_info->type,
                                0, w->codec_info->name,
                                w->codec_info->decoding_parameters[i].name,
                                &(w->decode_widget->parameter_info[i].val_default));
      index++;
      }
    }
  }

void lqtgtk_destroy_codec_config_window(LqtGtkCodecConfigWindow *w)
  {
  gtk_widget_destroy(w->window);
  free(w);
  }

#define STRING_TO_FOURCC( str ) \
  ( ( (uint32_t)(unsigned char)(str[0]) << 24 ) | \
    ( (uint32_t)(unsigned char)(str[1]) << 16 ) | \
    ( (uint32_t)(unsigned char)(str[2]) << 8 ) | \
    ( (uint32_t)(unsigned char)(str[3]) ) )

LqtGtkCodecInfoWidget *
lqtgtk_create_codec_info_widget(const lqt_codec_info_t * info)
  {
  int i;
  char * tmp1;
  char * tmp2;
  
  LqtGtkCodecInfoWidget * ret = calloc(1, sizeof(LqtGtkCodecInfoWidget));

  ret->real_name = gtk_label_new(info->long_name);
  gtk_misc_set_alignment(GTK_MISC(ret->real_name), 0.0, 0.5);
  ret->short_name_label = gtk_label_new(_("Internal name: "));
  gtk_misc_set_alignment(GTK_MISC(ret->short_name_label), 0.0, 0.5);
  ret->short_name = gtk_label_new(info->name);
  gtk_misc_set_alignment(GTK_MISC(ret->short_name), 0.0, 0.5);
  ret->description = gtk_label_new(info->description);
  gtk_misc_set_alignment(GTK_MISC(ret->description), 0.0, 0.5);
  
  ret->module_filename = gtk_label_new(info->module_filename);
  gtk_misc_set_alignment(GTK_MISC(ret->module_filename), 0.0, 0.5);
  ret->module_filename_label = gtk_label_new(_("Module: "));
  gtk_misc_set_alignment(GTK_MISC(ret->module_filename_label), 0.0, 0.5);
  
  gtk_widget_show(ret->real_name);
  gtk_widget_show(ret->short_name);
  gtk_widget_show(ret->short_name_label);
  gtk_widget_show(ret->description);

  gtk_widget_show(ret->module_filename);
  gtk_widget_show(ret->module_filename_label);
    
  /* Create the fourccs label */

  if(info->num_fourccs)
    {
    tmp1 = malloc(info->num_fourccs * 30);
    tmp2 = malloc(30);
    
    *tmp1 = '\0';
    
    for(i = 0; i < info->num_fourccs - 1; i++)
      {
      sprintf(tmp2, "0x%08X (%s)\n", STRING_TO_FOURCC(info->fourccs[i]),
              info->fourccs[i]);
      strcat(tmp1, tmp2);
      }
    
    /* Last one without newline */
    
    sprintf(tmp2, "0x%08X (%s)", STRING_TO_FOURCC(info->fourccs[i]),
            info->fourccs[i]);
    strcat(tmp1, tmp2);
    
    ret->fourccs_label = gtk_label_new(tmp1);
    gtk_widget_show(ret->fourccs_label);
    
    free(tmp1);
    free(tmp2);
    }
  
  /* Create wav_ids label */

  if(info->num_wav_ids)
    {
    tmp1 = malloc(info->num_wav_ids * 30);
    tmp2 = malloc(30);
    
    *tmp1 = '\0';
    
    for(i = 0; i < info->num_wav_ids - 1; i++)
      {
      sprintf(tmp2, "0x%02x,", info->wav_ids[i]);
      strcat(tmp1, tmp2);
      }
    
    /* Last one without comma */
    
    sprintf(tmp2, "0x%02x", info->wav_ids[i]);
    strcat(tmp1, tmp2);
    
    ret->wav_ids_label = gtk_label_new(tmp1);
    gtk_widget_show(ret->wav_ids_label);
    
    free(tmp1);
    free(tmp2);
    }
    
  /* Create encoding colormodels label */

  
  /* Pack all widgets onto their containers */

  if(ret->fourccs_label)
    {
    ret->fourccs_frame = gtk_frame_new(_("Fourccs"));
    
    gtk_container_add(GTK_CONTAINER(ret->fourccs_frame), ret->fourccs_label);
    gtk_widget_show(ret->fourccs_frame);
    }
  
  if(ret->wav_ids_label)
    {
    ret->wav_ids_frame = gtk_frame_new(_("WAV Id(s)"));
    
    gtk_container_add(GTK_CONTAINER(ret->wav_ids_frame), ret->wav_ids_label);
    gtk_widget_show(ret->wav_ids_frame);
    }
  
  ret->label_table = gtk_table_new(6, 2, 0);

  gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
                            ret->real_name, 0, 2, 0, 1);

  gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
                            ret->short_name_label, 0, 1, 1, 2);

  gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
                            ret->short_name, 1, 2, 1, 2);

  gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
                            ret->module_filename_label, 0, 1, 2, 3);

  gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
                            ret->module_filename, 1, 2, 2, 3);
 
  gtk_table_attach_defaults(GTK_TABLE(ret->label_table),
                            ret->description, 0, 2, 3, 4);

  gtk_widget_show(ret->label_table);

  ret->table = gtk_table_new(3, 2, 0);

  gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->label_table,
                            0, 2, 0, 1);

  if(info->type == LQT_CODEC_VIDEO)
    {
    if(ret->fourccs_frame)
      {
      gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->fourccs_frame,
                                0, 2, 1, 2);
      }
    }
  else if(ret->wav_ids_frame)
    {
    if(ret->fourccs_frame)
      {
      gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->fourccs_frame,
                                0, 1, 1, 2);
      gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->wav_ids_frame,
                                1, 2, 1, 2);
      }
    else
      gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->wav_ids_frame,
                                0, 2, 1, 2);
    }
  
  else if(ret->fourccs_frame)
    gtk_table_attach_defaults(GTK_TABLE(ret->table), ret->fourccs_frame,
                              0, 2, 1, 2);
  gtk_widget_show(ret->table);
  ret->widget = ret->table;
  return ret;
  }

void lqtgtk_destroy_codec_info_widget(LqtGtkCodecInfoWidget * w)
  {
  free(w);
  }

static void codec_info_window_button_callback(GtkWidget * w, gpointer data)
  {
  LqtGtkCodecInfoWindow * ciw = (LqtGtkCodecInfoWindow *)data;
  gtk_widget_hide(ciw->window);
  lqtgtk_destroy_codec_info_window(ciw);
  }

LqtGtkCodecInfoWindow *
lqtgtk_create_codec_info_window(const lqt_codec_info_t *info)
  {
  LqtGtkCodecInfoWindow * ret = calloc(1, sizeof(LqtGtkCodecInfoWindow));
  ret->info_widget = lqtgtk_create_codec_info_widget(info);
  ret->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title(GTK_WINDOW(ret->window), info->long_name);
  gtk_window_set_modal(GTK_WINDOW(ret->window), TRUE);

  ret->mainbox = gtk_vbox_new(0, 10);

  ret->close_button = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
  GTK_WIDGET_SET_FLAGS (ret->close_button, GTK_CAN_DEFAULT);

  g_signal_connect(G_OBJECT(ret->close_button), "clicked",
                     G_CALLBACK(codec_info_window_button_callback),
                     (gpointer)ret);
    
  gtk_widget_show(ret->close_button);
  
  gtk_box_pack_start_defaults(GTK_BOX(ret->mainbox), ret->info_widget->widget);
  gtk_box_pack_start_defaults(GTK_BOX(ret->mainbox), ret->close_button);
  
  gtk_widget_show(ret->mainbox);
  
  gtk_container_add(GTK_CONTAINER(ret->window), ret->mainbox);
  
  return ret;
  }

void
lqtgtk_destroy_codec_info_window(LqtGtkCodecInfoWindow * w)
  {
  lqtgtk_destroy_codec_info_widget(w->info_widget);
  gtk_widget_destroy(w->window);
  free(w);
  }

void 
lqtgtk_codec_info_window_run(LqtGtkCodecInfoWindow * w)
  {
  gtk_widget_show(w->window);
  }

#if 0


/*
 *   LqtGtkEncoderWidget
 */

static void
encoder_widget_button_callback(GtkWidget * w, gpointer data)
  {
  LqtGtkEncoderWidget * ew = (LqtGtkEncoderWidget*)data;
  LqtGtkCodecInfoWindow * iw;
  LqtGtkCodecConfigWindow * cw;
  if(w == ew->info_button)
    {
    iw = lqtgtk_create_codec_info_window(ew->encoders[ew->selected]);
    lqtgtk_codec_info_window_run(iw);
    }
  else if(w == ew->parameters_button)
    {
    cw = lqtgtk_create_codec_config_window(ew->encoders[ew->selected], 1, 0);
    lqtgtk_codec_config_window_run(cw);
    }
  }

LqtGtkEncoderWidget *
lqtgtk_create_encoder_widget(lqt_codec_type type)
  {
  LqtGtkEncoderWidget * ret = calloc(1, sizeof(LqtGtkEncoderWidget));
  ret->type = type;
  ret->info_button = gtk_button_new_with_label(_("Info..."));
  ret->parameters_button = gtk_button_new_with_label(_("Parameters..."));

  g_signal_connect(G_OBJECT(ret->info_button), "clicked",
		   G_CALLBACK(encoder_widget_button_callback),
		   (gpointer)ret);
  g_signal_connect(G_OBJECT(ret->parameters_button), "clicked",
		   G_CALLBACK(encoder_widget_button_callback),
		   (gpointer)ret);
    
  gtk_widget_show(ret->info_button);
  gtk_widget_show(ret->parameters_button);

  ret->optionmenu = gtk_option_menu_new();
  
  ret->menu = gtk_menu_new();
  gtk_widget_show(ret->menu);
  
  gtk_option_menu_set_menu(GTK_OPTION_MENU(ret->optionmenu), ret->menu);
  gtk_widget_show(ret->optionmenu);
  
  /* NEED CHECK AGAIN */
  /* gtk_widget_set_usize(ret->optionmenu, 200, ret->optionmenu->requisition.height); */
  gtk_widget_set_size_request(ret->optionmenu, 200, -1);
  
  return ret;
  }

void lqtgtk_destroy_encoder_widget(LqtGtkEncoderWidget * ew)
  {
  if(ew->encoders)
    lqt_destroy_codec_info(ew->encoders);
  }

static void encoder_widget_update_selected(LqtGtkEncoderWidget * ew)
  {
  gtk_option_menu_set_history(GTK_OPTION_MENU(ew->optionmenu), ew->selected);
  ew->current_encoder = ew->encoders[ew->selected];
  if(ew->current_encoder->num_encoding_parameters)
    gtk_widget_set_sensitive(ew->parameters_button, 1);
  else
    gtk_widget_set_sensitive(ew->parameters_button, 0);
  }

static void encoder_widget_menu_callback(GtkWidget * w, gpointer data)
  {
  int i;
  
  LqtGtkEncoderWidget * ew = (LqtGtkEncoderWidget*)data;
  
  for(i = 0; i < ew->num_encoders; i++)
    {
    if(w == ew->menu_items[i])
      {
      ew->selected = i;
      encoder_widget_update_selected(ew);
      }
    }
  
  }

void lqtgtk_encoder_widget_update(LqtGtkEncoderWidget * ew)
  {
  GtkWidget ** new_items;
  int i;
  char * label_text;
  
  if(ew->encoders)
    lqt_destroy_codec_info(ew->encoders);
    
  if(ew->type == LQT_CODEC_AUDIO)
    ew->encoders = lqt_query_registry(1, 0, 1, 0);
  else
    ew->encoders = lqt_query_registry(0, 1, 1, 0);

  /* Count the codecs */
  ew->num_encoders = 0;
    
  while(1)
    {
    if(!(ew->encoders[ew->num_encoders]))
      break;
    else
      ew->num_encoders++;
    }

  /* Create new menu items */
  
  if(ew->num_menu_items < ew->num_encoders)
    {
    new_items = calloc(1, ew->num_encoders * sizeof(GtkWidget*));

    /* Copy old items */

    if(ew->menu_items)
      {
      for(i = 0; i < ew->num_menu_items; i++)
        new_items[i] = ew->menu_items[i];
      free(ew->menu_items);
      }
    ew->menu_items = new_items;
        
    /* Create new items */
    
    for(i = ew->num_menu_items; i < ew->num_encoders; i++)
      {
      ew->menu_items[i] = gtk_menu_item_new_with_label(" ");
      g_signal_connect(G_OBJECT(ew->menu_items[i]),
		       "activate",
		       G_CALLBACK(encoder_widget_menu_callback),
		       (gpointer)ew);
      gtk_menu_shell_append(GTK_MENU_SHELL(ew->menu), ew->menu_items[i]);
      }
    
    ew->num_menu_items = ew->num_encoders;
    }

  /* Update menu labels and show all active items */

  for(i = 0; i < ew->num_encoders; i++)
    {
    label_text = g_strdup_printf("%s (%s)",
                          ew->encoders[i]->long_name,
                          ew->encoders[i]->name);
    if(GTK_BIN(ew->menu_items[i])->child)
      {
      gtk_label_set_text(GTK_LABEL(GTK_BIN(ew->menu_items[i])->child),
                         label_text);
      }
    else
      {
	gtk_button_set_label(GTK_BUTTON(ew->optionmenu), label_text);
      }
    g_free(label_text);
    gtk_widget_show(ew->menu_items[i]);
    }

  /* Hide other items */

  for(i = ew->num_encoders; i < ew->num_menu_items; i++)
    gtk_widget_hide(ew->menu_items[i]);

  if(ew->selected >= ew->num_encoders)
    ew->selected = 0;
  encoder_widget_update_selected(ew);
  }

const char * lqtgtk_encoder_widget_get_encoder(LqtGtkEncoderWidget * ew)
  {
  return ew->current_encoder->name;
  }

void lqtgtk_encoder_widget_set_encoder(LqtGtkEncoderWidget * ew,
                                       const char * name)
  {
  int i;
  ew->selected = 0;

  for(i = 0; i < ew->num_encoders; i++)
    {
    if(!strcmp(ew->encoders[i]->name, name))
      {
      ew->selected = i;
      break;
      }
    }
  encoder_widget_update_selected(ew);
  }

#endif