gammu-ringtone.h File Reference

#include <gammu-types.h>
#include <gammu-error.h>
#include <gammu-limits.h>
#include <gammu-statemachine.h>
#include <stdio.h>

Include dependency graph for gammu-ringtone.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	GSM_RingNote
struct	GSM_RingCommand
struct	GSM_NoteRingtone
struct	GSM_NokiaBinaryRingtone
struct	GSM_BinaryTone
struct	GSM_Ringtone
struct	GSM_RingtoneInfo
struct	GSM_AllRingtonesInfo

Enumerations
enum	GSM_RingNoteStyle { NaturalStyle = 0x00 << 6, ContinuousStyle = 0x01 << 6, StaccatoStyle = 0x02 << 6, INVALIDStyle }
enum	GSM_RingNoteNote {   Note_Pause = 0x00 << 4, Note_C = 0x01 << 4, Note_Cis = 0x02 << 4, Note_D = 0x03 << 4,   Note_Dis = 0x04 << 4, Note_E = 0x05 << 4, Note_F = 0x06 << 4, Note_Fis = 0x07 << 4,   Note_G = 0x08 << 4, Note_Gis = 0x09 << 4, Note_A = 0x0a << 4, Note_Ais = 0x0b << 4,   Note_H = 0x0c << 4, Note_INVALID }
enum	GSM_RingNoteDuration {   Duration_Full = 0x00 << 5, Duration_1_2 = 0x01 << 5, Duration_1_4 = 0x02 << 5, Duration_1_8 = 0x03 << 5,   Duration_1_16 = 0x04 << 5, Duration_1_32 = 0x05 << 5, Duration_INVALID }
enum	GSM_RingNoteDurationSpec {   NoSpecialDuration = 0x00 << 6, DottedNote = 0x01 << 6, DoubleDottedNote = 0x02 << 6, Length_2_3 = 0x03 << 6,   DurationSpec_INVALID }
enum	GSM_RingNoteScale {   Scale_55 = 1, Scale_110, Scale_220, Scale_440,   Scale_880, Scale_1760, Scale_3520, Scale_7040,   Scale_14080 }
enum	GSM_RingCommandType {   RING_Note = 1, RING_EnableVibra, RING_DisableVibra, RING_EnableLight,   RING_DisableLight, RING_EnableLED, RING_DisableLED, RING_Repeat }
enum	GSM_RingtoneFormat { RING_NOTETONE = 1, RING_NOKIABINARY, RING_MIDI, RING_MMF }

Functions
GSM_Error	PHONE_RTTLPlayOneNote (GSM_StateMachine *s, GSM_RingNote note, gboolean first)
GSM_Error	PHONE_Beep (GSM_StateMachine *s)
GSM_Error	GSM_GetRingtone (GSM_StateMachine *s, GSM_Ringtone *Ringtone, gboolean PhoneRingtone)
GSM_Error	GSM_SetRingtone (GSM_StateMachine *s, GSM_Ringtone *Ringtone, int *maxlength)
GSM_Error	GSM_GetRingtonesInfo (GSM_StateMachine *s, GSM_AllRingtonesInfo *Info)
GSM_Error	GSM_DeleteUserRingtones (GSM_StateMachine *s)
GSM_Error	GSM_PlayTone (GSM_StateMachine *s, int Herz, unsigned char Volume, gboolean start)
GSM_Error	GSM_RingtoneConvert (GSM_Ringtone *dest, GSM_Ringtone *src, GSM_RingtoneFormat Format)
GSM_Error	GSM_ReadRingtoneFile (char *FileName, GSM_Ringtone *ringtone)
GSM_Error	GSM_SaveRingtoneFile (char *FileName, GSM_Ringtone *ringtone)
GSM_Error	GSM_SaveRingtoneOtt (FILE *file, GSM_Ringtone *ringtone)
GSM_Error	GSM_SaveRingtoneMidi (FILE *file, GSM_Ringtone *ringtone)
GSM_Error	GSM_SaveRingtoneIMelody (FILE *file, GSM_Ringtone *ringtone)
GSM_Error	GSM_SaveRingtoneWav (FILE *file, GSM_Ringtone *ringtone)
GSM_Error	GSM_SaveRingtoneRttl (FILE *file, GSM_Ringtone *ringtone)
const unsigned char *	GSM_GetRingtoneName (const GSM_AllRingtonesInfo *Info, const int ID)
int	GSM_RTTLGetTempo (int Beats)

Detailed Description

Author

Michal Čihař

Ringtone data and functions.

Definition in file gammu-ringtone.h.

Enumeration Type Documentation

GSM_RingCommandType

enum GSM_RingCommandType

Enumerator
RING_Note
RING_EnableVibra
RING_DisableVibra
RING_EnableLight
RING_DisableLight
RING_EnableLED
RING_DisableLED
RING_Repeat

Definition at line 114 of file gammu-ringtone.h.

             {
        RING_Note = 1,
        RING_EnableVibra,
        RING_DisableVibra,
        RING_EnableLight,
        RING_DisableLight,
        RING_EnableLED,
        RING_DisableLED,
        RING_Repeat
} GSM_RingCommandType;

GSM_RingNoteDuration

enum GSM_RingNoteDuration

Enumerator
Duration_Full
Duration_1_2
Duration_1_4
Duration_1_8
Duration_1_16
Duration_1_32
Duration_INVALID

Definition at line 61 of file gammu-ringtone.h.

             {
        Duration_Full = 0x00 << 5,
        Duration_1_2 = 0x01 << 5,
        Duration_1_4 = 0x02 << 5,
        Duration_1_8 = 0x03 << 5,
        Duration_1_16 = 0x04 << 5,
        Duration_1_32 = 0x05 << 5,

        Duration_INVALID
} GSM_RingNoteDuration;

GSM_RingNoteDurationSpec

enum GSM_RingNoteDurationSpec

Enumerator
NoSpecialDuration
DottedNote
DoubleDottedNote
Length_2_3
DurationSpec_INVALID

Definition at line 72 of file gammu-ringtone.h.

             {
        NoSpecialDuration = 0x00 << 6,
        DottedNote = 0x01 << 6,
        DoubleDottedNote = 0x02 << 6,
        Length_2_3 = 0x03 << 6,

        DurationSpec_INVALID
} GSM_RingNoteDurationSpec;

GSM_RingNoteNote

enum GSM_RingNoteNote

Enumerator
Note_Pause
Note_C
Note_Cis
Note_D
Note_Dis
Note_E
Note_F
Note_Fis
Note_G
Note_Gis
Note_A
Note_Ais
Note_H
Note_INVALID

Definition at line 43 of file gammu-ringtone.h.

             {
        Note_Pause = 0x00 << 4,
        Note_C = 0x01 << 4,
        Note_Cis = 0x02 << 4,
        Note_D = 0x03 << 4,
        Note_Dis = 0x04 << 4,
        Note_E = 0x05 << 4,
        Note_F = 0x06 << 4,
        Note_Fis = 0x07 << 4,
        Note_G = 0x08 << 4,
        Note_Gis = 0x09 << 4,
        Note_A = 0x0a << 4,
        Note_Ais = 0x0b << 4,
        Note_H = 0x0c << 4,

        Note_INVALID
} GSM_RingNoteNote;

GSM_RingNoteScale

enum GSM_RingNoteScale

Enumerator
Scale_55	55 Hz for note A
Scale_110	110 Hz for note A
Scale_220
Scale_440	first scale for Nokia
Scale_880
Scale_1760
Scale_3520	last scale for Nokia
Scale_7040
Scale_14080

Definition at line 81 of file gammu-ringtone.h.

             {
        Scale_55 = 1,
        Scale_110,
        Scale_220,
        Scale_440,
        Scale_880,
        Scale_1760,
        Scale_3520,
        Scale_7040,
        Scale_14080
} GSM_RingNoteScale;

GSM_RingNoteStyle

enum GSM_RingNoteStyle

Enumerator
NaturalStyle	Natural style (rest between notes)
ContinuousStyle	Continuous style (no rest between notes)
StaccatoStyle	Staccato style (shorter notes and longer rest period)
INVALIDStyle

Definition at line 26 of file gammu-ringtone.h.

             {
        NaturalStyle = 0x00 << 6,
        ContinuousStyle = 0x01 << 6,
        StaccatoStyle = 0x02 << 6,

        INVALIDStyle
} GSM_RingNoteStyle;

GSM_RingtoneFormat

enum GSM_RingtoneFormat

Enumerator
RING_NOTETONE
RING_NOKIABINARY
RING_MIDI
RING_MMF

Definition at line 149 of file gammu-ringtone.h.

             {
        RING_NOTETONE = 1,
        RING_NOKIABINARY,
        RING_MIDI,
        RING_MMF
} GSM_RingtoneFormat;

Function Documentation

GSM_DeleteUserRingtones()

GSM_Error GSM_DeleteUserRingtones

(

GSM_StateMachine *

s

)

Deletes user defined ringtones from phone.

Definition at line 1092 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone_Functions::DeleteUserRingtones, GSM_Phone::Functions, _GSM_StateMachine::Phone, and PRINT_LOG_ERROR.

{
        GSM_Error err;

        CHECK_PHONE_CONNECTION();

        err = s->Phone.Functions->DeleteUserRingtones(s);
        PRINT_LOG_ERROR(err);
        return err;
}

GSM_GetRingtone()

GSM_Error GSM_GetRingtone	(	GSM_StateMachine *	s,
		GSM_Ringtone *	Ringtone,
		gboolean	PhoneRingtone
	)

Gets ringtone from phone.

Definition at line 1053 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, GSM_Phone_Functions::GetRingtone, _GSM_StateMachine::Phone, and PRINT_LOG_ERROR.

{
        GSM_Error err;

        CHECK_PHONE_CONNECTION();

        err = s->Phone.Functions->GetRingtone(s, Ringtone, PhoneRingtone);
        PRINT_LOG_ERROR(err);
        return err;
}

GSM_GetRingtoneName()

const unsigned char* GSM_GetRingtoneName	(	const GSM_AllRingtonesInfo *	Info,
		const int	ID
	)

Returns ringtone name, NULL if not found.

Definition at line 1713 of file gsmring.c.

References GSM_RingtoneInfo::ID, GSM_RingtoneInfo::Name, GSM_AllRingtonesInfo::Number, and GSM_AllRingtonesInfo::Ringtone.

{
        int             i;

        for (i = 0; i < Info->Number; i++) {
                if (Info->Ringtone[i].ID == ID) {
                        return Info->Ringtone[i].Name;
                }
        }

        return NULL;
}

GSM_GetRingtonesInfo()

GSM_Error GSM_GetRingtonesInfo	(	GSM_StateMachine *	s,
		GSM_AllRingtonesInfo *	Info
	)

Acquires ringtone informaiton.

Definition at line 1079 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, GSM_Phone_Functions::GetRingtonesInfo, _GSM_StateMachine::Phone, and PRINT_LOG_ERROR.

{
        GSM_Error err;

        CHECK_PHONE_CONNECTION();

        err = s->Phone.Functions->GetRingtonesInfo(s, Info);
        PRINT_LOG_ERROR(err);
        return err;
}

GSM_PlayTone()

GSM_Error GSM_PlayTone	(	GSM_StateMachine *	s,
		int	Herz,
		unsigned char	Volume,
		gboolean	start
	)

Plays tone.

Definition at line 1105 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, _GSM_StateMachine::Phone, GSM_Phone_Functions::PlayTone, and PRINT_LOG_ERROR.

{
        GSM_Error err;

        CHECK_PHONE_CONNECTION();

        err = s->Phone.Functions->PlayTone(s, Herz, Volume, start);
        PRINT_LOG_ERROR(err);
        return err;
}

GSM_ReadRingtoneFile()

GSM_Error GSM_ReadRingtoneFile	(	char *	FileName,
		GSM_Ringtone *	ringtone
	)

Definition at line 874 of file gsmring.c.

References GSM_NoteRingtone::AllNotesScale, dbgprintf, EncodeUnicode(), ERR_CANTOPENFILE, ERR_FILENOTSUPPORTED, ERR_MOREMEMORY, ERR_UNKNOWN, FALSE, GSM_Ringtone::Format, GSM_MAX_RINGTONE_NAME_LENGTH, loadbin(), loadcommunicator(), loadmmf(), loadott(), loadpuremidi(), loadre(), loadrttl(), GSM_Ringtone::Name, GSM_Ringtone::NoteTone, RING_MIDI, RING_MMF, RING_NOKIABINARY, and RING_NOTETONE.

{
        FILE            *file;
        unsigned char   buffer[300];
        GSM_Error       error = ERR_UNKNOWN;
        size_t readbytes;
        char    *file_only_name;
        size_t len;

        dbgprintf(NULL, "Loading ringtone %s\n",FileName);
        file = fopen(FileName, "rb");
        if (file == NULL) return ERR_CANTOPENFILE;

        file_only_name = strrchr(FileName, '/');
        if (file_only_name == NULL) {
                file_only_name = strrchr(FileName, '\\');
        } else {
                file_only_name++;
        }
        if (file_only_name == NULL) {
                file_only_name = FileName;
        } else {
                file_only_name++;
        }
        len = strlen(file_only_name);
        if (len > GSM_MAX_RINGTONE_NAME_LENGTH){
                fclose(file);
                return ERR_MOREMEMORY;
        }

        EncodeUnicode(ringtone->Name, file_only_name, len);

        /* Read the header of the file. */
        readbytes = fread(buffer, 1, 4, file);
        if (ringtone->Format == 0x00 && readbytes == 4) {
                ringtone->Format = RING_NOTETONE;
                if (buffer[0]==0x00 && buffer[1]==0x00 &&
                    buffer[2]==0x0C && buffer[3]==0x01) {
                        ringtone->Format = RING_NOKIABINARY;
                }
                if (buffer[0]==0x00 && buffer[1]==0x00 &&
                    buffer[2]==0x00) {
                        ringtone->Format = RING_NOKIABINARY;
                }
                if (buffer[0]==0x4D && buffer[1]==0x54 &&
                    buffer[2]==0x68 && buffer[3]==0x64) {
                        ringtone->Format = RING_MIDI;
                }
                if (buffer[0]==0x4D && buffer[1]==0x4D &&
                    buffer[2]==0x4D && buffer[3]==0x44) {
                        ringtone->Format = RING_MMF;
                }
                if (buffer[0]=='R' && buffer[1]=='I' &&
                    buffer[2]=='F' && buffer[3]=='F') {
                        dbgprintf(NULL, "RIFF is not supported for loading!\n");
                        fclose(file);
                        return ERR_FILENOTSUPPORTED;
                }
        }
        rewind(file);
        switch (ringtone->Format) {
        case RING_NOTETONE:
                if (buffer[0]==0x02 && buffer[1]==0x4A) {
                        error=loadott(file,ringtone);
                } else if (buffer[0]==0xC7 && buffer[1]==0x45) {
                        error=loadcommunicator(file,ringtone);
                } else {
                        error=loadrttl(file,ringtone);
                }
                ringtone->NoteTone.AllNotesScale=FALSE;
                break;
        case RING_NOKIABINARY:
                if (buffer[0]==0x00 && buffer[1]==0x00 &&
                    buffer[2]==0x0C && buffer[3]==0x01) {
                        error=loadbin(file,ringtone);
                }
                if (buffer[0]==0x00 && buffer[1]==0x00 &&
                    buffer[2]==0x00) {
                        error=loadre(file,ringtone);
                }
                break;
        case RING_MIDI:
                error = loadpuremidi(file,ringtone);
                break;
        case RING_MMF:
                error = loadmmf(file,ringtone);
                break;
        default:
                error = ERR_FILENOTSUPPORTED;
                break;
        }
        fclose(file);
        return error ;
}

GSM_RingtoneConvert()

GSM_Error GSM_RingtoneConvert	(	GSM_Ringtone *	dest,
		GSM_Ringtone *	src,
		GSM_RingtoneFormat	Format
	)

Definition at line 1543 of file gsmring.c.

References Binary2RTTL(), CopyUnicodeString(), ERR_NONE, ERR_NOTIMPLEMENTED, GSM_Ringtone::Format, GSM_Ringtone::Name, RING_NOKIABINARY, RING_NOTETONE, and RTTL2Binary().

{
        dest->Format = Format;
        CopyUnicodeString(dest->Name,src->Name);
        if (src->Format==RING_NOTETONE && Format==RING_NOKIABINARY) {
                RTTL2Binary(dest, src);
                return ERR_NONE;
        }
        if (src->Format==RING_NOKIABINARY && Format==RING_NOTETONE) {
                Binary2RTTL(dest, src);
                return ERR_NONE;
        }
        /* The same source and target format */
        if (src->Format==Format) {
                memcpy(dest,src,sizeof(GSM_Ringtone));
                return ERR_NONE;
        }
        return ERR_NOTIMPLEMENTED;
}

GSM_RTTLGetTempo()

int GSM_RTTLGetTempo

(

int

Beats

)

Definition at line 979 of file gsmring.c.

References SM_BeatsPerMinute.

Referenced by GSM_EncodeNokiaRTTLRingtone().

{
        int i=0;

        while (Beats > SM_BeatsPerMinute[i] && SM_BeatsPerMinute[i] != 900) i++;

        return i<<3;
}

GSM_SaveRingtoneFile()

GSM_Error GSM_SaveRingtoneFile	(	char *	FileName,
		GSM_Ringtone *	ringtone
	)

Definition at line 494 of file gsmring.c.

References ERR_CANTOPENFILE, ERR_UNKNOWN, GSM_Ringtone::Format, GSM_SaveRingtoneIMelody(), GSM_SaveRingtoneMidi(), GSM_SaveRingtoneOtt(), GSM_SaveRingtoneRttl(), GSM_SaveRingtoneWav(), RING_MIDI, RING_MMF, RING_NOKIABINARY, RING_NOTETONE, savebin(), savemmf(), and savepuremidi().

{
        FILE *file;
        GSM_Error error = ERR_UNKNOWN;;


        file = fopen(FileName, "wb");
        if (file == NULL) return ERR_CANTOPENFILE;

        switch (ringtone->Format) {
        case RING_NOTETONE:
                if (strstr(FileName,".ott")) {
                        error = GSM_SaveRingtoneOtt(file,ringtone);
                } else if (strstr(FileName,".rng")) {
                        error = GSM_SaveRingtoneOtt(file,ringtone);
                } else if (strstr(FileName,".mid")) {
                        error = GSM_SaveRingtoneMidi(file,ringtone);
                } else if (strstr(FileName,".imy")) {
                        error = GSM_SaveRingtoneIMelody(file,ringtone);
                } else if (strstr(FileName,".ime")) {
                        error = GSM_SaveRingtoneIMelody(file,ringtone);
                } else if (strstr(FileName,".wav")) {
                        error = GSM_SaveRingtoneWav(file,ringtone);
                } else {
                        error = GSM_SaveRingtoneRttl(file, ringtone);
                }
                break;
        case RING_NOKIABINARY:
                error = savebin(file, ringtone);
                break;
        case RING_MIDI:
                error = savepuremidi(file, ringtone);
                break;
        case RING_MMF:
                error = savemmf(file, ringtone);
                break;
        }

        fclose(file);

        return error;
}

GSM_SaveRingtoneIMelody()

GSM_Error GSM_SaveRingtoneIMelody	(	FILE *	file,
		GSM_Ringtone *	ringtone
	)

Definition at line 377 of file gsmring.c.

References chk_fwrite, ERR_NONE, ERR_WRITING_FILE, GSM_EncodeEMSSound(), GSM_Ring_IMelody12, and TRUE.

Referenced by GSM_SaveRingtoneFile().

{
        char    Buffer[2000];
        size_t  i=2000;

        GSM_EncodeEMSSound(ringtone, Buffer, &i, GSM_Ring_IMelody12, TRUE);

        chk_fwrite(Buffer, 1, i, file);
        return ERR_NONE;
fail:
        return ERR_WRITING_FILE;
}

GSM_SaveRingtoneMidi()

GSM_Error GSM_SaveRingtoneMidi	(	FILE *	file,
		GSM_Ringtone *	ringtone
	)

Definition at line 413 of file gsmring.c.

References chk_fwrite, GSM_NoteRingtone::Commands, ERR_NONE, ERR_WRITING_FILE, FALSE, GSM_RingNoteGetFullDuration(), GSM_RingNote::Note, GSM_RingCommand::Note, Note_C, Note_H, Note_Pause, GSM_Ringtone::NoteTone, GSM_NoteRingtone::NrCommands, RING_Note, GSM_RingNote::Scale, GSM_RingNote::Tempo, TRUE, GSM_RingCommand::Type, and WriteVarLen().

Referenced by GSM_SaveRingtoneFile().

{
        int             pause_time      = 0, duration, i, note=0, length = 20;
        size_t current = 26;
        gboolean                started = FALSE;
        GSM_RingNote    *Note;
        unsigned char midifile[3000] = {
                0x4D, 0x54, 0x68, 0x64, /*  MThd */
                0x00, 0x00, 0x00, 0x06, /*  chunk length */
                0x00, 0x00,             /*  format 0 */
                0x00, 0x01,             /*  one track */
                0x00, 0x20,             /*  32 per quarter note */
                0x4D, 0x54, 0x72, 0x6B, /*  MTrk */
                0x00, 0x00, 0x00, 0x00, /*  chunk length */
                0x00, 0xFF, 0x51, 0x03, /*  tempo meta event */
                0x00, 0x00, 0x00};      /*  3 bytes for us for a quarter note */

        for (i = 0; i < ringtone->NoteTone.NrCommands; i++) {
                if (ringtone->NoteTone.Commands[i].Type == RING_Note) {
                        Note = &ringtone->NoteTone.Commands[i].Note;
                        if (!started) {
                                /* readmid does not read pauses at the beginning */
                                if (Note->Note != Note_Pause) {
                                        /* FIXME: we need add tempo before each note or so... */
                                        duration = 60000000/Note->Tempo;

                                        midifile[current++] = (unsigned char)(duration >> 16);
                                        midifile[current++] = (unsigned char)(duration >> 8);
                                        midifile[current++] = (unsigned char)duration;

                                        started = TRUE;
                                }
                        }
                        if (!started) continue;
                        duration = GSM_RingNoteGetFullDuration(*Note);
                        if (Note->Note == Note_Pause) {
                                pause_time += duration;
                        } else {
                                if (Note->Note >= Note_C && Note->Note <= Note_H) {
                                        note = Note->Note/16 + 12 * Note->Scale - 1;
                                }

                                WriteVarLen(midifile,&current,pause_time);
                                pause_time=0;
                                midifile[current++]=0x90;   /*  note on */
                                midifile[current++]=note;
                                midifile[current++]=0x64;   /*  forte */

                                WriteVarLen(midifile,&current,duration);
                                midifile[current++]=0x80;   /*  note off */
                                midifile[current++]=note;
                                midifile[current++]=0x64;
                        }
                }
        }
        midifile[current++] = 0x00;
        midifile[current++] = 0xFF;             /*  track end */
        midifile[current++] = 0x2F;
        midifile[current++] = 0x00;
        midifile[length++] = (current-22) >> 8;
        midifile[length] = current-22;

        chk_fwrite(midifile,1,current,file);
        return ERR_NONE;
fail:
        return ERR_WRITING_FILE;
}

GSM_SaveRingtoneOtt()

GSM_Error GSM_SaveRingtoneOtt	(	FILE *	file,
		GSM_Ringtone *	ringtone
	)

Definition at line 481 of file gsmring.c.

References chk_fwrite, ERR_NONE, ERR_WRITING_FILE, and GSM_EncodeNokiaRTTLRingtone().

Referenced by GSM_SaveRingtoneFile().

{
        char    Buffer[2000];
        size_t  i=2000;

        GSM_EncodeNokiaRTTLRingtone(ringtone, Buffer, &i);

        chk_fwrite(Buffer, 1, i, file);
        return ERR_NONE;
fail:
        return ERR_WRITING_FILE;
}

GSM_SaveRingtoneRttl()

GSM_Error GSM_SaveRingtoneRttl	(	FILE *	file,
		GSM_Ringtone *	ringtone
	)

Definition at line 201 of file gsmring.c.

References GSM_NoteRingtone::Commands, ContinuousStyle, dbgprintf, DecodeUnicodeString(), DottedNote, DoubleDottedNote, GSM_RingNote::Duration, Duration_1_16, Duration_1_2, Duration_1_32, Duration_1_4, Duration_1_8, Duration_Full, Duration_INVALID, GSM_RingNote::DurationSpec, ERR_NONE, FALSE, INVALIDStyle, GSM_Ringtone::Name, NaturalStyle, NoSpecialDuration, GSM_RingNote::Note, GSM_RingCommand::Note, Note_A, Note_Ais, Note_C, Note_Cis, Note_D, Note_Dis, Note_E, Note_F, Note_Fis, Note_G, Note_Gis, Note_H, Note_Pause, GSM_Ringtone::NoteTone, GSM_NoteRingtone::NrCommands, RING_Note, GSM_RingNote::Scale, Scale_14080, Scale_55, StaccatoStyle, GSM_RingNote::Style, GSM_RingNote::Tempo, TRUE, and GSM_RingCommand::Type.

Referenced by GSM_SaveRingtoneFile().

{
        GSM_RingNoteScale       DefNoteScale;
        GSM_RingNoteDuration    DefNoteDuration;

        GSM_RingNoteStyle       DefNoteStyle=0;
        int                     DefNoteTempo=0;

        gboolean                        started = FALSE, firstcomma = TRUE;
        GSM_RingNote            *Note;

        unsigned char           buffer[15];
        int                     i,j,k=0;

        /* Saves ringtone name */
        fprintf(file,"%s:",DecodeUnicodeString(ringtone->Name));

        /* Find the most frequently used duration */
        for (i=0;i<6;i++) buffer[i]=0;
        for (i=0;i<ringtone->NoteTone.NrCommands;i++) {
                if (ringtone->NoteTone.Commands[i].Type == RING_Note) {
                        Note = &ringtone->NoteTone.Commands[i].Note;
                        /* some durations need 2 bytes in file, some 1 */
                        /* Typecasting to silent GCC warning, Duration is usually unsigned */
                        if ((int)Note->Duration >= Duration_Full && Note->Duration <= Duration_1_8) {
                                buffer[Note->Duration/32]++;
                        }
                        if (Note->Duration >= Duration_1_16 && Note->Duration <= Duration_1_32) {
                                buffer[Note->Duration/32]+=2;
                        }
                }
        }
        /* 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 */
        DefNoteDuration = k * 32;
        dbgprintf(NULL, "DefNoteDuration=%d\n", DefNoteDuration);
        switch (DefNoteDuration) {
                case Duration_INVALID: break;
                case Duration_Full:fprintf(file,"d=1"); break;
                case Duration_1_2 :fprintf(file,"d=2"); break;
                case Duration_1_4 :fprintf(file,"d=4"); break;
                case Duration_1_8 :fprintf(file,"d=8"); break;
                case Duration_1_16:fprintf(file,"d=16");break;
                case Duration_1_32:fprintf(file,"d=32");break;
        }

        /* Find the most frequently used scale */
        for (i=0;i<9;i++) buffer[i]=0;
        for (i=0;i<ringtone->NoteTone.NrCommands;i++) {
                if (ringtone->NoteTone.Commands[i].Type == RING_Note) {
                        Note = &ringtone->NoteTone.Commands[i].Note;
                        if (Note->Note!=Note_Pause &&
                            Note->Scale >= Scale_55 && Note->Scale <= Scale_14080) {
                                buffer[Note->Scale - 1]++;
                        }
                }
        }
        j=0;
        for (i=0;i<9;i++) {
                if (buffer[i]>j) {
                        k = i;
                        j=buffer[i];
                }
        }
        DefNoteScale = k + 1;
        /* Save the default scale */
        fprintf(file,",o=%i,",DefNoteScale);
        dbgprintf(NULL, "DefNoteScale=%d\n", DefNoteScale);

        for (i=0;i<ringtone->NoteTone.NrCommands;i++) {
                if (ringtone->NoteTone.Commands[i].Type != RING_Note) continue;

                Note = &ringtone->NoteTone.Commands[i].Note;

                /* Trick from PPM Edit */
                if (Note->DurationSpec == DoubleDottedNote) {
                        switch (Note->Duration) {
                                case Duration_INVALID: break;
                                case Duration_Full:Note->Duration = Duration_Full;break;
                                case Duration_1_2 :Note->Duration = Duration_Full;break;
                                case Duration_1_4 :Note->Duration = Duration_1_2; break;
                                case Duration_1_8 :Note->Duration = Duration_1_4; break;
                                case Duration_1_16:Note->Duration = Duration_1_8; break;
                                case Duration_1_32:Note->Duration = Duration_1_16;break;
                        }
                        Note->DurationSpec = NoSpecialDuration;
                }

                if (!started) {
                        DefNoteTempo=Note->Tempo;
                        DefNoteStyle=Note->Style;
                        switch (Note->Style) {
                                case StaccatoStyle      : fprintf(file,"s=S,"); break;
                                case NaturalStyle       : fprintf(file,"s=N,"); break;
                                case ContinuousStyle    :                       break;
                                case INVALIDStyle: break;
                        }
                        /* Save the default tempo */
                        fprintf(file,"b=%i:",DefNoteTempo);
                        dbgprintf(NULL, "DefNoteTempo=%d\n", DefNoteTempo);
                        started         = TRUE;
                        firstcomma      = TRUE;
                }

                if (Note->Style!=DefNoteStyle) {
                        /* And a separator */
                        if (!firstcomma) fprintf(file,",");
                        firstcomma = FALSE;
                        DefNoteStyle=Note->Style;
                        switch (Note->Style) {
                                case StaccatoStyle  : fprintf(file,"s=S"); break;
                                case NaturalStyle   : fprintf(file,"s=N"); break;
                                case ContinuousStyle: fprintf(file,"s=C"); break;
                                case INVALIDStyle: break;
                        }
                }
                if (Note->Tempo!=DefNoteTempo) {
                        /* And a separator */
                        if (!firstcomma) fprintf(file,",");
                        firstcomma = FALSE;
                        DefNoteTempo=Note->Tempo;
                        fprintf(file,"b=%i",DefNoteTempo);
                }
                /* This note has a duration different than the default. We must save it */
                if (Note->Duration!=DefNoteDuration) {
                        /* And a separator */
                        if (!firstcomma) fprintf(file,",");
                        firstcomma = FALSE;
                        switch (Note->Duration) {
                                case Duration_INVALID: break;
                                case Duration_Full:fprintf(file,"1"); break;
                                case Duration_1_2 :fprintf(file,"2"); break;
                                case Duration_1_4 :fprintf(file,"4"); break;
                                case Duration_1_8 :fprintf(file,"8"); break;
                                case Duration_1_16:fprintf(file,"16");break;
                                case Duration_1_32:fprintf(file,"32");break;
                        }
                } else {
                        /* And a separator */
                        if (!firstcomma) fprintf(file,",");
                        firstcomma = FALSE;
                }
                /* Now save the actual note */
                switch (Note->Note) {
                        case Note_C  :fprintf(file,"c");        break;
                        case Note_Cis:fprintf(file,"c#");       break;
                        case Note_D  :fprintf(file,"d");        break;
                        case Note_Dis:fprintf(file,"d#");       break;
                        case Note_E  :fprintf(file,"e");        break;
                        case Note_F  :fprintf(file,"f");        break;
                        case Note_Fis:fprintf(file,"f#");       break;
                        case Note_G  :fprintf(file,"g");        break;
                        case Note_Gis:fprintf(file,"g#");       break;
                        case Note_A  :fprintf(file,"a");        break;
                        case Note_Ais:fprintf(file,"a#");       break;
                        case Note_H  :fprintf(file,"h");        break;
                        default      :fprintf(file,"p");        break; /*Pause ?*/
                }
                switch (Note->DurationSpec) {
                        case DottedNote : fprintf(file,".");    break;
                        default         :                       break;
                }
                if (Note->Note!=Note_Pause && Note->Scale != DefNoteScale) {
                        fprintf(file,"%i",Note->Scale);
                }
        }
        return ERR_NONE;
}

GSM_SaveRingtoneWav()

GSM_Error GSM_SaveRingtoneWav	(	FILE *	file,
		GSM_Ringtone *	ringtone
	)

Definition at line 105 of file gsmring.c.

References chk_fwrite, GSM_NoteRingtone::Commands, ERR_NONE, ERR_WRITING_FILE, GSM_RingNoteGetFrequency(), GSM_RingNoteGetFullDuration(), GSM_RingCommand::Note, GSM_Ringtone::NoteTone, GSM_NoteRingtone::NrCommands, PI, RING_Note, GSM_RingCommand::Type, and WAV_SAMPLE_RATE.

Referenced by GSM_SaveRingtoneFile().

{

        unsigned char   WAV_Header[] = {
                        'R','I','F','F',
                        0x00,0x00,0x00,0x00,    /* Length */
                        'W','A','V','E'};
        unsigned char   FMT_Header[] = {'f','m','t',' ',
                        0x10,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x44,0xac,
                        0x00,0x00,0x88,0x58,0x01,0x00,0x02,0x00,0x10,0x00};
        unsigned char   DATA_Header[] = {
                        'd','a','t','a',
                        0x00,0x00,0x00,0x00};   /* Length */
        short           DATA;
        long            wavfilesize;
        GSM_RingNote    *Note;
        int             i;
        size_t          j,length=0, duration;
        double          phase=0,phase_step;

        chk_fwrite(&WAV_Header, 1, sizeof(WAV_Header),  file);
        chk_fwrite(&FMT_Header, 1, sizeof(FMT_Header),  file);
        chk_fwrite(&DATA_Header,        1, sizeof(DATA_Header), file);

        for (i=0;i<ringtone->NoteTone.NrCommands;i++) {
                if (ringtone->NoteTone.Commands[i].Type == RING_Note) {
                        Note            = &ringtone->NoteTone.Commands[i].Note;

                        phase_step      = GSM_RingNoteGetFrequency(*Note);
                        phase_step      *= WAV_SAMPLE_RATE * 1.5;

                        duration        = GSM_RingNoteGetFullDuration(*Note);
                        duration        *= WAV_SAMPLE_RATE / 70;

                        for (j = 0; j < duration; j++) {
                                DATA = ((int)(sin(phase*PI) * 50000));
                                chk_fwrite(&DATA, sizeof(short), 1, file);
                                phase = phase + phase_step;
                                length++;
                        }
                }
        }

        wavfilesize     = sizeof(WAV_Header) + sizeof(FMT_Header) + sizeof(DATA_Header) + length*2;
        WAV_Header[4]   = ((unsigned char)wavfilesize % 256);
        WAV_Header[5]   = ((unsigned char)wavfilesize / 256);
        WAV_Header[6]   = ((unsigned char)wavfilesize / (256*256));
        WAV_Header[7]   = ((unsigned char)wavfilesize / (256*256*256));
        wavfilesize     = wavfilesize - 54;
        DATA_Header[4]  = ((unsigned char)wavfilesize % 256);
        DATA_Header[5]  = ((unsigned char)wavfilesize / 256);
        DATA_Header[6]  = ((unsigned char)wavfilesize / (256*256));
        DATA_Header[7]  = ((unsigned char)wavfilesize / (256*256*256));

        fseek( file, 0, SEEK_SET);
        chk_fwrite(&WAV_Header, 1, sizeof(WAV_Header),  file);
        chk_fwrite(&FMT_Header, 1, sizeof(FMT_Header),  file);
        chk_fwrite(&DATA_Header,        1, sizeof(DATA_Header), file);

        return ERR_NONE;
fail:
        return ERR_WRITING_FILE;
}

GSM_SetRingtone()

GSM_Error GSM_SetRingtone	(	GSM_StateMachine *	s,
		GSM_Ringtone *	Ringtone,
		int *	maxlength
	)

Sets ringtone in phone.

Definition at line 1066 of file api.c.

References CHECK_PHONE_CONNECTION, GSM_Phone::Functions, _GSM_StateMachine::Phone, PRINT_LOG_ERROR, and GSM_Phone_Functions::SetRingtone.

{
        GSM_Error err;

        CHECK_PHONE_CONNECTION();

        err = s->Phone.Functions->SetRingtone(s, Ringtone, maxlength);
        PRINT_LOG_ERROR(err);
        return err;
}

PHONE_Beep()

GSM_Error PHONE_Beep

(

GSM_StateMachine *

s

)

Makes phone beek using state machine interface.

Definition at line 129 of file pfunc.c.

References ERR_NONE, FALSE, GSM_Phone::Functions, _GSM_StateMachine::Phone, GSM_Phone_Functions::PlayTone, and TRUE.

{
        GSM_Error error;

        error=s->Phone.Functions->PlayTone(s, 4000, 5,TRUE);
        if (error!=ERR_NONE) return error;

        usleep(500000);

        return s->Phone.Functions->PlayTone(s,255*255,0,FALSE);
}

PHONE_RTTLPlayOneNote()

GSM_Error PHONE_RTTLPlayOneNote	(	GSM_StateMachine *	s,
		GSM_RingNote	note,
		gboolean	first
	)

Play one note using state machine interface.

Definition at line 94 of file pfunc.c.

References ContinuousStyle, ERR_NONE, FALSE, GSM_Phone::Functions, GSM_RingNoteGetFrequency(), GSM_RingNoteGetFullDuration(), INVALIDStyle, NaturalStyle, _GSM_StateMachine::Phone, GSM_Phone_Functions::PlayTone, StaccatoStyle, GSM_RingNote::Style, and GSM_RingNote::Tempo.

{
        int             duration, Hz;
        GSM_Error       error;

        Hz=GSM_RingNoteGetFrequency(note);

        error=s->Phone.Functions->PlayTone(s,Hz,5,first);
        if (error!=ERR_NONE) return error;

        duration = GSM_RingNoteGetFullDuration(note);

        /* Is it correct ? Experimental values here */
        switch (note.Style) {
                case INVALIDStyle:
                        break;
                case StaccatoStyle:
                        usleep(7500000);
                        error=s->Phone.Functions->PlayTone(s,0,0,FALSE);
                        if (error != ERR_NONE) return error;
                        usleep ((1400000000L/note.Tempo*duration)-(7500000));
                        break;
                case ContinuousStyle:
                        usleep(1400000000L/note.Tempo*duration);
                        break;
                case NaturalStyle:
                        usleep(1400000000L/note.Tempo*duration-50000);
                        error=s->Phone.Functions->PlayTone(s,0,0,FALSE);
                        if (error != ERR_NONE) return error;
                        usleep(50000);
                        break;
        }
        return ERR_NONE;
}