void Export_SRT(FILE *outf) { struct Lyric_Line *curline=NULL; //Conductor of the lyric line linked list struct Lyric_Piece *temp=NULL; //A conductor for the lyric pieces list unsigned long ctr=1; //The lyric counter assert_wrapper(outf != NULL); //This must not be NULL assert_wrapper(Lyrics.piececount != 0); //This function is not to be called with an empty Lyrics structure if(Lyrics.verbose) printf("\nExporting SRT subtitles to file \"%s\"\n\nWriting subtitles\n",Lyrics.outfilename); //Export the lyric pieces curline=Lyrics.lines; //Point lyric line conductor to first line of lyrics while(curline != NULL) //For each line of lyrics { temp=curline->pieces; //Starting with the first piece of lyric in this line if(Lyrics.verbose) printf("\tSubtitle line %lu: ",ctr); while(temp != NULL) //For each piece of lyric in this line { if(ctr != 1) { //All subtitles after the first are prefixed with two newline characters if(fprintf(outf,"\n\n") < 0) { printf("Error writing double space between subtitles: %s\nAborting\n",strerror(errno)); exit_wrapper(1); } } if((fprintf(outf,"%lu\n",ctr) < 0) || Write_SRT_Timestamp(outf,temp->start) || (fprintf(outf," --> ") < 0) || Write_SRT_Timestamp(outf,temp->start+temp->duration) || (fprintf(outf,"\n%s",temp->lyric) < 0)) { //Write the subtitle number, the start timestamp, the "-->" separator, the end timestamp and the subtitle text printf("Error exporting lyric %lu: %s\nAborting\n",ctr,strerror(errno)); exit_wrapper(2); } if(Lyrics.verbose) printf("'%s'",temp->lyric); temp=temp->next; //Advance to next lyric piece as normal ctr++; }//end while(temp != NULL) curline=curline->next; //Advance to next line of lyrics if(Lyrics.verbose) (void) putchar('\n'); } if(Lyrics.verbose) printf("\nSRT export complete. %lu subtitles written",Lyrics.piececount); }
void Export_ID3(FILE *inf, FILE *outf) { struct ID3Tag tag={NULL,0,0,0,0,0,0.0,NULL,0,NULL,NULL,NULL,NULL}; //Validate parameters assert_wrapper((inf != NULL) && (outf != NULL)); assert_wrapper(Lyrics.piececount != 0); //This function is not to be called with an empty Lyrics structure tag.fp=inf; //Store the input file pointer into the ID3 tag structure //Seek to first MPEG frame in input file (after ID3 tag, otherwise presume it's at the beginning of the file) if(Lyrics.verbose) (void) puts("Parsing input MPEG audio file"); if(FindID3Tag(&tag)) //Find start and end of ID3 tag fseek_err(tag.fp,tag.tagend,SEEK_SET); //Seek to the first MP3 frame (immediately after the ID3 tag) else rewind_err(tag.fp); //Rewind file if no ID3 tag is found //Load MPEG information if(GetMP3FrameDuration(&tag) == 0) //Find the sample rate defined in the MP3 frame at the current file position { printf("Error loading MPEG information from file \"%s\"\nAborting",Lyrics.srcfilename); exit_wrapper(1); } //Load any existing ID3 frames (void) ID3FrameProcessor(&tag); //Build output file (void) BuildID3Tag(&tag,outf); //Release memory DestroyID3(&tag); //Release the ID3 structure's memory DestroyOmitID3framelist(Lyrics.nosrctag); //Release ID3 frame omission list }
void WriteTextInfoFrame(FILE *outf,const char *frameid,const char *string) { size_t size=0; //Validate input parameters assert_wrapper((outf != NULL) && (frameid != NULL) && (string != NULL)); if(strlen(frameid) != 4) { printf("Error: Attempted export of invalid frame ID \"%s\"\nAborting",frameid); exit_wrapper(1); } if(Lyrics.verbose >= 2) printf("\tWriting frame \"%s\"\n",frameid); size=strlen(string)+1; //The frame payload size is the string and the encoding byte //Write ID3 frame header fwrite_err(frameid,4,1,outf); //Write frame ID WriteDWORDBE(outf,(unsigned long)size); //Write frame size (total frame size-header size) in Big Endian format fputc_err(0xC0,outf); //Write first flag byte (preserve frame for both tag and file alteration) fputc_err(0,outf); //Write second flag byte (no compression, encryption or grouping identity) //Write frame data fputc_err(0,outf); //Write ASCII encoding fwrite_err(string,(size_t)size-1,1,outf); //Write the string }
int EOF_EXPORT_TO_LC(EOF_VOCAL_TRACK * tp, char *outputfilename, char *string2, int format) { unsigned long linectr = 0, lyrctr = 0, lastlyrtime = 0, linestart = 0, lineend = 0; unsigned char pitch = 0; FILE *outf = NULL; //Used to open output file FILE *pitchedlyrics = NULL; //Used to open output pitched lyric fle char *vrhythmid = NULL; EOF_PHRASE_SECTION temp; //Used to store the first lyric line in the project, which gets overridden with one covering all lyrics during RS1 export unsigned long original_lines; char *tempoutputfilename = "lyrics.temp"; eof_log("EOF_EXPORT_TO_LC() entered", 1); if((tp == NULL) || (outputfilename == NULL) || (tp->lyrics == 0)) return -1; //Return failure //Initialize variables InitLyrics(); //Initialize all variables in the Lyrics structure InitMIDI(); //Initialize all variables in the MIDI structure qsort(tp->line, (size_t)tp->lines, sizeof(EOF_PHRASE_SECTION), eof_song_qsort_phrase_sections); //Sort the lyric lines temp = tp->line[0]; //Preserve the original lyric line information original_lines = tp->lines; //Set export-specific settings if(format == SCRIPT_FORMAT) { Lyrics.grouping = 2; //Enable line grouping for script.txt export Lyrics.nohyphens = 3; //Disable hyphen output Lyrics.noplus = 1; //Disable plus output Lyrics.filter = DuplicateString("^=%#/"); //Use default filter list Lyrics.defaultfilter = 1; //Track that the above string will need to be freed } else if((format == RS_FORMAT) || (format == RS2_FORMAT)) { Lyrics.noplus = 1; //Disable plus output Lyrics.filter = DuplicateString("^=%#/"); //Use default filter list Lyrics.defaultfilter = 1; //Track that the above string will need to be freed if((format == RS_FORMAT) || (!tp->lines)) { //If exporting to Rocksmith 1 format or if the lyrics don't have any lines defined tp->lines = 0; //Temporarily disregard any existing lyric lines (void) eof_vocal_track_add_line(tp, 0, tp->lyric[tp->lyrics - 1]->pos + 1, 0xFF); //Create a single line encompassing all lyrics } } else if(format == PLAIN_FORMAT) { //This format option is meant to invoke script export with the plain flag set and filtering enabled Lyrics.nohyphens = 3; //Disable hyphen output Lyrics.noplus = 1; //Disable plus output Lyrics.filter = DuplicateString("^=%#/"); //Use default filter list Lyrics.defaultfilter = 1; //Track that the above string will need to be freed format = SCRIPT_FORMAT; Lyrics.plain = 1; Lyrics.grouping = 2; //Enable line grouping for script.txt export } //Import lyrics from EOF structure lyrctr = 0; //Begin indexing into lyrics from the very first lastlyrtime = 0; //First lyric is expected to be greater than or equal to this timestamp for(linectr = 0; linectr < (unsigned long)tp->lines; linectr++) { //For each line of lyrics in the EOF structure linestart = (tp->line[linectr]).start_pos; lineend = (tp->line[linectr]).end_pos; if(linestart > lineend) //If the line starts after it ends { ReleaseMemory(1); return -1; //Return failure } if(lyrctr < tp->lyrics) //If there are lyrics remaining CreateLyricLine(); //Initialize new line of lyrics if((tp->line[linectr]).flags & EOF_LYRIC_LINE_FLAG_OVERDRIVE) //If this line is overdrive Lyrics.overdrive_on = 1; else Lyrics.overdrive_on = 0; while(lyrctr < tp->lyrics) { //For each lyric if((tp->lyric[lyrctr])->text[0] != '\0') { //If this lyric's text isn't an empty string if((tp->lyric[lyrctr])->pos < lastlyrtime) //If this lyric precedes the previous lyric { (void) snprintf(eof_log_string, sizeof(eof_log_string) - 1, "\tLogic error while preparing lyrics for export to file \"%s\"", tempoutputfilename); eof_log(eof_log_string, 1); ReleaseMemory(1); return -1; //Return failure } if((tp->lyric[lyrctr])->pos < linestart) //If this lyric precedes the beginning of the line { (void) snprintf(eof_log_string, sizeof(eof_log_string) - 1, "\tWarning: Lyric \"%s\" at %lums is outside of defined lyric lines", tp->lyric[lyrctr]->text, tp->lyric[lyrctr]->pos); eof_log(eof_log_string, 1); CreateLyricLine(); //Initialize new line of lyrics } if((tp->lyric[lyrctr])->pos > lineend) //If this lyric is placed beyond the end of this line { break; //Break from this while loop to have another line created } pitch = (tp->lyric[lyrctr])->note; //Store the lyric's pitch if((tp->lyric[lyrctr])->note == 0) //Remap EOF's pitchless value to FLC's pitchless value pitch = PITCHLESS; if(!Lyrics.line_on) //If a lyric line is not in progress CreateLyricLine(); //Force one to be before adding the next lyric AddLyricPiece((tp->lyric[lyrctr])->text, (tp->lyric[lyrctr])->pos, (tp->lyric[lyrctr])->pos+(tp->lyric[lyrctr])->length, pitch, 0); //Add the lyric to the Lyrics structure if((Lyrics.lastpiece != NULL) && (Lyrics.lastpiece->lyric[strlen(Lyrics.lastpiece->lyric)-1] == '-')) //If the piece that was just added ended in a hyphen Lyrics.lastpiece->groupswithnext = 1; //Set its grouping status }//If this lyric's text isn't an empty string lyrctr++; //Advance to next lyric } ForceEndLyricLine(); //End the current line of lyrics } if(Lyrics.piececount == 0) //No lyrics imported { ReleaseMemory(1); return 0; //Return no lyrics found } //Load chart tags if(eof_song->tags->artist[0] != '\0') Lyrics.Artist = DuplicateString(eof_song->tags->artist); if(eof_song->tags->title[0] != '\0') Lyrics.Title = DuplicateString(eof_song->tags->title); if(eof_song->tags->frettist[0] != '\0') Lyrics.Editor = DuplicateString(eof_song->tags->frettist); if(eof_song->tags->album[0] != '\0') Lyrics.Album = DuplicateString(eof_song->tags->album); PostProcessLyrics(); //Perform hyphen and grouping validation/handling Lyrics.outfilename = tempoutputfilename; Lyrics.out_format = format; //If the export format is MIDI-based, write a MIDI file header and a MIDI track (track 0) specifying a tempo of 120BPM if((Lyrics.out_format == MIDI_FORMAT) || (Lyrics.out_format == VRHYTHM_FORMAT) || (Lyrics.out_format == SKAR_FORMAT) || (Lyrics.out_format == KAR_FORMAT)) { outf = fopen_err(Lyrics.outfilename,"wb"); //These are binary formats Write_Default_Track_Zero(outf); } //Export lyrics switch(Lyrics.out_format) { case SCRIPT_FORMAT: //Export as script.txt format file outf = fopen_err(Lyrics.outfilename,"wt"); //Script.txt is a text format Export_Script(outf); break; case VL_FORMAT: //Export as VL format file outf = fopen_err(Lyrics.outfilename,"wb"); //VL is a binary format Export_VL(outf); break; case MIDI_FORMAT: //Export as MIDI format file. Default export track is "PART VOCALS" if(string2 == NULL) //If a destination track name wasn't given Lyrics.outputtrack = DuplicateString("PART VOCALS"); //Write track name as PART VOCALS by default else Lyrics.outputtrack = DuplicateString(string2); Export_MIDI(outf); break; case USTAR_FORMAT: //Export as UltraStar format file outf = fopen_err(Lyrics.outfilename,"wt"); //UltraStar is a text format Export_UStar(outf); break; case LRC_FORMAT: //Export as simple LRC case ELRC_FORMAT: //Export as extended LRC outf = fopen_err(Lyrics.outfilename,"wt"); //LRC is a text format Export_LRC(outf); break; case VRHYTHM_FORMAT: //Export as Vocal Rhythm (MIDI and text file) if(string2 == NULL) //If a pitched lyric file wasn't given { fclose_err(outf); return -1; //Return failure } pitchedlyrics = fopen_err(string2,"wt"); //Pitched lyrics is a text format vrhythmid = DuplicateString("G4"); Export_Vrhythm(outf, pitchedlyrics, vrhythmid); fflush_err(pitchedlyrics); //Commit any pending pitched lyric writes to file fclose_err(pitchedlyrics); //Close pitched lyric file free(vrhythmid); break; case SKAR_FORMAT: //Export as Soft Karaoke. Default export track is "Words" if(string2 == NULL) //If a destination track name wasn't given Lyrics.outputtrack = DuplicateString("Words"); //Write track name as "Words" by default else Lyrics.outputtrack = DuplicateString(string2); Export_SKAR(outf); break; case KAR_FORMAT: //Export as unofficial KAR. Default export track is "Melody" if(Lyrics.outputtrack == NULL) { (void) puts("\aNo ouput track name for KAR file was given. A track named \"Melody\" will be used by default"); Lyrics.outputtrack = DuplicateString("Melody"); } Export_MIDI(outf); break; case RS_FORMAT: //Export as Rocksmith XML outf = fopen_err(Lyrics.outfilename,"wt"); //XML is a text format Lyrics.rocksmithver = 1; Export_RS(outf); break; case RS2_FORMAT: //Export as Rocksmith 2 XML outf = fopen_err(Lyrics.outfilename,"wt"); //XML is a text format Lyrics.rocksmithver = 2; Export_RS(outf); break; default: (void) puts("Unexpected error in export switch\nAborting"); exit_wrapper(4); break; } if((Lyrics.out_format == MIDI_FORMAT) || (Lyrics.out_format == VRHYTHM_FORMAT) || (Lyrics.out_format == SKAR_FORMAT) || (Lyrics.out_format == KAR_FORMAT)) { //Update the MIDI header to reflect the number of MIDI tracks written to file for all applicable export formats fseek_err(outf, 10, SEEK_SET); //The number of tracks is 10 bytes in from the start of the file header fputc_err(MIDIstruct.trackswritten>>8, outf); fputc_err(MIDIstruct.trackswritten&0xFF, outf); }
void JB_Load(FILE *inf) { size_t maxlinelength; //I will count the length of the longest line (including NULL char/newline) in the //input file so I can create a buffer large enough to read any line into char *buffer; //Will be an array large enough to hold the largest line of text from input file unsigned long index=0; //Used to index within a line of input text unsigned long index2=0; //Used to index within an output buffer char textbuffer[101]={0}; //Allow for a 100 character lyric text unsigned long processedctr=0; //The current line number being processed in the text file unsigned long bufferctr=0; //Ensure textbuffer[] isn't overflowed char notename=0; //Used for parsing note names double timestamp=0.0; //Used to read timestamp char linetype=0; //Is set to one of the following: 1 = lyric, 2 = line break, 3 = end of file unsigned char pitch=0; //Stores the lyric pitch transposed to middle octave int readerrordetected = 0; assert_wrapper(inf != NULL); //This must not be NULL //Find the length of the longest line maxlinelength=FindLongestLineLength(inf,1); //Allocate memory buffer large enough to hold any line in this file buffer=(char *)malloc_err(maxlinelength); (void) fgets_err(buffer,(int)maxlinelength,inf); //Read first line of text, capping it to prevent buffer overflow if(Lyrics.verbose) printf("\nImporting C9C lyrics from file \"%s\"\n\n",Lyrics.infilename); processedctr=0; //This will be set to 1 at the beginning of the main while loop while(!feof(inf) && !readerrordetected) //Until end of file is reached or fgets() returns an I/O error { processedctr++; if(Lyrics.verbose) printf("\tProcessing line %lu\n",processedctr); index = 0; //Read end of file if(strcasestr_spec(buffer,"ENDFILE")) { //A line starting with "ENDFILE" denotes the end of the lyric entries linetype = 3; } //Read the lyric pitch else if(isalpha(buffer[index])) { //A line starting with an alphabetical letter is a normal lyric entry linetype = 1; notename = toupper(buffer[index++]); if(isalpha(buffer[index])) index++; //The first lyric entry seems to repeat the note name pitch=60; //The pitches will be interpreted as ranging from C4 to B4 switch(notename) //Add value of note in current octave { case 'B': pitch+=11; break; case 'A': pitch+=9; break; case 'G': pitch+=7; break; case 'F': pitch+=5; break; case 'E': pitch+=4; break; case 'D': pitch+=2; break; default: break; } if(buffer[index] == '#') { //If the note name is followed by a sharp character, pitch++; //increase the pitch by one half step index++; //Seek past the sharp character } while(buffer[index] != ':') { //Seek to the expected colon character if(buffer[index] == '\0') { //The line ends unexpectedly printf("Error: Invalid lyric entry in line %lu during C9C lyric import (colon missing)\nAborting\n",processedctr); exit_wrapper(1); } index++; } index++; //Seek beyond the colon //Read the lyric text index2=bufferctr=0; while(!isspace(buffer[index])) { //Until whitespace is reached if(buffer[index] == '\0') { //The line ends unexpectedly printf("Error: Invalid lyric entry in line %lu during C9C lyric import (whitespace missing)\nAborting\n",processedctr); exit_wrapper(2); } textbuffer[index2++] = buffer[index++]; //Copy the character to a buffer bufferctr++; if(bufferctr == 100) { //Unexpectedly long lyric reached printf("Error: Invalid lyric entry in line %lu during C9C lyric import (lyric is too long)\nAborting\n",processedctr); exit_wrapper(3); } } textbuffer[index2++] = '\0'; //Terminate the string }//A line starting with an alphabetical letter is a normal lyric entry //Read line break else if(buffer[index] == '-') { //A line starting with "--:S" is the start of a period of silence between lyrics (will be treated as a line break) linetype = 2; } else { //Invalid input printf("Error: Invalid input \"%s\" in line %lu during C9C import\nAborting\n",&(buffer[index]),processedctr); exit_wrapper(4); } //Seek to timestamp while(!isdigit(buffer[index])) { //Until a number (the timestamp) is reached if(buffer[index] == '\0') { //The line ends unexpectedly printf("Error: Invalid line break entry in line %lu during C9C lyric import (timestamp missing)\nAborting\n",processedctr); exit_wrapper(5); } index++; } //Read timestamp if(sscanf(&(buffer[index]), "%20lf", ×tamp) != 1) { //Double floating point value didn't parse printf("Error: Invalid lyric entry in line %lu during C9C lyric import (error parsing timestamp)\nAborting\n",processedctr); exit_wrapper(6); } timestamp *= 1000.0; //Convert to milliseconds //Adjust previous lyric's end position if(Lyrics.lastpiece) { //If there was a previous lyric unsigned long length; assert_wrapper(Lyrics.lastpiece->lyric != NULL); length = (unsigned long)strlen(Lyrics.lastpiece->lyric); Lyrics.lastpiece->duration = timestamp + 0.5 - Lyrics.realoffset - Lyrics.lastpiece->start; //Remember to offset start by realoffset, otherwise Lyrics.lastpiece->start could be the larger operand, causing an overflow if(Lyrics.lastpiece->lyric[length - 1] == '-') { //If the previous lyric ended in a hyphen, the previous lyric lasts all the way up to the start of this one Lyrics.lastpiece->groupswithnext=1; //The previous lyric piece will group with this one } else { //Otherwise space out the lyrics a bit, 1/32 second was suggested if(Lyrics.lastpiece->duration > 31) Lyrics.lastpiece->duration -= 31; //31ms ~= 1 sec/32 } } //Add lyric if(linetype == 1) //If this line defined a new lyric { //Track for pitch changes, enabling Lyrics.pitch_tracking if applicable if((Lyrics.last_pitch != 0) && (Lyrics.last_pitch != pitch)) //There's a pitch change Lyrics.pitch_tracking=1; Lyrics.last_pitch=pitch; //Consider this the last defined pitch if(Lyrics.line_on != 1) //If we're at this point, there should be a line of lyrics in progress CreateLyricLine(); AddLyricPiece(textbuffer,timestamp + 0.5,timestamp + 0.5,pitch,0); //Add lyric with no defined duration } //Add line break else if(linetype == 2) { //If this line defined a line break EndLyricLine(); Lyrics.lastpiece = NULL; //Prevent the first lyric from the new line from altering the previous lyric's duration, which was set by the line break position } //End processing else break; if(fgets(buffer, (int)maxlinelength,inf) == NULL) //Read next line of text, so the EOF condition can be checked, don't exit on EOF readerrordetected = 1; }//while(!feof(inf) && !readerrordetected) free(buffer); //No longer needed, release the memory before exiting function ForceEndLyricLine(); RecountLineVars(Lyrics.lines); //Rebuild line durations since this lyric format required adjusting timestamps after lines were parsed if(Lyrics.verbose) printf("C9C import complete. %lu lyrics loaded\n\n",Lyrics.piececount); }
unsigned long ConvertSRTTimestamp(char **ptr,int *errorstatus) { char *temp=NULL; unsigned int ctr=1; char failed=0; //Boolean: Parsing indicated that ptr didn't point at a valid timestamp, abort char hours[SRTTIMESTAMPMAXFIELDLENGTH+1]={0}; //Allow for pre-defined # of hours chars (and NULL terminator) char minutes[SRTTIMESTAMPMAXFIELDLENGTH+1]={0}; //Allow for pre-defined # of minute chars (and NULL terminator) char seconds[SRTTIMESTAMPMAXFIELDLENGTH+1]={0}; //Allow for pre-defined # of seconds chars (and NULL terminator) char millis[SRTTIMESTAMPMAXFIELDLENGTH+1]={0}; //Allow for pre-defined # of milliseconds chars (and NULL terminator) unsigned int index=0; //index variable into the 3 timestamp strings unsigned long sum=0; long conversion=0; //Will store the integer conversions of each of the 3 timestamp strings if(ptr == NULL) failed=1; else { temp=*ptr; //To improve readability for string parsing if(temp == NULL) failed=1; } //Validate that the string has brackets if((temp != NULL) && !isdigit(temp[0])) //If this character is not a beginning character for a timestamp failed=1; //Parse hours portion of timestamp index=0; while(!failed) { assert_wrapper(temp != NULL); if((temp[ctr] == '\0') || (!isdigit(temp[ctr]) && (temp[ctr] != ':'))) //Numerical char(s) followed by delimiter are expected failed=1; else { if(isdigit(temp[ctr])) //Is a numerical character { if(index > SRTTIMESTAMPMAXFIELDLENGTH) //If more than the defined limit of chars have been parsed failed=2; //This is more than we allow for else hours[index++]=temp[ctr++]; //copy character into hours string, increment indexes } else { //this character is a delimiter ctr++; //seek past the colon break; //break from loop } } } assert_wrapper(index < SRTTIMESTAMPMAXFIELDLENGTH+1); //Ensure that writing the NULL character won't overflow hours[index]='\0'; //Terminate hours string //validate minutes portion of timestamp index=0; while(!failed) { assert_wrapper(temp != NULL); if((temp[ctr] == '\0') || (!isdigit(temp[ctr]) && (temp[ctr] != ':'))) //Numerical char(s) followed by delimiter are expected failed=1; else { if(isdigit(temp[ctr])) //Is a numerical character { if(index > SRTTIMESTAMPMAXFIELDLENGTH) //If more than the defined limit of chars have been parsed failed=2; //This is more than we allow for else minutes[index++]=temp[ctr++]; //copy character into minutes string, increment indexes } else { //this character is a delimiter ctr++; //seek past the colon break; //break from loop } } } assert_wrapper(index < SRTTIMESTAMPMAXFIELDLENGTH+1); //Ensure that writing the NULL character won't overflow minutes[index]='\0'; //Terminate minutes string //validate seconds portion of timestamp index=0; while(!failed) { assert_wrapper(temp != NULL); if((temp[ctr] == '\0') || (!isdigit(temp[ctr]) && (temp[ctr] != ','))) //Numerical char(s) followed by delimiter are expected failed=1; else { if(isdigit(temp[ctr])) //Is a numerical character { if(index > SRTTIMESTAMPMAXFIELDLENGTH) //If more than the defined limit of chars have been parsed failed=2; //This is more than we allow for else seconds[index++]=temp[ctr++]; //copy character into seconds string, increment indexes } else { //this character is a delimiter ctr++; //seek past the colon break; //break from loop } } } assert_wrapper(index < SRTTIMESTAMPMAXFIELDLENGTH+1); //Ensure that writing the NULL character won't overflow seconds[index]='\0'; //Terminate seconds string //validate milliseconds portion of timestamp index=0; while(!failed) { assert_wrapper(temp != NULL); if((temp[ctr] == '\0') || !isdigit(temp[ctr])) //If not a numerical character { if(isspace(temp[ctr]) || (temp[ctr] == '\0'))//If this character is a whitespace/newline/carriage return/NULL character break; //break from loop else failed=1; } else { if(index > SRTTIMESTAMPMAXFIELDLENGTH) //If more than the defined limit of chars have been parsed failed=2; else millis[index++]=temp[ctr++]; //copy character into milliseconds string, increment indexes } } assert_wrapper(index < SRTTIMESTAMPMAXFIELDLENGTH+1); //Ensure that writing the NULL character won't overflow millis[index]='\0'; //Terminate milliseconds string if(failed) //If parsing failed { printf("Error: Invalid timestamp \"%s\"\n",temp); if(errorstatus != NULL) { *errorstatus=1; return 0; } else { (void) puts("Aborting"); exit_wrapper(1); } } assert_wrapper((ptr != NULL) && (temp != NULL)); if((ptr != NULL) && (temp != NULL)) { //Redundant check to satisfy cppcheck *ptr=&(temp[ctr+1]); //Store address of first character following end of timestamp } //Convert hours string to integer and add to sum temp=RemoveLeadingZeroes(hours); if(temp[0] != '0') //If hours is not 0 { conversion=atol(temp); //get integer conversion if(conversion<1) //Values of 0 are errors from atol(), negative values are not allowed for timestamps { (void) puts("Error converting string to integer\nAborting"); free(temp); if(errorstatus != NULL) { *errorstatus=2; return 0; } else exit_wrapper(2); } sum+=conversion*3600000; //one hour is 3600000 milliseconds } free(temp); //Convert minutes string to integer and add to sum temp=RemoveLeadingZeroes(minutes); if(temp[0] != '0') //If minutes is not 0 { conversion=atol(temp); //get integer conversion if(conversion<1) //Values of 0 are errors from atol(), negative values are not allowed for timestamps { (void) puts("Error converting string to integer\nAborting"); free(temp); if(errorstatus != NULL) { *errorstatus=2; return 0; } else exit_wrapper(2); } sum+=conversion*60000; //one minute is 60,000 milliseconds } free(temp); //Convert seconds string to integer and add to sum temp=RemoveLeadingZeroes(seconds); if(temp[0] != '0') //If minutes is not 0 { conversion=atol(temp); //get integer conversion if(conversion<1) //Values of 0 are errors from atol(), negative values are not allowed for timestamps { (void) puts("Error converting string to integer\nAborting"); free(temp); if(errorstatus != NULL) { *errorstatus=3; return 0; } else exit_wrapper(3); } sum+=conversion*1000; //one second is 1,000 milliseconds } free(temp); //Convert milliseconds string to integer and add to sum temp=RemoveLeadingZeroes(millis); if(temp[0] != '0') //If minutes is not 0 { conversion=atol(temp); //get integer conversion if(conversion<1) //Values of 0 are errors from atol(), negative values are not allowed for timestamps { (void) puts("Error converting string to integer\nAborting"); free(temp); if(errorstatus != NULL) { *errorstatus=4; return 0; } else exit_wrapper(4); } sum+=conversion; } free(temp); return sum; }
void VL_Load(FILE *inf) { unsigned long ctr=0; //Generic counter unsigned long start_off=0; //Starting offset of a lyric piece in milliseconds unsigned long end_off=0; //Ending offset of a lyric piece in milliseconds char *temp=NULL; //Pointer for string manipulation struct VL_Text_entry *curtext=NULL; //Conductor for text chunk linked list struct VL_Sync_entry *cursync=NULL; //Conductor for sync chunk linked list unsigned short cur_line_len=0; //The length of the currently line of lyrics unsigned short start_char=0; //The starting character offset for the current sync entry unsigned short end_char=0; //The ending character offset for the current sync entry char groupswithnext=0; //Tracks grouping, passed to AddLyricPiece() assert_wrapper(inf != NULL); //This must not be NULL Lyrics.freestyle_on=1; //VL is a pitch-less format, so import it as freestyle if(Lyrics.verbose) printf("Importing VL lyrics from file \"%s\"\n\n",Lyrics.infilename); //Build the VL storage structure (void) VL_PreLoad(inf,0); //Process offset if(Lyrics.offsetoverride == 0) { if(Lyrics.Offset == NULL) { if(Lyrics.verbose) (void) puts("No offset defined in VL file, applying offset of 0"); Lyrics.realoffset=0; } else if(strcmp(Lyrics.Offset,"0") != 0) { //If the VL file's offset is not zero and the command line offset is not specified assert_wrapper(Lyrics.Offset != NULL); //atol() crashes if NULL is passed to it Lyrics.realoffset=atol(Lyrics.Offset); //convert to number if(Lyrics.realoffset == 0) //atol returns 0 on error { printf("Error converting \"%s\" to integer value\nAborting\n",Lyrics.Offset); exit_wrapper(1); } if(Lyrics.verbose) printf("Applying offset defined in VL file: %ldms\n",Lyrics.realoffset); } //if the VL file's offset is defined as 0, that's what Lyrics.realoffset is initialized to already } if(Lyrics.verbose) (void) puts("Processing lyrics and sync entries"); //Process sync points, adding lyrics to Lyrics structure cursync=VL.Syncs; //Begin with first sync entry while(cursync != NULL) //For each sync point { groupswithnext=0; //Reset this condition start_off=cursync->start_time*10; //VL stores offsets as increments of 10 milliseconds each end_off=cursync->end_time*10; //Validate the lyric line number if(cursync->lyric_number >= VL.numlines) //lyric_number count starts w/ 0 instead of 1 and should never meet/exceed numlines { (void) puts("Error: Invalid line number detected during VL load\nAborting"); exit_wrapper(2); } //Validate the start and end character numbers in the sync entry start_char=cursync->start_char; end_char=cursync->end_char; if(start_char == 0xFFFF) { (void) puts("Error: Sync entry has no valid lyric during VL load\nAborting"); exit_wrapper(3); } //Seek to the correct lyric entry curtext=VL.Lyrics; //Point conductor to first text entry for(ctr=0; ctr<cursync->lyric_number; ctr++) if(curtext->next == NULL) { (void) puts("Error: Unexpected end of text piece linked list\nAborting"); exit_wrapper(4); } else curtext=curtext->next; //Seek forward to next piece cur_line_len = (unsigned short) strlen(curtext->text); //This value will be used several times in the rest of the loop if(start_char >= cur_line_len) //The starting offset cannot be past the end of the line of lyrics { (void) puts("Error: Sync entry has invalid starting offset during VL load\nAborting"); exit_wrapper(5); } if((end_char!=0xFFFF) && (end_char >= cur_line_len)) { //The ending offset cannot be past the end of the line of lyrics (void) puts("Error: Sync entry has invalid ending offset during VL load\nAborting"); exit_wrapper(6); } //Build the lyric based on the start and end character offsets temp=DuplicateString(curtext->text+start_char); //Copy the current text piece into a new string, starting from the character indexed by the sync entry if(Lyrics.verbose>=2) printf("\tProcessing sync entry #%lu: \"%s\"\tstart char=%u\tend char=%u\t\n",ctr,curtext->text,start_char,end_char); if(end_char != 0xFFFF) //If the sync entry ends before the end of the text piece { //"abcdef" strlen=6 st=2,en=4->"cde" if((isspace((unsigned char)temp[end_char-start_char-1])==0) && (isspace((unsigned char)temp[end_char-start_char])==0)) //if this sync entry's text doesn't end in whitespace and the next entry's doesn't begin in whitespace groupswithnext=1; //Allow AddLyricPiece to handle grouping and optional hyphen insertion //I've had to go back and forth on this line, but currently, end_char-start_char seems to mark the location at which to truncate, not the last character to keep before truncating temp[end_char-start_char]='\0'; //Truncate the string as indicated by the sync entry's end index (after the end_char) } //Add lyric to Lyric structure if(cursync->start_char == 0) //If this piece is the beginning of a line of lyrics { //Ensure a line of lyrics isn't already in progress if(Lyrics.line_on == 1) { (void) puts("Error: Lyric lines overlap during VL load\nAborting"); exit_wrapper(7); } if(Lyrics.verbose>=2) (void) puts("New line of lyrics:"); CreateLyricLine(); //Initialize the line } //Add lyric to Lyrics structure. AddLyricPiece(temp,start_off,end_off,PITCHLESS,groupswithnext); //Add the lyric piece to the Lyric structure, no defined pitch free(temp); //Release memory for this temporary string if((end_char == 0xFFFF) || (end_char == cur_line_len)) //If this piece ends a line of lyrics { //Ensure a line of lyrics is in progress if(Lyrics.line_on == 0) { (void) puts("Error: End of lyric line detected when none is started during VL load\nAborting"); exit_wrapper(8); } if(Lyrics.verbose>=2) (void) puts("End line of lyrics"); EndLyricLine(); //End the line } cursync=cursync->next; }//end while(cursync != NULL) ForceEndLyricLine(); if(Lyrics.verbose) printf("VL import complete. %lu lyrics loaded\n",Lyrics.piececount); ReleaseVL(); //Release memory used to build the VL structure }
int VL_PreLoad(FILE *inf,char validate) { long ftell_result=0; //Used to store return value from ftell() char buffer[5]= {0}; //Used to read word/doubleword integers from file unsigned long ctr=0; //Generic counter char *temp=NULL; //Temporary pointer for allocated strings struct VL_Sync_entry se= {0,0,0,0,0,NULL}; //Used to store sync entries from file during parsing struct VL_Text_entry *ptr1=NULL; //Used for allocating links for the text chunk list struct VL_Sync_entry *ptr2=NULL; //Used for allocation links for the sync chunk list struct VL_Text_entry *curtext; //Conductor for text chunk linked list struct VL_Sync_entry *cursync; //Conductor for sync chunk linked list assert_wrapper(inf != NULL); //Initialize variables VL.numlines=0; VL.numsyncs=0; VL.filesize=0; VL.textsize=0; VL.syncsize=0; VL.Lyrics=NULL; VL.Syncs=NULL; curtext=NULL; //list starts out empty cursync=NULL; //list starts out empty se.next=NULL; //In terms of linked lists, this always represents the last link if(Lyrics.verbose) (void) puts("Reading VL file header"); //Read file header fread_err(buffer,4,1,inf); //Read 4 bytes, which should be 'V','L','2',0 ReadDWORDLE(inf,&(VL.filesize)); //Read doubleword from file in little endian format if(strncmp(buffer,"VL2",4) != 0) { if(validate) return 1; else { (void) puts("Error: Invalid file header string\nAborting"); exit_wrapper(1); } } //Read text header fread_err(buffer,4,1,inf); //Read 4 bytes, which should be 'T','E','X','T' buffer[4]='\0'; //Add a NULL character to make buffer into a proper string ReadDWORDLE(inf,&(VL.textsize)); //Read doubleword from file in little endian format if(VL.textsize % 4 != 0) { (void) puts("Error: VL spec. violation: Sync chunk is not padded to a double-word alignment"); if(validate) return 2; else { (void) puts("Aborting"); exit_wrapper(2); } } if(strncmp(buffer,"TEXT",5) != 0) { (void) puts("Error: Invalid text header string"); if(validate) return 3; else { (void) puts("Aborting"); exit_wrapper(3); } } //Read sync header, which should be th.textsize+16 bytes into the file fseek_err(inf,VL.textsize+16,SEEK_SET); fread_err(buffer,4,1,inf); //Read 4 bytes, which should be 'S','Y','N','C' buffer[4]='\0'; //Add a NULL character to make buffer into a proper string ReadDWORDLE(inf,&(VL.syncsize)); //Read doubleword from file in little endian format if(strncmp(buffer,"SYNC",5) != 0) { (void) puts("Error: Invalid sync header string"); if(validate) return 4; else { (void) puts("Aborting"); exit_wrapper(4); } } //Validate chunk sizes given in headers (textsize was already validated if the Sync header was correctly read) fseek_err(inf,0,SEEK_END); //Seek to end of file ftell_result = ftell(inf); //Get position of end of file if(ftell_result < 0) { printf("Error determining file length during file size validation: %s\n",strerror(errno)); if(validate) return 5; else { (void) puts("Aborting"); exit_wrapper(5); } } if((unsigned long)ftell_result != VL.filesize+8) //Validate filesize { (void) puts("Error: Filesize does not match size given in file header"); if(validate) return 6; else { (void) puts("Aborting"); exit_wrapper(6); } } if(VL.filesize != VL.textsize + VL.syncsize + 16) //Validate syncsize { (void) puts("Error: Incorrect size given in sync chunk"); if(validate) return 7; else { (void) puts("Aborting"); exit_wrapper(7); } } //Load tags if(Lyrics.verbose) (void) puts("Loading VL tag strings"); fseek_err(inf,16,SEEK_SET); //Seek to the Title tag for(ctr=0; ctr<5; ctr++) //Expecting 5 null terminated unicode strings { temp=ReadUnicodeString(inf); //Allocate array and read Unicode string if(temp[0] != '\0') //If the string wasn't empty, save the tag switch(ctr) { //Look at ctr to determine which tag we have read, and assign to the appropriate tag string: case 0: SetTag(temp,'n',0); break; case 1: SetTag(temp,'s',0); break; case 2: SetTag(temp,'a',0); break; case 3: SetTag(temp,'e',0); break; case 4: //Offset SetTag(temp,'o',0); //Do not multiply the offset by -1 break; default: (void) puts("Unexpected error"); if(validate) return 8; else { (void) puts("Aborting"); exit_wrapper(8); } break; }//end switch(ctr) free(temp); //Free string, a copy of which would have been stored in the Lyrics structure as necessary }//end for(ctr=0;ctr<5;) //Validate the existence of three empty unicode strings for(ctr=0; ctr<3; ctr++) //Expecting 3 empty, null terminated unicode strings if(ParseUnicodeString(inf) != 0) { (void) puts("Error: Reserved string is not empty during load"); if(validate) return 9; else { (void) puts("Aborting"); exit_wrapper(9); } } //Load the lyric strings if(Lyrics.verbose) (void) puts("Loading text chunk entries"); while(1) //Read lyric lines { //Check to see if the Sync Chunk has been reached if((unsigned long)ftell_err(inf) >= VL.textsize + 16) //The Text chunk size + the file and text header sizes is the position of the Sync chunk break; //Read lyric string temp=ReadUnicodeString(inf); ftell_result=ftell_err(inf); //If this string is empty if(temp[0] == '\0') { if(VL.textsize+16 - ftell_result <= 3) //This 0 word value ends within 3 bytes of the sync header (is padding) { free(temp); //Release string as it won't be used break; //text chunk has been read } else { printf("Error: Empty lyric string detected before file position 0x%lX\n",ftell_result); free(temp); if(validate) return 10; else { (void) puts("Aborting"); exit_wrapper(10); } } } if((unsigned long)ftell_result > VL.textsize + 16) //If reading this string caused the file position to cross into Sync chunk { (void) puts("Error: Lyric string overlapped into Sync chunk"); free(temp); if(validate) return 11; else { (void) puts("Aborting"); exit_wrapper(11); } } if(Lyrics.verbose) printf("\tLoading text piece #%lu: \"%s\"\n",VL.numlines,temp); //Allocate link ptr1=malloc_err(sizeof(struct VL_Text_entry)); //Allocate memory for new link //Build link and insert into list ptr1->text=temp; ptr1->next=NULL; if(VL.Lyrics == NULL) //This is the first lyric piece read from the input file VL.Lyrics=ptr1; else { assert_wrapper(curtext != NULL); curtext->next=ptr1; //The end of the list points forward to this new link } curtext=ptr1; //This link is now at the end of the list VL.numlines++; //one more lyric string has been parsed }//end while(1) if(Lyrics.verbose) printf("%lu text chunk entries loaded\n",VL.numlines); //Load the Sync points if(Lyrics.verbose) (void) puts("Loading sync chunk entries"); fseek_err(inf,VL.textsize+16+8,SEEK_SET); //Seek to first sync entry (8 bytes past start of sync header) while(ReadSyncEntry(&se,inf) == 0) //Read all entries { if(se.start_char > se.end_char) { (void) puts("Error: Invalid sync point offset is specified to start after end offset"); if(validate) return 12; else { (void) puts("Aborting"); exit_wrapper(12); } } if(se.lyric_number!=0xFFFF && se.start_char!=0xFFFF && se.start_time!=0xFFFFFFFF) { //This is a valid sync entry //Allocate link ptr2=malloc_err(sizeof(struct VL_Sync_entry)); //Build link and insert into list memcpy(ptr2,&se,sizeof(struct VL_Sync_entry)); //copy structure into newly allocated link if(VL.Syncs == NULL) //This is the first sync piece read from the input file VL.Syncs=ptr2; else //The end of the list points forward to this new link { assert_wrapper(cursync != NULL); cursync->next=ptr2; } cursync=ptr2; //This link is now at the end of the list VL.numsyncs++; //one more sync entry has been parsed } } if(Lyrics.verbose) (void) puts("VL_PreLoad completed"); return 0; }
unsigned long BuildID3Tag(struct ID3Tag *ptr,FILE *outf) { unsigned long tagpos=0; //Records the position of the ID3 tag in the output file unsigned long framepos=0; //Records the position of the SYLT frame in the output file unsigned long ctr=0; struct ID3Frame *temp=NULL; struct Lyric_Line *curline=NULL; //Conductor of the lyric line linked list struct Lyric_Piece *curpiece=NULL; //A conductor for the lyric pieces list unsigned long framesize=0; //The calculated size of the written SYLT frame unsigned long tagsize=0; //The calculated size of the modified ID3 tag unsigned char array[4]={0}; //Used to build the 28 bit ID3 tag size unsigned char defaultID3tag[10]={'I','D','3',3,0,0,0,0,0,0}; //If the input file had no ID3 tag, this tag will be written unsigned long fileendpos=0; //Used to store the size of the input file char newline=0; //ID3 spec indicates that newline characters should be used at the beginning //of the new line instead of at the end of a line, use this to track for this //Validate input parameters if((ptr == NULL) || (ptr->fp == NULL) || (outf == NULL)) return 0; //Return failure if(Lyrics.verbose) printf("\nExporting ID3 lyrics to file \"%s\"\n",Lyrics.outfilename); //Conditionally copy the existing ID3v2 tag from the source file, or create one from scratch if(ptr->frames == NULL) { //If there was no ID3 tag in the input file if(Lyrics.verbose) (void) puts("Writing new ID3v2 tag"); tagpos=ftell_err(outf); //Record this file position so the tag size can be rewritten later fwrite_err(defaultID3tag,10,1,outf); //Write a pre-made ID3 tag //Write tag information obtained from input file if(Lyrics.Title != NULL) WriteTextInfoFrame(outf,"TIT2",Lyrics.Title); //Write song title frame if(Lyrics.Artist != NULL) WriteTextInfoFrame(outf,"TPE1",Lyrics.Artist); //Write song artist frame if(Lyrics.Album != NULL) WriteTextInfoFrame(outf,"TALB",Lyrics.Album); //Write album frame } else { //If there was an ID3v2 tag in the source file rewind_err(ptr->fp); //If the ID3v2 header isn't at the start of the source file, copy all data that precedes it to the output file BlockCopy(ptr->fp,outf,(size_t)(ptr->tagstart - ftell_err(ptr->fp))); //Copy the original ID3v2 header from source file to output file (record the file position) if(Lyrics.verbose) (void) puts("Copying ID3v2 tag header"); tagpos=ftell_err(outf); //Record this file position so the tag size can be rewritten later BlockCopy(ptr->fp,outf,(size_t)(ptr->framestart - ftell_err(ptr->fp))); //Write tag information from input file if applicable, and ensure that equivalent ID3v2 frames from the source file are omitted if(Lyrics.Title != NULL) { WriteTextInfoFrame(outf,"TIT2",Lyrics.Title); //Write song title frame Lyrics.nosrctag=AddOmitID3framelist(Lyrics.nosrctag,"TIT2"); //Linked list create/append to omit source song title frame } if(Lyrics.Artist != NULL) { WriteTextInfoFrame(outf,"TPE1",Lyrics.Artist); //Write song artist frame Lyrics.nosrctag=AddOmitID3framelist(Lyrics.nosrctag,"TPE1"); //Linked list create/append to omit source song artist frame } if(Lyrics.Album != NULL) { WriteTextInfoFrame(outf,"TALB",Lyrics.Album); //Write album frame Lyrics.nosrctag=AddOmitID3framelist(Lyrics.nosrctag,"TALB"); //Linked list create/append to omit source album frame } if(Lyrics.Year != NULL) { WriteTextInfoFrame(outf,"TYER",Lyrics.Year); //Write year frame Lyrics.nosrctag=AddOmitID3framelist(Lyrics.nosrctag,"TYER"); //Linked list create/append to omit source year frame } //Omit any existing SYLT frame from the source file Lyrics.nosrctag=AddOmitID3framelist(Lyrics.nosrctag,"SYLT"); //Linked list create/append with SYLT frame ID to ensure SYLT source frame is omitted //Write all frames from source MP3 to export MP3 except for those in the omit list for(temp=ptr->frames;temp!=NULL;temp=temp->next) { //For each ID3Frame in the list if(SearchOmitID3framelist(Lyrics.nosrctag,temp->frameid) == 0) //If the source frame isn't to be omitted { if(Lyrics.verbose >= 2) printf("\tCopying frame \"%s\"\n",temp->frameid); if((unsigned long)ftell_err(ptr->fp) != temp->pos) //If the input file isn't already positioned at the frame fseek_err(ptr->fp,temp->pos,SEEK_SET); //Seek to it now BlockCopy(ptr->fp,outf,(size_t)temp->length + 10); //Copy frame body size + header size number of bytes ctr++; //Increment counter } else if(Lyrics.verbose >= 2) printf("\tOmitting \"%s\" frame from source file\n",temp->frameid); } }//If there was an ID3 tag in the input file if(Lyrics.verbose) (void) puts("Writing SYLT frame header"); //Write SYLT frame header framepos=ftell_err(outf); //Record this file position so the frame size can be rewritten later fputs_err("SYLTxxxx\xC0",outf); //Write the Frame ID, 4 dummy bytes for the unknown frame size and the first flag byte (preserve frame for both tag and file alteration) fputc_err(0,outf); //Write second flag byte (no compression, encryption or grouping identity) fputc_err(0,outf); //ASCII encoding fputs_err("eng\x02\x01",outf); //Write the language as "English", the timestamp format as milliseconds and the content type as "lyrics" fputs_err(PROGVERSION,outf); //Embed the program version as the content descriptor fputc_err(0,outf); //Write NULL terminator for content descriptor //Write SYLT frame using the Lyrics structure curline=Lyrics.lines; //Point lyric line conductor to first line of lyrics if(Lyrics.verbose) (void) puts("Writing SYLT lyrics"); while(curline != NULL) //For each line of lyrics { curpiece=curline->pieces; //Starting with the first piece of lyric in this line while(curpiece != NULL) //For each piece of lyric in this line { if(newline) //If the previous lyric was the last in its line { fputc_err('\n',outf); //Append a newline character in front of this lyric entry newline=0; //Reset this status } fputs_err(curpiece->lyric,outf); //Write the lyric if(Lyrics.verbose >= 2) printf("\t\"%s\"\tstart=%lu\t",curpiece->lyric,curpiece->start); //Line/word grouping logic if(curpiece->next == NULL) //If this is the last lyric in the line { newline=1; if(Lyrics.verbose >= 2) printf("(newline)"); } else if(!curpiece->groupswithnext) //Otherwise, if this lyric does not group with the next { fputc_err(' ',outf); //Append a space if(Lyrics.verbose >= 2) printf("(whitespace)"); } if(Lyrics.verbose >= 2) (void) putchar('\n'); fputc_err(0,outf); //Write a NULL terminator WriteDWORDBE(outf,curpiece->start); //Write the lyric's timestamp as a big endian value curpiece=curpiece->next; //Point to next lyric in the line } curline=curline->next; //Point to next line of lyrics } framesize=ftell_err(outf)-framepos-10; //Find the length of the SYLT frame that was written (minus frame header size) ctr++; //Increment counter if(ptr->frames != NULL) { //If the input MP3 had an ID3 tag //Copy any unidentified data (ie. padding) that occurs between the end of the last ID3 frame in the list and the defined end of the ID3 tag for(temp=ptr->frames;temp->next!=NULL;temp=temp->next); //Seek to last frame link fseek_err(ptr->fp,temp->pos + temp->length + 10,SEEK_SET); //Seek to one byte past the end of the frame BlockCopy(ptr->fp,outf,(size_t)(ptr->tagend - ftell_err(ptr->fp))); } tagsize=ftell_err(outf)-tagpos-10; //Find the length of the ID3 tag that has been written (minus tag header size) if(Lyrics.verbose) (void) puts("Copying audio data"); fileendpos=GetFileEndPos(ptr->fp); //Find the position of the last byte in the input MP3 file (the filesize) if(ptr->id3v1present && SearchOmitID3framelist(Lyrics.nosrctag,"*")) //If the user specified to leave off the ID3v1 tag, and the source MP3 has an ID3 tag { BlockCopy(ptr->fp,outf,(size_t)(fileendpos - ftell_err(ptr->fp) - 128)); //Copy rest of source file to output file (minus 128 bytes, the size of the ID3v1 tag) ptr->id3v1present=0; //Consider the tag as being removed, so a new ID3v1 tag is written below } else BlockCopy(ptr->fp,outf,(size_t)(fileendpos - ftell_err(ptr->fp))); //Copy rest of source file to output file //Write/Overwrite ID3v1 tag if(ptr->id3v1present) //If an ID3v1 tag existed in the source MP3 { //Overwrite it with tags from the input file if(Lyrics.verbose) (void) puts("Editing ID3v1 tag"); fseek_err(outf,-125,SEEK_CUR); //Seek 125 bytes back, where the first field of this tag should exist if(Lyrics.Title != NULL) //If the input file defined a Title WritePaddedString(outf,Lyrics.Title,30,0); //Overwrite the Title field (30 bytes) else fseek_err(outf,30,SEEK_CUR); //Otherwise seek 30 bytes ahead to the next field if(Lyrics.Artist != NULL) //If the input file defined an Artist WritePaddedString(outf,Lyrics.Artist,30,0); //Overwrite the Artist field (30 bytes) else fseek_err(outf,30,SEEK_CUR); //Otherwise seek 30 bytes ahead to the next field if(Lyrics.Album != NULL) //If the input file defined an Album WritePaddedString(outf,Lyrics.Album,30,0); //Overwrite the Album field (30 bytes) else fseek_err(outf,30,SEEK_CUR); //Otherwise seek 30 bytes ahead to the next field if(Lyrics.Year != NULL) //If the input file defined a Year WritePaddedString(outf,Lyrics.Year,4,0); //Overwrite the Year field (4 bytes) } else { //Write a new ID3v1 tag if(Lyrics.verbose) (void) puts("Writing new ID3v1 tag"); fseek_err(outf,0,SEEK_END); //Seek to end of file fputs_err("TAG",outf); //Write ID3v1 header WritePaddedString(outf,Lyrics.Title,30,0); //Write the Title field (30 bytes) WritePaddedString(outf,Lyrics.Artist,30,0); //Write the Artist field (30 bytes) WritePaddedString(outf,Lyrics.Album,30,0); //Write the Album field (30 bytes) WritePaddedString(outf,ptr->id3v1year,4,0); //Write the Year field (4 bytes) WritePaddedString(outf,NULL,30,0); //Write a blank Comment field (30 bytes) fputc_err(255,outf); //Write unknown genre (1 byte) } if(Lyrics.verbose) (void) puts("Correcting ID3 headers"); //Rewind to the SYLT header in the output file and write the correct frame length fseek_err(outf,framepos+4,SEEK_SET); //Seek to where the SYLT frame size is to be written WriteDWORDBE(outf,framesize); //Write the SYLT frame size //Rewind to the ID3 header in the output file and write the correct ID3 tag length fseek_err(outf,ptr->tagstart+6,SEEK_SET); //Seek to where the ID3 tag size is to be written if(tagsize > 0x0FFFFFFF) { (void) puts("\aError: Tag size is larger than the ID3 specification allows"); exit_wrapper(2); } array[3]=tagsize & 127; //Mask out everything except the lowest 7 bits array[2]=(tagsize>>7) & 127; //Mask out everything except the 2nd set of 7 bits array[1]=(tagsize>>14) & 127; //Mask out everything except the 3rd set of 7 bits array[0]=(tagsize>>21) & 127; //Mask out everything except the 4th set of 7 bits fwrite_err(array,4,1,outf); //Write the ID3 tag size if(Lyrics.verbose) printf("\nID3 export complete. %lu lyrics written\n",Lyrics.piececount); return ctr; //Return counter }
void SYLT_Parse(struct ID3Tag *tag) { unsigned char frameheader[10]={0}; //This is the ID3 frame header unsigned char syltheader[6]={0}; //This is the SYLT frame header, excluding the terminated descriptor string that follows char *contentdescriptor=NULL; //The null terminated string located after the SYLT frame header char timestampformat=0; //Will be set based on the SYLT header (1= MPEG Frames, 2=Milliseconds) char *string=NULL; //Used to store SYLT strings that are read char *string2=NULL; //Used to build a display version of the string for debug output (minus newline) unsigned char timestamparray[4]={0};//Used to store the timestamp for a lyric string unsigned long timestamp=0; //The timestamp converted to milliseconds unsigned long breakpos; //Will be set to the first byte beyond the SYLT frame unsigned long framesize=0; char groupswithnext=0; //Used for grouping logic char linebreaks=0; //Tracks whether the imported lyrics defined linebreaks (if not, each ID3 lyric should be treated as one line) struct Lyric_Piece *ptr=NULL,*ptr2=NULL; //Used to insert line breaks as necessary struct Lyric_Line *lineptr=NULL; //Used to insert line breaks as necessary unsigned long length=0; //Used to store the length of each string that is read from file unsigned long filepos=0; //Used to track the current file position during SYLT lyric parsing //Validate input assert_wrapper((tag != NULL) && (tag->fp != NULL)); breakpos=ftell_err(tag->fp); //Load and validate ID3 frame header and SYLT frame header fread_err(frameheader,10,1,tag->fp); //Load ID3 frame header fread_err(syltheader,6,1,tag->fp); //Load SYLT frame header if((frameheader[9] & 192) != 0) { (void) puts("ID3 Compression and Encryption are not supported\nAborting"); exit_wrapper(3); } if(syltheader[0] != 0) { (void) puts("Unicode ID3 lyrics are not supported\nAborting"); exit_wrapper(4); } //Load and validate content descriptor string contentdescriptor=ReadString(tag->fp,NULL,0); //Load content descriptor string if(contentdescriptor == NULL) //If the content descriptor string couldn't be read { (void) puts("Damaged Content Descriptor String\nAborting"); exit_wrapper(1); } //Validate timestamp format timestampformat=syltheader[4]; if((timestampformat != 1) && (timestampformat != 2)) { printf("Warning: Invalid timestamp format (%d) specified, ms timing assumed\n",timestampformat); timestampformat=2; //Assume millisecond timing } //Process framesize as a 4 byte Big Endian integer framesize=((unsigned long)frameheader[4]<<24) | ((unsigned long)frameheader[5]<<16) | ((unsigned long)frameheader[6]<<8) | ((unsigned long)frameheader[7]); //Convert to 4 byte integer if(framesize & 0x80808080) //According to the ID3v2 specification, the MSB of each of the 4 bytes defining the tag size must be zero exit_wrapper(5); //If this isn't the case, the size is invalid assert(framesize < 0x80000000); //Redundant assert() to resolve a false positive with Coverity (this assertion will never be triggered because the above exit_wrapper() call would be triggered first) breakpos=breakpos + framesize + 10; //Find the position that is one byte past the end of the SYLT frame if(Lyrics.verbose>=2) printf("SYLT frame info:\n\tFrame size is %lu bytes\n\tEnds after byte 0x%lX\n\tTimestamp format: %s\n\tLanguage: %c%c%c\n\tContent Type %d\n\tContent Descriptor: \"%s\"\n\n",framesize,breakpos-1,timestampformat == 1 ? "MPEG frames" : "Milliseconds",syltheader[1],syltheader[2],syltheader[3],syltheader[5],contentdescriptor != NULL ? contentdescriptor : "(none)"); if(Lyrics.verbose) (void) puts("Parsing SYLT frame:"); free(contentdescriptor); //Release this, it's not going to be used contentdescriptor=NULL; //Load SYLT lyrics filepos=ftell_err(tag->fp); while(filepos < breakpos) //While we haven't reached the end of the SYLT frame { //Load the lyric text string=ReadString(tag->fp,&length,0); //Load SYLT lyric string, save the string length if(string == NULL) { (void) puts("Invalid SYLT lyric string\nAborting"); exit_wrapper(6); } //Load the timestamp if(fread(timestamparray,4,1,tag->fp) != 1) //Read timestamp { (void) puts("Error reading SYLT timestamp\nAborting"); exit_wrapper(7); } filepos+=length+4; //The number of bytes read from the input file during this iteration is the string length and the timestamp length //Process the timestamp as a 4 byte Big Endian integer timestamp=(unsigned long)((timestamparray[0]<<24) | (timestamparray[1]<<16) | (timestamparray[2]<<8) | timestamparray[3]); if(timestampformat == 1) //If this timestamp is in MPEG frames instead of milliseconds timestamp=((double)timestamp * tag->frameduration + 0.5); //Convert to milliseconds, rounding up //Perform line break logic assert(string != NULL); //(check string for NULL again to satisfy cppcheck) if((string[0] == '\r') || (string[0] == '\n')) //If this lyric begins with a newline or carriage return { EndLyricLine(); //End the lyric line before the lyric is added linebreaks=1; //Track that line break character(s) were found in the lyrics } if(Lyrics.verbose >= 2) { string2=DuplicateString(string); //Make a copy of the string for display purposes string2=TruncateString(string2,1); //Remove leading/trailing whitespace, newline chars, etc. printf("Timestamp: 0x%X%X%X%X\t%lu %s\t\"%s\"\t%s",timestamparray[0],timestamparray[1],timestamparray[2],timestamparray[3],timestamp,(timestampformat == 1) ? "MPEG frames" : "Milliseconds",string2,(string[0]=='\n') ? "(newline)\n" : "\n"); free(string2); string2=NULL; } //Perform grouping logic //Handle whitespace at the beginning of the parsed lyric piece as a signal that the piece will not group with previous piece if(isspace(string[0])) if(Lyrics.curline->pieces != NULL) //If there was a previous lyric piece on this line Lyrics.lastpiece->groupswithnext=0; //Ensure it is set to not group with this lyric piece if(isspace(string[strlen(string)-1])) //If the lyric ends in a space groupswithnext=0; else groupswithnext=1; if(Lyrics.line_on == 0) //Ensure that a line phrase is started CreateLyricLine(); //Add lyric piece, during testing, I'll just write it with a duration of 1ms AddLyricPiece(string,timestamp,timestamp+1,PITCHLESS,groupswithnext); //Write lyric with no defined pitch free(string); //Free string if((Lyrics.lastpiece != NULL) && (Lyrics.lastpiece->prev != NULL) && (Lyrics.lastpiece->prev->groupswithnext)) //If this piece groups with the previous piece Lyrics.lastpiece->prev->duration=Lyrics.lastpiece->start-Lyrics.realoffset-Lyrics.lastpiece->prev->start; //Extend previous piece's length to reach this piece, take the current offset into account }//While we haven't reached the end of the SYLT frame //If the imported lyrics did not contain line breaks, they must be inserted manually if(!linebreaks && Lyrics.piececount) { if(Lyrics.verbose) (void) puts("\nImported ID3 lyrics did not contain line breaks, adding..."); ptr=Lyrics.lines->pieces; lineptr=Lyrics.lines; //Point to first line of lyrics (should be the only line) assert_wrapper((lineptr != NULL) && (ptr != NULL)); //This shouldn't be possible if Lyrics.piececount is nonzero if(lineptr->next != NULL) //If there is another line of lyrics defined return; //abort the insertion of automatic line breaks while((ptr != NULL) && (ptr->next != NULL)) //For each lyric { ptr2=ptr->next; //Store pointer to next lyric lineptr=InsertLyricLineBreak(lineptr,ptr2); //Insert a line break between this lyric and the next, line conductor points to new line ptr=ptr2; //lyric conductor points to the next lyric, which is at the beginning of the new line } } }
void ID3_Load(FILE *inf) { //Parses the file looking for an ID3 tag. If found, the first MP3 frame is examined to obtain the sample rate //Then an SYLT frame is searched for within the ID3 tag. If found, synchronized lyrics are imported struct ID3Tag tag={NULL,0,0,0,0,0,0.0,NULL,0,NULL,NULL,NULL,NULL}; struct ID3Frame *frameptr=NULL; struct ID3Frame *frameptr2=NULL; assert_wrapper(inf != NULL); //This must not be NULL tag.fp=inf; if(Lyrics.verbose) printf("Importing ID3 lyrics from file \"%s\"\n\nParsing input MPEG audio file\n",Lyrics.infilename); if(ID3FrameProcessor(&tag) == 0) //Build a list of the ID3 frames { DestroyID3(&tag); //Release the ID3 structure's memory return; //Return if no frames were successfully parsed } //Parse MPEG frame header fseek_err(tag.fp,tag.tagend,SEEK_SET); //Seek to the first MP3 frame (immediately after the ID3 tag) if(GetMP3FrameDuration(&tag) == 0) //Find the sample rate defined in the MP3 frame { DestroyID3(&tag); //Release the ID3 structure's memory return; //Return if the sample rate was not found or was invalid } frameptr=FindID3Frame(&tag,"SYLT"); //Search ID3 frame list for SYLT ID3 frame frameptr2=FindID3Frame(&tag,"USLT"); //Search ID3 frame list for USLT ID3 frame if(frameptr != NULL) { //Perform Synchronized ID3 Lyric import fseek_err(tag.fp,frameptr->pos,SEEK_SET); //Seek to SYLT ID3 frame SYLT_Parse(&tag); } else if(frameptr2 != NULL) { //Perform Unsynchronized ID3 Lyric import (void) puts("\aUnsynchronized ID3 lyric import currently not supported"); exit_wrapper(1); } else { DestroyID3(&tag); //Release the ID3 structure's memory return; //Return if neither lyric frame is present } //Load song tags Lyrics.Title=GrabID3TextFrame(&tag,"TIT2",NULL,0); //Return the defined song title, if it exists Lyrics.Artist=GrabID3TextFrame(&tag,"TPE1",NULL,0); //Return the defined artist, if it exists Lyrics.Album=GrabID3TextFrame(&tag,"TALB",NULL,0); //Return the defined album, if it exists Lyrics.Year=GrabID3TextFrame(&tag,"TYER",NULL,0); //Return the defined year, if it exists if(Lyrics.Title == NULL) //If there was no Title defined in the ID3v2 tag Lyrics.Title=DuplicateString(tag.id3v1title); //Use one defined in the ID3v1 tag if it exists if(Lyrics.Artist == NULL) //If there was no Artist defined in the ID3v2 tag Lyrics.Artist=DuplicateString(tag.id3v1artist); //Use one defined in the ID3v1 tag if it exists if(Lyrics.Album == NULL) //If there was no Album defined in the ID3v2 tag Lyrics.Album=DuplicateString(tag.id3v1album); //Use one defined in the ID3v1 tag if it exists if(Lyrics.Year == NULL) //If there was no Year defined in the ID3v2 tag Lyrics.Year=DuplicateString(tag.id3v1year); //Use one defined in the ID3v1 tag if it exists ForceEndLyricLine(); DestroyID3(&tag); //Release the ID3 structure's memory if(Lyrics.verbose) printf("ID3 import complete. %lu lyrics loaded\n\n",Lyrics.piececount); }