After Effect SDK memory managing

Question

Hello, guys!
I'm new at AE SDK, so..
I have, for example, such in sequence memory handle:
struct
     char* a1;
     char* a2;
} MyData;
During sequence setup, i ask host to allocate memory for it:
    PF_Handle    seq_dataH =    suites.HandleSuite1()->host_new_handle(sizeof(MyData));
    if (seq_dataH){
        MyData    *myData = static_cast<MyData*>(suites.HandleSuite1()->host_lock_handle(seq_dataH));
        if (seqP){
            PF_Handle a1_handle    =    suites.HandleSuite1()->host_new_handle(255);
            PF_Handle a2_handle    =    suites.HandleSuite1()->host_new_handle(255);
            myData->a1 = static_cast<char*>(suites.HandleSuite1()->host_lock_handle(a1_handle));
            myData->a2 = static_cast<char*>(suites.HandleSuite1()->host_lock_handle(a2_handle));
            out_data->sequence_data = seq_dataH;
The question is: how can i release memory for MyData.a1 and MyData.a during SequeceSetdown if i have not appropriate PF_handle's at this moment (i have only sequence_data)? Is next code release ALL my sequence memory (including a1 and a2)
     suites.HandleSuite1()->host_dispose_handle(in_data->sequence_data)
In general i want to ask if should i keep all memory handles for locking, unlocking, disposing, resizing etc...
Thx.

Answer 1

er...
none of that strikes me as correct... at least in some respects.
the sequence data is used for two purposes:
1. storing data that lasts session long for this particular instance of your effect.
2. storing data with the project, that will be retrieved on the next session, again, for this particular instance.
so from what i gather from your code (and i may be wrong), it works for the first reason and not the second.
you define your data structure like so:
struct
     char* a1;
     char* a2;
} MyData;
that means that your data is 2 pointers.
NOT the content of these points, but the pointers THEMSELVES.
so when the project is saved and re-loaded, you'll have two pointers that point to a no longer valid piece of memory.
if you defined:
struct
     char a1[256];
     char a2[256];
} MyData;
and then:
out_data->sequence_data = PF_NEW_HANDLE(sizeof(MyData));
then you would now have a handle that stores the content of two 256 char arrays, and not just pointer to such arrays.
if you do it this way, the content of the two arrays will be stored with the project, and retrieved on the next session.
what you did is not wrong, it just works for a different purpose.
and another thing:
there is the handle_suite, and the memory_suite.
these should be used for different things. (though they can be interchangeable)
the handle suite is used for handles provided to you by AE. (i.e. the global_data, sequence_data and frame_data)
these handles are locked and unlocked for you, whenever AE is calling your plug-in.
the memory suite is used to manage pieces of memory that are not the 3 handles given by AE.
that allocated memory is up to you lock, unlock, move and free.
consider this mixed solution:
struct
     char a1[256];
     char a2[256];
     char* a3;
     AEGP_MemHandle a3H;
} MyData;
out_data->sequence_data = PF_NEW_HANDLE(sizeof(MyData));//allocating the memory
MyData *myData;//creating a local instance of the structure to work with
myData = *(MyData**)out_data->sequence_data;//connecting the local structure to the global handle.
so now the sequence_data handle points to a structure of two ready to use arrays (a1, a2), and one pointer that points to nothing (a3), and a mem handle, to be used soon.
to associate a chunk of memory to the a3 pointer you should use the memory suite.
ERR(suites.MemorySuite1()->AEGP_NewMemHandle( NULL,
                                                                                "a string to be displayed in case of an error",
                                                                                666, //size of chuck in bytes
                                                                                AEGP_MemFlag_CLEAR,//use this flag to get a zeroed out chunk
                                                                                &myData->a3H));
ERR(suites.MemorySuite1()->AEGP_LockMemHandle(myData->a3H, reinterpret_cast<void**>(&myData->a3)));
this is it.
a3 is now the proud owner of 666 bytes.
all of which will be available until the a3H handle is freed.
it is now up to you to free that memory.
you could do that at any time but most likely you'd want to free it during sequence_setdown
so first you should free a3H. why? because it's handle is stored with with the sequence_data handle, and if you free the sequence_data handle first, you won't have that a3H handle available to free it.
if(myData->a3H)
{ ERR2(suites.MemorySuite1()->AEGP_UnlockMemHandle(myData->a3H));
  ERR2(suites.MemorySuite1()->AEGP_FreeMemHandle(myData->a3H)); }
and now you can dispose of the sequence_data:
PF_DISPOSE_HANDLE(in_data->sequence_data);
that's it.
that last thing you should do is lookup PF_Cmd_SEQUENCE_FLATTEN on the SDK guide.
apart from that, we've made a round trip.