Pero teniendo en cuenta que cada frame habría que enviarlo en varios paquetes igual es mucho lio para reconstruirlos en el destino.
Por UDP puedes enviar tantos paquetes como quieras... si a cada paquete le añades un campo con un identificador secuencial, se pueden ordenar sin problemas al llegar al destino.
La verdad, es que dándote la razón, me gustaría hacer una prueba inicial con TCP a ver que rendimiento resulta.
Dado que TCP intenta por todos los medios garantizar la entrega de los paquetes, como la calidad de la conexión no se ajuste a la velocidad de transmisión requerida no va llegar absolutamente nada... o si llega lo va a hacer con un retraso importante.
UDP en cambio te permite gestionar la recepción de paquetes, lo que te permite descartar automáticamente paquetes antiguos sin perjudicar el rendimiento.
Los datos a transferir serían bytes. En el destino busco renderizar la imagen RGB24 usando OpenGL. Entonces lo que quiero es reconstruir el array tal cual lo envío en bytes.
La red solo entiende de tramas... y las tramas son campos de bytes... a la red le da igual si estás enviando una foto, un video porno casero o la fórmula de la cocacola... lo que tú introduzcas en un extremo de la conexión lo vas a recuperar en el otro.
Es decir, vas a enviar un chorizo de bytes y vas a recuperar un chorizo de bytes. Es responsabilidad tuya saber generar ese chorizo de bytes y, por tanto, de saber reconvertirlo en algo útil para ti.
OniRGB888* textura es un puntero a una posición de memoria. textura+1 sería el siguiente pixel y cada pixel son 3 bytes (uno por color), por lo tanto, se enviarían 3 bytes cada vez que avanzo el puntero. (Creo no equivocarme).
Como te comenté, a la red eso le da absolutamente igual. Este dato es importante para ti, lo necesitas para saber como obtener un stream de bytes que represente la imagen que quieres enviar... luego troceas ese stream en fragmentos de... no se... 1000 bytes.
Cada red tiene un tamaño máximo de trama (MTU), si la red recibe una trama mayor, la troceará para enviarla... eso es transparente para ti, pero es importante saberlo por si te genera problemas. un MTU típico es 1500, tienes que tener en cuenta que ese MTU incluye los datos que envías y la cabecera propia de cada trama, que depende del protocolo de la red.
Aquí es donde no se como tengo que enviar este objeto. Se que el método send me devuelve los bytes enviados y tengo iterar hasta envíar el frame completo. ¿Como le paso al método send la posición de memoria de este objeto?¿Como le digo que vaya en bytes en lugar de 3 bytes?
Lo primero que tienes que hacer es obtener una secuencia de bytes con la que puedas recomponer la imagen... el formato de esa secuencia puede ser libre, pero ha de ser conocido tanto por cliente como por servidor.
Después tienes que enviarlo por la red. En este caso tienes dos opciones:
* Lo envías "crudo", es decir, tal cual. El problema que te puedes encontrar es que una máquina se
big endian y la otra
little endian y tengas que implementar algoritmos diferentes para recomponer la imagen.
* Lo envías usando un protocolo de aplicación ya conocido ( XDR, Protocol buffers, JSon... ) estos protocolos suelen incluir codificaciones especiales para que la información se pueda recuperar sin problemas independientemente de las peculiaridades de las máquinas que intervienen en la comunicación.
Además de esto, puedes implementar tu propia capa de control. Esto te permitiría desechar mensajes antiguos y ordenar las diferentes tramas que componen una imagen. Esto se puede hacer de varias formas:
* Antes de enviar una imagen, envías un mensaje en el que indicas el número de tramas que van a componer la imagen... puedes enviar más información, como la fecha de la imagen, su número de identificación... lo que se te ocurra. Este mensaje lo recibe la máquina destino y le permite conocer de antemano lo que tiene que recibir. Luego cada parte de la imagen la tienes que enviar con el mismo identificador que la primera trama y luego un número de orden.
* Te ahorras el mensaje inicial y haces que en cada parte de la imagen viaje toda la información necesaria:
#define MAX_BUFF_IMAGEN 1000
typedef struct
{
int id_imagen; // Identificador de la imagen, cada imagen diferente tendra un identificador distinto
int index // Indice para poder ordenar los mensajes de una misma imagen.
int numDatos; // Numero de datos en el buffer "datos"
char[ MAX_BUFF_IMAGEN ] datos; // Buffer para almacenar un fragmento de la imagen
} Trama;
void enviar( char* imagen, int longImagen )
{
Trama trama;
trama.id_imagen = 0;
int partes = longImagen / MAX_BUFF_IMAGEN;
if ( longImagen % MAX_BUFF_IMAGEN != 0 )
partes++;
int i;
for ( i = 0; i < partes; i++ )
{
trama.index = i;
// Se envian como mucho 1000 bytes
if ( longImagen > MAX_BUFF_IMAGEN )
trama.numDatos = MAX_BUFF_IMAGEN;
else
trama.numDatos = longImagen;
// Se copia una parte de la imagen
memcpy( trama.
datos, imagen
+ i
* MAX_BUFF_IMAGEN
, trama.
numDatos );
// Se envia el mensaje
send( socket, &trama, sizeof( trama ), 0);
}
}
Autor
En línea
