/[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 2482 by schoenebeck, Mon Nov 25 02:22:38 2013 UTC revision 2547 by schoenebeck, Tue May 13 11:17:24 2014 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file access library    *   *   libgig - C++ cross-platform Gigasampler format file access library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2013 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2014 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  *
# Line 581  namespace { Line 581  namespace {
581          // update '3gix' chunk          // update '3gix' chunk
582          pData = (uint8_t*) pCk3gix->LoadChunkData();          pData = (uint8_t*) pCk3gix->LoadChunkData();
583          store16(&pData[0], iSampleGroup);          store16(&pData[0], iSampleGroup);
584    
585            // if the library user toggled the "Compressed" attribute from true to
586            // false, then the EWAV chunk associated with compressed samples needs
587            // to be deleted
588            RIFF::Chunk* ewav = pWaveList->GetSubChunk(CHUNK_ID_EWAV);
589            if (ewav && !Compressed) {
590                pWaveList->DeleteSubChunk(ewav);
591            }
592      }      }
593    
594      /// Scans compressed samples for mandatory informations (e.g. actual number of total sample points).      /// Scans compressed samples for mandatory informations (e.g. actual number of total sample points).
# Line 1700  namespace { Line 1708  namespace {
1708          //NOTE: copy code copied from assignment constructor above, see comment there as well          //NOTE: copy code copied from assignment constructor above, see comment there as well
1709                    
1710          *this = *orig; // default memberwise shallow copy of all parameters          *this = *orig; // default memberwise shallow copy of all parameters
1711            
1712            // restore members that shall not be altered
1713          pParentList = p; // restore the chunk pointer          pParentList = p; // restore the chunk pointer
1714            pRegion = pOriginalRegion;
1715                    
1716          // only take the raw sample reference & parent region reference if the          // only take the raw sample reference reference if the
1717          // two DimensionRegion objects are part of the same file          // two DimensionRegion objects are part of the same file
1718          if (pOriginalRegion->GetParent()->GetParent() != orig->pRegion->GetParent()->GetParent()) {          if (pOriginalRegion->GetParent()->GetParent() != orig->pRegion->GetParent()->GetParent()) {
             pRegion = pOriginalRegion;  
1719              pSample = pOriginalSample;              pSample = pOriginalSample;
1720          }          }
1721                    
# Line 2079  namespace { Line 2089  namespace {
2089          return pRegion;          return pRegion;
2090      }      }
2091    
2092    // show error if some _lev_ctrl_* enum entry is not listed in the following function
2093    // (commented out for now, because "diagnostic push" not supported prior GCC 4.6)
2094    // TODO: uncomment and add a GCC version check (see also commented "#pragma GCC diagnostic pop" below)
2095    //#pragma GCC diagnostic push
2096    //#pragma GCC diagnostic error "-Wswitch"
2097    
2098      leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {      leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
2099          leverage_ctrl_t decodedcontroller;          leverage_ctrl_t decodedcontroller;
2100          switch (EncodedController) {          switch (EncodedController) {
# Line 2190  namespace { Line 2206  namespace {
2206                  decodedcontroller.controller_number = 95;                  decodedcontroller.controller_number = 95;
2207                  break;                  break;
2208    
2209                // format extension (these controllers are so far only supported by
2210                // LinuxSampler & gigedit) they will *NOT* work with
2211                // Gigasampler/GigaStudio !
2212                case _lev_ctrl_CC3_EXT:
2213                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2214                    decodedcontroller.controller_number = 3;
2215                    break;
2216                case _lev_ctrl_CC6_EXT:
2217                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2218                    decodedcontroller.controller_number = 6;
2219                    break;
2220                case _lev_ctrl_CC7_EXT:
2221                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2222                    decodedcontroller.controller_number = 7;
2223                    break;
2224                case _lev_ctrl_CC8_EXT:
2225                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2226                    decodedcontroller.controller_number = 8;
2227                    break;
2228                case _lev_ctrl_CC9_EXT:
2229                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2230                    decodedcontroller.controller_number = 9;
2231                    break;
2232                case _lev_ctrl_CC10_EXT:
2233                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2234                    decodedcontroller.controller_number = 10;
2235                    break;
2236                case _lev_ctrl_CC11_EXT:
2237                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2238                    decodedcontroller.controller_number = 11;
2239                    break;
2240                case _lev_ctrl_CC14_EXT:
2241                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2242                    decodedcontroller.controller_number = 14;
2243                    break;
2244                case _lev_ctrl_CC15_EXT:
2245                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2246                    decodedcontroller.controller_number = 15;
2247                    break;
2248                case _lev_ctrl_CC20_EXT:
2249                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2250                    decodedcontroller.controller_number = 20;
2251                    break;
2252                case _lev_ctrl_CC21_EXT:
2253                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2254                    decodedcontroller.controller_number = 21;
2255                    break;
2256                case _lev_ctrl_CC22_EXT:
2257                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2258                    decodedcontroller.controller_number = 22;
2259                    break;
2260                case _lev_ctrl_CC23_EXT:
2261                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2262                    decodedcontroller.controller_number = 23;
2263                    break;
2264                case _lev_ctrl_CC24_EXT:
2265                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2266                    decodedcontroller.controller_number = 24;
2267                    break;
2268                case _lev_ctrl_CC25_EXT:
2269                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2270                    decodedcontroller.controller_number = 25;
2271                    break;
2272                case _lev_ctrl_CC26_EXT:
2273                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2274                    decodedcontroller.controller_number = 26;
2275                    break;
2276                case _lev_ctrl_CC27_EXT:
2277                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2278                    decodedcontroller.controller_number = 27;
2279                    break;
2280                case _lev_ctrl_CC28_EXT:
2281                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2282                    decodedcontroller.controller_number = 28;
2283                    break;
2284                case _lev_ctrl_CC29_EXT:
2285                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2286                    decodedcontroller.controller_number = 29;
2287                    break;
2288                case _lev_ctrl_CC30_EXT:
2289                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2290                    decodedcontroller.controller_number = 30;
2291                    break;
2292                case _lev_ctrl_CC31_EXT:
2293                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2294                    decodedcontroller.controller_number = 31;
2295                    break;
2296                case _lev_ctrl_CC68_EXT:
2297                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2298                    decodedcontroller.controller_number = 68;
2299                    break;
2300                case _lev_ctrl_CC69_EXT:
2301                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2302                    decodedcontroller.controller_number = 69;
2303                    break;
2304                case _lev_ctrl_CC70_EXT:
2305                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2306                    decodedcontroller.controller_number = 70;
2307                    break;
2308                case _lev_ctrl_CC71_EXT:
2309                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2310                    decodedcontroller.controller_number = 71;
2311                    break;
2312                case _lev_ctrl_CC72_EXT:
2313                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2314                    decodedcontroller.controller_number = 72;
2315                    break;
2316                case _lev_ctrl_CC73_EXT:
2317                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2318                    decodedcontroller.controller_number = 73;
2319                    break;
2320                case _lev_ctrl_CC74_EXT:
2321                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2322                    decodedcontroller.controller_number = 74;
2323                    break;
2324                case _lev_ctrl_CC75_EXT:
2325                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2326                    decodedcontroller.controller_number = 75;
2327                    break;
2328                case _lev_ctrl_CC76_EXT:
2329                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2330                    decodedcontroller.controller_number = 76;
2331                    break;
2332                case _lev_ctrl_CC77_EXT:
2333                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2334                    decodedcontroller.controller_number = 77;
2335                    break;
2336                case _lev_ctrl_CC78_EXT:
2337                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2338                    decodedcontroller.controller_number = 78;
2339                    break;
2340                case _lev_ctrl_CC79_EXT:
2341                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2342                    decodedcontroller.controller_number = 79;
2343                    break;
2344                case _lev_ctrl_CC84_EXT:
2345                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2346                    decodedcontroller.controller_number = 84;
2347                    break;
2348                case _lev_ctrl_CC85_EXT:
2349                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2350                    decodedcontroller.controller_number = 85;
2351                    break;
2352                case _lev_ctrl_CC86_EXT:
2353                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2354                    decodedcontroller.controller_number = 86;
2355                    break;
2356                case _lev_ctrl_CC87_EXT:
2357                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2358                    decodedcontroller.controller_number = 87;
2359                    break;
2360                case _lev_ctrl_CC89_EXT:
2361                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2362                    decodedcontroller.controller_number = 89;
2363                    break;
2364                case _lev_ctrl_CC90_EXT:
2365                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2366                    decodedcontroller.controller_number = 90;
2367                    break;
2368                case _lev_ctrl_CC96_EXT:
2369                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2370                    decodedcontroller.controller_number = 96;
2371                    break;
2372                case _lev_ctrl_CC97_EXT:
2373                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2374                    decodedcontroller.controller_number = 97;
2375                    break;
2376                case _lev_ctrl_CC102_EXT:
2377                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2378                    decodedcontroller.controller_number = 102;
2379                    break;
2380                case _lev_ctrl_CC103_EXT:
2381                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2382                    decodedcontroller.controller_number = 103;
2383                    break;
2384                case _lev_ctrl_CC104_EXT:
2385                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2386                    decodedcontroller.controller_number = 104;
2387                    break;
2388                case _lev_ctrl_CC105_EXT:
2389                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2390                    decodedcontroller.controller_number = 105;
2391                    break;
2392                case _lev_ctrl_CC106_EXT:
2393                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2394                    decodedcontroller.controller_number = 106;
2395                    break;
2396                case _lev_ctrl_CC107_EXT:
2397                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2398                    decodedcontroller.controller_number = 107;
2399                    break;
2400                case _lev_ctrl_CC108_EXT:
2401                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2402                    decodedcontroller.controller_number = 108;
2403                    break;
2404                case _lev_ctrl_CC109_EXT:
2405                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2406                    decodedcontroller.controller_number = 109;
2407                    break;
2408                case _lev_ctrl_CC110_EXT:
2409                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2410                    decodedcontroller.controller_number = 110;
2411                    break;
2412                case _lev_ctrl_CC111_EXT:
2413                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2414                    decodedcontroller.controller_number = 111;
2415                    break;
2416                case _lev_ctrl_CC112_EXT:
2417                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2418                    decodedcontroller.controller_number = 112;
2419                    break;
2420                case _lev_ctrl_CC113_EXT:
2421                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2422                    decodedcontroller.controller_number = 113;
2423                    break;
2424                case _lev_ctrl_CC114_EXT:
2425                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2426                    decodedcontroller.controller_number = 114;
2427                    break;
2428                case _lev_ctrl_CC115_EXT:
2429                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2430                    decodedcontroller.controller_number = 115;
2431                    break;
2432                case _lev_ctrl_CC116_EXT:
2433                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2434                    decodedcontroller.controller_number = 116;
2435                    break;
2436                case _lev_ctrl_CC117_EXT:
2437                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2438                    decodedcontroller.controller_number = 117;
2439                    break;
2440                case _lev_ctrl_CC118_EXT:
2441                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2442                    decodedcontroller.controller_number = 118;
2443                    break;
2444                case _lev_ctrl_CC119_EXT:
2445                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2446                    decodedcontroller.controller_number = 119;
2447                    break;
2448    
2449              // unknown controller type              // unknown controller type
2450              default:              default:
2451                  throw gig::Exception("Unknown leverage controller type.");                  throw gig::Exception("Unknown leverage controller type.");
2452          }          }
2453          return decodedcontroller;          return decodedcontroller;
2454      }      }
2455        
2456    // see above (diagnostic push not supported prior GCC 4.6)
2457    //#pragma GCC diagnostic pop
2458    
2459      DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) {      DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) {
2460          _lev_ctrl_t encodedcontroller;          _lev_ctrl_t encodedcontroller;
# Line 2283  namespace { Line 2542  namespace {
2542                      case 95:                      case 95:
2543                          encodedcontroller = _lev_ctrl_effect5depth;                          encodedcontroller = _lev_ctrl_effect5depth;
2544                          break;                          break;
2545    
2546                        // format extension (these controllers are so far only
2547                        // supported by LinuxSampler & gigedit) they will *NOT*
2548                        // work with Gigasampler/GigaStudio !
2549                        case 3:
2550                            encodedcontroller = _lev_ctrl_CC3_EXT;
2551                            break;
2552                        case 6:
2553                            encodedcontroller = _lev_ctrl_CC6_EXT;
2554                            break;
2555                        case 7:
2556                            encodedcontroller = _lev_ctrl_CC7_EXT;
2557                            break;
2558                        case 8:
2559                            encodedcontroller = _lev_ctrl_CC8_EXT;
2560                            break;
2561                        case 9:
2562                            encodedcontroller = _lev_ctrl_CC9_EXT;
2563                            break;
2564                        case 10:
2565                            encodedcontroller = _lev_ctrl_CC10_EXT;
2566                            break;
2567                        case 11:
2568                            encodedcontroller = _lev_ctrl_CC11_EXT;
2569                            break;
2570                        case 14:
2571                            encodedcontroller = _lev_ctrl_CC14_EXT;
2572                            break;
2573                        case 15:
2574                            encodedcontroller = _lev_ctrl_CC15_EXT;
2575                            break;
2576                        case 20:
2577                            encodedcontroller = _lev_ctrl_CC20_EXT;
2578                            break;
2579                        case 21:
2580                            encodedcontroller = _lev_ctrl_CC21_EXT;
2581                            break;
2582                        case 22:
2583                            encodedcontroller = _lev_ctrl_CC22_EXT;
2584                            break;
2585                        case 23:
2586                            encodedcontroller = _lev_ctrl_CC23_EXT;
2587                            break;
2588                        case 24:
2589                            encodedcontroller = _lev_ctrl_CC24_EXT;
2590                            break;
2591                        case 25:
2592                            encodedcontroller = _lev_ctrl_CC25_EXT;
2593                            break;
2594                        case 26:
2595                            encodedcontroller = _lev_ctrl_CC26_EXT;
2596                            break;
2597                        case 27:
2598                            encodedcontroller = _lev_ctrl_CC27_EXT;
2599                            break;
2600                        case 28:
2601                            encodedcontroller = _lev_ctrl_CC28_EXT;
2602                            break;
2603                        case 29:
2604                            encodedcontroller = _lev_ctrl_CC29_EXT;
2605                            break;
2606                        case 30:
2607                            encodedcontroller = _lev_ctrl_CC30_EXT;
2608                            break;
2609                        case 31:
2610                            encodedcontroller = _lev_ctrl_CC31_EXT;
2611                            break;
2612                        case 68:
2613                            encodedcontroller = _lev_ctrl_CC68_EXT;
2614                            break;
2615                        case 69:
2616                            encodedcontroller = _lev_ctrl_CC69_EXT;
2617                            break;
2618                        case 70:
2619                            encodedcontroller = _lev_ctrl_CC70_EXT;
2620                            break;
2621                        case 71:
2622                            encodedcontroller = _lev_ctrl_CC71_EXT;
2623                            break;
2624                        case 72:
2625                            encodedcontroller = _lev_ctrl_CC72_EXT;
2626                            break;
2627                        case 73:
2628                            encodedcontroller = _lev_ctrl_CC73_EXT;
2629                            break;
2630                        case 74:
2631                            encodedcontroller = _lev_ctrl_CC74_EXT;
2632                            break;
2633                        case 75:
2634                            encodedcontroller = _lev_ctrl_CC75_EXT;
2635                            break;
2636                        case 76:
2637                            encodedcontroller = _lev_ctrl_CC76_EXT;
2638                            break;
2639                        case 77:
2640                            encodedcontroller = _lev_ctrl_CC77_EXT;
2641                            break;
2642                        case 78:
2643                            encodedcontroller = _lev_ctrl_CC78_EXT;
2644                            break;
2645                        case 79:
2646                            encodedcontroller = _lev_ctrl_CC79_EXT;
2647                            break;
2648                        case 84:
2649                            encodedcontroller = _lev_ctrl_CC84_EXT;
2650                            break;
2651                        case 85:
2652                            encodedcontroller = _lev_ctrl_CC85_EXT;
2653                            break;
2654                        case 86:
2655                            encodedcontroller = _lev_ctrl_CC86_EXT;
2656                            break;
2657                        case 87:
2658                            encodedcontroller = _lev_ctrl_CC87_EXT;
2659                            break;
2660                        case 89:
2661                            encodedcontroller = _lev_ctrl_CC89_EXT;
2662                            break;
2663                        case 90:
2664                            encodedcontroller = _lev_ctrl_CC90_EXT;
2665                            break;
2666                        case 96:
2667                            encodedcontroller = _lev_ctrl_CC96_EXT;
2668                            break;
2669                        case 97:
2670                            encodedcontroller = _lev_ctrl_CC97_EXT;
2671                            break;
2672                        case 102:
2673                            encodedcontroller = _lev_ctrl_CC102_EXT;
2674                            break;
2675                        case 103:
2676                            encodedcontroller = _lev_ctrl_CC103_EXT;
2677                            break;
2678                        case 104:
2679                            encodedcontroller = _lev_ctrl_CC104_EXT;
2680                            break;
2681                        case 105:
2682                            encodedcontroller = _lev_ctrl_CC105_EXT;
2683                            break;
2684                        case 106:
2685                            encodedcontroller = _lev_ctrl_CC106_EXT;
2686                            break;
2687                        case 107:
2688                            encodedcontroller = _lev_ctrl_CC107_EXT;
2689                            break;
2690                        case 108:
2691                            encodedcontroller = _lev_ctrl_CC108_EXT;
2692                            break;
2693                        case 109:
2694                            encodedcontroller = _lev_ctrl_CC109_EXT;
2695                            break;
2696                        case 110:
2697                            encodedcontroller = _lev_ctrl_CC110_EXT;
2698                            break;
2699                        case 111:
2700                            encodedcontroller = _lev_ctrl_CC111_EXT;
2701                            break;
2702                        case 112:
2703                            encodedcontroller = _lev_ctrl_CC112_EXT;
2704                            break;
2705                        case 113:
2706                            encodedcontroller = _lev_ctrl_CC113_EXT;
2707                            break;
2708                        case 114:
2709                            encodedcontroller = _lev_ctrl_CC114_EXT;
2710                            break;
2711                        case 115:
2712                            encodedcontroller = _lev_ctrl_CC115_EXT;
2713                            break;
2714                        case 116:
2715                            encodedcontroller = _lev_ctrl_CC116_EXT;
2716                            break;
2717                        case 117:
2718                            encodedcontroller = _lev_ctrl_CC117_EXT;
2719                            break;
2720                        case 118:
2721                            encodedcontroller = _lev_ctrl_CC118_EXT;
2722                            break;
2723                        case 119:
2724                            encodedcontroller = _lev_ctrl_CC119_EXT;
2725                            break;
2726    
2727                      default:                      default:
2728                          throw gig::Exception("leverage controller number is not supported by the gig format");                          throw gig::Exception("leverage controller number is not supported by the gig format");
2729                  }                  }
# Line 2760  namespace { Line 3201  namespace {
3201       *                        dimension bits limit is violated       *                        dimension bits limit is violated
3202       */       */
3203      void Region::AddDimension(dimension_def_t* pDimDef) {      void Region::AddDimension(dimension_def_t* pDimDef) {
3204            // some initial sanity checks of the given dimension definition
3205            if (pDimDef->zones < 2)
3206                throw gig::Exception("Could not add new dimension, amount of requested zones must always be at least two");
3207            if (pDimDef->bits < 1)
3208                throw gig::Exception("Could not add new dimension, amount of requested requested zone bits must always be at least one");
3209            if (pDimDef->dimension == dimension_samplechannel) {
3210                if (pDimDef->zones != 2)
3211                    throw gig::Exception("Could not add new 'sample channel' dimensions, the requested amount of zones must always be 2 for this dimension type");
3212                if (pDimDef->bits != 1)
3213                    throw gig::Exception("Could not add new 'sample channel' dimensions, the requested amount of zone bits must always be 1 for this dimension type");
3214            }
3215    
3216          // check if max. amount of dimensions reached          // check if max. amount of dimensions reached
3217          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
3218          const int iMaxDimensions = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;          const int iMaxDimensions = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;
# Line 2935  namespace { Line 3388  namespace {
3388          if (pDimDef->dimension == dimension_layer) Layers = 1;          if (pDimDef->dimension == dimension_layer) Layers = 1;
3389      }      }
3390    
3391        /**
3392         * Searches in the current Region for a dimension of the given dimension
3393         * type and returns the precise configuration of that dimension in this
3394         * Region.
3395         *
3396         * @param type - dimension type of the sought dimension
3397         * @returns dimension definition or NULL if there is no dimension with
3398         *          sought type in this Region.
3399         */
3400        dimension_def_t* Region::GetDimensionDefinition(dimension_t type) {
3401            for (int i = 0; i < Dimensions; ++i)
3402                if (pDimensionDefinitions[i].dimension == type)
3403                    return &pDimensionDefinitions[i];
3404            return NULL;
3405        }
3406    
3407      Region::~Region() {      Region::~Region() {
3408          for (int i = 0; i < 256; i++) {          for (int i = 0; i < 256; i++) {
3409              if (pDimensionRegions[i]) delete pDimensionRegions[i];              if (pDimensionRegions[i]) delete pDimensionRegions[i];
# Line 4220  namespace { Line 4689  namespace {
4689          return NULL;          return NULL;
4690      }      }
4691    
4692        /**
4693         * Returns the group with the given group name.
4694         *
4695         * Note: group names don't have to be unique in the gig format! So there
4696         * can be multiple groups with the same name. This method will simply
4697         * return the first group found with the given name.
4698         *
4699         * @param name - name of the sought group
4700         * @returns sought group or NULL if there's no group with that name
4701         */
4702        Group* File::GetGroup(String name) {
4703            if (!pGroups) LoadGroups();
4704            GroupsIterator = pGroups->begin();
4705            for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i)
4706                if ((*GroupsIterator)->Name == name) return *GroupsIterator;
4707            return NULL;
4708        }
4709    
4710      Group* File::AddGroup() {      Group* File::AddGroup() {
4711          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
4712          // there must always be at least one group          // there must always be at least one group
Legend:
Removed from v.2482  
changed lines
  Added in v.2547
  ViewVC Help
Powered by ViewVC