audio_dialog.cpp

MPEG4音频视频压缩编码(含G.711/ACC/H.261等)

  gtk_container_add(GTK_CONTAINER(AudioSourceBrowse), alignment21);

  hbox78 = gtk_hbox_new(FALSE, 2);
  gtk_widget_show(hbox78);
  gtk_container_add(GTK_CONTAINER(alignment21), hbox78);

  image21 = gtk_image_new_from_stock("gtk-open", GTK_ICON_SIZE_BUTTON);
  gtk_widget_show(image21);
  gtk_box_pack_start(GTK_BOX(hbox78), image21, FALSE, FALSE, 0);

  label163 = gtk_label_new_with_mnemonic(_("Browse"));
  gtk_widget_show(label163);
  gtk_box_pack_start(GTK_BOX(hbox78), label163, FALSE, FALSE, 0);

  AudioPortMenu = gtk_option_menu_new();
  gtk_widget_show(AudioPortMenu);
  gtk_table_attach(GTK_TABLE(table6), AudioPortMenu, 1, 2, 2, 3,
                   (GtkAttachOptions)(GTK_FILL),
                   (GtkAttachOptions)(0), 0, 0);
  gtk_tooltips_set_tip(tooltips, AudioPortMenu, _("Audio Source Device"), NULL);

  dialog_action_area7 = GTK_DIALOG(AudioSourceDialog)->action_area;
  gtk_widget_show(dialog_action_area7);
  gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area7), GTK_BUTTONBOX_END);

  AudioSourceCancel = gtk_button_new_from_stock("gtk-cancel");
  gtk_widget_show(AudioSourceCancel);
  gtk_dialog_add_action_widget(GTK_DIALOG(AudioSourceDialog), AudioSourceCancel, GTK_RESPONSE_CANCEL);
  GTK_WIDGET_SET_FLAGS(AudioSourceCancel, GTK_CAN_DEFAULT);

  okbutton7 = gtk_button_new_from_stock("gtk-ok");
  gtk_widget_show(okbutton7);
  gtk_dialog_add_action_widget(GTK_DIALOG(AudioSourceDialog), okbutton7, GTK_RESPONSE_OK);
  GTK_WIDGET_SET_FLAGS(okbutton7, GTK_CAN_DEFAULT);

  g_signal_connect((gpointer) AudioSourceDialog, "response",
                    G_CALLBACK(on_AudioSourceDialog_response),
                    NULL);
  g_signal_connect((gpointer) AudioSourceBrowse, "clicked", 
		   G_CALLBACK(on_source_browse_button),
		   NULL);
  g_signal_connect((gpointer) AudioTypeMenu, "changed",
		   G_CALLBACK(ChangeSource),
		   NULL);
  SetEntryValidator(GTK_OBJECT(AudioSourceFile),
		    GTK_SIGNAL_FUNC(on_source_entry_changed),
		    GTK_SIGNAL_FUNC(on_source_leave));

  /* Store pointers to all widgets, for use by lookup_widget(). */
  GLADE_HOOKUP_OBJECT_NO_REF(AudioSourceDialog, AudioSourceDialog, "AudioSourceDialog");
  GLADE_HOOKUP_OBJECT_NO_REF(AudioSourceDialog, dialog_vbox8, "dialog_vbox8");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, table6, "table6");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, audioTypeLabel, "audioTypeLabel");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, label157, "label157");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, label158, "label158");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, hbox77, "hbox77");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, AudioSourceFile, "AudioSourceFile");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, AudioSourceBrowse, "AudioSourceBrowse");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, alignment21, "alignment21");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, hbox78, "hbox78");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, image21, "image21");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, label163, "label163");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, AudioTypeMenu, "AudioTypeMenu");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, AudioPortMenu, "AudioPortMenu");
  GLADE_HOOKUP_OBJECT_NO_REF(AudioSourceDialog, dialog_action_area7, "dialog_action_area7");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, AudioSourceCancel, "AudioSourceCancel");
  GLADE_HOOKUP_OBJECT(AudioSourceDialog, okbutton7, "okbutton7");
  GLADE_HOOKUP_OBJECT_NO_REF(AudioSourceDialog, tooltips, "tooltips");

  gtk_entry_set_text(GTK_ENTRY(AudioSourceFile),
		     MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_NAME));
  uint inputIndex = 0;
  for (u_int8_t i = 0; i < sizeof(inputValues) / sizeof(u_int8_t); i++) {
    if (!strcasecmp(MyConfig->GetStringValue(CONFIG_AUDIO_INPUT_NAME),
		    inputValues[i])) {
      inputIndex = i;
      break;
    }
  }

  CreateOptionMenu(AudioPortMenu,
		   inputNames, 
		   sizeof(inputNames) / sizeof(char*),
		   inputIndex);

  source_modified = false;
  source_type = MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_TYPE);
  pAudioCaps = (CAudioCapabilities *)MyConfig->m_audioCapabilities;
  inputIndex = 0;
  for (u_int8_t i = 0; i < sizeof(inputTypes) / sizeof(u_int8_t); i++) {
    if (!strcasecmp(source_type,
		    inputTypes[i])) {
      inputIndex = i;
      break;
    }
  }
  CreateOptionMenu(AudioTypeMenu,
		   inputTypes, 
		   sizeof(inputTypes) / sizeof(char*),
		   inputIndex);

  gtk_widget_show(AudioSourceDialog);
}

/***************************************************************************
 * Audio Profile Dialog
 ***************************************************************************/
static uint GetAudioEncoderIndex (void)
{
  GtkWidget *encoder_widget = lookup_widget(AudioProfileDialog, 
					    "AudioProfileEncoder");
  return gtk_option_menu_get_history(GTK_OPTION_MENU(encoder_widget));
}
  
static void CreateChannelMenu (GtkWidget *menu = NULL,
			       bool haveChans = false,
			       uint chans = 0)
{
  audio_encoder_table_t *aenct;
  
  aenct = audio_encoder_table[GetAudioEncoderIndex()];
	
  if (menu == NULL) {
    menu = lookup_widget(AudioProfileDialog, "ChannelMenu");
  }
  
  uint channelIndex = haveChans ? chans - 1 : 
    gtk_option_menu_get_history(GTK_OPTION_MENU(menu));

  if (channelIndex + 1 > aenct->max_channels) {
    channelIndex = 0;
  } 
  
  CreateOptionMenu(menu,
		   channelNames, 
		   aenct->max_channels,
		   channelIndex);
}

static void CreateSamplingRateMenu(CAudioCapabilities* pNewAudioCaps,
				   bool haveSrate = false,
				   uint32_t oldSamplingRate = 0)
{
	// remember current sampling rate
  uint32_t ix;
  uint samplingRateIndex;
  uint encoderIndex = GetAudioEncoderIndex();
  GtkWidget *menu = lookup_widget(AudioProfileDialog, "SampleRateMenu");
  if (haveSrate == false) {
    samplingRateIndex = gtk_option_menu_get_history(GTK_OPTION_MENU(menu));
    oldSamplingRate = samplingRateValues[samplingRateIndex];
  }     
  
  if (samplingRateNames != NULL) {
    for (ix = 0; ix < samplingRateNumber; ix++) {
      free((void *)samplingRateNames[ix]);
    }
    free(samplingRateNames);
    free(samplingRateValues);
  }
  audio_encoder_table_t *aenct;
	
  aenct = audio_encoder_table[encoderIndex];
  samplingRateNumber = aenct->num_sample_rates;

  samplingRateNames = (const char **)malloc(samplingRateNumber * sizeof(char *));
  samplingRateValues = (uint32_t *)malloc(samplingRateNumber * sizeof(uint32_t));

  uint32_t newSampleRates = 0;
  const uint32_t *checkSampleRates;
  uint32_t checkSampleRatesSize;
  
  if (pNewAudioCaps == NULL) {
    checkSampleRates = allSampleRateTable;
    checkSampleRatesSize = allSampleRateTableSize;
  } else {
    checkSampleRates = pNewAudioCaps->m_samplingRates;
    checkSampleRatesSize = pNewAudioCaps->m_numSamplingRates;
  }
  samplingRateIndex = 0; // start with default
  for (ix = 0; ix < aenct->num_sample_rates; ix++) {
    bool found = false;
    for (uint32_t iy = 0; found == false && iy < checkSampleRatesSize; iy++) {
      if (aenct->sample_rates[ix] == checkSampleRates[iy]) {
        found = true;
      }
    }
    if (found == true) {
      samplingRateValues[newSampleRates] = aenct->sample_rates[ix];
      char buffer[20];
      sprintf(buffer, "%d", aenct->sample_rates[ix]);
      samplingRateNames[newSampleRates] = strdup(buffer);
      if (oldSamplingRate == aenct->sample_rates[ix]) {
        samplingRateIndex = newSampleRates;
      }
      newSampleRates++;
    }
  }
  
  CreateOptionMenu(menu,
		   samplingRateNames, 
		   newSampleRates,
		   samplingRateIndex);

  samplingRateNumber = newSampleRates;
}

static void CreateBitRateMenu(GtkWidget *menu = NULL,
			      bool haverate = false,
			      uint32_t oldBitRate = 0)
{
  u_int8_t i;
  GtkWidget *temp;
  temp = lookup_widget(AudioProfileDialog, "SampleRateMenu");
  u_int32_t samplingRate = 
    samplingRateValues[gtk_option_menu_get_history(GTK_OPTION_MENU(temp))];

  if (menu == NULL) {
    menu = lookup_widget(AudioProfileDialog, "AudioBitRateMenu");
  }
  if (bitRateValues != NULL && haverate == false) {
    i = gtk_option_menu_get_history(GTK_OPTION_MENU(menu));
    if (i >= bitRateNumber) i = 0;
    oldBitRate = bitRateValues[i];
  }
  // free up old names
  if (bitRateNames != NULL) {
    for (i = 0; i < bitRateNumber; i++) {
      free((void *)bitRateNames[i]);
      bitRateNames[i] = NULL;
    }
    free(bitRateNames);
  }
  bitRateNumber = 0;
	
  audio_encoder_table_t *aenct;
	
  aenct = audio_encoder_table[GetAudioEncoderIndex()];
  temp = lookup_widget(AudioProfileDialog, "ChannelMenu");
  uint channelIndex = gtk_option_menu_get_history(GTK_OPTION_MENU(temp));
  bitRateValues = aenct->bitrates_for_samplerate(samplingRate, 
						 channelIndex + 1,
						 &bitRateNumber);

  // make current bitrate index invalid, will fixup below
  bitRateNames = (const char **)malloc(sizeof(char *) * bitRateNumber);

  uint bitRateIndex = 0;
  for (uint32_t ix = 0; ix < bitRateNumber; ix++) {
    char buf[64];
    snprintf(buf, sizeof(buf), "%u",
	     bitRateValues[ix]);
    bitRateNames[ix] = strdup(buf);
    
    // preserve user's current choice if we can
    if (oldBitRate == bitRateValues[ix]) {
      bitRateIndex = ix;
    }
  }

	// (re)create the menu
  CreateOptionMenu(menu,
		   bitRateNames, 
		   bitRateNumber,
		   bitRateIndex);
}

static void on_SamplingRateMenu_changed (GtkOptionMenu *optionmenu,
					 gpointer user_data)
{
  CreateBitRateMenu();
}

void
on_AudioEncoderSettingsButton          (GtkButton *button,
					gpointer user_data)
{
  CAudioProfile *profile = (CAudioProfile *)user_data;
  GtkWidget *temp;
  temp = lookup_widget(AudioProfileDialog, "AudioProfileEncoder");
  encoder_gui_options_base_t **settings_array;
  uint settings_array_count;
  audio_encoder_table_t *aenct;
	
  aenct = audio_encoder_table[GetAudioEncoderIndex()];
  
  if ((aenct->get_gui_options)(&settings_array, &settings_array_count) == false) {
    return;
  }
  
  CreateEncoderSettingsDialog(profile, AudioProfileDialog,
			      aenct->dialog_selection_name,
			      settings_array,
			      settings_array_count);
}

static void
on_AudioProfileEncoder_changed         (GtkOptionMenu   *optionmenu,
                                        gpointer         user_data)
{
  GtkWidget *temp;
  audio_encoder_table_t *aenct;
	
  aenct = audio_encoder_table[GetAudioEncoderIndex()];
  CreateChannelMenu();
  CreateSamplingRateMenu((CAudioCapabilities *)MyConfig->m_audioCapabilities);
  CreateBitRateMenu();
  bool enable_settings;
  if (aenct->get_gui_options == NULL) {
    enable_settings = false;
  } else {
    enable_settings = (aenct->get_gui_options)(NULL, NULL);
  }
  temp = lookup_widget(AudioProfileDialog, "AudioEncoderSettingsButton");
  gtk_widget_set_sensitive(temp, enable_settings);
}

// This will create a new audio profile (if it doesn't already
// exist).
static bool CreateNewProfile (GtkWidget *dialog,
			      CAudioProfile *profile)
{