Commit cafcbc69 authored by agustin's avatar agustin
Browse files

Anda cliente, falta control de video

parent a888047f
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>Obligatorio2Grupo51</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
</buildSpec>
<natures>
</natures>
</projectDescription>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdlib.h>
#include <stdio.h>
#include <opencv2/opencv.hpp>
#include <vector>
#include <array>
#include <pthread.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <iostream>
#include <sys/types.h>
#include <string.h>
using namespace cv;
using namespace std;
#define PORT "3490"
#define MY_IP "127.0.0.1"
#define HOST "localhost"
#define MAXLEN 1024
#define MAX_MSG_SIZE 65536
struct parametros{
int client_;
int socket_UDP;
};
void* stream(void *);
int main(){
int puertocTCP, numbytes,puerto;
char buf[100];
struct hostent *he;
/* estructura que recibirá información sobre el nodo remoto */
struct sockaddr_in server;
/* información sobre la dirección del servidor */
int socket_de_clienteUDP = socket(AF_INET, SOCK_DGRAM, 0);
struct sockaddr_in udp_addr;
socklen_t udp_addr_size = sizeof udp_addr;
udp_addr.sin_family = AF_INET;
udp_addr.sin_port = htons(0);
udp_addr.sin_addr.s_addr = inet_addr(MY_IP);
udp_addr.sin_addr.s_addr = inet_addr(MY_IP);
bind(socket_de_clienteUDP,(struct sockaddr*)&udp_addr, udp_addr_size);
struct sockaddr_in udpaddr;
socklen_t udpaddrlen = sizeof udpaddr;
getsockname(socket_de_clienteUDP,(struct sockaddr*)&udpaddr,&udpaddrlen);
cout << ntohs(udpaddr.sin_port) << endl;
puerto = ntohs(udpaddr.sin_port) ; // puerto udp del cliente
//num_port = to_string(ntohs(udpaddr.sin_port)).c_str();
//num_port=strdup(to_string(ntohs(udpaddr.sin_port)).c_str());
if ((he=gethostbyname(MY_IP))==NULL){
/* llamada a gethostbyname() */
printf("gethostbyname() error\n");
exit(-1);
}
//Paso 2, definicion de socket
if ((puertocTCP=socket(AF_INET, SOCK_STREAM, 0))==-1){
/* llamada a socket() */
printf("socket() error\n");
exit(-1);
}
//Datos del servidor
server.sin_family = AF_INET;
server.sin_port = htons(3490);
server.sin_addr = *((struct in_addr *)he->h_addr);
/*he->h_addr pasa la información de ``*he'' a "h_addr" */
bzero(&(server.sin_zero),8);
//Paso 3, conectarnos al servidor
if(connect(puertocTCP, (struct sockaddr *)&server,
sizeof(struct sockaddr))==-1){
/* llamada a connect() */
printf("connect() error\n");
exit(-1);
}
send(puertocTCP,to_string(puerto).c_str(),to_string(puerto).size(), 0);
int aux;
do {
cout << "Presione 1 para iniciar la reproduccion del video" << endl;
cin >> aux;
} while (aux != 1);
send(puertocTCP, (void *) &aux, sizeof(int), 0);
int main(void)
{
//primitiva SOCKET tcp
int client_socket = socket(AF_INET, SOCK_STREAM, 0);
//obtenemos la direccion con getaddrinfo
struct addrinfo hints, *res;
memset(&hints, 0, sizeof hints); //hints en 0
hints.ai_family = AF_INET; //designa el tipo de direcciones con el cual el skt se comunica= IP version 4.
hints.ai_socktype = SOCK_STREAM; //designa el tipo de skt con el que se comunica=TCP
getaddrinfo(HOST, PORT, &hints, &res);
//res tenemos el socket del servidor
//primitiva CONNECT, abre la conexion skt con skt servidor, clientskt=o succes, clientskt=-1 error
connect(client_socket, res->ai_addr, res->ai_addrlen);
//primitiva SEND, retorna sent_msg..=-1 error o el numero bytes enviados
char *msg = "Mensaje de prueba";
int msg_size = strlen(msg);
int sent_msg_size = send(client_socket, msg, msg_size, 0);
printf("Enviado al servidor (%d bytes): %s\n", sent_msg_size, msg);
//primitiva RECEIVE
char* data = malloc(MAXLEN);
int data_size = MAXLEN;
int received_data_size = recv(client_socket, data, data_size, 0);
printf("Recibido del servidor (%d bytes): %s\n", received_data_size, data);
//primitiva CLOSE
close(client_socket); //cierra skt y libera recursos asociados
freeaddrinfo(res); //libera la informacion de res
//viejo
char * dataV = new char[4];
int received_data_size = recv(
socket_de_clienteUDP,
dataV, sizeof(dataV), 0
);
dataV[received_data_size] = '\0';
cout << dataV << endl;
int j = 0;
//nuevo
struct parametros *p = new parametros;
p->client_= puertocTCP;
p->socket_UDP=socket_de_clienteUDP;
pthread_t hilo_stream;
pthread_create(&hilo_stream, NULL, stream,(void *) p);
//menu
bool reproduciendo = true;
bool pausado = false;
string opcion2;
int opcion = 1;
char const *msg;
int msg_size;
do{
cout << "Menu" << endl;
if (!reproduciendo){
cout << "1 - iniciar" << endl;
}else {
if (pausado)
cout << "2 - Reanudar Reproduccion" << endl;
else
cout << "3 - Pausar" << endl;
cout << "4 - Finalizar Reproduccion de Video" << endl;
}
cout << "5 - Salir" << endl;
cin >> opcion2;
//primitiva SEND, retorna sent_msg..=-1 error o el numero bytes enviados
try{
opcion=stoi(opcion2);
}catch(invalid_argument e){
opcion = 0;
}
switch (opcion){
case 1:
msg = "1";
msg_size = strlen(msg);
send(puertocTCP, msg, msg_size, 0);
reproduciendo = true;
pausado = false;
break;
case 2:
msg = "2";
msg_size = strlen(msg);
send(puertocTCP, msg, msg_size, 0);
pausado = false;
break;
case 3:
msg = "3";
msg_size = strlen(msg);
send(puertocTCP, msg, msg_size, 0);
pausado = true;
break;
case 4:
msg = "4";
msg_size = strlen(msg);
send(puertocTCP, msg, msg_size, 0);
reproduciendo = false;
break;
case 5:
msg = "5";
msg_size = strlen(msg);
send(puertocTCP, msg, msg_size, 0);
pthread_cancel(hilo_stream);//problema 1
close(socket_de_clienteUDP);
break;
}
}while(opcion != 5);//mate a stream y termino menu
close(puertocTCP);
}//fin del main
void *stream(void* pol){
parametros* p = (parametros*)pol;
int j;
while(true){
char* dataV2 = new char[66000];
//struct sockaddr_in server_addr;
//socklen_t server_addr_size = sizeof(server_addr);
int received_data_size = recv(
p->socket_UDP,
dataV2, 66000, 0
);
if(j < 1){
cout<<"hice recieve"<<endl;
j++;
}
namedWindow("cliente", CV_WINDOW_AUTOSIZE);
Mat rawData = Mat(1, received_data_size, CV_8UC1, dataV2); //matriz con la imagen recibida.
Mat frame = imdecode(rawData, CV_LOAD_IMAGE_COLOR); //decodifica la imagen
imshow("cliente", frame); //muestra la imagen en la ventana cliente
waitKey(1);
// hasta aca recibe el video (anda)
}
/* muestra el mensaje de bienvenida del servidor =) */
while(true);
}
......@@ -3,61 +3,224 @@
#include <netinet/in.h>
#include <stdlib.h>
#include <stdio.h>
#include <opencv2/opencv.hpp>
#include <vector>
#include <array>
#include <pthread.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <netdb.h>
#define PORT 3490
#define MY_IP "127.0.0.1"
#define MAX_QUEUE 10
#define MAX_MSG_SIZE 1024
int main(void)
{
//primitiva SOCKET
int server_socket = socket(AF_INET, SOCK_STREAM, 0);
//primitiva BIND
struct sockaddr_in server_addr;
socklen_t server_addr_size = sizeof server_addr;
server_addr.sin_family = AF_INET;
server_addr.sin_port = htons(PORT);
server_addr.sin_addr.s_addr = inet_addr(MY_IP);
bind(server_socket, (struct sockaddr*)&server_addr, server_addr_size); // le fijo a ese skt, el ip y puerto mio, no a donde mando, no hay conexiones de nada aun.
//se le da identidad/ configura el skt servidor
//primitiva LISTEN
listen(server_socket, MAX_QUEUE); //si hay mas de 10 encolados, se descartan las solicitudes nuevas
while (1) {
//primitiva ACCEPT
struct sockaddr_in client_addr;
socklen_t client_addr_size = sizeof client_addr;
int socket_to_client = accept(server_socket, (struct sockaddr *)&client_addr, &client_addr_size);
//abre conexion, si no hay nadie solicitando, me quedo aca bloqueado esperando
//primitiva RECEIVE
char* data = malloc(MAX_MSG_SIZE);
int data_size = MAX_MSG_SIZE;
int received_data_size = recv(socket_to_client, data, data_size, 0);
printf("Recibido del cliente (%d bytes): %s\n", received_data_size, data);
int i;
for (i = 0; i < received_data_size; i++) {
data[i] = toupper(data[i]);
}
//primitiva SEND
int sent_data_size = send(socket_to_client, data, received_data_size, 0);
printf("Enviado al cliente (%d bytes): %s\n", sent_data_size, data);
//primitiva CLOSE
close(socket_to_client);
}
//CLOSE del socket que espera conexiones
close(server_socket);
using namespace cv;
using namespace std;
#define PORT 3490 //servidor
#define PORTUDP 45568
#define MY_IP "127.0.0.1" //esto me redirige al IP de mi PC (buscarlo)
#define MAX_QUEUE 20
#define MAX_MSG_SIZE 65535
#define INACTIVO 0
#define INICIO 1
#define REPRODUCIR 2
#define PAUSA 3
#define FINALIZAR 4
#define SALIR 5
struct parametros{
//int id_cliente;
Mat frame;
VideoCapture cap;
vector<uchar> encoded;
sockaddr_in addr_destinoudp;
int pTCPcliente; //recivo msj tcp
//int *comunicacion;
int socket_de_clienteUDP; //evido msj udp
};
void* streamVideo(void*);
void* controlVideo(void*);
int main(){
//Primer paso, definir variables
int fd,pTCPcliente,longitud_cliente,puerto;
puerto=PORT;
//Se necesitan dos estructuras del tipo sockaddr
//La primera guarda info del server
//La segunda del cliente
struct sockaddr_in server;
struct sockaddr_in client;
//Configuracion del servidor
server.sin_family= AF_INET; //Familia TCP/IP
server.sin_port = htons(puerto); //Puerto
server.sin_addr.s_addr = INADDR_ANY; //Cualquier cliente puede conectarse
bzero(&(server.sin_zero),8); //Funcion que rellena con 0's
//Paso 2, definicion de socket
if (( fd=socket(AF_INET,SOCK_STREAM,0) )<0){
perror("Error de apertura de socket");
exit(-1);
}
//Paso 3, avisar al sistema que se creo un socket
if(bind(fd,(struct sockaddr*)&server, sizeof(struct sockaddr))==-1) {
printf("error en bind() \n");
exit(-1);
}
//Paso 4, establecer el socket en modo escucha
if(listen(fd,5) == -1) {
printf("error en listen()\n");
exit(-1);
}
Mat frame; //array que representa los frames del video
vector<uchar> encoded; //vector para almacenar el frame codificado en jpeg
VideoCapture cap("/home/agustin/Descargas/video_prueba.mp4"); //Obtener el video desde archivo.
//Crea una nueva ventana con nombre servidor
namedWindow("servidor", CV_WINDOW_AUTOSIZE);
/*while(true){
cap >> frame;
imshow("servidor",frame);
waitKey(1000/30);
}*/
cout << "llegue a hacer video" << endl;
//Paso5, aceptar conexiones
while(1) {
socklen_t longitud_cliente= sizeof(struct sockaddr_in);
/* A continuación la llamada a accept() */
if ((pTCPcliente = accept(fd,(struct sockaddr *)&client,&longitud_cliente))==-1) { //pTCPcliente es el puerto tcp del cliente
printf("error en accept()\n");
exit(-1);
}
char * buf= new char[100];
recv(pTCPcliente,buf,100,0);// aca en buf queda el puertoUDP del cliente
cout << string(buf)<< endl;
int i=0;
int socket_de_clienteUDP = socket(AF_INET, SOCK_DGRAM, 0);
struct sockaddr_in udp_addr;
socklen_t udp_addr_size = sizeof udp_addr;
udp_addr.sin_family = AF_INET;
udp_addr.sin_port = htons(0);
udp_addr.sin_addr.s_addr = inet_addr(MY_IP);
udp_addr.sin_addr.s_addr = inet_addr(MY_IP);
bind(socket_de_clienteUDP,(struct sockaddr*)&udp_addr, udp_addr_size);
struct sockaddr_in addr_destinoudp;
socklen_t addr_destinodup_len = sizeof addr_destinoudp;
addr_destinoudp.sin_family = AF_INET;
addr_destinoudp.sin_port = htons(atoi(buf)); //buf es para la comunicacion entre cliente y el servidor
addr_destinoudp.sin_addr.s_addr = inet_addr(MY_IP);
int sent_data_size = sendto(
socket_de_clienteUDP,
"hola", 4, 0,
(struct sockaddr*)&addr_destinoudp,addr_destinodup_len
);
int j = 0;
char* data=new char;
recv(pTCPcliente, (void *)data, 1, 0); // espera el 1 para empezar a reproducir
struct parametros *p= new parametros;
//p->id_cliente= id_cliente;
p->frame= frame;
p->cap= cap;
p->encoded= encoded;
//p->comunicacion=comunicacion;
p->addr_destinoudp= addr_destinoudp;
p->pTCPcliente=pTCPcliente;
p->socket_de_clienteUDP=socket_de_clienteUDP;
pthread_t hilo_control;
int aux2 = pthread_create(&hilo_control, NULL, controlVideo,(void*)p); //separo thread (idcliente, tcp)
cout<< "Hice el thread control"<< endl;
pthread_join(hilo_control, NULL);//problema number 1
//primitiva CLOSE
close(pTCPcliente);
}
close(fd);
}
void *controlVideo(void* pol){
parametros* p = (parametros*)pol;
//pthread_mutex_init(&finalizar, NULL);
//pthread_mutex_init(&pausa, NULL);
pthread_t hilo_stream;
int aux3=pthread_create(&hilo_stream, NULL, streamVideo,(void *)p);
cout<< "Hizo el thread stream"<< endl;
int aux = 1;
char *data = new char[1];
while (aux!=5){
//primitiva RECEIVE
recv(p->pTCPcliente, (void *)data, 1, MSG_WAITALL);
aux = atoi(data);
switch (aux){
case 1:
cout<< "Apretaron 1"<< endl;
//pthread_mutex_unlock(&finalizar);
break;
case 2:
cout<< "Apretaron 2"<< endl;
//pthread_mutex_unlock(&pausa);
break;
case 3:
//a= nombre[10];
cout<< "Apretaron 3"<< endl;
//pthread_mutex_lock(&pausa);
break;
case 4:
cout<< "Apretaron 4"<< endl;
//pthread_mutex_lock(&finalizar);
break;
case 5:
cout<< "Apretaron 5"<< endl;
pthread_cancel(hilo_stream);//problema number 3
break;
}
//pthread_mutex_lock(&mutex);
//aux = p->comunicacion[p->id_cliente];
//pthread_mutex_unlock(&mutex);
}
pthread_join(hilo_stream, NULL);//problema number 2
}//termina control
//stream
void *streamVideo(void* pol){
parametros* p = (parametros*)pol;
while(true){
p->cap >> p->frame; //obtener nuevo frame
imshow("servidor", p->frame); //muestra la imagen en la ventana servidor
waitKey(1000/30); //espera para ver las frames y que se reproduzca el video en el servidor
//convertir la imagen a texto para enviar
vector <int> compression_params;
compression_params.push_back(CV_IMWRITE_JPEG_QUALITY);
compression_params.push_back(80);
imencode(".jpg", p->frame, p->encoded, compression_params);
unsigned char* data= p->encoded.data();
int sent_data_size = sendto(
p->socket_de_clienteUDP,
data, p->encoded.size(), 0,
(struct sockaddr*)&p->addr_destinoudp,sizeof(p->addr_destinoudp)
);
}
}
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment