Help with Procyon Looping Function

[Ben Willow]

Hello,

I am trying to understand the looping function for the Procyon Editor.

I have read the instructions provided with the Software User?s Guide, but I do not understand why my sessions are turning out the way they do.

In the example below, I have written 5 basic segments, and entered (2, 3, 1) and (3, 4, 2) on the first and second lines of the Looping dialogue box.

From a practical session designing point of view, I would have expected (2, 3, 1) & (3, 4, 2) to mean : Start at segment 1, play 2 & 3, and repeat 2 & 3, once; then proceed to play 3 & 4, and repeat 3 & 4, twice; then continue to the end?

Thus expecting the following:

Start & play 1 2 3
Play first loop once 2 3
Continue 3 4
Play the second loop once 3 4
Play the second loop again 3 4
And continue to the end 5

resulting in the following 12 segment session:
1 2 3 2 3 3 4 3 4 3 4 5 (the empty spaces are included for clarity)

Instead of the expected sequence, I end up with a session running in the following sequence:

1 2 3 4
3 4
3
2 3 4
3 4
3 4 5

That is, a 15 segments session, as follows:
1 2 3 4 3 4 3 2 3 4 3 4 3 4 5

Could you please explain the concept, and also, what I should have entered in the Looping dialogue box, in order to generate the desired sequence of:
1 2 3 2 3 3 4 3 4 3 4 5 ?

Thank you

[Andy]

I'm not sure, but you may have created a nested loop.

Try:
3 4 2
2 3 1

You may not be able to have the same segment within different loops without it getting into a nesting situation, but I'll try and find out more.

-Andy.

[Ben Willow]

Andy,

thanks for your suggestion to reverse the order of the loops, but it does not work.

The User's Guide mentions that there can be multiple loops in a session, and they can overlap (nest), as long as they do not start on the same segment, which, in my example (2, 3, 1 ) & (3, 4, 2), they don't.

Essentially, I would appreciate a deeper explanation of the general concepts of using the looping function, than that provided in the User's Guide, especially in the light of designing sessions from intent - as in the simple example provided in the initial thread.

Thanks for looking into it. As usual, your help is much appreciated.

[Andy]

Hey Ben;

I'll look into this. I'm not much of a AVS programmer myself, but I'll see if I can figure it out.

If you don't hear back from me soon, send me a nudge...

-Andy.

[Andy]

Ok, Did some experimenting.

Seems that if any segment numbers match in the loop fields, then you get into a nested loop situation.

In your case, the loops are:

1

2
3 4
3 4
3

2
3 4
3 4
3

4
5

The 3/4 loop is nested inside the 2/3 loop.

One way to do what you want would be to put a "nothing" segment in at position #4, with the minimum time of 0.2 seconds.

So now your segments are:
1
2
3
4 (nothing)
5 (previously 4)
6 (previously 5)

Then set the loops to
2 3 1
5 6 2

You'll then get
1 2 3 2 3 4 5 6 5 6 5 6

The "nothing" 4 might cause a pause or glitch, so in the end it might be better to just repeat segments 2 and 3 again instead of using a loop.

Hopefully that makes some sort of sense. If not, then let me know and I'll try to explain better.

I think if you try my suggestions and experiment a bit yourself with the looping function, you'll see how it works. Since you cannot "disable" the nesting function, you will always get nested loops whenever a loop has a segment in it from another loop.

-Andy.

[Andy]

Update...

I was just informed by someone much more knowledgeable that the 4th segment should just be the same as segment #3, and what was 4 becomes #5, #5 becomes #6, then loop using:

2 3 1
4 5 2

and you'll get:
1

2 3
2 3

4 5 (old 3 + old 4)
4 5
4 5

6 (old 5)

Which I believe is what you wanted originally. (spaces and grouping added for clarity)

-Andy.

[Ben Willow]

Thanks for you reply, Andy,

Simple looping function is straight forward, and works fine if Starting at segment 2, for example, and Finishing at segment 32, for 32 times.
However, Starting at segment 2, and Finishing at segment 33 or above does not work (presently limited to 32), nor running 33 times or more (limited to 32x).

As for nested loops, from my perspective, the way they generate sessions is far from intuitive & straight.
Here's a practical example to illustrate from the perspective of a lay user (not an engineer or programmer, who understand the intricacies of loops).
Let's say I start with 8 segments and I wish to string/loop them to create the following session pattern:

Play segments 1, 2 & 3; (= 3 segments);
then play segments 2 & 3 once more; (= 2 segments);
then play segments 3 & 4 , 3 times; (= 6 segments);
then play segments 4, 5 & 6, 2 times; (= 6 segments);
and finish with segments 7 & 8; (= 2 segments).

It seems to me like a reasonable/straight forward way of designing a session.
Therefore, I would expect to see a session of 19 segments long (3+2+6+6+2), running as follows:
(1,2,3)+(2,3)+{(3,4),(3,4),(3,4)}+{(4,5,6),(4,5,6) }+(7,8).

It would seem "natural" to enter in the looping editor:
First loop on line 1, Start @ 2, Finish @ 3, 1 time;
Second loop on line 2, Start @ 3, Finish @ 4, 3 times;
Third loop on line 3, Start @ 4, Finish @ 6, 2 times.

However, when I do that, then run the session and examine the output, I notice it generates 64 segments instead of the expected 19.
The details of the session are as follows:
1,2,3,4,5,6,4,5,6,4,3,4,5,6,4,5,6,4,3,4,5,6,4,5,6, 4,3,2,3,4,5,6,4,5,6,4,3,4,5,6,4,5,6,4,3,4,5,6,4,5, 6,4,3,4,5,6,4,5,6,4,5,6,7,8.

I can see patterns and wrap my head around them, somewhat... and come up with "Ah! that's how it works... gee that's complicated!"

I guess my point is that even if it were mathematically correct, {that is, assuming there is no "mistake" in the looping function programming,
and that to generate the above 64 segments string, one must write the loops as I have done in the editor looping box}, from a lay person's point of view, you'd probably agree that it is not very intuitive nor user friendly.

If so, then redesigning the looping function from a practical point of view, more like a lay person would approach the creation of sessions by stringing segment blocks together, would seem to make more sense to me.

Failing that, I would appreciate a reference document explaining an even "clearer and easier" way of starting with those 8 sessions; and the general principles governing the way to enter the loops in the editor, in order to generate intuitive segment strings/patterns that create sessions one would have in mind, as in my example above.

Thanks,

ps. I will be out of town & away from pc's for the next 3~4 weeks...

[Andy]

No idea what kept me from responding to this message from so long ago. My apologies!

Play segments 1, 2 & 3; (= 3 segments);
then play segments 2 & 3 once more; (= 2 segments);
then play segments 3 & 4 , 3 times; (= 6 segments);
then play segments 4, 5 & 6, 2 times; (= 6 segments);
and finish with segments 7 & 8; (= 2 segments).

The simplest way to do all this is just as I've shown above. Don't allow any segments to overlap in the loops.

Double up segments that are in multiple loops. I will use letter to illustrate:
e.g. 3a and 3b are 2 segments that are just copies of each other.

For your example above just do this:

2 3a 1
3b 4a 3
4b 6 2


1 becomes 1
2 becomes 2
3a becomes 3
3b becomes 4 (same segment values as 3)
4a becomes 5
4b becomes 6 (same segment values as 5)
5 becomes 7
6 becomes 8
7 becomes 9
8 becomes 10

and the real loops are, once you've made the copies:

2 3 1
4 5 3
6 8 2

The way the Procyon looping is done allows for nested loops which is very powerful. With a bit of ingenuity you can do whatever you want. If you never want nested loops, then just make sure that your loop start and finish segments NEVER overlap!

-Andy.