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 * |
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 |
|
|
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) { |
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; |
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 |
} |
} |
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; |
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]; |
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 |