/[svn]/libgig/trunk/src/gig.cpp
ViewVC logotype

Diff of /libgig/trunk/src/gig.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 27 by schoenebeck, Thu Jan 1 23:46:41 2004 UTC revision 269 by schoenebeck, Fri Oct 8 17:25:28 2004 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file loader library    *   *   libgig - C++ cross-platform Gigasampler format file loader library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003 by Christian Schoenebeck                           *   *   Copyright (C) 2003, 2004 by Christian Schoenebeck                     *
6   *                         <cuse@users.sourceforge.net>                    *   *                               <cuse@users.sourceforge.net>              *
7   *                                                                         *   *                                                                         *
8   *   This library is free software; you can redistribute it and/or modify  *   *   This library is free software; you can redistribute it and/or modify  *
9   *   it under the terms of the GNU General Public License as published by  *   *   it under the terms of the GNU General Public License as published by  *
# Line 680  namespace gig { Line 680  namespace gig {
680          if (!pVelocityTables) pVelocityTables = new VelocityTableMap;          if (!pVelocityTables) pVelocityTables = new VelocityTableMap;
681    
682          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);
683          _3ewa->ReadInt32(); // unknown, allways 0x0000008C ?          _3ewa->ReadInt32(); // unknown, always 0x0000008C ?
684          LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());          LFO3Frequency = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
685          EG3Attack     = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());          EG3Attack     = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
686          _3ewa->ReadInt16(); // unknown          _3ewa->ReadInt16(); // unknown
# Line 696  namespace gig { Line 696  namespace gig {
696          _3ewa->ReadInt16(); // unknown          _3ewa->ReadInt16(); // unknown
697          EG1Sustain          = _3ewa->ReadUint16();          EG1Sustain          = _3ewa->ReadUint16();
698          EG1Release          = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());          EG1Release          = (double) GIG_EXP_DECODE(_3ewa->ReadInt32());
699          EG1Controller       = static_cast<eg1_ctrl_t>(_3ewa->ReadUint8());          EG1Controller       = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
700          uint8_t eg1ctrloptions        = _3ewa->ReadUint8();          uint8_t eg1ctrloptions        = _3ewa->ReadUint8();
701          EG1ControllerInvert           = eg1ctrloptions & 0x01;          EG1ControllerInvert           = eg1ctrloptions & 0x01;
702          EG1ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg1ctrloptions);          EG1ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg1ctrloptions);
703          EG1ControllerDecayInfluence   = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg1ctrloptions);          EG1ControllerDecayInfluence   = GIG_EG_CTR_DECAY_INFLUENCE_EXTRACT(eg1ctrloptions);
704          EG1ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg1ctrloptions);          EG1ControllerReleaseInfluence = GIG_EG_CTR_RELEASE_INFLUENCE_EXTRACT(eg1ctrloptions);
705          EG2Controller       = static_cast<eg2_ctrl_t>(_3ewa->ReadUint8());          EG2Controller       = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
706          uint8_t eg2ctrloptions        = _3ewa->ReadUint8();          uint8_t eg2ctrloptions        = _3ewa->ReadUint8();
707          EG2ControllerInvert           = eg2ctrloptions & 0x01;          EG2ControllerInvert           = eg2ctrloptions & 0x01;
708          EG2ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg2ctrloptions);          EG2ControllerAttackInfluence  = GIG_EG_CTR_ATTACK_INFLUENCE_EXTRACT(eg2ctrloptions);
# Line 764  namespace gig { Line 764  namespace gig {
764              ReleaseVelocityResponseDepth = 0;              ReleaseVelocityResponseDepth = 0;
765          }          }
766          VelocityResponseCurveScaling = _3ewa->ReadUint8();          VelocityResponseCurveScaling = _3ewa->ReadUint8();
767          AttenuationControlTreshold   = _3ewa->ReadInt8();          AttenuationControllerThreshold = _3ewa->ReadInt8();
768          _3ewa->ReadInt32(); // unknown          _3ewa->ReadInt32(); // unknown
769          SampleStartOffset = (uint16_t) _3ewa->ReadInt16();          SampleStartOffset = (uint16_t) _3ewa->ReadInt16();
770          _3ewa->ReadInt16(); // unknown          _3ewa->ReadInt16(); // unknown
# Line 774  namespace gig { Line 774  namespace gig {
774          else if (pitchTrackDimensionBypass & 0x20) DimensionBypass = dim_bypass_ctrl_95;          else if (pitchTrackDimensionBypass & 0x20) DimensionBypass = dim_bypass_ctrl_95;
775          else                                       DimensionBypass = dim_bypass_ctrl_none;          else                                       DimensionBypass = dim_bypass_ctrl_none;
776          uint8_t pan = _3ewa->ReadUint8();          uint8_t pan = _3ewa->ReadUint8();
777          Pan         = (pan < 64) ? pan : (-1) * (int8_t)pan - 63;          Pan         = (pan < 64) ? pan : -((int)pan - 63); // signed 7 bit -> signed 8 bit
778          SelfMask = _3ewa->ReadInt8() & 0x01;          SelfMask = _3ewa->ReadInt8() & 0x01;
779          _3ewa->ReadInt8(); // unknown          _3ewa->ReadInt8(); // unknown
780          uint8_t lfo3ctrl = _3ewa->ReadUint8();          uint8_t lfo3ctrl = _3ewa->ReadUint8();
781          LFO3Controller           = static_cast<lfo3_ctrl_t>(lfo3ctrl & 0x07); // lower 3 bits          LFO3Controller           = static_cast<lfo3_ctrl_t>(lfo3ctrl & 0x07); // lower 3 bits
782          LFO3Sync                 = lfo3ctrl & 0x20; // bit 5          LFO3Sync                 = lfo3ctrl & 0x20; // bit 5
783          InvertAttenuationControl = lfo3ctrl & 0x80; // bit 7          InvertAttenuationController = lfo3ctrl & 0x80; // bit 7
784          if (VCFType == vcf_type_lowpass) {          if (VCFType == vcf_type_lowpass) {
785              if (lfo3ctrl & 0x40) // bit 6              if (lfo3ctrl & 0x40) // bit 6
786                  VCFType = vcf_type_lowpassturbo;                  VCFType = vcf_type_lowpassturbo;
787          }          }
788          AttenuationControl = static_cast<attenuation_ctrl_t>(_3ewa->ReadUint8());          AttenuationController  = DecodeLeverageController(static_cast<_lev_ctrl_t>(_3ewa->ReadUint8()));
789          uint8_t lfo2ctrl       = _3ewa->ReadUint8();          uint8_t lfo2ctrl       = _3ewa->ReadUint8();
790          LFO2Controller         = static_cast<lfo2_ctrl_t>(lfo2ctrl & 0x07); // lower 3 bits          LFO2Controller         = static_cast<lfo2_ctrl_t>(lfo2ctrl & 0x07); // lower 3 bits
791          LFO2FlipPhase          = lfo2ctrl & 0x80; // bit 7          LFO2FlipPhase          = lfo2ctrl & 0x80; // bit 7
# Line 841  namespace gig { Line 841  namespace gig {
841                  case curve_type_nonlinear:                  case curve_type_nonlinear:
842                      for (int velocity = 0; velocity < 128; velocity++) {                      for (int velocity = 0; velocity < 128; velocity++) {
843                          pVelocityAttenuationTable[velocity] =                          pVelocityAttenuationTable[velocity] =
844                              GIG_VELOCITY_TRANSFORM_NONLINEAR((double)(velocity+1),(double)(VelocityResponseDepth+1),(double)VelocityResponseCurveScaling);                              GIG_VELOCITY_TRANSFORM_NONLINEAR(((double)velocity),((double)VelocityResponseDepth),((double)VelocityResponseCurveScaling));
845                          if      (pVelocityAttenuationTable[velocity] > 1.0) pVelocityAttenuationTable[velocity] = 1.0;                          if      (pVelocityAttenuationTable[velocity] > 1.0)   pVelocityAttenuationTable[velocity] = 1.0;
846                          else if (pVelocityAttenuationTable[velocity] < 0.0) pVelocityAttenuationTable[velocity] = 0.0;                          else if (pVelocityAttenuationTable[velocity] < 1e-15) pVelocityAttenuationTable[velocity] = 0.0;
847                       }                       }
848                       break;                       break;
849                  case curve_type_linear:                  case curve_type_linear:
850                      for (int velocity = 0; velocity < 128; velocity++) {                      for (int velocity = 0; velocity < 128; velocity++) {
851                          pVelocityAttenuationTable[velocity] =                          pVelocityAttenuationTable[velocity] =
852                              GIG_VELOCITY_TRANSFORM_LINEAR((double)velocity,(double)(VelocityResponseDepth+1),(double)VelocityResponseCurveScaling);                              GIG_VELOCITY_TRANSFORM_LINEAR(((double)velocity),((double)VelocityResponseDepth),((double)VelocityResponseCurveScaling));
853                          if      (pVelocityAttenuationTable[velocity] > 1.0) pVelocityAttenuationTable[velocity] = 1.0;                          if      (pVelocityAttenuationTable[velocity] > 1.0)   pVelocityAttenuationTable[velocity] = 1.0;
854                          else if (pVelocityAttenuationTable[velocity] < 0.0) pVelocityAttenuationTable[velocity] = 0.0;                          else if (pVelocityAttenuationTable[velocity] < 1e-15) pVelocityAttenuationTable[velocity] = 0.0;
855                      }                      }
856                      break;                      break;
857                  case curve_type_special:                  case curve_type_special:
858                      for (int velocity = 0; velocity < 128; velocity++) {                      for (int velocity = 0; velocity < 128; velocity++) {
859                          pVelocityAttenuationTable[velocity] =                          pVelocityAttenuationTable[velocity] =
860                              GIG_VELOCITY_TRANSFORM_SPECIAL((double)(velocity+1),(double)(VelocityResponseDepth+1),(double)VelocityResponseCurveScaling);                              GIG_VELOCITY_TRANSFORM_SPECIAL(((double)velocity),((double)VelocityResponseDepth),((double)VelocityResponseCurveScaling));
861                          if      (pVelocityAttenuationTable[velocity] > 1.0) pVelocityAttenuationTable[velocity] = 1.0;                          if      (pVelocityAttenuationTable[velocity] > 1.0)   pVelocityAttenuationTable[velocity] = 1.0;
862                          else if (pVelocityAttenuationTable[velocity] < 0.0) pVelocityAttenuationTable[velocity] = 0.0;                          else if (pVelocityAttenuationTable[velocity] < 1e-15) pVelocityAttenuationTable[velocity] = 0.0;
863                      }                      }
864                      break;                      break;
865                  case curve_type_unknown:                  case curve_type_unknown:
# Line 870  namespace gig { Line 870  namespace gig {
870          }          }
871      }      }
872    
873        leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
874            leverage_ctrl_t decodedcontroller;
875            switch (EncodedController) {
876                // special controller
877                case _lev_ctrl_none:
878                    decodedcontroller.type = leverage_ctrl_t::type_none;
879                    decodedcontroller.controller_number = 0;
880                    break;
881                case _lev_ctrl_velocity:
882                    decodedcontroller.type = leverage_ctrl_t::type_velocity;
883                    decodedcontroller.controller_number = 0;
884                    break;
885                case _lev_ctrl_channelaftertouch:
886                    decodedcontroller.type = leverage_ctrl_t::type_channelaftertouch;
887                    decodedcontroller.controller_number = 0;
888                    break;
889    
890                // ordinary MIDI control change controller
891                case _lev_ctrl_modwheel:
892                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
893                    decodedcontroller.controller_number = 1;
894                    break;
895                case _lev_ctrl_breath:
896                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
897                    decodedcontroller.controller_number = 2;
898                    break;
899                case _lev_ctrl_foot:
900                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
901                    decodedcontroller.controller_number = 4;
902                    break;
903                case _lev_ctrl_effect1:
904                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
905                    decodedcontroller.controller_number = 12;
906                    break;
907                case _lev_ctrl_effect2:
908                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
909                    decodedcontroller.controller_number = 13;
910                    break;
911                case _lev_ctrl_genpurpose1:
912                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
913                    decodedcontroller.controller_number = 16;
914                    break;
915                case _lev_ctrl_genpurpose2:
916                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
917                    decodedcontroller.controller_number = 17;
918                    break;
919                case _lev_ctrl_genpurpose3:
920                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
921                    decodedcontroller.controller_number = 18;
922                    break;
923                case _lev_ctrl_genpurpose4:
924                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
925                    decodedcontroller.controller_number = 19;
926                    break;
927                case _lev_ctrl_portamentotime:
928                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
929                    decodedcontroller.controller_number = 5;
930                    break;
931                case _lev_ctrl_sustainpedal:
932                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
933                    decodedcontroller.controller_number = 64;
934                    break;
935                case _lev_ctrl_portamento:
936                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
937                    decodedcontroller.controller_number = 65;
938                    break;
939                case _lev_ctrl_sostenutopedal:
940                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
941                    decodedcontroller.controller_number = 66;
942                    break;
943                case _lev_ctrl_softpedal:
944                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
945                    decodedcontroller.controller_number = 67;
946                    break;
947                case _lev_ctrl_genpurpose5:
948                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
949                    decodedcontroller.controller_number = 80;
950                    break;
951                case _lev_ctrl_genpurpose6:
952                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
953                    decodedcontroller.controller_number = 81;
954                    break;
955                case _lev_ctrl_genpurpose7:
956                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
957                    decodedcontroller.controller_number = 82;
958                    break;
959                case _lev_ctrl_genpurpose8:
960                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
961                    decodedcontroller.controller_number = 83;
962                    break;
963                case _lev_ctrl_effect1depth:
964                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
965                    decodedcontroller.controller_number = 91;
966                    break;
967                case _lev_ctrl_effect2depth:
968                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
969                    decodedcontroller.controller_number = 92;
970                    break;
971                case _lev_ctrl_effect3depth:
972                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
973                    decodedcontroller.controller_number = 93;
974                    break;
975                case _lev_ctrl_effect4depth:
976                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
977                    decodedcontroller.controller_number = 94;
978                    break;
979                case _lev_ctrl_effect5depth:
980                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
981                    decodedcontroller.controller_number = 95;
982                    break;
983    
984                // unknown controller type
985                default:
986                    throw gig::Exception("Unknown leverage controller type.");
987            }
988            return decodedcontroller;
989        }
990    
991      DimensionRegion::~DimensionRegion() {      DimensionRegion::~DimensionRegion() {
992          Instances--;          Instances--;
993          if (!Instances) {          if (!Instances) {
# Line 893  namespace gig { Line 1011  namespace gig {
1011       * triggered to get the volume with which the sample should be played       * triggered to get the volume with which the sample should be played
1012       * back.       * back.
1013       *       *
1014       * @param    MIDI velocity value of the triggered key (between 0 and 127)       * @param MIDIKeyVelocity  MIDI velocity value of the triggered key (between 0 and 127)
1015       * @returns  amplitude factor (between 0.0 and 1.0)       * @returns                amplitude factor (between 0.0 and 1.0)
1016       */       */
1017      double DimensionRegion::GetVelocityAttenuation(uint8_t MIDIKeyVelocity) {      double DimensionRegion::GetVelocityAttenuation(uint8_t MIDIKeyVelocity) {
1018          return pVelocityAttenuationTable[MIDIKeyVelocity];          return pVelocityAttenuationTable[MIDIKeyVelocity];
# Line 935  namespace gig { Line 1053  namespace gig {
1053                      pDimensionDefinitions[i].bits      = bits;                      pDimensionDefinitions[i].bits      = bits;
1054                      pDimensionDefinitions[i].zones     = 0x01 << bits; // = pow(2,bits)                      pDimensionDefinitions[i].zones     = 0x01 << bits; // = pow(2,bits)
1055                      pDimensionDefinitions[i].split_type = (dimension == dimension_layer ||                      pDimensionDefinitions[i].split_type = (dimension == dimension_layer ||
1056                                                             dimension == dimension_samplechannel) ? split_type_bit                                                             dimension == dimension_samplechannel ||
1057                                                                                                   : split_type_normal;                                                             dimension == dimension_releasetrigger) ? split_type_bit
1058                                                                                                      : split_type_normal;
1059                      pDimensionDefinitions[i].ranges = NULL; // it's not possible to check velocity dimensions for custom defined ranges at this point                      pDimensionDefinitions[i].ranges = NULL; // it's not possible to check velocity dimensions for custom defined ranges at this point
1060                      pDimensionDefinitions[i].zone_size  =                      pDimensionDefinitions[i].zone_size  =
1061                          (pDimensionDefinitions[i].split_type == split_type_normal) ? 128 / pDimensionDefinitions[i].zones                          (pDimensionDefinitions[i].split_type == split_type_normal) ? 128 / pDimensionDefinitions[i].zones
# Line 1034  namespace gig { Line 1153  namespace gig {
1153       * @see             Dimensions       * @see             Dimensions
1154       */       */
1155      DimensionRegion* Region::GetDimensionRegionByValue(uint Dim4Val, uint Dim3Val, uint Dim2Val, uint Dim1Val, uint Dim0Val) {      DimensionRegion* Region::GetDimensionRegionByValue(uint Dim4Val, uint Dim3Val, uint Dim2Val, uint Dim1Val, uint Dim0Val) {
1156          unsigned int bits[5] = {Dim0Val,Dim1Val,Dim2Val,Dim3Val,Dim4Val};          uint8_t bits[5] = {Dim0Val,Dim1Val,Dim2Val,Dim3Val,Dim4Val};
1157          for (uint i = 0; i < Dimensions; i++) {          for (uint i = 0; i < Dimensions; i++) {
1158              switch (pDimensionDefinitions[i].split_type) {              switch (pDimensionDefinitions[i].split_type) {
1159                  case split_type_normal:                  case split_type_normal:
# Line 1043  namespace gig { Line 1162  namespace gig {
1162                  case split_type_customvelocity:                  case split_type_customvelocity:
1163                      bits[i] = VelocityTable[bits[i]];                      bits[i] = VelocityTable[bits[i]];
1164                      break;                      break;
1165                  // else the value is already the sought dimension bit number                  case split_type_bit: // the value is already the sought dimension bit number
1166                        const uint8_t limiter_mask = (0xff << pDimensionDefinitions[i].bits) ^ 0xff;
1167                        bits[i] = bits[i] & limiter_mask; // just make sure the value don't uses more bits than allowed
1168                        break;
1169              }              }
1170          }          }
1171          return GetDimensionRegionByBit(bits[4],bits[3],bits[2],bits[1],bits[0]);          return GetDimensionRegionByBit(bits[4],bits[3],bits[2],bits[1],bits[0]);
Legend:
Removed from v.27  
changed lines
  Added in v.269
  ViewVC Help
Powered by ViewVC