gp.c

   1 /*
   2    Parser library for the Guitar Pro 3 file format
   3    (c) 2004: Jelmer Vernooij <jelmer@samba.org>
   4
   5    Based on gp3_loader.py from songwrite
   6         Copyright (C) 2003 Bertrand LAMY
   7         Copyright (C) 2003 Jean-Baptiste LAMY
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 2 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22  */
  23
  24 #include <stdio.h>
  25 #include <fcntl.h>
  26 #include <sys/stat.h>
  27 #include <string.h>
  28 #include <assert.h>
  29
  30 #ifdef HAVE_CONFIG_H
  31 #  include "config.h"
  32 #endif
  33
  34 #ifdef HAVE_STDINT_H
  35 #  include <stdint.h>
  36 #endif
  37
  38 #ifdef HAVE_CTYPE_H
  39 #  include <ctype.h>
  40 #endif\r
  41 \r
  42 #ifdef HAVE_UNISTD_H\r
  43 #  include <unistd.h>\r
  44 #endif\r
  45 \r
  46 #ifdef _WIN32\r
  47 #  include <io.h>\r
  48 #endif
  49 \r
  50 #define PTB_CORE
  51 #include "gp.h"
  52
  53 #define malloc_p(t, n) (t *) calloc(sizeof(t), n)
  54
  55 static void gp_read(struct gpf *gpf, void *data, size_t len)
  56 {
  57         int ret = read(gpf->fd, data, len);
  58         assert(ret == len);
  59 }
  60
  61 static void gp_read_unknown(struct gpf *gpf, size_t num)
  62 {
  63         char *tmp = malloc_p(char, num);
  64         gp_read(gpf, tmp, num);
  65         free(tmp);
  66 }
  67
  68 static void gp_read_string(struct gpf *gpf, const char **dest)
  69 {
  70         unsigned char len = 0;
  71         char *ret;
  72         gp_read(gpf, &len, 1);
  73         ret = malloc_p(char, len+1);
  74         gp_read(gpf, ret, len);
  75         *dest = ret;
  76 }
  77
  78 static void gp_read_uint8(struct gpf *gpf, uint8_t *n)
  79 {
  80         gp_read(gpf, n, sizeof(uint8_t));
  81 }
  82
  83 static void gp_read_uint32(struct gpf *gpf, uint32_t *n)
  84 {
  85         gp_read(gpf, n, sizeof(uint32_t));
  86 }
  87
  88 static void gp_read_long_string(struct gpf *gpf, const char **dest)
  89 {
  90         uint32_t l;
  91         char *ret;
  92         gp_read_uint32(gpf, &l);
  93         ret = malloc_p(char, l + 1);
  94         gp_read(gpf, ret, l);
  95         *dest = ret;
  96 }
  97
  98 static void gp_read_color(struct gpf *gpf, struct gp_color *color)
  99 {
 100         gp_read_uint8(gpf, &color->unknown);
 101         gp_read_uint8(gpf, &color->red);
 102         gp_read_uint8(gpf, &color->green);
 103         gp_read_uint8(gpf, &color->blue);
 104 }
 105
 106 static void gp_read_nstring(struct gpf *gpf, const char **dest, size_t len)
 107 {
 108         uint8_t _len;
 109         char *ret = malloc_p(char, len + 1);
 110         gp_read_uint8(gpf, &_len);
 111         assert(_len <= len);
 112         gp_read(gpf, ret, len);
 113         ret[_len] = '\0';
 114         *dest = ret;
 115 }
 116
 117 static void gp_read_header(struct gpf *gpf)
 118 {
 119         if (gpf->version >= 3.0) {
 120                 uint32_t i;
 121                 gp_read_long_string(gpf, &gpf->title);
 122                 gp_read_long_string(gpf, &gpf->subtitle);
 123                 gp_read_long_string(gpf, &gpf->artist);
 124                 gp_read_long_string(gpf, &gpf->album);
 125                 gp_read_long_string(gpf, &gpf->author);
 126                 gp_read_long_string(gpf, &gpf->copyright);
 127                 gp_read_long_string(gpf, &gpf->tab_by);
 128                 gp_read_long_string(gpf, &gpf->instruction);
 129
 130                 gp_read_uint32(gpf, &gpf->notice_num_lines);
 131                 gpf->notice = malloc_p(const char *, gpf->notice_num_lines);
 132                 for (i = 0; i < gpf->notice_num_lines; i++)
 133                 {
 134                         gp_read_long_string(gpf, &gpf->notice[i]);
 135                 }
 136                 gp_read_uint8(gpf, &gpf->shuffle);
 137         } else {
 138                 if (gpf->version >= 2.0) {
 139                         gp_read_unknown(gpf, 1);
 140                 }
 141                 gp_read_nstring(gpf, &gpf->title, 100);
 142                 gp_read_unknown(gpf, 1);
 143                 gp_read_nstring(gpf, &gpf->author, 50);
 144                 gp_read_unknown(gpf, 1);
 145                 gp_read_nstring(gpf, &gpf->instruction, 100);
 146         }
 147 }
 148
 149 static void gp_read_lyrics(struct gpf *gpf)
 150 {
 151         if (gpf->version >= 4.0)
 152         {
 153                 uint32_t i;
 154                 gp_read_uint32(gpf, &gpf->lyrics_track);
 155
 156                 gpf->num_lyrics = 5;
 157
 158                 gpf->lyrics = malloc_p(struct gp_lyric, gpf->num_lyrics);
 159
 160                 for (i = 0; i < gpf->num_lyrics; i++) {
 161                         gp_read_uint32(gpf, &gpf->lyrics[i].bar);
 162                         gp_read_long_string(gpf, &gpf->lyrics[i].data);
 163                 }
 164         }
 165 }
 166
 167 static void gp_read_instruments(struct gpf *gpf)
 168 {
 169         if (gpf->version >= 3.0) {
 170                 uint32_t i;
 171                 gpf->num_instruments = 64;
 172                 gpf->instrument = malloc_p(struct gp_instrument, gpf->num_instruments);
 173                 for (i = 0; i < gpf->num_instruments; i++)
 174                 {
 175                         gp_read_unknown(gpf, 12);
 176                 }
 177         } else {
 178                 uint32_t i;
 179                 for (i = 0; i < 8; i++)
 180                 {
 181                         uint32_t x;
 182                         gp_read_uint32(gpf, &x);
 183                         gp_read_unknown(gpf, x * 4);
 184                 }
 185         }
 186 }
 187
 188 static void gp_read_bars(struct gpf *gpf)
 189 {
 190         uint32_t i;
 191         gpf->bars = malloc_p(struct gp_bar, gpf->num_bars);
 192
 193         for (i = 0; i < gpf->num_bars; i++)
 194         {
 195                 gp_read_uint8(gpf, &gpf->bars[i].properties);
 196
 197                 assert((        gpf->bars[i].properties
 198                                         &~ GP_BAR_PROPERTY_CUSTOM_RHYTHM_1
 199                                         &~ GP_BAR_PROPERTY_CUSTOM_RHYTHM_2
 200                                         &~ GP_BAR_PROPERTY_REPEAT_OPEN
 201                                         &~ GP_BAR_PROPERTY_REPEAT_CLOSE
 202                                         &~ GP_BAR_PROPERTY_ALT_ENDING
 203                                         &~ GP_BAR_PROPERTY_MARKER
 204                                         &~ GP_BAR_PROPERTY_CHANGE_ARMOR
 205                                         &~ GP_BAR_PROPERTY_DOUBLE_ENDING) == 0);
 206
 207                 if (gpf->bars[i].properties & GP_BAR_PROPERTY_CUSTOM_RHYTHM_1) {
 208                         gp_read_uint8(gpf, &gpf->bars[i].rhythm_1);
 209                 } else {
 210                         gpf->bars[i].rhythm_1 = 4;
 211                 }
 212
 213                 if (gpf->bars[i].properties & GP_BAR_PROPERTY_CUSTOM_RHYTHM_2) {
 214                         gp_read_uint8(gpf, &gpf->bars[i].rhythm_2);
 215                 } else {
 216                         gpf->bars[i].rhythm_2 = 4;
 217                 }
 218
 219                 if (gpf->bars[i].properties & GP_BAR_PROPERTY_REPEAT_CLOSE) {
 220                         gp_read_uint8(gpf, &gpf->bars[i].repeat_close.volta);
 221                 }
 222
 223                 if (gpf->bars[i].properties & GP_BAR_PROPERTY_ALT_ENDING) {
 224                         gp_read_uint8(gpf, &gpf->bars[i].alternate_ending.type);
 225                 }
 226
 227                 if (gpf->bars[i].properties & GP_BAR_PROPERTY_MARKER) {
 228                         gp_read_long_string(gpf, &gpf->bars[i].marker.name);
 229                         gp_read_color(gpf, &gpf->bars[i].marker.color);
 230                 }
 231
 232                 if (gpf->bars[i].properties & GP_BAR_PROPERTY_CHANGE_ARMOR) {
 233                         gp_read_uint8(gpf, &gpf->bars[i].change_armor.armor_jumps);
 234                         gp_read_uint8(gpf, &gpf->bars[i].change_armor.minor);
 235                 }
 236         }
 237 }
 238
 239 static void gp_read_tracks(struct gpf *gpf)
 240 {
 241         uint32_t i;
 242
 243         gpf->tracks = malloc_p(struct gp_track, gpf->num_tracks);
 244
 245         if (gpf->version >= 3.0)
 246         {
 247                 for (i = 0; i < gpf->num_tracks; i++)
 248                 {
 249                         uint32_t j;
 250                         gp_read_uint8(gpf, &gpf->tracks[i].spc);
 251                         gp_read_nstring(gpf, &gpf->tracks[i].name, 40);
 252                         gp_read_uint32(gpf, &gpf->tracks[i].num_strings);
 253                         gpf->tracks[i].strings = malloc_p(struct gp_track_string, gpf->tracks[i].num_strings);
 254                         for (j = 0; j < 7; j++) {
 255                                 uint32_t string_pitch;
 256                                 gp_read_uint32(gpf, &string_pitch);
 257                                 if (j < gpf->tracks[i].num_strings) {
 258                                         gpf->tracks[i].strings[j].pitch = string_pitch;
 259                                 }
 260                         }
 261                         gp_read_uint32(gpf, &gpf->tracks[i].midi_port);
 262                         gp_read_uint32(gpf, &gpf->tracks[i].channel1);
 263                         gp_read_uint32(gpf, &gpf->tracks[i].channel2);
 264                         gp_read_uint32(gpf, &gpf->tracks[i].num_frets);
 265                         gp_read_uint32(gpf, &gpf->tracks[i].capo);
 266                         gp_read_color(gpf, &gpf->tracks[i].color);
 267                 }
 268         } else {
 269                 int i;
 270                 for (i = 0; i < 8; i++)
 271                 {
 272                         gp_read_unknown(gpf, 4);
 273                         gp_read_uint32(gpf, &gpf->tracks[i].num_frets);
 274                         gp_read_unknown(gpf, 1);
 275                         gp_read_nstring(gpf, &gpf->tracks[i].name, 40);
 276                         gp_read_unknown(gpf, 1 + 5 * 4);
 277                 }
 278                 gpf->num_tracks = 0;
 279         }
 280 }
 281
 282 static void gp_read_beat(struct gpf *gpf, struct gp_beat *beat)
 283 {
 284         int i;
 285         gp_read_uint8(gpf, &beat->properties);
 286         assert((beat->properties
 287                          &~ GP_BEAT_PROPERTY_DOTTED
 288                          &~ GP_BEAT_PROPERTY_CHORD
 289                          &~ GP_BEAT_PROPERTY_TEXT
 290                          &~ GP_BEAT_PROPERTY_EFFECT
 291                          &~ GP_BEAT_PROPERTY_CHANGE
 292                          &~ GP_BEAT_PROPERTY_TUPLET
 293                          &~ GP_BEAT_PROPERTY_REST) == 0);
 294
 295         if (beat->properties & GP_BEAT_PROPERTY_REST) {
 296                 gp_read_unknown(gpf, 1);
 297         }
 298
 299         gp_read_uint8(gpf, &beat->duration);
 300
 301         if (beat->properties & GP_BEAT_PROPERTY_TUPLET) {
 302                 gp_read_uint32(gpf, &beat->tuplet.n_tuplet);
 303         }
 304
 305         if (beat->properties & GP_BEAT_PROPERTY_CHORD) {
 306                 gp_read_uint8(gpf, &beat->chord.complete);
 307                 if (!beat->chord.complete) {
 308                         gp_read_long_string(gpf, &beat->chord.name);
 309                 } else {
 310                         if (gpf->version >= 4.0) {
 311                                 gp_read_unknown(gpf, 16);
 312                                 gp_read_string(gpf, &beat->chord.name);
 313                                 gp_read_unknown(gpf, 25);
 314                         } else {
 315                                 gp_read_unknown(gpf, 25);
 316                                 gp_read_string(gpf, &beat->chord.name);
 317                                 gp_read_unknown(gpf, 34);
 318                         }
 319                 }
 320                 gp_read_uint32(gpf, &beat->chord.top_fret);
 321                 if (beat->chord.top_fret == 0)
 322                 {
 323                         if (beat->chord.complete) {
 324                                 gp_read_unknown(gpf, 6 * 4);
 325                         } else {
 326                                 gp_read_unknown(gpf, 7 * 4);
 327                         }
 328                 }
 329                 if (beat->chord.complete)
 330                 {
 331                         if (gpf->version >= 4.0) {
 332                 gp_read_unknown(gpf, 24 + 7 + 1);
 333                         } else {
 334                                 gp_read_unknown(gpf, 32);
 335                         }
 336                 }
 337         }
 338
 339         if (beat->properties & GP_BEAT_PROPERTY_EFFECT)
 340         {
 341                 gp_read_uint8(gpf, &beat->effect.properties1);
 342
 343
 344                 if (gpf->version >= 4.0) {
 345                         gp_read_uint8(gpf, &beat->effect.properties2);
 346                 } else {
 347                         beat->effect.properties2 = 0;
 348                 }
 349
 350                 if (beat->effect.properties1 & GP_BEAT_EFFECT1_STROCKE) {
 351                         gp_read_unknown(gpf, 2);
 352                 }
 353
 354                 if (beat->effect.properties2 & GP_BEAT_EFFECT2_PICK_STROCKE) {
 355                         gp_read_unknown(gpf, 1);
 356                 }
 357
 358                 if (beat->effect.properties2 & GP_BEAT_EFFECT2_TREMOLO_BAR) {
 359                         gp_read_unknown(gpf, 5);
 360                         gp_read_uint32(gpf, &beat->effect.tremolo_bar.num_points);
 361                         gp_read_unknown(gpf, beat->effect.tremolo_bar.num_points * 9);
 362                 }
 363
 364                 if (gpf->version >= 4.0) {
 365                         if (beat->effect.properties1 & GP_BEAT_EFFECT1_4_STROCKE_EFFECT) {
 366                                 gp_read_unknown(gpf, 1);
 367                         }
 368                 } else {
 369                         if (beat->effect.properties1 & GP_BEAT_EFFECT1_TREMOLO_BAR) {
 370                                 gp_read_unknown(gpf, 5);
 371                         }
 372                 }
 373         }
 374
 375         if (beat->properties & GP_BEAT_PROPERTY_CHANGE)
 376         {
 377                 gp_read_uint8(gpf, &beat->change.new_instrument);
 378                 gp_read_uint8(gpf, &beat->change.new_volume);
 379                 gp_read_uint8(gpf, &beat->change.new_pan);
 380                 gp_read_uint8(gpf, &beat->change.new_chorus);
 381                 gp_read_uint8(gpf, &beat->change.new_reverb);
 382                 gp_read_uint8(gpf, &beat->change.new_phaser);
 383                 gp_read_uint8(gpf, &beat->change.new_tremolo);
 384                 gp_read_uint32(gpf, &beat->change.new_tempo);
 385                 if (beat->change.new_volume != 0xFF) gp_read_unknown(gpf, 1);
 386                 if (beat->change.new_pan != 0xFF) gp_read_unknown(gpf, 1);
 387                 if (beat->change.new_chorus != 0xFF) gp_read_unknown(gpf, 1);
 388                 if (beat->change.new_reverb != 0xFF) gp_read_unknown(gpf, 1);
 389                 if (beat->change.new_phaser != 0xFF) gp_read_unknown(gpf, 1);
 390                 if (beat->change.new_tremolo != 0xFF) gp_read_unknown(gpf, 1);
 391                 if (beat->change.new_tempo != -1) gp_read_unknown(gpf, 1);
 392
 393                 if (gpf->version >= 4.0) {
 394                         gp_read_unknown(gpf, 1);
 395                 }
 396         }
 397
 398         gp_read_uint8(gpf, &beat->strings_present);
 399
 400         for (i = 0; i < 7; i++)
 401         {
 402                 struct gp_note *n = &beat->notes[i];
 403
 404                 if (!(beat->strings_present & (1 << i))) continue;
 405
 406                 gp_read_uint8(gpf, &n->properties);
 407
 408                 if (n->properties & GP_NOTE_PROPERTY_ALTERATION) {
 409                         gp_read_uint8(gpf, &n->alteration);
 410                 } else {
 411                         n->alteration = 0;
 412                 }
 413
 414                 if (n->properties & GP_NOTE_PROPERTY_DURATION_SPECIAL) {
 415                         gp_read_uint8(gpf, &n->duration);
 416                         gp_read_unknown(gpf, 1);
 417                 } else {
 418                         n->duration = beat->duration;
 419                 }
 420
 421                 if (n->properties & GP_NOTE_PROPERTY_NUANCE_CHANGE) {
 422                         gp_read_uint8(gpf, &n->new_nuance);
 423                 }
 424
 425                 if (n->properties & GP_NOTE_PROPERTY_ALTERATION) {
 426                         gp_read_uint8(gpf, &n->value);
 427                 }
 428
 429                 if (n->properties & GP_NOTE_PROPERTY_FINGERING) {
 430                         gp_read_uint8(gpf, &n->fingering.left_hand);
 431                         gp_read_uint8(gpf, &n->fingering.right_hand);
 432                 }
 433
 434                 if (n->properties & GP_NOTE_PROPERTY_EFFECT) {
 435                         gp_read_uint8(gpf, &n->effect.properties1);
 436
 437                         if (gpf->version >= 4.0) {
 438                                 gp_read_uint8(gpf, &n->effect.properties2);
 439                         } else {
 440                                 n->effect.properties2 = 0;
 441                         }
 442
 443                         if (n->effect.properties1 & GP_NOTE_EFFECT1_BEND) {
 444                                 int k;
 445                                 gp_read_unknown(gpf, 5);
 446                                 gp_read_uint32(gpf, &n->effect.bend.num_points);
 447                                 n->effect.bend.points = malloc_p(struct gp_note_effect_bend_point, n->effect.bend.num_points);
 448                                 for (k = 0; k < n->effect.bend.num_points; k++)
 449                                 {
 450                                         gp_read_unknown(gpf, 4);
 451                                         gp_read_uint32(gpf, &n->effect.bend.points[k].pitch);
 452                                         gp_read_unknown(gpf, 1);
 453                                 }
 454                         }
 455
 456                         if (n->effect.properties1 & GP_NOTE_EFFECT1_APPOGIATURE)
 457                         {
 458                                 gp_read_uint8(gpf, &n->effect.appogiature.previous_note);
 459                                 gp_read_unknown(gpf, 1);
 460                                 gp_read_uint8(gpf, &n->effect.appogiature.transition);
 461                                 gp_read_uint8(gpf, &n->effect.appogiature.duration);
 462                         }
 463
 464                         if (n->effect.properties2 & GP_NOTE_EFFECT2_TREMOLO_PICKING)
 465                         {
 466                                 gp_read_uint8(gpf, &n->effect.tremolo_picking.duration);
 467                         }
 468
 469                         if (n->effect.properties2 & GP_NOTE_EFFECT2_SLIDE)
 470                         {
 471                                 gp_read_uint8(gpf, &n->effect.slide.type);
 472                         }
 473
 474                         if (n->effect.properties2 & GP_NOTE_EFFECT2_HARMONIC)
 475                         {
 476                                 gp_read_uint8(gpf, &n->effect.harmonic.type);
 477                         }
 478
 479                         if (n->effect.properties2 & GP_NOTE_EFFECT2_TRILL)
 480                         {
 481                                 gp_read_uint8(gpf, &n->effect.trill.note_value);
 482                                 gp_read_uint8(gpf, &n->effect.trill.frequency);
 483                         }
 484                 }
 485         }
 486 }
 487
 488 static void gp_read_data(struct gpf *gpf)
 489 {
 490         uint32_t i, j, k;
 491         for (i = 0; i < gpf->num_bars; i++)
 492         {
 493                 gpf->bars[i].tracks = malloc_p(struct gp_bar_track, gpf->num_tracks);
 494                 for (j = 0; j < gpf->num_tracks; j++)
 495                 {
 496                         gp_read_uint32(gpf, &gpf->bars[i].tracks[j].num_beats);
 497                         gpf->bars[i].tracks[j].beats = malloc_p(struct gp_beat, gpf->bars[i].tracks[j].num_beats);
 498                         for (k = 0; k < gpf->bars[i].tracks[j].num_beats; k++)
 499                         {
 500                                 gp_read_beat(gpf, &gpf->bars[i].tracks[j].beats[k]);
 501                         }
 502                 }
 503         }
 504 }
 505
 506 static double find_version(const char *name)
 507 {
 508         int i;
 509         for(i = strlen(name)-1; isdigit(name[i]) || name[i] == '.'; i--);
 510
 511         return atof(name+i+1);
 512 }
 513
 514 struct gpf *gp_read_file(const char *filename)
 515 {
 516
 517         struct gpf *gpf = malloc_p(struct gpf, 1);
 518         gpf->fd = open(filename, O_RDONLY);
 519
 520         if (gpf->fd < 0) {
 521                 return NULL;
 522         }
 523
 524         gp_read_string(gpf, &gpf->version_string);
 525         gpf->version = find_version(gpf->version_string);
 526
 527         gp_read_unknown(gpf, 6);
 528
 529         gp_read_header(gpf);
 530
 531         gp_read_lyrics(gpf);
 532
 533         gp_read_uint32(gpf, &gpf->bpm);
 534
 535         if (gpf->version >= 4.0) {
 536                 gp_read_unknown(gpf, 5);
 537         } else if(gpf->version >= 3.0) {
 538                 gp_read_unknown(gpf, 4);
 539         } else {
 540                 gp_read_unknown(gpf, 8);
 541         }
 542
 543         gp_read_instruments(gpf);
 544
 545         gp_read_uint32(gpf, &gpf->num_bars);
 546
 547         if (gpf->version >= 3.0)
 548         {
 549                 gp_read_uint32(gpf, &gpf->num_tracks);
 550         } else {
 551                 gpf->num_tracks = 8;
 552         }
 553
 554         gp_read_bars(gpf);
 555
 556         gp_read_tracks(gpf);
 557
 558         gp_read_data(gpf);
 559
 560         gp_read_unknown(gpf, 2);
 561
 562         return gpf;
 563 }
 564
 565 void gp_free(struct gpf *ret)
 566 {
 567         /* FIXME */
 568         free(ret);
 569 }