void CreateBitRateMenu(uint32_t oldBitRate)
{
u_int8_t i;
u_int32_t samplingRate = samplingRateValues[samplingRateIndex];
// free up old names
for (i = 0; i < bitRateNumber; i++) {
free(bitRateNames[i]);
bitRateNames[i] = NULL;
}
free(bitRateNames);
bitRateNumber = 0;
audio_encoder_table_t *aenct;
aenct = audio_encoder_table[encodingIndex];
bitRateValues = aenct->bitrates_for_samplerate(samplingRate,
channelValues[channelIndex],
&bitRateNumber);
// make current bitrate index invalid, will fixup below
bitRateNames = (char **)malloc(sizeof(char *) * bitRateNumber);
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
bit_rate_menu = CreateOptionMenu(
bit_rate_menu,
bitRateNames,
bitRateNumber,
bitRateIndex,
GTK_SIGNAL_FUNC(on_bit_rate_menu_activate));
}
void CreateChannelMenu (uint32_t oldChannelNo)
{
audio_encoder_table_t *aenct;
aenct = audio_encoder_table[encodingIndex];
if (oldChannelNo > aenct->max_channels) {
channelIndex = 0;
} else {
channelIndex = oldChannelNo - 1;
}
channel_menu = CreateOptionMenu(channel_menu,
channelNames,
aenct->max_channels,
channelIndex,
GTK_SIGNAL_FUNC(on_channel_menu_activate));
}
static GtkWidget* CreateNullTrackMenu(
GtkWidget* menu,
char type,
const char* source,
u_int32_t* pIndex,
u_int32_t* pNumber,
u_int32_t** ppValues)
{
u_int32_t* newTrackValues =
(u_int32_t*)malloc(sizeof(u_int32_t));
newTrackValues[0] = 0;
char** newTrackNames =
(char**)malloc(sizeof(char*));
newTrackNames[0] = strdup("");
// (re)create the menu
menu = CreateOptionMenu(
menu,
newTrackNames,
1,
0,
GTK_SIGNAL_FUNC(on_track_menu_activate));
// free up old names
for (u_int8_t i = 0; i < *pNumber; i++) {
free(trackNames[i]);
}
free(*ppValues);
free(trackNames);
*pIndex = 0;
*pNumber = 1;
*ppValues = newTrackValues;
trackNames = newTrackNames;
return menu;
}
void create_TextProfileDialog (CTextProfile *tp)
{
GtkWidget *TextEncoderDialog;
GtkWidget *dialog_vbox11;
GtkWidget *table8;
GtkWidget *TextEncodingOptionMenu;
GtkWidget *label211;
GtkWidget *label212;
GtkObject *TextRepeatTimeSpinner_adj;
GtkWidget *TextRepeatTimeSpinner;
GtkWidget *label213;
GtkWidget *TextProfileEntry;
GtkWidget *dialog_action_area10;
GtkWidget *cancelbutton8;
GtkWidget *okbutton10;
TextEncoderDialog = gtk_dialog_new();
gtk_window_set_title(GTK_WINDOW(TextEncoderDialog), _("Text Encoder"));
gtk_window_set_modal(GTK_WINDOW(TextEncoderDialog), TRUE);
gtk_window_set_resizable(GTK_WINDOW(TextEncoderDialog), FALSE);
dialog_vbox11 = GTK_DIALOG(TextEncoderDialog)->vbox;
gtk_widget_show(dialog_vbox11);
table8 = gtk_table_new(3, 2, TRUE);
gtk_widget_show(table8);
gtk_box_pack_start(GTK_BOX(dialog_vbox11), table8, TRUE, TRUE, 0);
gtk_table_set_row_spacings(GTK_TABLE(table8), 11);
gtk_table_set_col_spacings(GTK_TABLE(table8), 7);
TextEncodingOptionMenu = gtk_option_menu_new();
gtk_widget_show(TextEncodingOptionMenu);
gtk_table_attach(GTK_TABLE(table8), TextEncodingOptionMenu, 1, 2, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
label211 = gtk_label_new(_("Text Encoder:"));
gtk_widget_show(label211);
gtk_table_attach(GTK_TABLE(table8), label211, 0, 1, 1, 2,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label211), 0, 0.5);
label212 = gtk_label_new(_("Repeat Time:"));
gtk_widget_show(label212);
gtk_table_attach(GTK_TABLE(table8), label212, 0, 1, 2, 3,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label212), 0, 0.5);
TextRepeatTimeSpinner_adj = gtk_adjustment_new(tp != NULL ? tp->GetFloatValue(CFG_TEXT_REPEAT_TIME_SECS) : 1, 0, 100, 1, 10, 10);
TextRepeatTimeSpinner = gtk_spin_button_new(GTK_ADJUSTMENT(TextRepeatTimeSpinner_adj), 1, 1);
gtk_widget_show(TextRepeatTimeSpinner);
gtk_table_attach(GTK_TABLE(table8), TextRepeatTimeSpinner, 1, 2, 2, 3,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(TextRepeatTimeSpinner), TRUE);
label213 = gtk_label_new(_("Text Profile:"));
gtk_widget_show(label213);
gtk_table_attach(GTK_TABLE(table8), label213, 0, 1, 0, 1,
(GtkAttachOptions)(GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
gtk_misc_set_alignment(GTK_MISC(label213), 0, 0.5);
TextProfileEntry = gtk_entry_new();
gtk_widget_show (TextProfileEntry);
gtk_table_attach (GTK_TABLE(table8), TextProfileEntry, 1, 2, 0, 1,
(GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
(GtkAttachOptions)(0), 0, 0);
dialog_action_area10 = GTK_DIALOG(TextEncoderDialog)->action_area;
gtk_widget_show(dialog_action_area10);
gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area10), GTK_BUTTONBOX_END);
cancelbutton8 = gtk_button_new_from_stock("gtk-cancel");
gtk_widget_show(cancelbutton8);
gtk_dialog_add_action_widget(GTK_DIALOG(TextEncoderDialog), cancelbutton8, GTK_RESPONSE_CANCEL);
GTK_WIDGET_SET_FLAGS(cancelbutton8, GTK_CAN_DEFAULT);
okbutton10 = gtk_button_new_from_stock("gtk-ok");
gtk_widget_show(okbutton10);
gtk_dialog_add_action_widget(GTK_DIALOG(TextEncoderDialog), okbutton10, GTK_RESPONSE_OK);
GTK_WIDGET_SET_FLAGS(okbutton10, GTK_CAN_DEFAULT);
g_signal_connect((gpointer) TextEncoderDialog, "response",
G_CALLBACK(on_TextEncoderDialog_response),
tp);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF(TextEncoderDialog, TextEncoderDialog, "TextEncoderDialog");
GLADE_HOOKUP_OBJECT_NO_REF(TextEncoderDialog, dialog_vbox11, "dialog_vbox11");
GLADE_HOOKUP_OBJECT(TextEncoderDialog, table8, "table8");
GLADE_HOOKUP_OBJECT(TextEncoderDialog, TextEncodingOptionMenu, "TextEncodingOptionMenu");
GLADE_HOOKUP_OBJECT(TextEncoderDialog, label211, "label211");
GLADE_HOOKUP_OBJECT(TextEncoderDialog, label212, "label212");
GLADE_HOOKUP_OBJECT(TextEncoderDialog, TextRepeatTimeSpinner, "TextRepeatTimeSpinner");
GLADE_HOOKUP_OBJECT (TextEncoderDialog, label213, "label213");
GLADE_HOOKUP_OBJECT (TextEncoderDialog, TextProfileEntry, "TextProfileEntry");
GLADE_HOOKUP_OBJECT_NO_REF(TextEncoderDialog, dialog_action_area10, "dialog_action_area10");
GLADE_HOOKUP_OBJECT(TextEncoderDialog, cancelbutton8, "cancelbutton8");
GLADE_HOOKUP_OBJECT(TextEncoderDialog, okbutton10, "okbutton10");
uint encoderIndex = 0;
uint ix = 0;
encoderNames = (const char **)malloc(text_encoder_table_size *
sizeof(const char *));
for (ix = 0; ix < text_encoder_table_size; ix++) {
if (tp != NULL &&
strcasecmp(tp->GetStringValue(CFG_TEXT_ENCODING),
text_encoder_table[ix].text_encoding) == 0) {
encoderIndex = ix;
}
encoderNames[ix] = text_encoder_table[ix].dialog_selection_name;
}
CreateOptionMenu(TextEncodingOptionMenu,
encoderNames,
text_encoder_table_size,
encoderIndex);
if (tp != NULL) {
gtk_entry_set_text(GTK_ENTRY(TextProfileEntry),
tp->GetStringValue(CFG_TEXT_PROFILE_NAME));
gtk_widget_set_sensitive(TextProfileEntry, false);
}
gtk_widget_show(TextEncoderDialog);
}
void CreateAudioDialog (void)
{
GtkWidget* hbox;
GtkWidget* vbox;
GtkWidget* hbox2;
GtkWidget* label;
GtkWidget* button;
const char *audioEncoder;
SDL_LockMutex(dialog_mutex);
if (dialog != NULL) {
SDL_UnlockMutex(dialog_mutex);
return;
}
SDL_UnlockMutex(dialog_mutex);
pAudioCaps = MyConfig->m_audioCapabilities;
dialog = gtk_dialog_new();
gtk_signal_connect(GTK_OBJECT(dialog),
"destroy",
GTK_SIGNAL_FUNC(on_destroy_dialog),
&dialog);
gtk_window_set_title(GTK_WINDOW(dialog), "Audio Settings");
gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
hbox = gtk_hbox_new(FALSE, 1);
gtk_widget_show(hbox);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 5);
vbox = gtk_vbox_new(TRUE, 1);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5);
label = gtk_label_new(" Source:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
input_label = gtk_label_new(" Input Port:");
gtk_misc_set_alignment(GTK_MISC(input_label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), input_label, FALSE, FALSE, 0);
track_label = gtk_label_new(" Track:");
gtk_misc_set_alignment(GTK_MISC(track_label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), track_label, FALSE, FALSE, 0);
label = gtk_label_new(" Output:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
label = gtk_label_new(" Encoding :");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
label = gtk_label_new(" Channels:");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
label = gtk_label_new(" Sampling Rate (Hz):");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
label = gtk_label_new(" Bit Rate (bps):");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
vbox = gtk_vbox_new(TRUE, 1);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 5);
hbox2 = gtk_hbox_new(FALSE, 1);
gtk_widget_show(hbox2);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
source_type = MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_TYPE);
// source entry
free(source_name);
source_name =
strdup(MyConfig->GetStringValue(CONFIG_AUDIO_SOURCE_NAME));
source_modified = false;
source_combo = CreateFileCombo(source_name);
source_entry = GTK_COMBO(source_combo)->entry;
SetEntryValidator(GTK_OBJECT(source_entry),
GTK_SIGNAL_FUNC(on_source_entry_changed),
GTK_SIGNAL_FUNC(on_source_leave));
source_list = GTK_COMBO(source_combo)->list;
gtk_signal_connect(GTK_OBJECT(source_list), "select_child",
GTK_SIGNAL_FUNC(on_source_list_changed), NULL);
gtk_widget_show(source_combo);
gtk_box_pack_start(GTK_BOX(hbox2), source_combo, TRUE, TRUE, 0);
// browse button
browse_button = gtk_button_new_with_label(" Browse... ");
gtk_signal_connect(GTK_OBJECT(browse_button),
"clicked",
GTK_SIGNAL_FUNC(on_source_browse_button),
NULL);
gtk_widget_show(browse_button);
gtk_box_pack_start(GTK_BOX(hbox2), browse_button, FALSE, FALSE, 5);
// input menu
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;
}
}
input_menu = CreateOptionMenu (NULL,
inputNames,
sizeof(inputNames) / sizeof(char*),
inputIndex,
GTK_SIGNAL_FUNC(on_input_menu_activate));
gtk_box_pack_start(GTK_BOX(vbox), input_menu, TRUE, TRUE, 0);
// track menu
track_menu = NULL;
track_menu = CreateTrackMenu(
track_menu,
'A',
gtk_entry_get_text(GTK_ENTRY(source_entry)),
&trackIndex,
&trackNumber,
&trackValues);
trackIndex = 0;
for (u_int8_t i = 0; i < trackNumber; i++) {
if (MyConfig->GetIntegerValue(CONFIG_AUDIO_SOURCE_TRACK)
== trackValues[i]) {
trackIndex = i;
break;
}
}
gtk_box_pack_start(GTK_BOX(vbox), track_menu, FALSE, FALSE, 0);
// spacer
label = gtk_label_new(" ");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_widget_show(label);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
encodingNames = (char **)malloc(sizeof(char *) * audio_encoder_table_size);
audioEncoder =
MyConfig->GetStringValue(CONFIG_AUDIO_ENCODER);
for (uint32_t ix = 0; ix < audio_encoder_table_size; ix++) {
encodingNames[ix] = strdup(audio_encoder_table[ix]->dialog_selection_name);
if ((strcasecmp(audioEncoder,
audio_encoder_table[ix]->audio_encoder) == 0) &&
(strcasecmp(MyConfig->GetStringValue(CONFIG_AUDIO_ENCODING),
audio_encoder_table[ix]->audio_encoding) == 0)) {
encodingIndex = ix;
}
}
encoding_menu = CreateOptionMenu (NULL,
encodingNames,
audio_encoder_table_size,
encodingIndex,
GTK_SIGNAL_FUNC(on_encoding_menu_activate));
gtk_box_pack_start(GTK_BOX(vbox), encoding_menu, TRUE, TRUE, 0);
// channel menu
channel_menu = NULL;
CreateChannelMenu(MyConfig->GetIntegerValue(CONFIG_AUDIO_CHANNELS));
gtk_box_pack_start(GTK_BOX(vbox), channel_menu, TRUE, TRUE, 0);
sampling_rate_menu = NULL;
CreateSamplingRateMenu(pAudioCaps);
gtk_box_pack_start(GTK_BOX(vbox), sampling_rate_menu, TRUE, TRUE, 0);
// set sampling rate value based on MyConfig
SetSamplingRate(MyConfig->GetIntegerValue(CONFIG_AUDIO_SAMPLE_RATE));
bit_rate_menu = NULL;
CreateBitRateMenu(MyConfig->GetIntegerValue(CONFIG_AUDIO_BIT_RATE));
gtk_box_pack_start(GTK_BOX(vbox), bit_rate_menu, TRUE, TRUE, 0);
// set bit rate value based on MyConfig
for (u_int8_t i = 0; i < bitRateNumber; i++) {
if (MyConfig->GetIntegerValue(CONFIG_AUDIO_BIT_RATE)
== bitRateValues[i]) {
bitRateIndex = i;
break;
}
}
gtk_option_menu_set_history(
GTK_OPTION_MENU(bit_rate_menu), bitRateIndex);
// Add standard buttons at bottom
button = AddButtonToDialog(dialog,
" OK ",
GTK_SIGNAL_FUNC(on_ok_button));
GTK_WIDGET_SET_FLAGS(button, GTK_CAN_DEFAULT);
AddButtonToDialog(dialog,
" Cancel ",
GTK_SIGNAL_FUNC(on_cancel_button));
ShowSourceSpecificSettings();
gtk_widget_show(dialog);
}
void CreateSamplingRateMenu(CAudioCapabilities* pNewAudioCaps)
{
// remember current sampling rate
u_int32_t oldSamplingRate = 0;
uint32_t ix;
if (samplingRateValues) {
oldSamplingRate = samplingRateValues[samplingRateIndex];
}
if (samplingRateNames != NULL) {
for (ix = 0; ix < samplingRateNumber; ix++) {
free(samplingRateNames[ix]);
}
free(samplingRateNames);
free(samplingRateValues);
}
audio_encoder_table_t *aenct;
aenct = audio_encoder_table[encodingIndex];
samplingRateNumber = aenct->num_sample_rates;
samplingRateNames = (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++;
}
}
// (re)create the menu
sampling_rate_menu = CreateOptionMenu(
sampling_rate_menu,
samplingRateNames,
newSampleRates,
samplingRateIndex,
GTK_SIGNAL_FUNC(on_sampling_rate_menu_activate));
samplingRateNumber = newSampleRates;
}
static GtkWidget* CreateMpeg2TrackMenu(
GtkWidget* menu,
char type,
const char* source,
u_int32_t* pIndex,
u_int32_t* pNumber,
u_int32_t** ppValues)
{
*pIndex = 0;
u_int32_t newTrackNumber = 1;
mpeg2ps_t* mpeg2File = mpeg2ps_init(source);
if (mpeg2File) {
if (type == 'V') {
newTrackNumber = mpeg2ps_get_video_stream_count(mpeg2File);
} else {
newTrackNumber = mpeg2ps_get_audio_stream_count(mpeg2File);
}
}
u_int32_t* newTrackValues =
(u_int32_t*)malloc(sizeof(u_int32_t) * newTrackNumber);
char** newTrackNames =
(char**)malloc(sizeof(char*) * newTrackNumber);
if (!mpeg2File) {
newTrackValues[0] = 0;
newTrackNames[0] = strdup("");
} else {
for (u_int8_t i = 0; i < newTrackNumber; i++) {
newTrackValues[i] = i;
char buf[64];
if (type == 'V') {
snprintf(buf, sizeof(buf),
"%u - %u x %u @ %.2f fps",
i + 1,
mpeg2ps_get_video_stream_width(mpeg2File, i),
mpeg2ps_get_video_stream_height(mpeg2File, i),
mpeg2ps_get_video_stream_framerate(mpeg2File, i));
} else {
const char* afmt =
mpeg2ps_get_audio_stream_name(mpeg2File, i);
// use more familar though less accurate name
snprintf(buf, sizeof(buf),
"%u - %s %u channels @ %u Hz",
i + 1,
afmt,
mpeg2ps_get_audio_stream_channels(mpeg2File, i),
mpeg2ps_get_audio_stream_sample_freq(mpeg2File, i));
}
newTrackNames[i] = strdup(buf);
}
mpeg2ps_close(mpeg2File);
}
// (re)create the menu
menu = CreateOptionMenu(
menu,
newTrackNames,
newTrackNumber,
*pIndex,
GTK_SIGNAL_FUNC(on_track_menu_activate));
// free up old names
for (u_int8_t i = 0; i < *pNumber; i++) {
free(trackNames[i]);
}
free(trackNames);
free(*ppValues);
*pNumber = newTrackNumber;
trackNames = newTrackNames;
*ppValues = newTrackValues;
return menu;
}
static GtkWidget* CreateMp4TrackMenu(
GtkWidget* menu,
char type,
const char* source,
u_int32_t* pIndex,
u_int32_t* pNumber,
u_int32_t** ppValues)
{
*pIndex = 0;
u_int32_t newTrackNumber = 1;
MP4FileHandle mp4File = MP4Read(source);
char* trackType = NULL;
if (mp4File) {
if (type == 'V') {
trackType = MP4_VIDEO_TRACK_TYPE;
} else {
trackType = MP4_AUDIO_TRACK_TYPE;
}
newTrackNumber =
MP4GetNumberOfTracks(mp4File, trackType);
}
u_int32_t* newTrackValues =
(u_int32_t*)malloc(sizeof(u_int32_t) * newTrackNumber);
char** newTrackNames =
(char**)malloc(sizeof(char*) * newTrackNumber);
if (!mp4File) {
newTrackValues[0] = 0;
newTrackNames[0] = strdup("");
} else {
for (u_int8_t i = 0; i < newTrackNumber; i++) {
MP4TrackId trackId =
MP4FindTrackId(mp4File, i, trackType);
char* trackName = "Unknown";
char buf[64];
if (trackType == MP4_VIDEO_TRACK_TYPE) {
u_int8_t videoType =
MP4GetTrackEsdsObjectTypeId(mp4File,
trackId);
switch (videoType) {
case MP4_MPEG1_VIDEO_TYPE:
trackName = "MPEG1";
break;
case MP4_MPEG2_SIMPLE_VIDEO_TYPE:
case MP4_MPEG2_MAIN_VIDEO_TYPE:
case MP4_MPEG2_SNR_VIDEO_TYPE:
case MP4_MPEG2_SPATIAL_VIDEO_TYPE:
case MP4_MPEG2_HIGH_VIDEO_TYPE:
case MP4_MPEG2_442_VIDEO_TYPE:
trackName = "MPEG2";
break;
case MP4_MPEG4_VIDEO_TYPE:
trackName = "MPEG4";
break;
case MP4_YUV12_VIDEO_TYPE:
trackName = "YUV12";
break;
case MP4_H263_VIDEO_TYPE:
trackName = "H263";
break;
case MP4_H261_VIDEO_TYPE:
trackName = "H261";
break;
}
snprintf(buf, sizeof(buf),
"%u - %s %u x %u %.2f fps %u kbps",
trackId,
trackName,
MP4GetTrackVideoWidth(mp4File, trackId),
MP4GetTrackVideoHeight(mp4File, trackId),
MP4GetTrackVideoFrameRate(mp4File, trackId),
(MP4GetTrackBitRate(mp4File, trackId) + 500) / 1000);
} else { // audio
u_int8_t audioType =
MP4GetTrackEsdsObjectTypeId(mp4File,
trackId);
switch (audioType) {
case MP4_MPEG1_AUDIO_TYPE:
case MP4_MPEG2_AUDIO_TYPE:
trackName = "MPEG (MP3)";
break;
case MP4_MPEG2_AAC_MAIN_AUDIO_TYPE:
case MP4_MPEG2_AAC_LC_AUDIO_TYPE:
case MP4_MPEG2_AAC_SSR_AUDIO_TYPE:
case MP4_MPEG4_AUDIO_TYPE:
trackName = "AAC";
break;
case MP4_PCM16_LITTLE_ENDIAN_AUDIO_TYPE:
trackName = "PCM16 LITTLE ENDIAN";
break;
case MP4_PCM16_BIG_ENDIAN_AUDIO_TYPE:
trackName = "PCM16 BIG ENDIAN";
case MP4_AC3_AUDIO_TYPE:
trackName = "AC3";
break;
case MP4_VORBIS_AUDIO_TYPE:
trackName = "Ogg Vorbis";
break;
case MP4_ALAW_AUDIO_TYPE:
trackName = "G711 aLaw";
break;
case MP4_ULAW_AUDIO_TYPE:
trackName = "G711 uLaw";
break;
}
snprintf(buf, sizeof(buf),
"%u - %s %u kbps",
trackId,
trackName,
(MP4GetTrackBitRate(mp4File, trackId) + 500) / 1000);
}
newTrackValues[i] = trackId;
newTrackNames[i] = strdup(buf);
}
MP4Close(mp4File);
}
// (re)create the menu
menu = CreateOptionMenu(
menu,
newTrackNames,
newTrackNumber,
*pIndex,
GTK_SIGNAL_FUNC(on_track_menu_activate));
// free up old names
for (u_int8_t i = 0; i < *pNumber; i++) {
free(trackNames[i]);
}
free(trackNames);
free(*ppValues);
*pNumber = newTrackNumber;
trackNames = newTrackNames;
*ppValues = newTrackValues;
return menu;
}
