frontend para ffmpeg

ffmpegtk es un frontend para ffmpeg. Sirve para recodificar y cambiar formatos a archivos de video y audio. La idea es no tener que usar ffmpeg desde la linea de comandos. No es que esté en contra de la linea de comandos, sino que a veces se hace difícil recordar los argumentos de cada programa. Es un proyecto que empezé y nunca terminé (al igual que MediaBash, y GigaBash que nombré en el post anterior, y que muchísimos otros), pero como, aunque esté incompleto, funciona, voy a publicarlo.
Está escrito en C y GTK. Para compilarlo hay que tener instaladas las bibliotecas de desarrollo de GTK, guardar el código en un archivo de nombre ffmpegtk.c y usar el comando:

gcc -Wall -g ffmpegtk.c -o ffmpegtk $(pkg-config --cflags gtk+-2.0) $(pkg-config --libs gtk+-2.0)

Licencia WTFPL
DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

0. You just DO WHAT THE FUCK YOU WANT TO.


#include
#include
#include
#include

void checkboxActionHide (GtkWidget * caller, GtkWidget * argument)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(caller)))
gtk_widget_show(argument);
else
gtk_widget_hide(argument);
}

void checkboxActionShow (GtkWidget * caller, GtkWidget * argument)
{
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(caller)))
gtk_widget_hide(argument);
else
gtk_widget_show(argument);
}

void infoButtonAction(GtkWidget * caller, GtkWidget * argument)
{
gtk_widget_show(argument);
}

void encodeButtonAction(GtkWidget * caller, GtkWidget ** optionsArray)
{
GtkWidget * entryInputFile=optionsArray[1];
GtkWidget * formatCombobox=optionsArray[2];
GtkWidget * entryOutputFile=optionsArray[3];
GtkWidget * filesizelimitCheckbox=optionsArray[20];
GtkWidget * filesizelimitSpin=optionsArray[22];
GtkWidget * durationlimitCheckbox=optionsArray[30];
GtkWidget * durationlimitSpinHours=optionsArray[31];
GtkWidget * durationlimitSpinMinutes=optionsArray[32];
GtkWidget * durationlimitSpinSeconds=optionsArray[33];
GtkWidget * durationlimitSpinMiliseconds=optionsArray[34];
GtkWidget * starttimeCheckbox=optionsArray[40];
GtkWidget * starttimeSpinHours=optionsArray[41];
GtkWidget * starttimeSpinMinutes=optionsArray[42];
GtkWidget * starttimeSpinSeconds=optionsArray[43];
GtkWidget * starttimeSpinMiliseconds=optionsArray[44];
GtkWidget * enablevideoCheckbox=optionsArray[50];
GtkWidget * copyVideoCheckbox=optionsArray[51];
GtkWidget * videoBitrateSpin=optionsArray[52];
GtkWidget * videoFpsSpin=optionsArray[53];
GtkWidget * videoCodecCombobox=optionsArray[54];
GtkWidget * videoResolutionCheckbox=optionsArray[55];
GtkWidget * videoResolutionXSpin=optionsArray[56];
GtkWidget * videoResolutionYSpin=optionsArray[57];
GtkWidget * enableaudioCheckbox=optionsArray[60];
GtkWidget * copyAudioCheckbox=optionsArray[61];
GtkWidget * audioBitrateSpin=optionsArray[62];
GtkWidget * audioChannelsSpin=optionsArray[63];
GtkWidget * audioRateCombobox=optionsArray[64];
GtkWidget * audioCodecCombobox=optionsArray[65];
GtkWidget * titleCheckbox=optionsArray[70];
GtkWidget * titleEntry=optionsArray[71];
GtkWidget * authorCheckbox=optionsArray[72];
GtkWidget * authorEntry=optionsArray[73];
GtkWidget * trackCheckbox=optionsArray[74];
GtkWidget * trackSpin=optionsArray[75];
GtkWidget * albumCheckbox=optionsArray[76];
GtkWidget * albumEntry=optionsArray[77];
GtkWidget * yearCheckbox=optionsArray[78];
GtkWidget * yearSpin=optionsArray[79];
GtkWidget * commentCheckbox=optionsArray[80];
GtkWidget * commentEntry=optionsArray[81];
GtkWidget * copyrightCheckbox=optionsArray[82];
GtkWidget * copyrightEntry=optionsArray[83];
char commandLine[1024];
char tempString[512];
commandLine[0]=”;
strcat(commandLine, “xterm -hold -e ffmpeg -y “);

//input
if(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(entryInputFile)) && strcmp(gtk_entry_get_text(GTK_ENTRY(entryOutputFile)), “” ) )
{
strcat(commandLine, “-i ‘”);
strcat(commandLine, gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(entryInputFile)));
strcat(commandLine, “‘ “);
}

//format
if( strcmp( (char *) gtk_combo_box_get_active_text(GTK_COMBO_BOX(formatCombobox)), “Default” ) )
{
strcat(commandLine, “-f “);
strcat(commandLine, (char *) gtk_combo_box_get_active_text(GTK_COMBO_BOX(formatCombobox)));
strcat(commandLine, ” “);
}
//filesize
if( gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(filesizelimitCheckbox)) )
{
strcat(commandLine, “-fs “);
sprintf(tempString, “%d”, (gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(filesizelimitSpin))*1024) );
strcat(commandLine, tempString);
strcat(commandLine, ” “);
}
//duration
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(durationlimitCheckbox)))
{
strcat(commandLine, “-t “);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(durationlimitSpinHours)) );
strcat(commandLine, tempString);
strcat(commandLine, “:”);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(durationlimitSpinMinutes)) );
strcat(commandLine, tempString);
strcat(commandLine, “:”);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(durationlimitSpinSeconds)) );
strcat(commandLine, tempString);
strcat(commandLine, “.”);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(durationlimitSpinMiliseconds)) );
strcat(commandLine, tempString);
strcat(commandLine, ” “);
}
//start time
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(starttimeCheckbox)))
{
strcat(commandLine, “-ss “);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(starttimeSpinHours)) );
strcat(commandLine, tempString);
strcat(commandLine, “:”);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(starttimeSpinMinutes)) );
strcat(commandLine, tempString);
strcat(commandLine, “:”);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(starttimeSpinSeconds)) );
strcat(commandLine, tempString);
strcat(commandLine, “.”);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(starttimeSpinMiliseconds)) );
strcat(commandLine, tempString);
strcat(commandLine, ” “);
}
//video
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(enablevideoCheckbox)))
{
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(copyVideoCheckbox)))
{
strcat(commandLine, “-vcodec copy “);
}
else
{
//video bitrate
strcat(commandLine, “-b “);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(videoBitrateSpin)) );
strcat(commandLine, tempString);
strcat(commandLine, “k “);
//video fps
strcat(commandLine, “-r “);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(videoFpsSpin)) );
strcat(commandLine, tempString);
strcat(commandLine, ” “);
//video resolution
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(videoResolutionCheckbox)))
{
strcat(commandLine, “-s “);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(videoResolutionXSpin)) );
strcat(commandLine, tempString);
strcat(commandLine, “x”);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(videoResolutionYSpin)) );
strcat(commandLine, tempString);
strcat(commandLine, ” “);
}
//video codec
if(strcmp( (char *) gtk_combo_box_get_active_text(GTK_COMBO_BOX(videoCodecCombobox)), “Default” ))
{
strcat(commandLine, “-vcodec “);
strcat(commandLine, (char *) gtk_combo_box_get_active_text(GTK_COMBO_BOX(videoCodecCombobox)));
strcat(commandLine, ” “);
}
}
}
else
strcat(commandLine, “-vn “);
//audio
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(enableaudioCheckbox)))
{
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(copyAudioCheckbox)))
{
strcat(commandLine, “-acodec copy “);
}
else
{
//audio bitrate
strcat(commandLine, “-ab “);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(audioBitrateSpin)));
strcat(commandLine, tempString);
strcat(commandLine, “k “);
//audio channels
strcat(commandLine, “-ac “);
sprintf(tempString, “%d”, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(audioChannelsSpin)));
strcat(commandLine, tempString);
strcat(commandLine, ” “);
//audio rate
strcat(commandLine, “-ar “);
strcat(commandLine, gtk_combo_box_get_active_text(GTK_COMBO_BOX(audioRateCombobox)));
strcat(commandLine, ” “);
//audio codec
if(strcmp( (char *) gtk_combo_box_get_active_text(GTK_COMBO_BOX(audioCodecCombobox)), “Default” ))
{
strcat(commandLine, “-acodec “);
strcat(commandLine, (char *) gtk_combo_box_get_active_text(GTK_COMBO_BOX(audioCodecCombobox)));
strcat(commandLine, ” “);
}
}
}
else
{
strcat(commandLine, “-an “);
}
//title
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(titleCheckbox)))
{
strcat(commandLine, “-title ‘”);
strcat(commandLine, gtk_entry_get_text(GTK_ENTRY(titleEntry)));
strcat(commandLine, “‘ “);
}
//author
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(authorCheckbox)))
{
strcat(commandLine, “-author ‘”);
strcat(commandLine, gtk_entry_get_text(GTK_ENTRY(authorEntry)));
strcat(commandLine, “‘ “);
}
//track
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(trackCheckbox)))
{
sprintf(tempString, “-track %d “, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(trackSpin)));
strcat(commandLine, tempString);
}
//album
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(albumCheckbox)))
{
strcat(commandLine, “-album ‘”);
strcat(commandLine, gtk_entry_get_text(GTK_ENTRY(albumEntry)));
strcat(commandLine, “‘ “);
}
//year
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(yearCheckbox)))
{
sprintf(tempString, “-year %d “, gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(yearSpin)));
strcat(commandLine, tempString);
}
//comment
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(commentCheckbox)))
{
strcat(commandLine, “-comment ‘”);
strcat(commandLine, gtk_entry_get_text(GTK_ENTRY(commentEntry)));
strcat(commandLine, “‘ “);
}
//copyright
if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(copyrightCheckbox)))
{
strcat(commandLine, “-copyright ‘”);
strcat(commandLine, gtk_entry_get_text(GTK_ENTRY(copyrightEntry)));
strcat(commandLine, “‘ “);
}
//output
if(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(entryInputFile)) && strcmp(gtk_entry_get_text(GTK_ENTRY(entryOutputFile)), “” ) )
{
strcat(commandLine, “‘”);
strcat(commandLine, gtk_entry_get_text(GTK_ENTRY(entryOutputFile)));
strcat(commandLine, “‘”);
}
else
return;
printf(“command: %s\n”, commandLine);
strcat(commandLine, “&”);
system(commandLine);
}

void drawMainWindow()
{
GtkWidget * optionsArray[90];
GtkWidget * mainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
GtkWidget * mainBox = gtk_vbox_new(0, 4);
GtkWidget * labelInputFile = gtk_label_new(“Input File:”);
GtkWidget * entryInputFile = gtk_file_chooser_button_new(“Input File”, GTK_FILE_CHOOSER_ACTION_OPEN);
GtkWidget * formatBox = gtk_hbox_new(0, 0);
GtkWidget * formatLabel = gtk_label_new(“File format:”);
GtkWidget * formatCombobox = gtk_combo_box_entry_new_text();
GtkWidget * infoButton = gtk_button_new_with_label(“Set info”);
GtkWidget * filesizelimitBox = gtk_vbox_new(0, 0);
GtkWidget * filesizelimitCheckbox = gtk_check_button_new_with_label(“File size limit:”);
GtkWidget * filesizelimitBoxChild = gtk_hbox_new(0, 0);
GtkWidget * filesizelimitSpin = gtk_spin_button_new_with_range(1, 99999999, 1);
GtkWidget * filesizelimitLabel = gtk_label_new(“KiB”);
GtkWidget * durationlimitBox = gtk_vbox_new(0, 0);
GtkWidget * durationlimitCheckbox = gtk_check_button_new_with_label(“Duration limit:”);
GtkWidget * durationlimitBoxChild = gtk_hbox_new(0, 0);
GtkWidget * durationlimitSpinHours = gtk_spin_button_new_with_range(0, 99, 1);
GtkWidget * durationlimitLabel2 = gtk_label_new(“:”);
GtkWidget * durationlimitSpinMinutes = gtk_spin_button_new_with_range(0, 60, 1);
GtkWidget * durationlimitLabel3 = gtk_label_new(“:”);
GtkWidget * durationlimitSpinSeconds = gtk_spin_button_new_with_range(0, 60, 1);
GtkWidget * durationlimitLabel4 = gtk_label_new(“.”);
GtkWidget * durationlimitSpinMiliseconds = gtk_spin_button_new_with_range(0, 999, 1);
GtkWidget * starttimeBox = gtk_vbox_new(0, 0);
GtkWidget * starttimeCheckbox = gtk_check_button_new_with_label(“Custom start time:”);
GtkWidget * starttimeBoxChild = gtk_hbox_new(0, 0);
GtkWidget * starttimeSpinHours = gtk_spin_button_new_with_range(0, 99, 1);
GtkWidget * starttimeLabel2 = gtk_label_new(“:”);
GtkWidget * starttimeSpinMinutes = gtk_spin_button_new_with_range(0, 60, 1);
GtkWidget * starttimeLabel3 = gtk_label_new(“:”);
GtkWidget * starttimeSpinSeconds = gtk_spin_button_new_with_range(0, 60, 1);
GtkWidget * starttimeLabel4 = gtk_label_new(“.”);
GtkWidget * starttimeSpinMiliseconds = gtk_spin_button_new_with_range(0, 999, 1);
GtkWidget * hbox = gtk_hbox_new(0, 4);
GtkWidget * videoBox = gtk_vbox_new(0, 4);
GtkWidget * videoLabel = gtk_label_new(“Video options:”);
GtkWidget * enablevideoCheckbox = gtk_check_button_new_with_label(“Enable video”);
GtkWidget * videoOptionsBox = gtk_vbox_new(0, 4);
GtkWidget * copyVideoCheckbox = gtk_check_button_new_with_label(“Copy video stream”);
GtkWidget * videoOptionsBoxChild = gtk_vbox_new(0, 4);
GtkWidget * videoBitrateBox = gtk_hbox_new(0, 0);
GtkWidget * videoBitrateLabel1 = gtk_label_new(“Bitrate:”);
GtkWidget * videoBitrateSpin = gtk_spin_button_new_with_range(1, 99999999, 1);
GtkWidget * videoBitrateLabel2 = gtk_label_new(“Kb/s”);
GtkWidget * videoFpsBox = gtk_hbox_new(0, 0);
GtkWidget * videoFpsLabel1 = gtk_label_new(“Frame rate:”);
GtkWidget * videoFpsSpin = gtk_spin_button_new_with_range(1, 99999999, 1);
GtkWidget * videoFpsLabel2 = gtk_label_new(“FPS”);
GtkWidget * videoCodecBox = gtk_hbox_new(0, 0);
GtkWidget * videoCodecLabel = gtk_label_new(“Codec:”);
GtkWidget * videoCodecCombobox = gtk_combo_box_entry_new_text();
GtkWidget * videoResolutionBox = gtk_vbox_new(0,0);
GtkWidget * videoResolutionCheckbox = gtk_check_button_new_with_label(“Custom video size”);
GtkWidget * videoResolutionBoxChild = gtk_hbox_new(0,0);
GtkWidget * videoResolutionXSpin = gtk_spin_button_new_with_range(1, 99999999, 1);
GtkWidget * videoResolutionLabel = gtk_label_new(“X”);
GtkWidget * videoResolutionYSpin = gtk_spin_button_new_with_range(1, 99999999, 1);
GtkWidget * audioBox = gtk_vbox_new(0, 4);
GtkWidget * audioLabel = gtk_label_new(“Audio options:”);
GtkWidget * enableaudioCheckbox = gtk_check_button_new_with_label(“Enable audio”);
GtkWidget * audioOptionsBox = gtk_vbox_new(0, 4);
GtkWidget * copyAudioCheckbox = gtk_check_button_new_with_label(“Copy audio stream”);
GtkWidget * audioOptionsBoxChild = gtk_vbox_new(0, 4);
GtkWidget * audioBitrateBox = gtk_hbox_new(0, 0);
GtkWidget * audioBitrateLabel1 = gtk_label_new(“Bitrate:”);
GtkWidget * audioBitrateSpin = gtk_spin_button_new_with_range(1, 99999999, 1);
GtkWidget * audioBitrateLabel2 = gtk_label_new(“Kb/s”);
GtkWidget * audioChannelsBox = gtk_hbox_new(0, 0);
GtkWidget * audioChannelsLabel = gtk_label_new(“Channels:”);
GtkWidget * audioChannelsSpin = gtk_spin_button_new_with_range(1, 16, 1);
GtkWidget * audioRateBox = gtk_vbox_new(0, 0);
GtkWidget * audioRateLabel = gtk_label_new(“Sampling frequency (Hz):”);
GtkWidget * audioRateCombobox = gtk_combo_box_entry_new_text();
GtkWidget * audioCodecBox = gtk_hbox_new(0, 0);
GtkWidget * audioCodecLabel = gtk_label_new(“Codec:”);
GtkWidget * audioCodecCombobox = gtk_combo_box_entry_new_text();
GtkWidget * labelOutputFile = gtk_label_new(“Output File:”);
GtkWidget * entryOutputFile = gtk_entry_new();
GtkWidget * buttonEncode = gtk_button_new_with_label (“Encode!”);
GtkWidget * infoWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
GtkWidget * infoMainBox = gtk_vbox_new(0, 4);
GtkWidget * titleBox = gtk_vbox_new(0, 0);
GtkWidget * titleCheckbox = gtk_check_button_new_with_label(“Title”);
GtkWidget * titleEntry = gtk_entry_new();
GtkWidget * authorBox = gtk_vbox_new(0, 0);
GtkWidget * authorCheckbox = gtk_check_button_new_with_label(“Author”);
GtkWidget * authorEntry = gtk_entry_new();
GtkWidget * copyrightBox = gtk_vbox_new(0, 0);
GtkWidget * copyrightCheckbox = gtk_check_button_new_with_label(“Copyright”);
GtkWidget * copyrightEntry = gtk_entry_new();
GtkWidget * commentBox = gtk_vbox_new(0, 0);
GtkWidget * commentCheckbox = gtk_check_button_new_with_label(“Comment”);
GtkWidget * commentEntry = gtk_entry_new();
GtkWidget * albumBox = gtk_vbox_new(0, 0);
GtkWidget * albumCheckbox = gtk_check_button_new_with_label(“Album”);
GtkWidget * albumEntry = gtk_entry_new();
GtkWidget * trackBox = gtk_vbox_new(0, 0);
GtkWidget * trackCheckbox = gtk_check_button_new_with_label(“Track number”);
GtkWidget * trackSpin = gtk_spin_button_new_with_range(1, 999, 1);
GtkWidget * yearBox = gtk_vbox_new(0, 0);
GtkWidget * yearCheckbox = gtk_check_button_new_with_label(“Year”);
GtkWidget * yearSpin = gtk_spin_button_new_with_range(1, 9999, 1);

gtk_container_add (GTK_CONTAINER(mainWindow), mainBox);
gtk_box_pack_start(GTK_BOX(mainBox), labelInputFile, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainBox), entryInputFile, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainBox), formatBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(formatBox), formatLabel, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(formatBox), formatCombobox, FALSE, FALSE, 0);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “Default”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “3g2″);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “3gp”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “aiff”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “amr”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “asf”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “au”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “avi”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “dv”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “dvd”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “flv”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “gif”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “ipod”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “matroska”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “mov”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “mp2″);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “mp3″);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “mp4″);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “mpeg”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “ogg”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “psp”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “rm”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “svcd”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “swf”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “vcd”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “vob”);
gtk_combo_box_append_text(GTK_COMBO_BOX(formatCombobox), “wav”);
gtk_combo_box_set_active(GTK_COMBO_BOX(formatCombobox), 0);
gtk_box_pack_start(GTK_BOX(formatBox), infoButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainBox), filesizelimitBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(filesizelimitBox), filesizelimitCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(filesizelimitBox), filesizelimitBoxChild, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(filesizelimitBoxChild), filesizelimitSpin, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(filesizelimitBoxChild), filesizelimitLabel, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainBox), durationlimitBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(durationlimitBox), durationlimitCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(durationlimitBox), durationlimitBoxChild, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(durationlimitBoxChild), durationlimitSpinHours, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(durationlimitBoxChild), durationlimitLabel2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(durationlimitBoxChild), durationlimitSpinMinutes, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(durationlimitBoxChild), durationlimitLabel3, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(durationlimitBoxChild), durationlimitSpinSeconds, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(durationlimitBoxChild), durationlimitLabel4, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(durationlimitBoxChild), durationlimitSpinMiliseconds, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainBox), starttimeBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(starttimeBox), starttimeCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(starttimeBox), starttimeBoxChild, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(starttimeBoxChild), starttimeSpinHours, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(starttimeBoxChild), starttimeLabel2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(starttimeBoxChild), starttimeSpinMinutes, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(starttimeBoxChild), starttimeLabel3, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(starttimeBoxChild), starttimeSpinSeconds, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(starttimeBoxChild), starttimeLabel4, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(starttimeBoxChild), starttimeSpinMiliseconds, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainBox), gtk_hseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainBox), hbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), videoBox, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoBox), videoLabel, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoBox), enablevideoCheckbox, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enablevideoCheckbox), TRUE);
gtk_box_pack_start(GTK_BOX(videoBox), videoOptionsBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoOptionsBox), copyVideoCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoOptionsBox), videoOptionsBoxChild, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoOptionsBoxChild), videoBitrateBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoBitrateBox), videoBitrateLabel1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoBitrateBox), videoBitrateSpin, FALSE, FALSE, 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(videoBitrateSpin), 200);
gtk_box_pack_start(GTK_BOX(videoBitrateBox), videoBitrateLabel2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoOptionsBoxChild), videoFpsBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoFpsBox), videoFpsLabel1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoFpsBox), videoFpsSpin, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoFpsBox), videoFpsLabel2, FALSE, FALSE, 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(videoFpsSpin), 25);
gtk_box_pack_start(GTK_BOX(videoOptionsBoxChild), videoResolutionBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoResolutionBox), videoResolutionCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoResolutionBox), videoResolutionBoxChild, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoResolutionBoxChild), videoResolutionXSpin, FALSE, FALSE, 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(videoResolutionXSpin), 640);
gtk_box_pack_start(GTK_BOX(videoResolutionBoxChild), videoResolutionLabel, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoResolutionBoxChild), videoResolutionYSpin, FALSE, FALSE, 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(videoResolutionYSpin), 480);
gtk_box_pack_start(GTK_BOX(videoOptionsBoxChild), videoCodecBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoCodecBox), videoCodecLabel, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(videoCodecBox), videoCodecCombobox, FALSE, FALSE, 0);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “Default”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “dvvideo”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “ffv1″);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “ffvhuff”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “flashsv”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “flv”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “gif”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “h261″);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “h263″);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “h263p”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “huffyuv”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “libdirac”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “libtheora”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “libx264″);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “libxvid”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “ljpeg”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “mjpeg”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “mpeg1video”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “mpeg2video”);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “mpeg4″);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “msmpeg4″);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “wmv1″);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “wmv2″);
gtk_combo_box_append_text(GTK_COMBO_BOX(videoCodecCombobox), “zlib”);
gtk_combo_box_set_active(GTK_COMBO_BOX(videoCodecCombobox), 0);
gtk_box_pack_start(GTK_BOX(hbox), gtk_vseparator_new(), TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), audioBox, 1, 0, 0);
gtk_box_pack_start(GTK_BOX(audioBox), audioLabel, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioBox), enableaudioCheckbox, FALSE, FALSE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(enableaudioCheckbox), TRUE);
gtk_box_pack_start(GTK_BOX(audioBox), audioOptionsBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioOptionsBox), copyAudioCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioOptionsBox), audioOptionsBoxChild, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioOptionsBoxChild), audioBitrateBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioBitrateBox), audioBitrateLabel1, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioBitrateBox), audioBitrateSpin, FALSE, FALSE, 0);
gtk_spin_button_set_value(GTK_SPIN_BUTTON(audioBitrateSpin), 64);
gtk_box_pack_start(GTK_BOX(audioBitrateBox), audioBitrateLabel2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioOptionsBoxChild), audioChannelsBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioChannelsBox), audioChannelsLabel, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioChannelsBox), audioChannelsSpin, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioOptionsBoxChild), audioRateBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioRateBox), audioRateLabel, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioRateBox), audioRateCombobox, FALSE, FALSE, 0);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioRateCombobox), “8000″);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioRateCombobox), “11025″);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioRateCombobox), “16000″);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioRateCombobox), “22050″);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioRateCombobox), “32000″);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioRateCombobox), “44100″);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioRateCombobox), “48000″);
gtk_combo_box_set_active(GTK_COMBO_BOX(audioRateCombobox), 5);
gtk_box_pack_start(GTK_BOX(audioOptionsBoxChild), audioCodecBox, FALSE, FALSE, 0 );
gtk_box_pack_start(GTK_BOX(audioCodecBox), audioCodecLabel, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(audioCodecBox), audioCodecCombobox, FALSE, FALSE, 0);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “Default”);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “ac3″);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “alac”);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “flac”);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “g726″);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “libamr_nb”);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “libamr_wb”);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “libfaac”);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “libgsm”);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “libmp3lame”);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “libvorbis”);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “mp2″);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “vorbis”);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “wmav1″);
gtk_combo_box_append_text(GTK_COMBO_BOX(audioCodecCombobox), “wmav2″);
gtk_combo_box_set_active(GTK_COMBO_BOX(audioCodecCombobox), 0);
gtk_box_pack_start(GTK_BOX(mainBox), gtk_hseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainBox), labelOutputFile, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainBox), entryOutputFile, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainBox), buttonEncode, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(infoWindow), infoMainBox);
gtk_box_pack_start(GTK_BOX(infoMainBox),titleBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(titleBox), titleCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(titleBox), titleEntry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(infoMainBox),authorBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(authorBox), authorCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(authorBox), authorEntry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(infoMainBox),trackBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(trackBox), trackCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(trackBox), trackSpin, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(infoMainBox),albumBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(albumBox), albumCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(albumBox), albumEntry, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(infoMainBox),yearBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(yearBox), yearCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(yearBox), yearSpin,FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(infoMainBox), commentBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(commentBox), commentCheckbox,FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(commentBox), commentEntry,FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(infoMainBox),copyrightBox ,FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(copyrightBox), copyrightCheckbox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(copyrightBox), copyrightEntry, FALSE, FALSE, 0);

gtk_signal_connect(GTK_OBJECT (mainWindow), “delete_event”, GTK_SIGNAL_FUNC (gtk_exit), NULL);
gtk_signal_connect(GTK_OBJECT (infoWindow), “delete_event”, GTK_SIGNAL_FUNC (gtk_widget_hide), NULL);
gtk_signal_connect(GTK_OBJECT (durationlimitCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), durationlimitBoxChild);
gtk_signal_connect(GTK_OBJECT (starttimeCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), starttimeBoxChild);
gtk_signal_connect(GTK_OBJECT (filesizelimitCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), filesizelimitBoxChild);
gtk_signal_connect(GTK_OBJECT (videoResolutionCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), videoResolutionBoxChild);
gtk_signal_connect(GTK_OBJECT (enablevideoCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), videoOptionsBox);
gtk_signal_connect(GTK_OBJECT (enableaudioCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), audioOptionsBox);
gtk_signal_connect(GTK_OBJECT (titleCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), titleEntry);
gtk_signal_connect(GTK_OBJECT (authorCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), authorEntry);
gtk_signal_connect(GTK_OBJECT (trackCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), trackSpin);
gtk_signal_connect(GTK_OBJECT (albumCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), albumEntry);
gtk_signal_connect(GTK_OBJECT (yearCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), yearSpin);
gtk_signal_connect(GTK_OBJECT (commentCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), commentEntry);
gtk_signal_connect(GTK_OBJECT (copyrightCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionHide), copyrightEntry);
gtk_signal_connect(GTK_OBJECT (copyVideoCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionShow), videoOptionsBoxChild);
gtk_signal_connect(GTK_OBJECT (copyAudioCheckbox), “toggled”, GTK_SIGNAL_FUNC (checkboxActionShow), audioOptionsBoxChild);
optionsArray[1]=entryInputFile;
optionsArray[2]=formatCombobox;
optionsArray[20]=filesizelimitCheckbox;
optionsArray[22]=filesizelimitSpin;
optionsArray[30]=durationlimitCheckbox;
optionsArray[31]=durationlimitSpinHours;
optionsArray[32]=durationlimitSpinMinutes;
optionsArray[33]=durationlimitSpinSeconds;
optionsArray[34]=durationlimitSpinMiliseconds;
optionsArray[40]=starttimeCheckbox;
optionsArray[41]=starttimeSpinHours;
optionsArray[42]=starttimeSpinMinutes;
optionsArray[43]=starttimeSpinSeconds;
optionsArray[44]=starttimeSpinMiliseconds;
optionsArray[50]=enablevideoCheckbox;
optionsArray[51]=copyVideoCheckbox;
optionsArray[52]=videoBitrateSpin;
optionsArray[53]=videoFpsSpin;
optionsArray[54]=videoCodecCombobox;
optionsArray[55]=videoResolutionCheckbox;
optionsArray[56]=videoResolutionXSpin;
optionsArray[57]=videoResolutionYSpin;
optionsArray[60]=enableaudioCheckbox;
optionsArray[61]=copyAudioCheckbox;
optionsArray[62]=audioBitrateSpin;
optionsArray[63]=audioChannelsSpin;
optionsArray[64]=audioRateCombobox;
optionsArray[65]=audioCodecCombobox;
optionsArray[70]=titleCheckbox;
optionsArray[71]=titleEntry;
optionsArray[72]=authorCheckbox;
optionsArray[73]=authorEntry;
optionsArray[74]=trackCheckbox;
optionsArray[75]=trackSpin;
optionsArray[76]=albumCheckbox;
optionsArray[77]=albumEntry;
optionsArray[78]=yearCheckbox;
optionsArray[79]=yearSpin;
optionsArray[80]=commentCheckbox;
optionsArray[81]=commentEntry;
optionsArray[82]=copyrightCheckbox;
optionsArray[83]=copyrightEntry;
optionsArray[3]=entryOutputFile;
gtk_signal_connect(GTK_OBJECT (infoButton), “clicked”, GTK_SIGNAL_FUNC(infoButtonAction), infoWindow);
gtk_signal_connect(GTK_OBJECT (buttonEncode), “clicked”, GTK_SIGNAL_FUNC(encodeButtonAction), optionsArray);

gtk_widget_show_all (mainWindow);
gtk_widget_show_all (infoMainBox);
gtk_widget_hide(durationlimitBoxChild);
gtk_widget_hide(starttimeBoxChild);
gtk_widget_hide(filesizelimitBoxChild);
gtk_widget_hide(videoResolutionBoxChild);
gtk_widget_hide(titleEntry);
gtk_widget_hide(authorEntry);
gtk_widget_hide(albumEntry);
gtk_widget_hide(commentEntry);
gtk_widget_hide(copyrightEntry);
gtk_widget_hide(trackSpin);
gtk_widget_hide(yearSpin);
gtk_main();
}

int main (int argc, char *argv[])
{
gtk_init (&argc, &argv);
drawMainWindow();
return(0);
}

GigaBash y MediaBash

Estoy escribiendo gestores de descarga para MediaFire y GigaSize. Proximamente GigaBash y MediaBash…

Adjuntar archivos en imágenes

Es posible esconder un archivo en una imagen, para después extraerlo. El funcionamiento es bastante sencillo en realidad lo que se hace es pegar el archivo al final de la imagen. Para extraerlo es necesario saber dónde empieza el archivo, por lo que es necesario saber cual era el tamaño de la imágen antes de “pegarle” el otro archivo.

Voy a explicar como hacerlo en sistemas tipo Unix.

Por ejemplo, tengo una imagen llamada gnu.jpg y un archivo pdf llamado Javascript.pdf

En primer lugar tengo que saber cuantos bytes ocupa gnu.jpg, para eso abro una terminal, uso el comando cd para entrar al directorio donde están los archivos y escribo el comando
stat -c %s "gnu.jpg"

El resultado es 3716.

Ahora tengo que concatenar (pegar al final) el archivo Javascript.pdf. El comando para hacerlo es:
cat "Javascript.pdf" >>"gnu.jpg"

Para extraerlo se usa el comando:
tail -c +3717 "gnu.jpg" > "Javascript.pdf"

Hay dos cosas importantes a tener en cuenta: La primera es que el número 3717 es el byte donde empieza el archivo Javascript.pdf, por lo que tiene que ser un byte más que el tamaño original de la imagen gnu.jpg (3716).  La segunda es que no hay que olvidar escribir el símbolo + antes del número.

Como demostración voy a subir la imagen a este blog para que ustedes (los que lean esto) puedan extraer el archivo Javascript.pdf.

Imagen de GNU

Para extraer Javascript.pdf click secundario en la imagen, guardar imagen como…, abrir una terminal, usar el comando cd para entrar en el directorio donde se guardó la imagen y ejecutar el comando para extraerlo antes mencionado.

¿Para qué puede servir esto? Para usar páginas como imageshack, o la función de insertar imágenes en los blogs para publicar un archivo.

Conversación de voz a traves de Jabber Jingle

Últimamente estuvo probando la conversación de voz a través del prótocolo Jingle en Jabber (compatible con Google Talk), y la verdad es que me quedé bastante decepcionado por lo mal que va la cosa en cuanto a clientes libres con soporte.

Para empezar en los repositorios de Debian Lenny no encontré ningún cliente compilado con soporte para jingle. Entonces me puse a buscar un poco y me topé con jabbin, un fork de PSI con soporte para audioconferencia.

Las versiones anteriores se basaban en TINS, pero versión 2.0beta2, que está disponible en sourceforge soporta jingle. El problema con este cliente fue que yo no escuchaba lo que el otro decía, aunque el otro sí me escuchaba a mi.

Screenshot de jabbin

Despues de desistir con este jabbin, me puse a buscar, y encontré menciones a un cliente llamado Tapioca. Desafortunadamente, cuando intenté entrar a su página web, me encontré con el horrible error 403.

Entonces seguí buscando y encontré la información de que en algún momento kopete y PSI habían hecho un intento de incluir soporte para jingle. Sin embargo, los binarios que hay en Debian no están compilados con esa característica activada ya que en ambos es experimental. Intenté compilarlos, pero siempre me fue imposible compilar algo, y esta vez no fue la excepción (Maldito C).

Entonces ya casi rendido continué con mi búsqueda y encontré que en google code había una versión más nueva de jabbin.

La descargué y me pareció muy bonita, aunque tenía algunas cosas que no me gustaban como que no funcione la opción de recordar contraseña y que no permita tener más de una cuenta abierta. Con esta versión yo podía escuchar al que me hablaba, y el a mi, pero funcionaba terriblemente mal. Se escuchaba cortado, es decir de cada palabra se escuchaban dos letras. No me servía.

Ya pensando que había perdido probé el Google Talk para Windows (con wine), aunque sabía que no era software libre, afortunadamente no funcionó.

Como era ilógico que ninguna opción funcione, seguí buscando, y buscando, hasta que encontré algo que me salvó: Binarios de PSI y Kopete con soporte jingle. El Kopete no lo probé porque está en un paquete llamado kdenetwork, así que debe incluir otros programas y se me habría hecho un lío al instalarlos. Para instalar PSI lo bajé de el siguiente enlace psi-jingle-0.10-1.df.i386.rpm, y lo instalé con el alien (programa de Debian que permite transformar paquetes, en este caso RPM a DEB). Además tuve que instalar el paquete ortp-0.7.1-3.liq.fc4.i386.rpm que está en el mismo link de arriba, ya que con la versión de Debian de libortp no funciona.

En definitiva, con esta versión de PSI funcionó la audioconferencia, no perfectamente, pero al menos aceptablemente.
Lo malo de PSI es que bloquea el audio, por lo que no se puede reproducir nada mientras se este usando.

Editado: Empathy, la solución definitiva

Después de escribir este post encontré empathy, y fue grata mi sorpresa al ver que estaba en los repositorios de Debian. Para que funcione la conversación de voz hay que instalar también los paquetes recomendados, no sólo las dependencias. Este cliente es multiprotocolo, pero no me gusta mucho porque es bastante minimalista, sin embargo para audioconferencia es lo mejor que hay. A diferencia de los que mencioné anteriormente, no bloquea el sonido, por lo que se puede hablar y a la vez escuchar música.
apt-get install empathy

empathy screenshot

Automatizar descargas de MegaUpload: MegaUpbash

MegaupBash es un gestor de descargas de archivos alojados en el servidor www.megaupload.com. Permite automatizar las descargas, para facilitar el proceso de descarga de muchos archivos. Además puede encontrar enlaces a archivos alojados en MegaUpload en páginas web o en un archivo local.

En mi post anterior mostraba RapiBash: un programa que tiene la misma funcionalidad, pero para el servidor rapidshare.com.
Este programa es igual en cuanto apariencia y modo de uso que rapibash.
Si alguien quiere dar una sugerencia, crítica, mejora, quiere aportar con una traducción, o simplemente lo ha probado y le funcionó bien, por favor escriba un comentario.
La interfaz gráfica usa zenity, o Xdialog por lo que uno de esos dos programas debe estar instalado.
Para resolver los captchas usa un algoritmo creado para Plowshare.(Gracias tokland).
Depende de Python, Python Imaging Library, Tesseract-ocr, y Tesseract-ocr-eng.
Para instalar las dependencias en un sistema Debian (o derivados como ubuntu):
apt-get install zenity python python-imaging tesseract-ocr tesseract-ocr-eng

Uso desde la linea de comandos

Agregar enlaces a la lista:
megaupbash add http://link-de-descarga1 http://link-de-descarga2 http://link-de-descarga3 http://link-de-descarga4
Iniciar las descargas:
megaupbash start
Detener las descargas:
megaupbash stop
Cambiar el orden de un enlace en la lista de descargas:
megaupbash move numero-de-la-linea-a-mover nuevo-lugar-de-la-linea

Imagen

Descargar

Descargar shell script

Descagar paquete DEB (para Debian o derivados como Ubuntu)

Una cosa que me gustaría que comentaran es si prefieren que este programa se fusione con RapiBash para crear un sólo gestor de descargas para ambos servidores, o si creen que es mejor que esten separados.

A la fecha de hoy (14 de abril de 2009) el programa funciona, pero seguramente en poco tiempo megaupload va a cambiar algo y ya no va a funcionar.

Automatizar descargas de RapidShare: RapiBash

RapiBash es un gestor de descargas de archivos alojados en el servidor rapidshare.com. Permite automatizar las descargas, para facilitar el proceso de descarga de muchos archivos. Además puede encontrar enlaces a archivos alojados en RapidShare en páginas web o en un archivo local.
En mi post anterior mostraba un pequeño script que servía para descargar varias cosas de rapidshare con un sólo comando. En un comentario del mismo decía que tenía pensado mejorarlo y hacerle una interfaz gráfica con kdialog o zenity. Lo hice.
Lo que comenzó siendo una mejora para el script terminó siendo un programa muy diferente, tanto en su funcionamiento interno como en su uso por el usuario.
Si alguien encuentra algún error, quiere dar una sugerencia, crítica, mejora, quiere aportar con una traducción, o simplemente lo ha probado y le funcionó bien, por favor escriba un comentario.
La interfaz gráfica usa zenity, o Xdialog por lo que uno de esos dos programas debe estar instalado.
También puede usarse desde la linea de comandos.

Uso desde la linea de comandos

Agregar enlaces a la lista:
rapibash add http://link-de-descarga1 http://link-de-descarga2 http://link-de-descarga3 http://link-de-descarga4
Iniciar las descargas:
rapibash start
Detener las descargas:
rapibash stop
Cambiar el orden de un enlace en la lista de descargas:
rapibash move numero-de-la-linea-a-mover nuevo-lugar-de-la-linea

Imagen

Nota: Difuminé lo que estaba descargando porque no estoy seguro si es legal ¬¬

Actualización

A partir del 9 de octubre de 2008 rapidshare volvió a poner tiempo de espera entre la descarga de un archivo y otro, por lo que la versión 0.1 del script actualmente no funciona. La versión 0.2 además soluciona el bug que reportó lavaramano, no permitiendo que haya dos enlaces iguales.

Descargar rapibash 0.2

Descargar shell script

Descargar paquete deb
Para Debian o otras distros que usen dpkg como sistema de paquetes (Ejemplo Ubuntu)

Si estas buscando un gestor de descargas para megaupload, entonces mira megaupbash

rapidshare-descargar: Script bash para descargar varios archivos automáticamente

IMPORTANTE: Este script es obsoleto, ya no funciona. Una versión muchísimo mejor de este programa que funciona está en el próximo post Automatizar descargas de RapidShare: RapiBash

Hace poco tiempo que para descargar algo de Rapidshare ya no es necesario escribir el código captcha (Ejemplo “Escribe las cuatro letras que tienen un gatito”), y que no hay que esperar entre una descarga y otra. Aprovechando esto hice un script para descargar varias cosas de rapidshare con un sólo comando.

¿Para que sirve? Sin este script habría que esperar hasta que una descarga finalice entrar al próximo enlace de descarga, hacer click en free, esperar unos segundos y hacer click en Download now para empezar a descargar otra cosa. Este script evita tener que hacer todo eso por cada enlace, por ejemplo para descargar un archivo que está dividido en 4 partes se usaría así: rapidshare-descargar archivo.parte1 archivo.parte2 archivo.parte3 archivo.parte4

Si todavía no entendés para que sirve (es dificil explicarlo) pensá en esto: Rapidshare tiene un límite se tamaño de archivo de 100MB. Los que suben archivos más grandes (ejemplo: películas) dividen estas películas en partes de cien megas. Supongamos que querés descargar todas esas partes durante una noche. Usando este script podés indicarle que descargue todas esas partes e irte a dormir. Sin este script tendrías que levantarte varias veces en la mitad de la noche para abrir un navegador y entrar al enlace de cada parte en la que está divida la película para poder descargarla.

NOTA: Este script es feo y sencillo, pero funciona. Si en algún momento rapidshare cambia la presentación de su web este script va a dejar de funcionar.


#!/bin/bash

if [ ! "$1" ];then echo “Debes especificar una URL”;exit 1;fi

function salirconerror {
echo “$1″;
rm “/tmp/rpdshr1″;
rm “/tmp/rpdshr2″;
continue;
}

for argumento in $*;do
echo -n “Paso 1 de 4: Descargando $argumento”
wget -q -O “/tmp/rpdshr1″ “$argumento” || salirconerror “Error al descargar $argumento”;
lineamagica=$(grep ‘action=’ “/tmp/rpdshr1″ | head -n 1) || salirconerror “Error: no se encuentra action= en $argumento”;
direccionmagica=$(echo “$lineamagica” | sed -e ’s/^.*action=”//’| sed -e ’s/”.*$//’) || salirconerror “Error, no se puede determinar el segundo enlace”;

echo -ne “\rPaso 2 de 4: Descargando $direccionmagica”
wget -q –post-data ‘dl.start=Free’ -O “/tmp/rpdshr2″ “$direccionmagica” || salirconerror “Error: al descargar $direccionmagica”;
lineamagica2=$(grep ‘action=’ “/tmp/rpdshr2″ | head -n 1) || salirconerror “Error: no se encuentra action= en $direccionmagica”;
direccionmagica2=$(echo “$lineamagica2″ | sed -e ’s/^.*action=”//’| sed -e ’s/”.*$//’) || salirconerror “Error, no se puede determinar el enlace al archivo”;

esperar=$(grep ‘var c=’ “/tmp/rpdshr2″ | head -n 1 | sed -e ’s/^.*var c=//’|sed -e ’s/;.*$//’) || ( echo “Error: no se puede determinar cuanto tiempo esperar, esperando 300 segundos”; esperar=300 )
while [ $esperar -ge 0 ];do echo -ne “\rPaso 3 de 4: Faltan $esperar segundos para que se pueda descargar el archivo.”;sleep 1; esperar=$(($esperar-1));done

echo -e “\rPaso 4 de 4: Descargando $direccionmagica2 \r”
wget “$direccionmagica2″ || salirconerror “Error al descargar el archivo”;

rm “/tmp/rpdshr1″;
rm “/tmp/rpdshr2″;
done

SM56 (modem Motorola Dial-Up 56k) en GNU/Linux

Hace mucho tiempo intenté hacer que este modem funcione en GNU/Linux, pero sin éxito.
Después, cuando ya había adquirido un poco más de conocimientos, con un poco de esfuerzo y suerte logré hacerlo. Esta es una muy breve explicación de como lo hice. No había escrito esto antes porque pensé que en esta época (año 2008) ya muy pocas personas usaban dial-up, por lo tanto sería inutil. Pero como alguien llamado coyote10 dijo en #debian-es que tenía uno de estos modems y quería usarlo con Linux, se me ocurrió que contar cómo lo hice sería de ayuda para otros. Si a alguien le sirve de ayuda me cuenta ;)

Para lograr que funcione usé Debian Sarge, el kernel 2.4.28-pre3, y un módulo que compilé usando otra versión del kernel, pero que mágica y casualmente funcionaba. Tuve que compilarlo para otra versión del kernel porque no encontré los headers para el 2.4.28-pre3.

¿Por qué usé esta versión del kernel? Probé en muchos otras versiones del kernel con resultados completamente insatisfactorios, que varian entre desconexión automática a los pocos segundos de conectarse a internet, hasta que la máquina se tilde cuando intentaba usar el modem. Esta versión fue en la única en la que pude hacer que funcione BIEN.

Primero instalé el kernel con dpkg -i kernel-image-2.4.28-pre3_1.01_i386.deb , creo recordar haber tenido algún problema de dependencias, pero no recuerdo cómo lo solucioné.

El módulo (driver) que usé era sm56.o.bz2. Nota está comprimido, hay que descomprimirlo antes de usarlo. Una vez descomprimido hay que copiarlo a /lib/modules/2.4.28-pre3/drivers/net/ y ejecutar como root depmod -a. Después de eso hay que cargarlo con modprobe sm56 y por último crear el dispositivo mknod /dev/sm56 c 24 0;rm /dev/modem;ln -s /dev/sm56 /dev/modem

Descargas

Kernel Linux 2.4.28-pre3
sm56.o.bz2 Nota está comprimido, hay que descomprimirlo antes de usarlo.

Reinauguración del Blog

Durante un tiempo tuve este blog funcionando, pero un día me dieron ganas de moverlo a /dev/null y lo hice. Como no había escrito mucho, tampoco perdí mucho.

Ahora voy a volver a abrirlo, pero con una idea ligeramente diferente a la que tenía la primera vez que lo abrí. Un tema recurrente va a ser (igual que antes) lo relacionado con informática, especialmente software libre.

Por ahora las “categorías” que tengo planeadas son:

1. Análisis de software
2. Opinión
3. Creaciones
4. Anécdotas

“Análisis de software” sería una categoría en la que pondría reviews o previews de programas, sistemas operativo, en fin, software que voy probando.

“Opinión” no creo que necesite explicación, sería una categoría en la que pondría pensamientos propios sobre determinado tema.

“Creaciones”: En el caso de que escriba software, dibuje, escriba una historia de ficción, o cualquier tipo de acto creativo, voy a ponerlo acá.

“Anecdotas”: Acá voy a poner anécdotas, como puede ser problemas por los que pasé y como los solucioné, por ejemplo “La tarde que ejecuté como root rm -rf /lib”

Creo que eso es todo por ahora. Saludos.