qfwfqduo

I am a Soft VNS user and have recently started learning Jitter. I would like to know if Jitter has the equivalent of SVNS' v.sequence object. It basically allows you to load/store images into a buffer and play the sequence. Any of the stored images can also be exported.

jitter-equivalent-of-v-sequence

On Mon, Apr 28, 2008 at 2:58 PM, qfwfqduo wrote:

> I am a Soft VNS user and have recently started learning Jitter. I would

> like to know if Jitter has the equivalent of SVNS' v.sequence object. It

> basically allows you to load/store images into a buffer and play the

> sequence. Any of the stored images can also be exported.

On Mon, Apr 28, 2008 at 2:58 PM, qfwfqduo  wrote:

>
> Hi,
>
> I am a Soft VNS user and have recently started learning Jitter. I would
> like to know if Jitter has the equivalent of SVNS' v.sequence object. It
> basically allows you to load/store images into a buffer and play the
> sequence. Any of the stored images can also be exported.
>
> Many thanks
>
> Greg
>

not quite. one of the benefits of softVNS was the easy management of fractional frames in v.sequence and v.buffers. you can buffer matrices in a jit.matrixset or a higher-dim jit.matrix than your source, but dealing with fractional frames requires something of a hat trick.

the methods of dealing with this differ depending on whether you're going to go the CPU or GPU routes. which one is it going to be?

not quite.  one of the benefits of softVNS was the easy management of fractional frames in v.sequence and v.buffers.  you can buffer matrices in a jit.matrixset or a higher-dim jit.matrix than your source, but dealing with fractional frames requires something of a hat trick.

the methods of dealing with this differ depending on whether you're going to go the CPU or GPU routes.  which one is it going to be?


On Mon, Apr 28, 2008 at 5:23 PM, joshua goldberg wrote:

> not quite. one of the benefits of softVNS was the easy management of

> fractional frames in v.sequence and v.buffers. you can buffer matrices in a

> jit.matrixset or a higher-dim jit.matrix than your source, but dealing with

> fractional frames requires something of a hat trick.

> the methods of dealing with this differ depending on whether you're going

> to go the CPU or GPU routes. which one is it going to be?

On Mon, Apr 28, 2008 at 5:23 PM, joshua goldberg  wrote:

>
> not quite.  one of the benefits of softVNS was the easy management of
> fractional frames in v.sequence and v.buffers.  you can buffer matrices in a
> jit.matrixset or a higher-dim jit.matrix than your source, but dealing with
> fractional frames requires something of a hat trick.
>
> the methods of dealing with this differ depending on whether you're going
> to go the CPU or GPU routes.  which one is it going to be?
>

PPC : G4 1.67 Ghz, 1.5 G Ram, OSX.4.11, Quicktime 7.4.5

When opening Max 5 it displays the status window, empty then crash 

without crash report. The same with Max 5.0.1

When opening an example file with the runtime, it displays an empty 

window (with the right background color) and when I ask for the Max 

Window, it hangs or shows an empty max window.

When running the activity monitor of OSX at the same time, I see that 

Max 5 crashes after the running of Midiserver, and with Max 5 runtime it 

says Midiserver is not responding. When I ask for the Max window it 

hangs, then crashes. See below the crash report.

Max 4.6.3 with Jitter 1.6.3 works as usual.

Path: /Applications/Max5/MaxMSP Runtime.app/Contents/MacOS/MaxMSP Runtime

Codes: KERN_PROTECTION_FAILURE (0x0002) at 0x00000000

juce::Graphics::drawImage(juce::Image const*, int, int, int, int, int, 

juce::Graphics::drawImageAt(juce::Image const*, int, int, bool) const + 64

3 com.cycling74.MaxRuntime 0x00112e8c jgraphics_image_surface_draw_fast 

4 com.cycling74.MaxRuntime 0x000d4430 jbox_paint_layer + 124

BoxComponent::paint(juce::Graphics&, juce::AffineTransform const&) + 616

juce::Component::paintEntireComponent(juce::Graphics&) + 432

juce::Component::paintEntireComponent(juce::Graphics&) + 1008

PatcherLayerComponent::paintEntireComponent(juce::Graphics&) + 100

juce::ComponentPeer::handlePaint(juce::LowLevelGraphicsContext&) + 56

juce::HIViewComponentPeer::RepaintManager::paint(CGContext*, int, int, 

juce::HIViewComponentPeer::hiViewEventHandler(OpaqueEventHandlerCallRef*, 

19 adc~ 0x93299934 DispatchEventToHandlers(EventTargetRec*, 

20 adc~ 0x9329908c SendEventToEventTargetInternal(OpaqueEventRef*, 

OpaqueEventTargetRef*, HandlerCallRec*) + 372

21 adc~ 0x93298f08 SendEventToEventTargetWithOptions + 40

22 adc~ 0x932c4560 HIView::SendDraw(short, OpaqueGrafPtr*, __HIShape 

23 adc~ 0x93425228 HIView::RecursiveDrawComposited(__HIShape const*, 

2 adc~ 0x9772fac8 XServerMachPort::ReceiveMessage(int&, void*, int&) + 84

3 adc~ 0x97722c80 MIDIInPortThread::Run() + 64

4 adc~ 0x97726f44 XThread::RunHelper(void*) + 28

5 adc~ 0x9773087c CAPThread::Entry(CAPThread*) + 96

0 adc~ 0x90054388 semaphore_timedwait_signal_trap + 8

1 adc~ 0x90070be8 pthread_cond_timedwait_relative_np + 556

2 adc~ 0x90bf73f4 TSWaitOnSemaphoreCommon + 176

2 com.cycling74.MaxRuntime 0x001df164 juce::WaitableEvent::wait(int) 

3 com.cycling74.MaxRuntime 0x001f474c juce::InternalTimerThread::run() + 236

juce::Thread::threadEntryPoint(juce::Thread*) + 408

5 com.cycling74.MaxRuntime 0x001df290 juce::threadEntryProc(void*) + 16

3 adc~ 0x907de29c CFRunLoopRunSpecific + 268

4 adc~ 0x91457524 HALRunLoop::OwnThread(void*) + 264

5 adc~ 0x914572c4 CAPThread::Entry(CAPThread*) + 96

Thread 0 crashed with PPC Thread State 64:

srr0: 0x0000000000270d4c srr1: 0x000000000200f030 vrsave: 0x0000000000000000

cr: 0x24022424 xer: 0x0000000000000004 lr: 0x0000000000270d44 ctr: 

r0: 0x0000000000000005 r1: 0x00000000bfffcff0 r2: 0x0000000000000000 r3: 

r4: 0x0000000000000000 r5: 0x00000000000000a1 r6: 0x00000000ffffffff r7: 

r8: 0x0000000000000889 r9: 0x0000000000000000 r10: 0x0000000000000003 

r12: 0x00000000900015c8 r13: 0x0000000000000002 r14: 0x0000000000000000 

r16: 0x00000000066b7430 r17: 0x00000000bfffdc1c r18: 0x0000000000000000 

r20: 0x000000000723cff0 r21: 0x00000000bfffd3f8 r22: 0x0000000000000000 

r24: 0x000000007fffffff r25: 0x000000007fffffff r26: 0x0000000000000000 

r28: 0x000000000723d120 r29: 0x00000000bfffd190 r30: 0x0000000000000018 

0x1000 - 0x403fff com.cycling74.MaxRuntime 5.0.1 (34740) (5.0.1) 

/Applications/Max5/MaxMSP Runtime.app/Contents/MacOS/MaxMSP Runtime

0x7fc000 - 0x7fdfff com.cycling74.augraph 5.0.1 (34740) (34740) 

'74/mididrivers/augraph.mxo/Contents/MacOS/augraph

0x1205000 - 0x1250fff com.cycling74.MaxAPI 1.0 /Applications/Max5/MaxMSP 

Runtime.app/Contents/Frameworks/MaxAPI.framework/MaxAPI

0x15f4000 - 0x15fbfff com.unsanity.smartcrashreports Smart Crash Reports 

version 1.0.3 (1.0.3b1) /Users/taprik/Library/InputManagers/Smart Crash 

Reports/Smart Crash Reports.bundle/Contents/MacOS/Smart Crash Reports

0x1760000 - 0x1767fff com.cycling74.autohelp 5.0.1 (34740) (34740) 

'74/extensions/autohelp.mxo/Contents/MacOS/autohelp

0x176c000 - 0x176ffff com.cycling74.debugwindow 5.0.1 (34740) (34740) 

'74/extensions/debugwindow.mxo/Contents/MacOS/debugwindow

0x1772000 - 0x179ffff com.cycling74.querylib 5.0.1 (34740) (34740) 

'74/extensions/querylib.mxo/Contents/MacOS/querylib

0x17f2000 - 0x17f5fff com.cycling74.zoomer 5.0.1 (34740) (34740) 

/Applications/Max5/Cycling '74/extensions/zoomer.mxo/Contents/MacOS/zoomer

0x17f8000 - 0x17fafff com.cycling74.coremidi 5.0.1 (34740) (34740) 

'74/mididrivers/coremidi.mxo/Contents/MacOS/coremidi

0x1865000 - 0x1864fff dac~ PEF binary: dac~

0x1869200 - 0xa33853d2 adc~ PEF binary: adc~

0x1873400 - 0x18733ff fffb~ PEF binary: fffb~

0x308a000 - 0x30eefff com.cycling74.sqlite 5.0.1 (34740) (34740) 

/Applications/Max5/Cycling '74/extensions/sqlite.mxo/Contents/MacOS/sqlite

0x34c1000 - 0x34c2fff com.cycling74.midi_adrewire 5.0.1 (34740) (34740) 

'74/mididrivers/midi_adrewire.mxo/Contents/MacOS/midi_adrewire

0x34c5000 - 0x34d6fff com.cycling74.MaxAudioAPI ??? (1.0) 

Runtime.app/Contents/Frameworks/MaxAudioAPI.framework/Versions/A/MaxAudioAPI

0x5e59000 - 0x5e59fff com.cycling74.delay 5.0.1 (34740) (34740) 

/Applications/Max5/Cycling '74/max-externals/delay.mxo/Contents/MacOS/delay

0x6374000 - 0x6377fff com.cycling74.fpic 5.0.1 (34740) (34740) 

/Applications/Max5/Cycling '74/max-externals/fpic.mxo/Contents/MacOS/fpic

0x64b1000 - 0x64b1fff com.cycling74.times~ 5.0.1 (34740) (34740) 

'74/msp-externals/times~.mxo/Contents/MacOS/times~

0x64b4000 - 0x64b4fff com.cycling74.pink~ 5.0.1 (34740) (34740) 

/Applications/Max5/Cycling '74/msp-externals/pink~.mxo/Contents/MacOS/pink~

0x64b7000 - 0x64b8fff com.cycling74.loadmess 5.0.1 (34740) (34740) 

'74/max-externals/loadmess.mxo/Contents/MacOS/loadmess

0x64bb000 - 0x64bcfff com.cycling74.gate~ 5.0.1 (34740) (34740) 

/Applications/Max5/Cycling '74/msp-externals/gate~.mxo/Contents/MacOS/gate~

Model: PowerBook5,8, BootROM 4.9.6f0, 1 processors, PowerPC G4 (1.5), 

Graphics: ATI Mobility Radeon 9700, ATY,RV360M11, AGP, 128 MB

Memory Module: SODIMM0/J20STANDARD, 512 MB, DDR2 SDRAM, PC2-4200S-444

Memory Module: SODIMM1/J23REVERSED, 1 GB, DDR2 SDRAM, PC2-4200S-444

AirPort: AirPort Extreme, 405.1 (3.90.34.0.p18)

Bluetooth: Version 1.9.5f4, 2 service, 0 devices, 1 incoming serial ports

Network Service: Modem interne, PPP (PPPSerial), modem

PCI Card: pci106b,4318, sppci_othernetwork, SLOT-A

PCI Card: TXN,PCIXXXX-00, cardbus, PC Card

Parallel ATA Device: ST9808211A, 74.53 GB

Parallel ATA Device: MATSHITADVD-R UJ-846

USB Device: Bluetooth USB Host Controller, Apple, Inc., Up to 12 Mb/sec, 

USB Device: Apple Internal Keyboard / Trackpad, Apple Computer, Up to 12 

When opening Max 5 it displays the status window, empty then crash 
without crash report. The same with Max 5.0.1

When opening an example file with the runtime, it displays an empty 
window (with the right background color) and when I ask for the Max 
Window, it hangs or shows an empty max window.

When running the activity monitor of OSX at the same time, I see that 
Max 5 crashes after the running of Midiserver, and with Max 5 runtime it 
says Midiserver is not responding. When I ask for the Max window it 
hangs, then crashes. See below the crash report.

Date/Time: 2008-04-28 18:27:35.495 +0200
OS Version: 10.4.11 (Build 8S165)
Report Version: 4

Command: MaxMSP Runtime
Path: /Applications/Max5/MaxMSP Runtime.app/Contents/MacOS/MaxMSP Runtime
Parent: WindowServer [93]

Exception: EXC_BAD_ACCESS (0x0001)
Codes: KERN_PROTECTION_FAILURE (0x0002) at 0x00000000

Thread 0 Crashed:
0 com.cycling74.MaxRuntime 0x00270d4c 
juce::Graphics::drawImage(juce::Image const*, int, int, int, int, int, 
int, int, int, bool) const + 204
1 com.cycling74.MaxRuntime 0x00270d44 
juce::Graphics::drawImage(juce::Image const*, int, int, int, int, int, 
int, int, int, bool) const + 196
2 com.cycling74.MaxRuntime 0x00271510 
juce::Graphics::drawImageAt(juce::Image const*, int, int, bool) const + 64
3 com.cycling74.MaxRuntime 0x00112e8c jgraphics_image_surface_draw_fast 
+ 152
4 com.cycling74.MaxRuntime 0x000d4430 jbox_paint_layer + 124
5 com.cycling74.MaxRuntime 0x000cfd24 
BoxComponent::paint(juce::Graphics&, juce::AffineTransform const&) + 616
6 com.cycling74.MaxRuntime 0x00223460 
juce::Component::paintEntireComponent(juce::Graphics&) + 432
7 com.cycling74.MaxRuntime 0x002236a0 
juce::Component::paintEntireComponent(juce::Graphics&) + 1008
8 com.cycling74.MaxRuntime 0x0018f17c 
PatcherLayerComponent::paintEntireComponent(juce::Graphics&) + 100
9 com.cycling74.MaxRuntime 0x002236a0 
juce::Component::paintEntireComponent(juce::Graphics&) + 1008
10 com.cycling74.MaxRuntime 0x002236a0 
juce::Component::paintEntireComponent(juce::Graphics&) + 1008
11 com.cycling74.MaxRuntime 0x002236a0 
juce::Component::paintEntireComponent(juce::Graphics&) + 1008
12 com.cycling74.MaxRuntime 0x002236a0 
juce::Component::paintEntireComponent(juce::Graphics&) + 1008
13 com.cycling74.MaxRuntime 0x002236a0 
juce::Component::paintEntireComponent(juce::Graphics&) + 1008
14 com.cycling74.MaxRuntime 0x002236a0 
juce::Component::paintEntireComponent(juce::Graphics&) + 1008
15 com.cycling74.MaxRuntime 0x002236a0 
juce::Component::paintEntireComponent(juce::Graphics&) + 1008
16 com.cycling74.MaxRuntime 0x0035d148 
juce::ComponentPeer::handlePaint(juce::LowLevelGraphicsContext&) + 56
17 com.cycling74.MaxRuntime 0x001e7498 
juce::HIViewComponentPeer::RepaintManager::paint(CGContext*, int, int, 
int, int) + 888
18 com.cycling74.MaxRuntime 0x001e9454 
juce::HIViewComponentPeer::hiViewEventHandler(OpaqueEventHandlerCallRef*, 
OpaqueEventRef*, void*) + 980
19 adc~ 0x93299934 DispatchEventToHandlers(EventTargetRec*, 
OpaqueEventRef*, HandlerCallRec*) + 692
20 adc~ 0x9329908c SendEventToEventTargetInternal(OpaqueEventRef*, 
OpaqueEventTargetRef*, HandlerCallRec*) + 372
21 adc~ 0x93298f08 SendEventToEventTargetWithOptions + 40
22 adc~ 0x932c4560 HIView::SendDraw(short, OpaqueGrafPtr*, __HIShape 
const*, CGContext*) + 396
23 adc~ 0x93425228 HIView::RecursiveDrawComposited(__HIShape const*, 
unsigned long, HIView*, CGContext*, unsigned char) + 548
24 adc~ 0x93425348 HIView::RecursiveDrawComposited(__HIShape const*, 
unsigned long, HIView*, CGContext*, unsigned char) + 836
25 adc~ 0x93425348 HIView::RecursiveDrawComposited(__HIShape const*, 
unsigned long, HIView*, CGContext*, unsigned char) + 836
26 adc~ 0x93424fa8 HIView::DrawComposited(short, OpaqueGrafPtr*, 
__HIShape const*, unsigned long, HIView*, CGContext*) + 576
27 adc~ 0x932b411c UpdateWindowVisibility(VisChangeState*) + 340
28 adc~ 0x932b3f30 _ShowHideWindows + 160
29 adc~ 0x932b3e80 ShowHide + 36
30 adc~ 0x932dcab0 ShowWindow + 56
31 com.cycling74.MaxRuntime 0x001ecd20 
juce::HIViewComponentPeer::setVisible(bool) + 96
32 com.cycling74.MaxRuntime 0x0022a428 juce::Component::setVisible(bool) 
+ 552
33 com.cycling74.MaxRuntime 0x0016bb20 MaxTopLevelWindow::makeVisible() 
+ 148
34 com.cycling74.MaxRuntime 0x000a7730 object_method + 1104
35 com.cycling74.MaxRuntime 0x0019791c 
patcherview_dovisible(_patcherview*, long) + 100
36 com.cycling74.MaxRuntime 0x00198844 
patcherview_patchernotify(_patcherview*, symbol*, short, atom*) + 264
37 com.cycling74.MaxRuntime 0x000a3f64 object_method_typedfun + 148
38 com.cycling74.MaxRuntime 0x001429f0 
jpatcher_call_object_method_typed(object*, _method_typed_data*) + 36
39 com.cycling74.MaxRuntime 0x00058234 linklist_funall + 92
40 com.cycling74.MaxRuntime 0x0013e4c0 jpatcher_patchernotify + 96
41 com.cycling74.MaxRuntime 0x00140008 jpatcher_vis_imp + 192
42 com.cycling74.MaxRuntime 0x000a7730 object_method + 1104
43 com.cycling74.MaxRuntime 0x00029c08 sysabout_show + 116
44 com.cycling74.MaxRuntime 0x000eba54 max_about + 20
45 com.cycling74.MaxRuntime 0x000a3f64 object_method_typedfun + 148
46 com.cycling74.MaxRuntime 0x00133264 jmenu_process + 556
47 com.cycling74.MaxRuntime 0x000eb56c interface_process + 16
48 com.cycling74.MaxRuntime 0x00010f28 
app_eventhandler(OpaqueEventHandlerCallRef*, OpaqueEventRef*, void*) + 196
49 adc~ 0x93299934 DispatchEventToHandlers(EventTargetRec*, 
OpaqueEventRef*, HandlerCallRec*) + 692
50 adc~ 0x9329908c SendEventToEventTargetInternal(OpaqueEventRef*, 
OpaqueEventTargetRef*, HandlerCallRec*) + 372
51 adc~ 0x9329fe90 SendEventToEventTarget + 40
52 adc~ 0x933187e8 SendHICommandEvent(unsigned long, HICommand const*, 
unsigned long, unsigned long, unsigned char, OpaqueEventTargetRef*, 
OpaqueEventTargetRef*, OpaqueEventRef**) + 380
53 adc~ 0x933486a0 SendMenuItemSelectedEvent + 136
54 adc~ 0x933485a8 FinishMenuSelection(MenuData*, MenuData*, 
MenuResult*, MenuResult*, unsigned long, unsigned long, unsigned long, 
unsigned char) + 144
55 adc~ 0x9332fa54 MenuSelectCore(MenuData*, Point, double, unsigned 
long, OpaqueMenuRef**, unsigned short*) + 404
56 adc~ 0x9332f53c MenuSelect + 100
57 com.cycling74.MaxRuntime 0x001ddb08 
juce::MouseClickHandlerProc(OpaqueEventHandlerCallRef*, OpaqueEventRef*, 
void*) + 152
58 adc~ 0x93299934 DispatchEventToHandlers(EventTargetRec*, 
OpaqueEventRef*, HandlerCallRec*) + 692
59 adc~ 0x9329908c SendEventToEventTargetInternal(OpaqueEventRef*, 
OpaqueEventTargetRef*, HandlerCallRec*) + 372
60 adc~ 0x9329fe90 SendEventToEventTarget + 40
61 adc~ 0x9348f3fc HandleMouseEvent(OpaqueEventRef*) + 388
62 adc~ 0x932a01fc 
ToolboxEventDispatcherHandler(OpaqueEventHandlerCallRef*, 
OpaqueEventRef*, void*) + 496
63 adc~ 0x93299b84 DispatchEventToHandlers(EventTargetRec*, 
OpaqueEventRef*, HandlerCallRec*) + 1284
64 adc~ 0x9329908c SendEventToEventTargetInternal(OpaqueEventRef*, 
OpaqueEventTargetRef*, HandlerCallRec*) + 372
65 adc~ 0x9329fe90 SendEventToEventTarget + 40
66 com.cycling74.MaxRuntime 0x001e31c0 
juce::juce_dispatchNextMessageOnSystemQueue(bool) + 992
67 com.cycling74.MaxRuntime 0x001f30c0 
juce::MessageManager::runDispatchLoop() + 128
68 com.cycling74.MaxRuntime 0x001ee32c 
juce::JUCEApplication::main(juce::String&, juce::JUCEApplication*) + 700
69 com.cycling74.MaxRuntime 0x001ee404 juce::JUCEApplication::main(int, 
char**, juce::JUCEApplication*) + 100
70 com.cycling74.MaxRuntime 0x0000257c _start + 760
71 com.cycling74.MaxRuntime 0x00002280 start + 48

Thread 1:
0 adc~ 0x9000b348 mach_msg_trap + 8
1 adc~ 0x9000b29c mach_msg + 60
2 adc~ 0x9772fac8 XServerMachPort::ReceiveMessage(int&, void*, int&) + 84
3 adc~ 0x97722c80 MIDIInPortThread::Run() + 64
4 adc~ 0x97726f44 XThread::RunHelper(void*) + 28
5 adc~ 0x9773087c CAPThread::Entry(CAPThread*) + 96
6 adc~ 0x9002bd08 _pthread_body + 96

Thread 2:
0 adc~ 0x90054388 semaphore_timedwait_signal_trap + 8
1 adc~ 0x90070be8 pthread_cond_timedwait_relative_np + 556
2 adc~ 0x90bf73f4 TSWaitOnSemaphoreCommon + 176
3 adc~ 0x90bff390 TimerThread + 60
4 adc~ 0x9002bd08 _pthread_body + 96

Thread 3:
0 adc~ 0x90054388 semaphore_timedwait_signal_trap + 8
1 adc~ 0x90070be8 pthread_cond_timedwait_relative_np + 556
2 com.cycling74.MaxRuntime 0x001df164 juce::WaitableEvent::wait(int) 
const + 164
3 com.cycling74.MaxRuntime 0x001f474c juce::InternalTimerThread::run() + 236
4 com.cycling74.MaxRuntime 0x002d2048 
juce::Thread::threadEntryPoint(juce::Thread*) + 408
5 com.cycling74.MaxRuntime 0x001df290 juce::threadEntryProc(void*) + 16
6 adc~ 0x9002bd08 _pthread_body + 96

Thread 4:
0 adc~ 0x9000b348 mach_msg_trap + 8
1 adc~ 0x9000b29c mach_msg + 60
2 adc~ 0x907de998 __CFRunLoopRun + 832
3 adc~ 0x907de29c CFRunLoopRunSpecific + 268
4 adc~ 0x91457524 HALRunLoop::OwnThread(void*) + 264
5 adc~ 0x914572c4 CAPThread::Entry(CAPThread*) + 96
6 adc~ 0x9002bd08 _pthread_body + 96

Thread 0 crashed with PPC Thread State 64:
srr0: 0x0000000000270d4c srr1: 0x000000000200f030 vrsave: 0x0000000000000000
cr: 0x24022424 xer: 0x0000000000000004 lr: 0x0000000000270d44 ctr: 
0x00000000900015c8
r0: 0x0000000000000005 r1: 0x00000000bfffcff0 r2: 0x0000000000000000 r3: 
0x00000000000000a1
r4: 0x0000000000000000 r5: 0x00000000000000a1 r6: 0x00000000ffffffff r7: 
0x00000000000000a1
r8: 0x0000000000000889 r9: 0x0000000000000000 r10: 0x0000000000000003 
r11: 0x00000000a0006208
r12: 0x00000000900015c8 r13: 0x0000000000000002 r14: 0x0000000000000000 
r15: 0x00000000a3299698
r16: 0x00000000066b7430 r17: 0x00000000bfffdc1c r18: 0x0000000000000000 
r19: 0x0000000000000000
r20: 0x000000000723cff0 r21: 0x00000000bfffd3f8 r22: 0x0000000000000000 
r23: 0x0000000000000000
r24: 0x000000007fffffff r25: 0x000000007fffffff r26: 0x0000000000000000 
r27: 0x0000000000000000
r28: 0x000000000723d120 r29: 0x00000000bfffd190 r30: 0x0000000000000018 
r31: 0x0000000000270c94

Model: PowerBook5,8, BootROM 4.9.6f0, 1 processors, PowerPC G4 (1.5), 
1.67 GHz, 1.5 GB
Graphics: ATI Mobility Radeon 9700, ATY,RV360M11, AGP, 128 MB
Memory Module: SODIMM0/J20STANDARD, 512 MB, DDR2 SDRAM, PC2-4200S-444
Memory Module: SODIMM1/J23REVERSED, 1 GB, DDR2 SDRAM, PC2-4200S-444
AirPort: AirPort Extreme, 405.1 (3.90.34.0.p18)
Modem: Jump, V.92, Version 1.0
Bluetooth: Version 1.9.5f4, 2 service, 0 devices, 1 incoming serial ports
Network Service: Modem interne, PPP (PPPSerial), modem
PCI Card: pci106b,4318, sppci_othernetwork, SLOT-A
PCI Card: TXN,PCIXXXX-00, cardbus, PC Card
PCI Card: usb, usb, USB20
PCI Card: usb, usb, USB20
PCI Card: usb, ehci, USB20
Parallel ATA Device: ST9808211A, 74.53 GB
Parallel ATA Device: MATSHITADVD-R UJ-846
USB Device: Bluetooth USB Host Controller, Apple, Inc., Up to 12 Mb/sec, 
500 mA
USB Device: Apple Internal Keyboard / Trackpad, Apple Computer, Up to 12 
Mb/sec, 500 mA

I think Joshua is referring to v.sequence's capability to output stored image using a float rather than just an integer. This means you can have the images fade into each other rather than jump from one to the next while outputting. It's very useful...

Quote: yair r. wrote on Mon, 28 April 2008 08:36

----------------------------------------------------

> On Mon, Apr 28, 2008 at 5:23 PM, joshua goldberg wrote:

> > not quite. one of the benefits of softVNS was the easy management of

> > fractional frames in v.sequence and v.buffers. you can buffer matrices in a

> > jit.matrixset or a higher-dim jit.matrix than your source, but dealing with

> > fractional frames requires something of a hat trick.

> > the methods of dealing with this differ depending on whether you're going

> > to go the CPU or GPU routes. which one is it going to be?

Quote: yair r. wrote on Mon, 28 April 2008 08:36
----------------------------------------------------
> what is a fractional frame?
>
> On Mon, Apr 28, 2008 at 5:23 PM, joshua goldberg  wrote:
>
> >
> > not quite.  one of the benefits of softVNS was the easy management of
> > fractional frames in v.sequence and v.buffers.  you can buffer matrices in a
> > jit.matrixset or a higher-dim jit.matrix than your source, but dealing with
> > fractional frames requires something of a hat trick.
> >
> > the methods of dealing with this differ depending on whether you're going
> > to go the CPU or GPU routes.  which one is it going to be?
> >
>
>
>
----------------------------------------------------


Quote: joshua goldberg wrote on Mon, 28 April 2008 08:23

> not quite. one of the benefits of softVNS was the easy management of fractional frames in v.sequence and v.buffers. you can buffer matrices in a jit.matrixset or a higher-dim jit.matrix than your source, but dealing with fractional frames requires something of a hat trick.

> the methods of dealing with this differ depending on whether you're going to go the CPU or GPU routes. which one is it going to be?

Well I'm not well enough versed with Jitter to answer the question. My main concern is filling a matrix with high resolution stills then output them sequentially. I am not too concerned with fractional frames. I've just started looking at the matrixset object and what I need to do is import about 100 images from a folder. Is this possible? I can't figure out how to do the indexing. (Yes, I know - read the tutorial...)

Quote: joshua goldberg wrote on Mon, 28 April 2008 08:23
----------------------------------------------------
> not quite.  one of the benefits of softVNS was the easy management of fractional frames in v.sequence and v.buffers.  you can buffer matrices in a jit.matrixset or a higher-dim jit.matrix than your source, but dealing with fractional frames requires something of a hat trick.
>
> the methods of dealing with this differ depending on whether you're going to go the CPU or GPU routes.  which one is it going to be?
----------------------------------------------------

Well I'm not well enough versed with Jitter to answer the question. My main concern is filling a matrix with high resolution stills then output them sequentially. I am not too concerned with fractional frames. I've just started looking at the matrixset object and what I need to do is import about 100 images from a folder. Is this possible? I can't figure out how to do the indexing. (Yes, I know - read the tutorial...) 

every frame you store in matrixset resides in memory, uncompressed so it can

i would offer you to consider "baking" you sequence to quicktime and work

On Mon, Apr 28, 2008 at 11:26 PM, qfwfqduo wrote:

> I think Joshua is referring to v.sequence's capability to output stored

> image using a float rather than just an integer. This means you can have the

> images fade into each other rather than jump from one to the next while

> Quote: yair r. wrote on Mon, 28 April 2008 08:36

> ----------------------------------------------------

> > On Mon, Apr 28, 2008 at 5:23 PM, joshua goldberg 

> > > not quite. one of the benefits of softVNS was the easy management of

> > > fractional frames in v.sequence and v.buffers. you can buffer

> > > jit.matrixset or a higher-dim jit.matrix than your source, but dealing

> > > fractional frames requires something of a hat trick.

> > > the methods of dealing with this differ depending on whether you're

> > > to go the CPU or GPU routes. which one is it going to be?

every frame you store in matrixset resides in memory, uncompressed so it can
get expensive, memory wise.

i would offer you to consider "baking" you sequence to quicktime and work
with that.

On Mon, Apr 28, 2008 at 11:26 PM, qfwfqduo  wrote:

>
> "what is a fractional frame?"
>
> I think Joshua is referring to v.sequence's capability to output stored
> image using a float rather than just an integer. This means you can have the
> images fade into each other rather than jump from one to the next while
> outputting. It's very useful...
>
>
>
> Quote: yair r. wrote on Mon, 28 April 2008 08:36
> ----------------------------------------------------
> > what is a fractional frame?
> >
> > On Mon, Apr 28, 2008 at 5:23 PM, joshua goldberg 
> wrote:
> >
> > >
> > > not quite.  one of the benefits of softVNS was the easy management of
> > > fractional frames in v.sequence and v.buffers.  you can buffer
> matrices in a
> > > jit.matrixset or a higher-dim jit.matrix than your source, but dealing
> with
> > > fractional frames requires something of a hat trick.
> > >
> > > the methods of dealing with this differ depending on whether you're
> going
> > > to go the CPU or GPU routes.  which one is it going to be?
> > >
> >
> >
> >
> ----------------------------------------------------
>
>
>

For aesthetic reasons I need to work with sequences that contain 640 x 480 images. Quicktime movies of that size are impossible to work with, but storing such images and outputting them gives great results.

Quote: yair r. wrote on Mon, 28 April 2008 15:05

> every frame you store in matrixset resides in memory, uncompressed so it can

> i would offer you to consider "baking" you sequence to quicktime and work

> On Mon, Apr 28, 2008 at 11:26 PM, qfwfqduo wrote:

> > I think Joshua is referring to v.sequence's capability to output stored

> > image using a float rather than just an integer. This means you can have the

> > images fade into each other rather than jump from one to the next while

> > Quote: yair r. wrote on Mon, 28 April 2008 08:36

> > ----------------------------------------------------

> > > On Mon, Apr 28, 2008 at 5:23 PM, joshua goldberg 

> > > > not quite. one of the benefits of softVNS was the easy management of

> > > > fractional frames in v.sequence and v.buffers. you can buffer

> > > > jit.matrixset or a higher-dim jit.matrix than your source, but dealing

> > > > fractional frames requires something of a hat trick.

> > > > the methods of dealing with this differ depending on whether you're

> > > > to go the CPU or GPU routes. which one is it going to be?

For aesthetic reasons I need to work with sequences that contain 640 x 480 images. Quicktime movies of that size are impossible to work with, but storing such images and outputting them gives great results. 

Quote: yair r. wrote on Mon, 28 April 2008 15:05
----------------------------------------------------
> sounds usufull.
>
> every frame you store in matrixset resides in memory, uncompressed so it can
> get expensive, memory wise.
>
> i would offer you to consider "baking" you sequence to quicktime and work
> with that.
>
> On Mon, Apr 28, 2008 at 11:26 PM, qfwfqduo  wrote:
>
> >
> > "what is a fractional frame?"
> >
> > I think Joshua is referring to v.sequence's capability to output stored
> > image using a float rather than just an integer. This means you can have the
> > images fade into each other rather than jump from one to the next while
> > outputting. It's very useful...
> >
> >
> >
> > Quote: yair r. wrote on Mon, 28 April 2008 08:36
> > ----------------------------------------------------
> > > what is a fractional frame?
> > >
> > > On Mon, Apr 28, 2008 at 5:23 PM, joshua goldberg 
> > wrote:
> > >
> > > >
> > > > not quite.  one of the benefits of softVNS was the easy management of
> > > > fractional frames in v.sequence and v.buffers.  you can buffer
> > matrices in a
> > > > jit.matrixset or a higher-dim jit.matrix than your source, but dealing
> > with
> > > > fractional frames requires something of a hat trick.
> > > >
> > > > the methods of dealing with this differ depending on whether you're
> > going
> > > > to go the CPU or GPU routes.  which one is it going to be?
> > > >
> > >
> > >
> > >
> > ----------------------------------------------------
> >
> >
> >
>
>
>
----------------------------------------------------


you should be able to store 100 frames, there is a simple calculation that i

Jitter Equivalent of v.sequence