--- /dev/null
+/*
+
+ G N O K I I
+
+ A Linux/Unix toolset and driver for Nokia mobile phones.
+
+ Released under the terms of the GNU GPL, see file COPYING for more details.
+
+ This file provides support for ringtones.
+
+*/
+
+#ifdef WIN32
+ #include <windows.h>
+ #include "misc_win32.h"
+#else
+ #include <unistd.h>
+#endif
+
+#include "gsm-api.h"
+
+GSM_Ringtone SMringtone;
+GSM_BinRingtone ringtone;
+
+/* Beats-per-Minute Encoding */
+
+int BeatsPerMinute[] = {
+ 25, 28, 31, 35, 40, 45, 50, 56, 63, 70,
+ 80, 90, 100, 112, 125, 140, 160, 180, 200, 225,
+ 250, 285, 320, 355, 400, 450, 500, 565, 635, 715,
+ 800, 900
+};
+
+struct OneRingtone RingingTones[] = {
+ {"",0,0},
+/* 1 */ {"Uploaded #1",0,0}, /* 2 */ {"Ring ring",0,0},
+/* 3 */ {"Low",0,0}, /* 4 */ {"Fly",0,0},
+/* 5 */ {"Mosquito",0,0}, /* 6 */ {"Bee",0,0},
+/* 7 */ {"Intro",0,0}, /* 8 */ {"Etude",0,0},
+/* 9 */ {"Hunt",0,0}, /* 10 */ {"Going up",0,0},
+/* 11 */ {"City bird",0,0}, /* 12 */ {"Chase",0,0},
+/* 13 */ {"Scifi",0,0}, /* 14 */ {"Kick",0,0},
+/* 15 */ {"Do-mi-so",0,0}, /* 16 */ {"Robo N1X",0,0},
+/* 17 */ {"Dizzy",0,0}, /* 18 */ {"Playground",0,0},
+/* 19 */ {"That's it!",0,0}, /* 20 */ {"Grande valse",0,0},
+/* 21 */ {"Knock knock",0,0}, /* 22 */ {"Knock again",0,0},
+/* 23 */ {"Helan",0,0}, /* 24 */ {"Fuga",0,0},
+/* 25 */ {"Menuet",0,0}, /* 26 */ {"Ode to Joy",0,0},
+/* 27 */ {"Elise",0,0}, /* 28 */ {"Mozart 40",0,0},
+/* 29 */ {"Piano Concerto",0,0},/* 30 */ {"William Tell",0,0},
+/* 31 */ {"Badinerie",0,0}, /* 32 */ {"Polka",0,0},
+/* 33 */ {"Attraction",0,0}, /* 34 */ {"Polite",0,0},
+/* 35 */ {"Persuasion",0,0}, /* 36 */ {"Tick tick",0,0},
+/* 37 */ {"Samba",0,0}, /* 38 */ {"Orient",0,0},
+/* 39 */ {"Charleston",0,0}, /* 40 */ {"Songette",0,0},
+/* 41 */ {"Jumping",0,0}, /* 42 */ {"Lamb",0,0},
+/* 43 */ {"Marry",0,0}, /* 44 */ {"Tango",0,0},
+/* 45 */ {"Tangoed",0,0}, /* 46 */ {"Down",0,0},
+/* 47 */ {"Polska",0,0}, /* 48 */ {"WalzeBrilliant",0,0},
+/* 49 */ {"Cicada",0,0}, /* 50 */ {"Trio",0,0},
+/* 51 */ {"Circles",0,0}, /* 52 */ {"Nokia tune",0,0},
+/* 53 */ {"Sunny walks",0,0}, /* 54 */ {"Basic rock",0,0},
+/* 55 */ {"Reveille",0,0}, /* 56 */ {"Groovy Blue",0,0},
+/* 57 */ {"Brave Scotland",0,0},/* 58 */ {"Matilda",0,0},
+/* 59 */ {"Bumblebee",0,0}, /* 60 */ {"Hungarian",0,0},
+/* 61 */ {"Valkyrie",0,0}, /* 62 */ {"Bach #3",0,0},
+/* 63 */ {"Toreador",0,0}, /* 64 */ {"9th Symphony",0,0},
+/* 65 */ {"Uploaded #2",0,0}, /* 66 */ {"Uploaded #3",0,0},
+/* 67 */ {"Uploaded #4",0,0}, /* 68 */ {"Uploaded #5",0,0},
+ {"",0,0}
+};
+
+int OctetAlign(unsigned char *Dest, int CurrentBit)
+{
+ int i=0;
+
+ while((CurrentBit+i)%8) {
+ ClearBit(Dest, CurrentBit+i);
+ i++;
+ }
+
+ return CurrentBit+i;
+}
+
+int OctetAlignNumber(int CurrentBit)
+{
+ int i=0;
+
+ while((CurrentBit+i)%8) { i++; }
+
+ return CurrentBit+i;
+}
+
+int BitPack(unsigned char *Dest, int CurrentBit, unsigned char *Source, int Bits)
+{
+
+ int i;
+
+ for (i=0; i<Bits; i++)
+ if (GetBit(Source, i)) SetBit(Dest, CurrentBit+i);
+ else ClearBit(Dest, CurrentBit+i);
+
+ return CurrentBit+Bits;
+}
+
+int GSM_GetTempo(int Beats) {
+
+ int i=0;
+
+ while ( i < sizeof(BeatsPerMinute)/sizeof(BeatsPerMinute[0])) {
+
+ if (Beats<=BeatsPerMinute[i]) break;
+ i++;
+ }
+
+ return i<<3;
+}
+
+int BitPackByte(unsigned char *Dest, int CurrentBit, unsigned char Command, int Bits) {
+
+ unsigned char Byte[]={Command};
+
+ return BitPack(Dest, CurrentBit, Byte, Bits);
+}
+
+
+/* This is messy but saves using the math library! */
+
+int GSM_GetDuration(int number, unsigned char *spec) {
+
+ int duration=0;
+
+ switch (number) {
+
+ case 128*3/2: duration=Duration_Full; *spec=DottedNote; break;
+ case 128*2/3: duration=Duration_Full; *spec=Length_2_3; break;
+ case 128 : duration=Duration_Full; *spec=NoSpecialDuration; break;
+ case 64*9/4 : duration=Duration_1_2; *spec=DoubleDottedNote; break;
+ case 64*3/2 : duration=Duration_1_2; *spec=DottedNote; break;
+ case 64*2/3 : duration=Duration_1_2; *spec=Length_2_3; break;
+ case 64 : duration=Duration_1_2; *spec=NoSpecialDuration; break;
+ case 32*9/4 : duration=Duration_1_4; *spec=DoubleDottedNote; break;
+ case 32*3/2 : duration=Duration_1_4; *spec=DottedNote; break;
+ case 32*2/3 : duration=Duration_1_4; *spec=Length_2_3; break;
+ case 32 : duration=Duration_1_4; *spec=NoSpecialDuration; break;
+ case 16*9/4 : duration=Duration_1_8; *spec=DoubleDottedNote; break;
+ case 16*3/2 : duration=Duration_1_8; *spec=DottedNote; break;
+ case 16*2/3 : duration=Duration_1_8; *spec=Length_2_3; break;
+ case 16 : duration=Duration_1_8; *spec=NoSpecialDuration; break;
+ case 8*9/4 : duration=Duration_1_16; *spec=DoubleDottedNote; break;
+ case 8*3/2 : duration=Duration_1_16; *spec=DottedNote; break;
+ case 8*2/3 : duration=Duration_1_16; *spec=Length_2_3; break;
+ case 8 : duration=Duration_1_16; *spec=NoSpecialDuration; break;
+ case 4*9/4 : duration=Duration_1_32; *spec=DoubleDottedNote; break;
+ case 4*3/2 : duration=Duration_1_32; *spec=DottedNote; break;
+ case 4*2/3 : duration=Duration_1_32; *spec=Length_2_3; break;
+ case 4 : duration=Duration_1_32; *spec=NoSpecialDuration; break;
+ }
+
+ return duration;
+}
+
+
+int GSM_GetNote(int number) {
+
+ int note=0;
+
+ if (number!=255) {
+ note=number%14;
+ switch (note) {
+
+ case 0: note=Note_C; break;
+ case 1: note=Note_Cis; break;
+ case 2: note=Note_D; break;
+ case 3: note=Note_Dis; break;
+ case 4: note=Note_E; break;
+ case 6: note=Note_F; break;
+ case 7: note=Note_Fis; break;
+ case 8: note=Note_G; break;
+ case 9: note=Note_Gis; break;
+ case 10: note=Note_A; break;
+ case 11: note=Note_Ais; break;
+ case 12: note=Note_H; break;
+ }
+ }
+ else note = Note_Pause;
+
+ return note;
+
+}
+
+int GSM_GetScale(int number) {
+
+ int scale=-1;
+
+ if (number!=255) {
+ scale=number/14;
+
+ /* Ensure the scale is valid */
+ scale%=4;
+
+ scale=scale<<6;
+ }
+ return scale;
+}
+
+/* This function packs the ringtone from the structure "ringtone" to
+ "package", where maxlength means length of package.
+ Function returns number of packed notes and change maxlength to
+ number of used chars in "package" */
+u8 GSM_PackRingtone(GSM_Ringtone *ringtone, unsigned char *package, int *maxlength)
+{
+ int StartBit=0;
+ unsigned char CommandLength = 0x02;
+ unsigned char spec;
+ int oldscale=10, newscale=0, oldstyle=0, oldtempo=0;
+ int HowMany=0; /* How many instructions packed */
+ int HowLong=0; /* How many bits packed */
+ int StartNote=0, EndNote=0; /* First and last packed note from ringtone */
+
+ /* Default ringtone parameters */
+ u8 DefNoteScale=2, DefNoteDuration=4;
+ int DefNoteTempo=63;
+ u8 DefNoteStyle=NaturalStyle;
+
+ int buffer[6]; /* Used to find default ringtone parameters */
+ int i,j,k=0,thisnote,thisnotelong;
+
+ /* Find the most frequently used duration and use this for the default */
+ for (i=0;i<6;i++) buffer[i]=0;
+ for (i=0;i<ringtone->NrNotes;i++) {
+ switch (ringtone->notes[i].duration) {
+ case 192: buffer[0]++; break;
+ case 128: buffer[0]++; break;
+ case 96: buffer[1]++; break;
+ case 64: buffer[1]++; break;
+ case 48: buffer[2]++; break;
+ case 32: buffer[2]++; break;
+ case 24: buffer[3]++; break;
+ case 16: buffer[3]++; break;
+ case 12: buffer[4]++; break;
+ case 8: buffer[4]++; break;
+ case 6: buffer[5]++; break;
+ case 4: buffer[5]++; break;
+ }
+ }
+
+ /* Now find the most frequently used */
+ j=0;
+ for (i=0;i<6;i++) {
+ if (buffer[i]>j) {
+ k=i;
+ j=buffer[i];
+ }
+ }
+
+ /* Finally convert the default duration */
+ switch (k) {
+ case 0: DefNoteDuration=128; break;
+ case 1: DefNoteDuration= 64; break;
+ case 2: DefNoteDuration= 32; break;
+ case 3: DefNoteDuration= 16; break;
+ case 4: DefNoteDuration= 8; break;
+ case 5: DefNoteDuration= 4; break;
+ default: DefNoteDuration= 16; break;
+ }
+
+ /* Find the most frequently used scale and use this for the default */
+ for (i=0;i<6;i++) buffer[i]=0;
+ for (i=0;i<ringtone->NrNotes;i++) {
+ if (ringtone->notes[i].note!=255) {
+ buffer[ringtone->notes[i].note/14]++;
+ }
+ }
+ j=0;
+ for (i=0;i<6;i++) {
+ if (buffer[i]>j) {
+ DefNoteScale=i;
+ j=buffer[i];
+ }
+ }
+
+ StartBit=BitPackByte(package, StartBit, CommandLength, 8);
+ StartBit=BitPackByte(package, StartBit, RingingToneProgramming, 7);
+
+ /* The page 3-23 of the specs says that <command-part> is always
+ octet-aligned. */
+ StartBit=OctetAlign(package, StartBit);
+
+ StartBit=BitPackByte(package, StartBit, Sound, 7);
+ StartBit=BitPackByte(package, StartBit, BasicSongType, 3);
+
+ /* Set special chars in ringtone name */
+ for (i=0;i<strlen(ringtone->name);i++) {
+ if (ringtone->name[i]=='~') ringtone->name[i]=1; //enables/disables blinking
+ if (ringtone->name[i]=='`') ringtone->name[i]=0; //hides rest ot contents
+ }
+
+ /* Packing the name of the tune. */
+ StartBit=BitPackByte(package, StartBit, strlen(ringtone->name)<<4, 4);
+ StartBit=BitPack(package, StartBit, ringtone->name, 8*strlen(ringtone->name));
+
+ /* Set special chars in ringtone name */
+ for (i=0;i<strlen(ringtone->name);i++) {
+ if (ringtone->name[i]==1) ringtone->name[i]='~'; //enables/disables blinking
+ if (ringtone->name[i]==0) ringtone->name[i]='`'; //hides rest ot contents
+ }
+
+ /* Info about song pattern */
+ StartBit=BitPackByte(package, StartBit, 0x01, 8); /* One song pattern */
+ StartBit=BitPackByte(package, StartBit, PatternHeaderId, 3);
+ StartBit=BitPackByte(package, StartBit, A_part, 2);
+ StartBit=BitPackByte(package, StartBit, ringtone->Loop<<4, 4);
+
+ /* Info, how long is contents for SMS */
+ HowLong=8+8+7+3+4+8*strlen(ringtone->name)+8+3+2+4+8+3+2+3+5;
+
+ /* Calculating number of instructions in the tune.
+ Each Note contains Note and (sometimes) Scale.
+ Default Tempo and Style are instructions too. */
+ HowMany=2; /* Default Tempo and Style */
+
+ /* Default style and tempo */
+ DefNoteStyle=ringtone->notes[0].style;
+ DefNoteTempo=ringtone->notes[0].tempo;
+ oldstyle=DefNoteStyle;
+ oldtempo=DefNoteTempo;
+
+ for(i=0; i<ringtone->NrNotes; i++) {
+
+ /* PC Composer 2.0.010 doesn't like, when we start ringtone from pause:
+ displays, that format is invalid and
+ hangs, when you move mouse over place, where pause is */
+ if (GSM_GetNote(ringtone->notes[i].note)==Note_Pause && oldscale==10) {
+ StartNote++;
+ } else {
+
+ thisnote=0;
+ thisnotelong=0;
+
+ /* we don't write Scale/Style info before "Pause" note - it saves place */
+ if (GSM_GetNote(ringtone->notes[i].note)!=Note_Pause) {
+
+ if (ringtone->allnotesscale ||
+ oldscale!=(newscale=GSM_GetScale(ringtone->notes[i].note))) {
+
+ /* We calculate, if we have space to add next scale instruction */
+ if (((OctetAlignNumber(HowLong+5)+8)/8)<=(*maxlength)) {
+ oldscale=newscale;
+ HowLong+=5;
+ HowMany++;
+ thisnote++;
+ thisnotelong+=5;
+ } else {
+ break;
+ }
+ }
+ if (ringtone->notes[i].style!=oldstyle) {
+ /* We calculate, if we have space to add next style instruction */
+ if (((OctetAlignNumber(HowLong+5)+8)/8)<=(*maxlength)) {
+ oldstyle=ringtone->notes[i].style;
+ HowLong+=5;
+ HowMany++;
+ thisnote++;
+ thisnotelong+=5;
+ } else {
+ HowLong=HowLong-thisnotelong;
+ HowMany=HowMany-thisnote;
+ break;
+ }
+ }
+ }
+
+ if (ringtone->notes[i].tempo!=oldtempo) {
+ /* We calculate, if we have space to add next tempo instruction */
+ if (((OctetAlignNumber(HowLong+8)+8)/8)<=(*maxlength)) {
+ oldtempo=ringtone->notes[i].tempo;
+ HowLong+=8;
+ HowMany++;
+ thisnote++;
+ thisnotelong+=8;
+ } else {
+ HowLong=HowLong-thisnotelong;
+ HowMany=HowMany-thisnote;
+ break;
+ }
+ }
+
+ /* We calculate, if we have space to add next note instruction */
+ if (((OctetAlignNumber(HowLong+12)+8)/8)<=(*maxlength)) {
+ HowMany++;
+ EndNote++;
+ HowLong+=12;
+ } else {
+ HowLong=HowLong-thisnotelong;
+ HowMany=HowMany-thisnote;
+ break;
+ }
+ }
+
+ /* We are sure, we pack it for SMS or setting to phone, not for OTT file */
+ if (*maxlength<1000) {
+ /* Like Pc Composer say - before of phone limitations...*/
+ if ((EndNote-StartNote)==FB61_MAX_RINGTONE_NOTES-1) break;
+ }
+ }
+
+ StartBit=BitPackByte(package, StartBit, HowMany, 8);
+#ifdef DEBUG
+// fprintf(stdout,_("length of new pattern: %i %i\n"),HowMany,StartBit);
+#endif
+
+ /* Style */
+ StartBit=BitPackByte(package, StartBit, StyleInstructionId, 3);
+ StartBit=BitPackByte(package, StartBit, DefNoteStyle, 2);
+
+ /* Beats per minute/tempo of the tune */
+ StartBit=BitPackByte(package, StartBit, TempoInstructionId, 3);
+ StartBit=BitPackByte(package, StartBit, GSM_GetTempo(DefNoteTempo), 5);
+#ifdef DEBUG
+// fprintf(stdout,_("def temp: %i %i\n"),GSM_GetTempo(DefNoteTempo),StartBit);
+#endif
+
+ /* Default scale */
+ oldscale=10;
+
+ /* Default style */
+ oldstyle=DefNoteStyle;
+
+ /* Default tempo */
+ oldtempo=DefNoteTempo;
+
+ /* Notes packing */
+ for(i=StartNote; i<(EndNote+StartNote); i++) {
+
+ /* we don't write Scale info before "Pause" note - it saves place */
+ if (GSM_GetNote(ringtone->notes[i].note)!=Note_Pause) {
+ if (ringtone->allnotesscale ||
+ oldscale!=(newscale=GSM_GetScale(ringtone->notes[i].note))) {
+#ifdef DEBUG
+// fprintf(stdout,_("Scale\n"));
+#endif
+ oldscale=newscale;
+ StartBit=BitPackByte(package, StartBit, ScaleInstructionId, 3);
+ StartBit=BitPackByte(package, StartBit, GSM_GetScale(ringtone->notes[i].note), 2);
+ }
+ if (ringtone->notes[i].style!=oldstyle) {
+ /* Style */
+ StartBit=BitPackByte(package, StartBit, StyleInstructionId, 3);
+ StartBit=BitPackByte(package, StartBit, ringtone->notes[i].style, 2);
+ oldstyle=ringtone->notes[i].style;
+ }
+ }
+
+ if (ringtone->notes[i].tempo!=oldtempo) {
+ /* Beats per minute/tempo of the tune */
+ StartBit=BitPackByte(package, StartBit, TempoInstructionId, 3);
+ StartBit=BitPackByte(package, StartBit, GSM_GetTempo(ringtone->notes[i].tempo), 5);
+ oldtempo=ringtone->notes[i].tempo;
+ }
+
+ /* Note */
+ StartBit=BitPackByte(package, StartBit, NoteInstructionId, 3);
+ StartBit=BitPackByte(package, StartBit, GSM_GetNote(ringtone->notes[i].note), 4);
+ StartBit=BitPackByte(package, StartBit, GSM_GetDuration(ringtone->notes[i].duration,&spec), 3);
+ StartBit=BitPackByte(package, StartBit, spec, 2);
+
+#ifdef DEBUG
+// fprintf(stdout,_("note(%i): %i, scale: %i, duration: %i, spec: %i\n"),i,ringtone->notes[i].note,GSM_GetScale(ringtone->notes[i].note),GSM_GetDuration(ringtone->notes[i].duration,&spec),spec);
+#endif
+
+ }
+
+ StartBit=OctetAlign(package, StartBit);
+
+ StartBit=BitPackByte(package, StartBit, CommandEnd, 8);
+
+#ifdef DEBUG
+ if (StartBit!=OctetAlignNumber(HowLong)+8)
+ fprintf(stdout,_("Error in PackRingtone - StartBit different to HowLong %d - %d)\n"),StartBit,OctetAlignNumber(HowLong)+8);
+#endif
+
+ *maxlength=StartBit/8;
+
+ return(EndNote+StartNote);
+}
+
+int BitUnPack(unsigned char *Dest, int CurrentBit, unsigned char *Source, int Bits)
+{
+ int i;
+
+ for (i=0; i<Bits; i++)
+ if (GetBit(Dest, CurrentBit+i)) { SetBit(Source, i); }
+ else { ClearBit(Source, i); }
+
+ return CurrentBit+Bits;
+}
+
+int BitUnPackInt(unsigned char *Src, int CurrentBit, int *integer, int Bits) {
+
+ int l=0,z=128,i;
+
+ for (i=0; i<Bits; i++) {
+ if (GetBit(Src, CurrentBit+i)) l=l+z;
+ z=z/2;
+ }
+
+ *integer=l;
+
+ return CurrentBit+i;
+}
+
+int OctetUnAlign(int CurrentBit)
+{
+ int i=0;
+
+ while((CurrentBit+i)%8) i++;
+
+ return CurrentBit+i;
+}
+
+/* TODO: better checking, if contents of ringtone is OK */
+GSM_Error GSM_UnPackRingtone(GSM_Ringtone *ringtone, char *package, int maxlength)
+{
+ int StartBit=0;
+ int HowMany;
+ int l,q,i;
+ int spec;
+
+ /* Default ringtone parameters */
+ u8 DefNoteScale=2, DefNoteDuration=4;
+ int DefNoteTempo=63;
+ u8 DefNoteStyle=NaturalStyle;
+
+ ringtone->allnotesscale=false;
+
+ StartBit=BitUnPackInt(package,StartBit,&l,8);
+#ifdef DEBUG
+ if (l!=0x02)
+ fprintf(stdout,_("Not header\n"));
+#endif
+ if (l!=0x02) return GE_SUBFORMATNOTSUPPORTED;
+
+ StartBit=BitUnPackInt(package,StartBit,&l,7);
+#ifdef DEBUG
+ if (l!=RingingToneProgramming)
+ fprintf(stdout,_("Not RingingToneProgramming\n"));
+#endif
+ if (l!=RingingToneProgramming) return GE_SUBFORMATNOTSUPPORTED;
+
+ /* The page 3-23 of the specs says that <command-part> is always
+ octet-aligned. */
+ StartBit=OctetUnAlign(StartBit);
+
+ StartBit=BitUnPackInt(package,StartBit,&l,7);
+#ifdef DEBUG
+ if (l!=Sound)
+ fprintf(stdout,_("Not Sound\n"));
+#endif
+ if (l!=Sound) return GE_SUBFORMATNOTSUPPORTED;
+
+ StartBit=BitUnPackInt(package,StartBit,&l,3);
+#ifdef DEBUG
+ if (l!=BasicSongType)
+ fprintf(stdout,_("Not BasicSongType\n"));
+#endif
+ if (l!=BasicSongType) return GE_SUBFORMATNOTSUPPORTED;
+
+ /* Getting length of the tune name */
+ StartBit=BitUnPackInt(package,StartBit,&l,4);
+ l=l>>4;
+#ifdef DEBUG
+// fprintf(stdout,_("Length of name: %i\n"),l);
+#endif
+
+ /* Unpacking the name of the tune. */
+ StartBit=BitUnPack(package, StartBit, ringtone->name, 8*l);
+ ringtone->name[l]=0;
+
+ /* Set special chars in ringtone name */
+ for (i=0;i<strlen(ringtone->name);i++) {
+ if (ringtone->name[i]==1) ringtone->name[i]='~'; //enables/disables blinking
+ if (ringtone->name[i]==0) ringtone->name[i]='`'; //hides rest ot contents
+ }
+
+#ifdef DEBUG
+// fprintf(stdout,_("Name: %s\n"),ringtone->name);
+#endif
+
+ StartBit=BitUnPackInt(package,StartBit,&l,8);
+#ifdef DEBUG
+// fprintf(stdout,_("Number of song patterns: %i\n"),l);
+#endif
+ if (l!=1) return GE_SUBFORMATNOTSUPPORTED; //we support only one song pattern
+
+ StartBit=BitUnPackInt(package,StartBit,&l,3);
+#ifdef DEBUG
+ if (l!=PatternHeaderId)
+ fprintf(stdout,_("Not PatternHeaderId\n"));
+#endif
+ if (l!=PatternHeaderId) return GE_SUBFORMATNOTSUPPORTED;
+
+ StartBit+=2; //Pattern ID - we ignore it
+
+ StartBit=BitUnPackInt(package,StartBit,&l,4);
+ l=l>>4;
+#ifdef DEBUG
+ fprintf(stdout,_("Loop value: %i\n"),l);
+#endif
+ ringtone->Loop=l;
+
+ HowMany=0;
+ StartBit=BitUnPackInt(package, StartBit, &HowMany, 8);
+#ifdef DEBUG
+ fprintf(stdout,_("length of new pattern: %i %i\n"),HowMany,StartBit);
+#endif
+
+ ringtone->NrNotes=0;
+
+ for (i=0;i<HowMany;i++) {
+
+ StartBit=BitUnPackInt(package,StartBit,&q,3);
+ switch (q) {
+ case VolumeInstructionId:
+#ifdef DEBUG
+// fprintf(stdout,_("Volume\n"));
+#endif
+ StartBit+=4;
+ break;
+ case StyleInstructionId:
+ StartBit=BitUnPackInt(package,StartBit,&l,2);
+#ifdef DEBUG
+// fprintf(stdout,_("Style %i\n"),l>>6);
+#endif
+ switch (l) {
+ case StaccatoStyle : DefNoteStyle=StaccatoStyle; break;
+ case ContinuousStyle: DefNoteStyle=ContinuousStyle; break;
+ case NaturalStyle : DefNoteStyle=NaturalStyle; break;
+ }
+ break;
+ case TempoInstructionId:
+ StartBit=BitUnPackInt(package,StartBit,&l,5);
+ l=l>>3;
+ DefNoteTempo=BeatsPerMinute[l];
+#ifdef DEBUG
+// fprintf(stdout,_("Tempo %i\n"),l);
+#endif
+ break;
+ case ScaleInstructionId:
+ StartBit=BitUnPackInt(package,StartBit,&l,2);
+ DefNoteScale=l>>6;
+#ifdef DEBUG
+// fprintf(stdout,_("scale: %i %i\n"),DefNoteScale,ringtone->NrNotes);
+#endif
+ break;
+ case NoteInstructionId:
+ StartBit=BitUnPackInt(package,StartBit,&l,4);
+
+ switch (l) {
+ case Note_C :ringtone->notes[ringtone->NrNotes].note=0;break;
+ case Note_Cis:ringtone->notes[ringtone->NrNotes].note=1;break;
+ case Note_D :ringtone->notes[ringtone->NrNotes].note=2;break;
+ case Note_Dis:ringtone->notes[ringtone->NrNotes].note=3;break;
+ case Note_E :ringtone->notes[ringtone->NrNotes].note=4;break;
+ case Note_F :ringtone->notes[ringtone->NrNotes].note=6;break;
+ case Note_Fis:ringtone->notes[ringtone->NrNotes].note=7;break;
+ case Note_G :ringtone->notes[ringtone->NrNotes].note=8;break;
+ case Note_Gis:ringtone->notes[ringtone->NrNotes].note=9;break;
+ case Note_A :ringtone->notes[ringtone->NrNotes].note=10;break;
+ case Note_Ais:ringtone->notes[ringtone->NrNotes].note=11;break;
+ case Note_H :ringtone->notes[ringtone->NrNotes].note=12;break;
+ default :ringtone->notes[ringtone->NrNotes].note=255;break; //Pause ?
+ }
+
+ if (ringtone->notes[ringtone->NrNotes].note!=255)
+ ringtone->notes[ringtone->NrNotes].note=ringtone->notes[ringtone->NrNotes].note+DefNoteScale*14;
+
+ StartBit=BitUnPackInt(package,StartBit,&l,3);
+ DefNoteDuration=l;
+
+ StartBit=BitUnPackInt(package,StartBit,&spec,2);
+
+ if (DefNoteDuration==Duration_Full && spec==DottedNote)
+ ringtone->notes[ringtone->NrNotes].duration=128*3/2;
+ if (DefNoteDuration==Duration_Full && spec==Length_2_3)
+ ringtone->notes[ringtone->NrNotes].duration=128*2/3;
+ if (DefNoteDuration==Duration_Full && spec==NoSpecialDuration)
+ ringtone->notes[ringtone->NrNotes].duration=128;
+ if (DefNoteDuration==Duration_1_2 && spec==DottedNote)
+ ringtone->notes[ringtone->NrNotes].duration=64*3/2;
+ if (DefNoteDuration==Duration_1_2 && spec==Length_2_3)
+ ringtone->notes[ringtone->NrNotes].duration=64*2/3;
+ if (DefNoteDuration==Duration_1_2 && spec==NoSpecialDuration)
+ ringtone->notes[ringtone->NrNotes].duration=64;
+ if (DefNoteDuration==Duration_1_4 && spec==DottedNote)
+ ringtone->notes[ringtone->NrNotes].duration=32*3/2;
+ if (DefNoteDuration==Duration_1_4 && spec==Length_2_3)
+ ringtone->notes[ringtone->NrNotes].duration=32*2/3;
+ if (DefNoteDuration==Duration_1_4 && spec==NoSpecialDuration)
+ ringtone->notes[ringtone->NrNotes].duration=32;
+ if (DefNoteDuration==Duration_1_8 && spec==DottedNote)
+ ringtone->notes[ringtone->NrNotes].duration=16*3/2;
+ if (DefNoteDuration==Duration_1_8 && spec==Length_2_3)
+ ringtone->notes[ringtone->NrNotes].duration=16*2/3;
+ if (DefNoteDuration==Duration_1_8 && spec==NoSpecialDuration)
+ ringtone->notes[ringtone->NrNotes].duration=16;
+ if (DefNoteDuration==Duration_1_16 && spec==DottedNote)
+ ringtone->notes[ringtone->NrNotes].duration=8*3/2;
+ if (DefNoteDuration==Duration_1_16 && spec==Length_2_3)
+ ringtone->notes[ringtone->NrNotes].duration=8*2/3;
+ if (DefNoteDuration==Duration_1_16 && spec==NoSpecialDuration)
+ ringtone->notes[ringtone->NrNotes].duration=8;
+ if (DefNoteDuration==Duration_1_32 && spec==DottedNote)
+ ringtone->notes[ringtone->NrNotes].duration=4*3/2;
+ if (DefNoteDuration==Duration_1_32 && spec==Length_2_3)
+ ringtone->notes[ringtone->NrNotes].duration=4*2/3;
+ if (DefNoteDuration==Duration_1_32 && spec==NoSpecialDuration)
+ ringtone->notes[ringtone->NrNotes].duration=4;
+
+ ringtone->notes[ringtone->NrNotes].style=DefNoteStyle;
+
+ ringtone->notes[ringtone->NrNotes].tempo=DefNoteTempo;
+
+#ifdef DEBUG
+// fprintf(stdout,_("note(%i): %i, scale: %i, duration: %i, spec: %i\n"),ringtone->NrNotes,ringtone->notes[ringtone->NrNotes].note,DefNoteScale,DefNoteDuration,spec);
+#endif
+ if (ringtone->NrNotes==FB61_MAX_RINGTONE_NOTES) break;
+
+ ringtone->NrNotes++;
+ break;
+ default:
+#ifdef DEBUG
+ fprintf(stdout,_("Unsupported block %i %i\n"),q,i);
+#endif
+ return GE_SUBFORMATNOTSUPPORTED;
+ }
+ }
+
+#ifdef DEBUG
+// printf("Number of notes=%d\n",ringtone->NrNotes);
+#endif
+
+ return GE_NONE;
+}
+
+GSM_Error GSM_ReadRingtone(GSM_SMSMessage *message, GSM_Ringtone *ringtone)
+{
+ if (message->UDHType==GSM_RingtoneUDH) {
+ return GSM_UnPackRingtone(ringtone, message->MessageText, message->Length);
+ } else return GE_SUBFORMATNOTSUPPORTED;
+}
+
+int GSM_GetFrequency(int number) {
+
+ int freq=0;
+
+ /* Values according to the software from http://iki.fi/too/sw/xring/
+ generated with:
+ perl -e 'print int(4400 * (2 **($_/12)) + .5)/10, "\n" for(3..14)'
+ */
+ if (number!=255) {
+ freq=number%14;
+ switch (freq) {
+
+ case 0: freq=523.3; break; // C
+ case 1: freq=554.4; break; // Cis
+
+ case 2: freq=587.3; break; //D
+ case 3: freq=622.3; break; //Dis
+
+ case 4: freq=659.3; break; //E
+
+ case 6: freq=698.5; break; //F
+ case 7: freq=740; break; //Fis
+
+ case 8: freq=784; break; //G
+ case 9: freq=830.6; break; //Gis
+
+ case 10: freq=880; break; //A
+ case 11: freq=932.3; break; //Ais
+
+ case 12: freq=987.8; break; //H
+
+ default: freq=0; break;
+ }
+ }
+ else freq = 0;
+
+ if ((number/14)!=0) freq=freq*(number/14);
+ else freq=freq/2;
+
+ return freq;
+
+}
+
+/* Very fast hack. It should be written correctly ! */
+void GSM_PlayOneNote (GSM_RingtoneNote note) {
+ int Hz;
+
+ Hz=GSM_GetFrequency(note.note);
+
+ GSM->PlayTone(Hz,5);
+
+ /* Is it correct ? Experimental values here */
+ switch (note.style) {
+ case StaccatoStyle:
+ usleep (7500);
+ GSM->PlayTone(0,0);
+ usleep ((1500000/note.tempo*note.duration)-(7500));
+ break;
+ case ContinuousStyle:
+ usleep (1500000/note.tempo*note.duration);
+ break;
+ case NaturalStyle:
+ usleep (1500000/note.tempo*note.duration-50);
+ GSM->PlayTone(0,0);
+ usleep (50);
+ break;
+ }
+}
+
+void GSM_PlayRingtone (GSM_Ringtone *ringtone) {
+
+ int i;
+
+ for (i=0;i<ringtone->NrNotes;i++) {
+ GSM_PlayOneNote(ringtone->notes[i]);
+ }
+
+ /* Disables buzzer */
+ GSM->PlayTone(255*255,0);
+}
+
+/* Initializes one ringtone: first is number of ringtone in
+ RingingTones in gnokii.h, second its' code, last position in phone menu */
+void RT(int number, int code, int menu) {
+ RingingTones[number].code=code;
+ RingingTones[number].menu=menu;
+}
+
+/* This function initializes structures with ringtones names adequate for
+ your phone model and firmware; if your phone is not now supported:
+ 1.set first ringtone in 1'st profile in your phone
+ 2.make ./gnokii --getprofile 1
+ 3.read ringtone code
+ 4.see in gnokii.h, if ringtone name is gnokii.h in RingingTones (if not, add)
+ 5.put here RT(a,b,c), where a is number of name in RingingTones in gnokii.h,
+ b is its' code and c is number of ringtone in phone menu
+ 6.repeat steps 1-5 for all ringtones
+ 7.send me (Marcin-Wiacek@Topnet.PL) all RT and phone model */
+void PrepareRingingTones(char model[64], char rev[64]) {
+
+ char rev2[64];
+ int i;
+ bool doit;
+
+ if (!RingingTones[0].code) {
+ if (!strcmp(model,"NSE-1")) //5110
+ {
+ RT( 2,18, 1);RT( 3,19, 2);RT( 7,23, 3);RT( 5,21, 4);RT( 9,25, 5);
+ RT(20,48, 7);RT(11,27, 8);RT(33,59, 9);RT(35,62,10);
+ RT(46,60,11);RT(16,36,12);RT(17,37,13);RT(13,32,14);RT(14,34,15);
+ RT(19,43,16);RT(18,39,17);RT(24,50,18);RT(31,57,19);RT(28,54,20);
+ RT(30,56,21);RT(40,73,22);RT(39,72,23);RT(37,69,24);
+ RT(23,49,26);RT(38,71,27); RT(41,74,29);
+
+ strcpy(rev2,"05.23"); //5.24 and higher
+ doit=false;
+ for(i=0;i<5;i++)
+ {
+ if (rev[i]<rev2[i]) break;
+ if (rev[i]>rev2[i]) doit=true;
+ }
+
+ if (doit) {
+ RT(22,47, 6);RT(47,58,25);RT(45,80,28);RT(43,75,30);
+ } else
+ {
+ RT(21,47, 6);RT(32,58,25);RT(44,80,28);RT(42,75,30);
+ }
+ RingingTones[0].menu=30; /* How many ringtones in phone */
+ }
+ if (!strcmp(model,"NSM-1")) //6150
+ {
+ RT( 2,18, 1);RT( 3,19, 2);RT( 7,23, 3);RT( 6,22, 4);
+ RT( 4,20, 5);RT( 5,21, 6);RT(15,35, 7);RT(12,30, 8);
+ RT( 9,25, 9);RT(20,47,10);RT( 8,24,11);RT(11,27,12);
+ RT(10,26,13);RT(34,60,14);RT(33,58,15);RT(35,61,16);
+ RT(16,36,17);RT(13,32,18);RT(19,43,19);RT(18,39,20);
+ RT(24,49,21);RT(31,56,22);RT(25,50,23);RT(27,52,24);
+ RT(26,51,25);RT(28,53,26);RT(29,54,27);RT(30,55,28);
+ RT(39,71,29);RT(37,68,30);RT(47,57,31);RT(23,48,32);
+ RT(38,70,33);RT(36,67,34);RT(41,73,35);
+ /*uploadable ringtone*/
+ RT( 1,17,36);
+ RingingTones[0].menu=36; /* How many ringtones in phone */
+ }
+ if (!strcmp(model,"NPE-3")) //6210
+ {
+ RT(19,64, 1);RT( 2,65, 2);RT( 3,66, 3);RT(15,67, 4);RT( 6,68, 5);
+ RT(49,69, 6);RT(50,70, 7);RT( 7,71, 8);RT(35,72, 9);RT(33,73,10);
+ RT(18,74,11);RT( 5,75,12);RT(51,76,13);RT(52,77,14);RT(53,78,15);
+ RT(37,79,16);RT(54,80,17);RT(55,81,18);RT(56,82,19);RT(57,83,20);
+ RT(58,84,21);RT(59,85,22);RT(25,86,23);RT(27,87,24);RT(30,88,25);
+ RT(39,89,26);RT(24,90,27);RT( 8,91,28);RT(60,92,29);RT(61,93,30);
+ RT(31,94,31);RT(62,95,32);RT(63,96,33);RT(64,97,34);RT(48,98,35);
+ /* Uploadable ringtones */
+ RT( 1,137,36);RT(65,138,37);RT(66,139,38);RT(67,140,39);RT(68,141,40);
+
+ RingingTones[0].menu=40; /* How many ringtones in phone */
+ }
+ RingingTones[0].code=true;
+ }
+}
+
+/* returns names from code or number in menu */
+char *RingingToneName(int code, int menu)
+{
+ int index=1;
+ GSM_Error error;
+
+ if (code==0)
+ {
+ while (strcmp(RingingTones[index].name,"")) {
+ if (RingingTones[index].menu==menu) break;
+ index++;
+ }
+ } else
+ {
+ while (strcmp(RingingTones[index].name,"")) {
+ if (RingingTones[index].code==code) break;
+ index++;
+ }
+ }
+
+ if (!strncmp(RingingTones[index].name,"Uploaded ",9)) {
+ ringtone.location=atoi(&RingingTones[index].name[10]);
+
+ error=GSM_GetPhoneRingtone(&ringtone,&SMringtone);
+
+ if (error==GE_NONE) {
+ if (GetModelFeature (FN_RINGTONES)==F_RING_SM) return SMringtone.name;
+ else return ringtone.name;
+ }
+ }
+
+ return RingingTones[index].name;
+}
+
+/* returns code from number in menu */
+int RingingToneCode(int menu)
+{
+ int index=1;
+
+ while ( RingingTones[index].menu!=menu) index++;
+
+ return RingingTones[index].code;
+}
+
+/* returns number in menu from code */
+int RingingToneMenu(int code)
+{
+ int index=1;
+
+ while ( RingingTones[index].code!=code) index++;
+
+ return RingingTones[index].menu;
+}
+
+int NumberOfRingtones()
+{
+ return RingingTones[0].menu;
+}
+
+int GSM_SaveRingtoneToSMS(GSM_MultiSMSMessage *SMS,
+ GSM_Ringtone *ringtone, bool profilestyle)
+{
+ int i, j;
+ unsigned char MessageBuffer[GSM_MAX_SMS_8_BIT_LENGTH*4];
+ unsigned char MessageBuffer2[GSM_MAX_SMS_8_BIT_LENGTH*4];
+ int MessageLength;
+ GSM_UDH UDHType;
+
+ EncodeUDHHeader(MessageBuffer, GSM_RingtoneUDH);
+ MessageLength=GSM_MAX_SMS_8_BIT_LENGTH-(MessageBuffer[0]+1);
+ i=GSM_PackRingtone(ringtone, MessageBuffer, &MessageLength);
+
+ if (i!=ringtone->NrNotes && profilestyle)
+ {
+ MessageLength=0;
+ MessageBuffer[MessageLength++]=0x30; //SM version. Here 3.0
+ MessageBuffer[MessageLength++]=SM30_RINGTONE; //ID for ringtone
+
+ MessageBuffer[MessageLength++]=0x01; //length hi.Later changed
+ MessageBuffer[MessageLength++]=0x00; //length lo.Later changed
+
+ j=SM30_MAX_RINGTONE_FRAME_LENGTH;
+ i=GSM_PackRingtone(ringtone, MessageBuffer2, &j);
+ MessageLength=MessageLength+j;
+ memcpy(MessageBuffer+4,MessageBuffer2,j);
+
+ MessageBuffer[2]=j/256;
+ MessageBuffer[3]=j%256;
+
+ UDHType=GSM_ProfileUDH;
+ } else
+ UDHType=GSM_RingtoneUDH;
+
+ GSM_MakeMultiPartSMS2(SMS,MessageBuffer,MessageLength, UDHType, GSM_Coding_Default);
+
+ return i;
+}
+
+GSM_Error GSM_GetPhoneRingtone(GSM_BinRingtone *ringtone,GSM_Ringtone *SMringtone)
+{
+ GSM_Error error;
+ int i;
+
+ error=GSM->GetBinRingtone(ringtone);
+
+ if (error==GE_UNKNOWNMODEL)
+ {
+ /* In 3310,... we have normal "Smart Messaging" format */
+ if (GetModelFeature (FN_RINGTONES)==F_RING_SM) {
+ i=7;
+ if (ringtone->frame[9]==0x4a && ringtone->frame[10]==0x3a) i=8;
+ ringtone->frame[i]=0x02;
+
+ GSM_UnPackRingtone(SMringtone, ringtone->frame+i, ringtone->length-i);
+
+ return GE_NONE;
+ }
+ }
+
+ return error;
+}
git://git.jankratochvil.net / gnokii.git / blobdiff