Foro de elhacker.net

Hola a todos. Soy un completo novato en todo esto pero quiero crear una aplicación y me han surgido varias dudas.

La cuestión es que quiero crear un plugin para After Effects que en realidad es la suma de varias partes de otros plugins. Quieros coger 5 trocitos de 4 plugins y hacer un único plugin. Para ello he pensado en la posibilidad de acceder al código de esos 4 plugins y seleccionar las partes necesarias.

¿Es posible realizar esto? Agradecería cualquier sugerencia o modo de empezar. Los plugins estan escritos en C++

Muchas gracias!!!

Si se puede, pero porque no programar tu propio plugin por ti mismo y todo incluido?
bueno de todos modos, la idea seria localizar el area de codigo que necesites obtener el offset a este, luego obtener la direccion base del plugin y sumarle ese offset luego solamente llamar a esa area de codigo, asegurarte que ese codigo tiene retorno, bueno de todos modos se puede hacer de cualquier manera no hay un impossible en nada sobre este asunto pero dependiendo de la situación esto podria llegar a ser tan rustico.

mi duda es:

puede un novato desarrollar un plugin de after effects? así, directamente? pasando a lo especifico y avanzado sin haber pasado antes por lo basico y general?

y dado que no conocemos la api de plugins de after effects? como puede x64_core hablar con tanta seguridad? y si hay tres rutinas main, una por cada plugin? concatenas el codigo y ya esta? y que hay con las direcciones de memoria del espacio de plugins? no habra que reorgnizarlo todo? y que hay de las interfaces, cuadros de dialogo, opciones, etc? acaso es viable agarrar tres programas y juntarlos sin mas esperando que salga uno solo 100% funcional?

y en resumen...

no estais alucinando un poco?

Luce como que nunca has hecho algo similar.

Coincido con alist3r: Teniendo en cuenta la infinidad de cosas que pueden hacerse en un plugin, es medio ilógico tratar de hacer algo así.

No digo que no se pueda sacar un poco de código de una DLL, pero hay que tener MUY en cuenta todo el funcionamiento: Lo que se inicializa al momento de cargar la DLL, lo que se inicializa al momento de cargar el plugin, la interface y las funciones usadas/exportadas.

La verdad, no he hecho un plugin para After Effects, pero calculo que es similiar a uno para, por ej.: Olly (quizás un poco más complejo  :P)


Y tu si?  ::)

Saludos!

Crees que diria algo solo por espamear un hilo?
Hay que distinguir dos cosas: Dificil != Imposible

Cambiar el comportamiento de un programa ya compilado no es dificil como la gente piensa, tener un conocimiento bastante amplio de las funciones del SO, manejar bastante las herramientas a usar, más la experiencia.
Basandose en que el programa fue hecho por profesionales entonces debe ser de tipo modular y no sera tan dificil identificar que funcion(s) es la responsable
de tales acciones.

Hola.

Muchísimas gracias a todos por responder!!! Les cuento mi caso con más detalle.

Trabajo con After Effects, creando efectos y diseños animados desde hace muchos años. La cuestión es que el programa tiene ya instalados varios efectos "plugins" como corrección de brillo, aumento de color azul, etc...
Utilizo una combinación de estos efectos para lograr un resultado concreto y quisiera tener este resultado con un único efecto ya que creo que sería muy util.

No sé de programación, me he descargado el SDK de After Effects donde vienen incluidas las heads necesarias para incluir en el código, pero la verdad es que empezar de cero me parece algo imposible. Por ello quería acceder al código de esos efectos y coger trozos para montar mi propio efecto. Los efectos de after effects están creados de forma modular y la interfaz (sliders) tambien.

Ejemplo de Interfaz:

static PF_Err ParamsSetup (
    PF_InData *in_data,
    PF_OutData *out_data,
    PF_ParamDef *params[],
    PF_LayerDef *output)
 {
    PF_Err err = PF_Err_NONE;
    PF_ParamDef def;   

    // Always clear out the PF_ParamDef
    // before adding your parameters.
    AEFX_CLR_STRUCT(def);

    // Create the LAYER parameter...
    def.param_type = PF_Param_LAYER;
    PF_STRCPY(def.name, "Displacement Layer:");
    def.u.ld.dephault = PF_LayerDefault_NONE;
    if (err = PF_ADD_PARAM(in_data, -1, &def))
       return err;
   
    // Create the ANGLE parameter...   
    def.param_type = PF_Param_ANGLE;
    PF_STRCPY(def.name, "Angle of Displacement");
    def.flags = 0;
    def.u.fd.value_str[0] =
       def.u.fd.value_desc[0] = '\0';
    def.u.fd.value = def.u.fd.dephault = 0;
    def.u.fd.valid_min =
       def.u.fd.slider_min = ANGLE_MIN;
    def.u.fd.valid_max =
       def.u.fd.slider_max = ANGLE_MAX;
    def.u.fd.precision = 0;
    def.u.fd.display_flags = 0;   
    if (err = PF_ADD_PARAM(in_data, -1, &def))
        return err;
   
    // Create the DISPLACEMENT SLIDER...   
    def.param_type = PF_Param_FIX_SLIDER;
    PF_STRCPY(def.name, "Amount of Displacement");
    def.flags = 0;
    def.u.fd.value_str[0] =
       def.u.fd.value_desc[0] = '\0';
    def.u.fd.value =
       def.u.fd.dephault = SHIFT_BLEND_DFLT;
    def.u.fd.valid_min =
       def.u.fd.slider_min = SHIFT_BLEND_MIN;
    def.u.fd.valid_max =
       def.u.fd.slider_max = SHIFT_BLEND_MAX;
    def.u.fd.precision = 1;
    def.u.fd.display_flags = 1; // display as percent
    if (err = PF_ADD_PARAM(in_data, -1, &def))
       return err;

    // GAMMA slider...
    AEFX_CLR_STRUCT(def);
    def.param_type = PF_Param_FIX_SLIDER;
    PF_STRCPY(def.name, "Source Gamma");
    def.u.fd.value_str[0] =
       def.u.fd.value_desc[0] = '\0';
    def.u.fd.value =
       def.u.fd.dephault = BIAS_DFLT;
    def.u.fd.valid_min =
       def.u.fd.slider_min = BIAS_MIN;
    def.u.fd.slider_max = BIAS_MAX;
    def.u.fd.valid_max = BIAS_BIG_MAX;
    def.u.fd.precision = 1;
    def.u.fd.display_flags = 0;
    if (err = PF_ADD_PARAM(in_data, -1, &def))
       return err;

    // Create the FIXED SLIDER parameter...   
    def.param_type = PF_Param_FIX_SLIDER;
    PF_STRCPY(def.name, "Blend With Original");
    def.flags = 0;
    def.u.fd.value_str[0] =
       def.u.fd.value_desc[0] = '\0';
    def.u.fd.value =
       def.u.fd.dephault = SHIFT_BLEND_DFLT;
    def.u.fd.valid_min =
       def.u.fd.slider_min = SHIFT_BLEND_MIN;
    def.u.fd.valid_max =
       def.u.fd.slider_max = SHIFT_BLEND_MAX;
    def.u.fd.precision = 1;
    def.u.fd.display_flags = 1; // display as percent
    if (err = PF_ADD_PARAM(in_data, -1, &def))
       return err;

    // Set number of parameters...
    out_data->num_params = SHIFT_NUM_PARAMS;

    return err;
 }

Agradecería que me pudieseis explicar como acceder al codigo de los plugins. Un saludo y muchas gracias!!!

x64Core:

todo tuyo! ilústranos!

yo mantengo mi postura junto a MCKSys

Sí, y como se espera que podas lograrlo?
Codigo Fuente? Esto es ingeniería inversa no?

Hola.

Solo quiero cual es el método a seguir para acceder al código de los efectos.
¿Se usa algun programa específico?

Un saludo y muchas gracias.

Sí, un depurador y tracear hasta donde se cuentra la funcion responsable después hacer lo que dije anteriormente.

ahora voy a dejar de hacerme el loco y voy a hablar con propiedad, tratando de ser práctico sin caer en el terreno de la teoría vacía ni la fantasía.

AVISO A TROLLS CHARLATANES Y TEORICOS EMPEDERNIDOS:
Esto es mas complejo de como lo explicaré ahora, paro para simplifiarlo, lo explico de esta manera:

un plugin es una biblioteca, un conjunto de rutinas de codigo ejecutable, y datos.
para llegar a ellos, no es que use un programa especifico, sino que se debe conocer el lenguaje, y tambien la API, o plataforma, o como se le quiera llamar, sobre la cual ha sido desarrollada la biblioteca.

por mucho que una persona sepa de lenguaje C, por ejemplo, si estamos desensamblando un plugin de after effects, ademas de saber C debemos conocer el funcionamiento de la API de after effects y sus "enganches" con el programa padre, la forma en la que interaccionan esos enganches, etc.
En resumidas cuentas, conocer la plataforma after effects por dentro y sus estructuras de datos. Aqui, la frontera entre los conocimientos genéricos de lenguajes de programación y el funcionamento interno del software de renderizado 3D de video, se vuelve difusa, y practicamente se podria decir que es necesario "tener un pie en cada lado del rio".

Así mismo, los plugins tienen siempre un punto de entrada, una rutina principal que se ejecuta cuando se les llama, y en base a esta llamada el plugin realiza operaciones con los datos que recibe.

Si intentas sumar tres plugins, indefectiblemente y no importa quien te diga lo contrario, lo que vas a obtener como resultado es una quimera, un aborto. Para empezar tendrias que determinar en qué orden se tendrian que realizar los tres procesamientos de datos de cada uno de los tres plugins, y conectar la salida de uno a la entrada de otro, rehaciendo totalmente las estructuras de datos y la logica de los programas originales. por no mencionar que el principio de interacción entre ambos podría destruir el proceso, ya que los datos modificados que uno ofrece como resultado,  podrian no ser validos como entrada para ninguno de los otros dos, pues como digo los datos ya han sido transformados.

En estructuras de datos sencillas, como funciones que realizan ecuaciones con numeros simples, por supuesto que podemos concatenar una funcion con otra, y podemos hacerlo a mano, analizando el codigo fuente...

Pero recordemos que tampoco tenemos el codigo fuente. Solo tenemos meros ejemplos simples de cabeceras para empezar a hacer un plugin desde cero. Y aunque se desensamblara con la ayuda de un descompilador, no es lo mismo tener el codigo maquina desensamblado, a tener el codigo fuente original que es mas legible.

Para estructuras de datos del nivel de complejidad de un software de renderizado de video... aseverar que "se puede hacer", maxime sin el codigo fuente original de los plugins, es cuando menos descabellado.

Cualquier desarrollador que se precie sabe que sumando tres workflows, no se obtiene uno solo, y que a nivel interno de la arquitectura de los PC's no se pueden superponer las cosas sin mas y pretender que se llegue mas lejos. Non son ladrillos, son programas.

Volviendo al caso personal que nos ocupa, considero que mc_deimon esta tres escalones por debajo del nivel necesario para hacer esta tarea. Me explico:

* le faltan conocimientos generales de desarrollo de apliaciones en lenguaje C.

* luego tendria que desarrollar conocimientos especificos de desarollo de plugins en el SDK de adobe. Es decir, saber construir el suyo propio.

* finalmente, tendriamos que hablar de ingenieria inversa: descompilar el cdigo de otros plugins, analizarlo, y con MUCHA paciencia y con pocas probabilidades de éxito real, tratar de aislar segmentos de codigo que se pudieran incorporar en su propio plugin.
 
sin esos tres conjuntos de habilidades, yo voy a mantener un rotundo
"NO ES POSIBLE".

Por no hablar de que After Effects es de Adobe, empresa promotora del famoso DRM, y que tiene por filosofia una fuerte protección digital de sus productos.

A buen entendedor pocas palabras bastan.

Personalmente no puedo aportar mas al tema, y por lo tanto me retiro, pero espero que mc_deimon encuentre alguna solucion directa o indirecta a su problema y necesidades.

saludos

PD: se me olvidaba añadir que los formularios y las interfaces tampoco se pueden "SUMAR", sino que se deben reescribir por trozos :)

Hola!!!

Os agradezco mucho a todos las respuestas que me habeis dado, ya que ahora soy más consciente de las dificultades que un empresa así implica. En este caso creo que viene muy a colación el viejo refrán de "la ignorancia es muy atrevida".

Yo pensaba que al estar disponibles esos efectos, y al permitir el propio programa convinarlos entre sí, no sería complicado usar algún método para unirlos en un único efecto, aunque fuese haciendo que funcionaran los 4 a la vez como se hace en el programa.

Creo que toca esperar.

Un saludo!!!

eso te iba a decir yo ahora.

si los efectos son stack-ables, no pierdes mucho en el caso de que NO puedas componer un plugin con la mezcla de los tres, verdad?
quiero decir que el mismo sistema de AE ya puede encargarse de hacer todas las complejas gestiones que implica encadenar varios plugins para realizar varias pasadas de tratamiento en el render.

no?

Hola Alister!!

Sí, la verdad es que la idea era hacer algo más chulo y que facilitara los accesos. Pero creo que toca seguir como hasta ahora. ;)

Un saludo.

si deseas automatizar tareas en lo que a hacer click se refiere, quizas quieras echar un vistazo a soluciones indirectas como por ejemplo ghostmouse, que te permite grabar pulsaciones de raton y automatizar alguna que otra cosa.

saludos