Universidad de Costa Rica Facultad de Ingeniería Escuela de Ingeniería Eléctrica IE – 0502 Proyecto Eléctrico Implementación de un sistema de captura de video y detección de movimiento utilizando el sistema Video4Linux Por: Andrés Díaz Soto Ciudad Universitaria Rodrigo Facio Junio del 2005 Implementación de un sistema de captura de video y detección de movimiento utilizando el sistema Video4Linux Por: Andrés Díaz Soto Sometido a la Escuela de Ingeniería Eléctrica de la Facultad de Ingeniería de la Universidad de Costa Rica como requisito parcial para optar por el grado de: BACHILLER EN INGENIERÍA ELÉCTRICA Aprobado por el tribunal: Ing. Federico Ruiz Ugalde Profesor Guía Ing. Francisco Siles Canales Profesor lector Ing. Enrique Coen Alfaro Profesor lector II DERECHOS DE PROPIEDAD INTELECTUAL Linux es una marca registrada de Linus Torvalds. Intel es una marca registrada de Intel Corporation. ImageMagick es una marca registrada de ImageMagick Studio LLC. USB (Universal Serial Bus Specification) es una marca registrada de Compaq Computer Corporation, Intel Corporation, NEC Corporation y otros. Las demás marcas registradas son propiedad de sus respectivos dueños. III DEDICATORIA A toda mi familia y a mis amigos, que han estado a mi lado a lo largo de estos años. IV ÍNDICE GENERAL ÍNDICE DE FIGURAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . VIII ÍNDICE DE CUADROS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . IX NOMENCLATURA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . X RESUMEN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . XII CAPÍTULO 1: Introducción . . . . . 1.1. Justificación . . . . . . . . . . 1.2. Objetivos . . . . . . . . . . . 1.2.1. Objetivo General . . . 1.2.2. Objetivos Específicos . 1.3. Metodología . . . . . . . . . . 1.4. Herramientas Utilizadas . . . . 1.4.1. Hardware . . . . . . . 1.4.2. Software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 1 2 2 2 2 3 3 3 CAPÍTULO 2: Desarrollo Teórico . . . . . . . . . . . . . . . 2.1. El sistema operativo GNU/Linux . . . . . . . . . . . 2.2. Acceso a dispositivos y funciones de entrada y salida 2.2.1. open() . . . . . . . . . . . . . . . . . . . . . 2.2.2. close() . . . . . . . . . . . . . . . . . . . . . 2.2.3. read() . . . . . . . . . . . . . . . . . . . . . 2.2.4. write() . . . . . . . . . . . . . . . . . . . . . 2.2.5. ioctl() . . . . . . . . . . . . . . . . . . . . . 2.3. Programación con múltiples hilos de procesamiento . 2.3.1. pthread_create() . . . . . . . . . . . . . . . 2.3.2. pthread_exit() . . . . . . . . . . . . . . . . . 2.3.3. pthread_join() . . . . . . . . . . . . . . . . . 2.3.4. pthead_mutex_init() . . . . . . . . . . . . . 2.3.5. pthread_mutex_lock() . . . . . . . . . . . . 2.3.6. pthread_mutex_unlock() . . . . . . . . . . . 2.3.7. pthread_mutex_destroy() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5 5 6 6 7 7 8 8 8 9 10 10 10 11 11 11 V . . . . . . . . . . . . . . . . . . . . . . . . . . . 2.4. El sistema Video4Linux . . . . . . . . . . . . . . . . 2.4.1. La interfaz de programación de Video4Linux 2.5. Algoritmos de detección de movimiento . . . . . . . 2.6. Reducción de ruido en las imágenes . . . . . . . . . 2.6.1. Filtro de media . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 12 16 18 18 CAPÍTULO 3: Descripción general del sistema de captura de video y detección de movimiento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.1. Estructura de la aplicación y aspectos generales . . . . . . . . . . . . . . . . 3.2. Estructura del servidor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.1. Inicialización y comunicación con el cliente . . . . . . . . . . . . . . 3.2.2. Captura de video . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2.3. Detección de movimiento . . . . . . . . . . . . . . . . . . . . . . . 3.2.4. Envío del video . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3. Estructura del cliente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3.1. Interfaz gráfica de usuario y mensajería TCP . . . . . . . . . . . . . 3.3.2. Recepción de los cuadros de video . . . . . . . . . . . . . . . . . . . 20 20 21 21 22 23 23 25 26 26 CAPÍTULO 4: Rutinas de captura de video . . . . . . . . . . . . . . . . . . . . . . . 29 4.1. Inicialización del sistema de video . . . . . . . . . . . . . . . . . . . . . . . 29 4.2. Ciclo de captura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31 CAPÍTULO 5: Rutinas de comunicación con el cliente y transmisión de video sobre la red . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.1. Creación del socket TCP en el servidor . . . . . . . . . . . . . . . . . . . . . 5.2. Envío y recepción de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3. Envío del video capturado al cliente . . . . . . . . . . . . . . . . . . . . . . 5.3.1. Creación del socket UDP . . . . . . . . . . . . . . . . . . . . . . . . 5.3.2. Fragmentación y envío de los cuadros de video . . . . . . . . . . . . 36 36 38 41 41 42 CAPÍTULO 6: Rutinas de detección de movimiento y escritura a disco duro 6.1. Algoritmo de detección de movimiento . . . . . . . . . . . . . . . . . 6.2. Filtrado de las imágenes . . . . . . . . . . . . . . . . . . . . . . . . . 6.3. Determinación de eventos de movimiento . . . . . . . . . . . . . . . . 6.4. Rutinas de escritura a disco duro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 44 46 48 52 CAPÍTULO 7: Rutinas de comunicación y despliegue de video en el cliente . 7.1. Envío de mensajes al servidor . . . . . . . . . . . . . . . . . . . . . . 7.2. Recepción de los cuadros de video . . . . . . . . . . . . . . . . . . . . 7.3. Despliegue de la imagen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 58 61 64 CAPÍTULO 8: Resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 8.1. Captura de video . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 8.2. Reducción de ruido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66 VI 8.3. Determinación de eventos de movimiento . . . . . . . . . . . . . . . . . . . 67 CAPÍTULO 9: Conclusiones y Recomendaciones . . . . . . . . . . . . . . . . . . . . 71 9.1. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 9.2. Recomendaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 BIBLIOGRAFÍA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 APÉNDICES . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 VII ÍNDICE DE FIGURAS Figura 3.1 Partes principales de la aplicación . . . . . . . . . . . . . . . . . . . . . . . . . Figura 3.2 Diagrama de flujo del hilo de inicialización y comunicación con el cliente. . . Figura 3.3 Diagrama de flujo del hilo de captura de video. . . . . . . . . . . . . . . . . . . Figura 3.4 Diagrama de flujo del hilo de detección de movimiento. . . . . . . . . . . . . . Figura 3.5 Diagrama de flujo del hilo de envío del video. . . . . . . . . . . . . . . . . . . . Figura 3.6 Estructura de la aplicación cliente. . . . . . . . . . . . . . . . . . . . . . . . . . Figura 3.7 Diagrama de flujo del hilo encargado de la interfaz gráfica y la mensajería TCP en el cliente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Figura 3.8 Diagrama de flujo del hilo de recepción de video. . . . . . . . . . . . . . . . . . 20 22 23 24 25 26 27 28 Figura 4.1 Diagrama del algoritmo de captura de video utilizado. . . . . . . . . . . . . . . 32 Figura 6.1 Diagrama de la máquina de estados encargada de detectar los eventos de movimiento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 Figura 8.1 Aplicación del filtro de media para reducir el ruido en las imágenes capturadas 67 Figura 8.2 Porcentaje de pixeles con diferencias durante un evento de movimiento . . . . 69 Figura 8.3 Respuesta del sistema ante un cambio rápido en la iluminación . . . . . . . . . 70 VIII ÍNDICE DE CUADROS Cuadro 2.1 Información contenida por la estructura video_capability. Cuadro 2.2 Información contenida por la estructura video_buffer. . . . Cuadro 2.3 información contenida por la estructura video_window. . . Cuadro 2.4 Información contenida por la estructura video_channel.. . Cuadro 2.5 Información contenida por la estructura video_picture. . . Cuadro 2.6 Información contenida por la estructura video_tuner. . . . Cuadro 2.7 Información contenida por la estructura video_mbuf. . . . Cuadro 2.8 Información contenida por la estructura video_mmap.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13 13 14 14 15 15 16 16 Cuadro 5.1 Mensajes implementados para la comunicación entre el cliente y el servidor . 39 Cuadro 6.1 Estados necesarios para el algoritmo de detección de eventos de movimiento 48 Cuadro 8.1 Cuadros por segundo capturados. . . . . . . . . . . . . . . . . . . . . . . . . . 66 Cuadro 8.2 Parámetros del sistema de detección de eventos de movimiento utilizados durante la prueba . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 IX NOMENCLATURA BSD: Berkeley Software Distribution. Familia de versiones de UNIX implementadas a partir de 1977. Muchas de las características de estos sistemas se han convertido en un estándar para implementaciones posteriores. buffer: Sector de memoria utilizado para el almacenamiento temporal de datos. FSF: Free Software Foundation, Fundación del Software Libre. GNU: Acrónimo recursivo: GNU is Not UNIX. Proyecto de FSF que busca crear un sistema operativo completo utilizando únicamente software libre. GTK: Gimp Toolkit. Conjunto de herramientas para la creación de interfaces de usuario gráficas. JPEG: Joint Picture Experts Group. Formato estandarizado de almacenamiento y compresión de imágenes. libc: Biblioteca Estándar del lenguaje C del sistema operativo GNU/Linux. LZO: Biblioteca de compresión de datos en tiempo real. MPEG: Moving Picture Expert Group. Formato estandarizado de compresión de video. POSIX: Portable Operating System Interface. Conjunto de estándares definidos por la IEEE que definen una interfaz de programación para software diseñado para ser ejecutado en variantes del sistema operativo UNIX. pthreads: POSIX threads. Implementación de hilos múltiples de procesamiento que forma parte del estándar POSIX. socket: Mecanismo para la creación de conexiones virtuales entre procesos, los cuales pueden ser ejecutados en una misma máquina, o en computadoras distintas. SYSV: UNIX System V. Versión de UNIX desarrollada en 1983 por AT&T. Esta versión dio lugar a un estándar conocido como System V Interface Definition. X TCP: Transfer Control Protocol. Protocolo de transmisión de datos orientado a conexión, que forma parte del conjunto de protocolos TCP/IP. TCP/IP: Conjunto de protocolos desarrollados para la transmisión de datos sobre Internet. UDP: User Datagram Protocol. Protocolo no orientado a conexión, que forma parte del conjunto de protocolos TCP/IP. UNIX: Sistema Operativo multitareas desarrollado en 1969 por Ken Thompson. Entre 1972 y 1974 fue implementado completamente en el lenguaje C, lo que lo convirtió en el primer sistema operativo portable a nivel de código fuente. Esto ha dado lugar a múltiples versiones e implementaciones, entre ellas Linux. USB: Universal Serial Bus, bus serial universal. V4L: Video4Linux. Interfaz para el acceso a dispositivos de video del sistema operativo GNU/Linux. V4L2: Video4Linux versión 2. XI RESUMEN Este proyecto tiene como objetivo desarrollar un sistema de adquisición de video que implemente algoritmos de detección de movimiento, con el fin de utilizarlo como parte de una aplicación de vigilancia, utilizando el conjunto de controladores y rutinas de acceso a dispositivos de video conocido como Video4Linux disponibles en el sistema operativo GNU/Linux. El sistema se implementó en el lenguaje de programación C, utilizando un modelo clienteservidor, con una aplicación principal encargada de llevar a cabo la adquisición y el procesamiento del video, y una aplicación cliente que se comunicaba con el servidor utilizando el protocolo TCP/IP y permitía controlar el sistema y observar el video capturado en tiempo real. Se utilizaron múltiples hilos de procesamiento, tanto en la aplicación cliente como en el servidor, con el fin de separar las distintas partes del sistema y de optimizar el desempeño. Se creó un sistema de adquisición de video que colocaba los cuadros capturados en memoria, a disposición de las otras partes del sistema . Posteriormente se desarrolló un conjunto de rutinas que permitían detectar movimiento con base en las diferencias de intensidad entre dos cuadros consecutivos de la secuencia capturada. También se implementó un sistema encargado de determinar la existencia de eventos de movimiento significativos, con el fin de eliminar eventos falsos, y de grabar los eventos detectados al disco duro de la computadora para su posterior revisión. Además, se creó un sistema utilizando sockets de red para llevar a cabo la transmisión de video y la comunicación entre el cliente y el servidor. Se logró capturar video a la mayor velocidad permitida por el dispositivo. Además, se obtuvieron buenos resultados en las rutinas de detección de movimiento, las cuales funcionaron de manera satisfactoria en las pruebas realizadas. El sistema final desarrollado resultó estable y eficiente, adecuado para una amplia gama de aplicaciones. XII CAPÍTULO 1: Introducción 1.1. Justificación En la actualidad, la mayoría de los sistemas de video están construidos utilizando sistemas propietarios, los cuales, además de ser costosos, limitan en gran medida la escalabilidad y la flexibilidad. Generalmente, estos productos utilizan protocolos cerrados, que dificultan e incluso impiden la interoperabilidad con dispositivos de otras marcas. Esto limita las opciones a la hora de una actualización y dificulta el mantenimiento del sistema. El desarrollo de estos sistemas sobre plataformas abiertas brinda una mayor versatilidad, dado que amplía la gama de opciones disponibles, además de que permite crear soluciones que se adapten de una mejor forma a cada situación particular. Hoy en día, una opción cada vez más utilizada consiste en utilizar sistemas de computo para el almacenamiento y el procesamiento del video. Esto proporciona una mayor versatilidad, debido a que facilita realizar cambios y añadir elementos. Actualmente pueden encontrarse en el mercado varios sistemas de esta clase, tanto propietarios como abiertos, para múltiples sistemas operativos. Para este proyecto se ha elegido implementar un conjunto de aplicaciones de adquisición y procesamiento de video sobre el sistema operativo GNU/Linux, utilizando el conjunto de controladores y herramientas Video4Linux, presente en este sistema. Entre las razones principales para esta elección se encuentran la gran estabilidad de este sistema operativo, así como sus características de seguridad. Además, existe una cantidad importante de dispositivos de bajo costo compatibles con Video4Linux, lo que reduce la inversión en equipo y brinda mayor flexibilidad. Por último, tanto la interfaz de acceso al hardware como el sistema operativo y demás aplicaciones necesarias son completamente abiertas, con todas las ventajas expuestas anteriormente. Si bien es cierto la aplicación principal para este sistema es la vigilancia, es posible adaptarlo para su utilización en una amplia gama de aplicaciones, lo que convierte a este sistema en una plataforma de de desarrollo para proyectos futuros. 1 2 1.2. Objetivos 1.2.1. Objetivo General Desarrollar un sistema de adquisición y procesamiento de video que implemente algoritmos de detección de movimiento, utilizando el sistema Video4Linux. 1.2.2. Objetivos Específicos Desarrollar un conjunto de rutinas que sean capaces de capturar video de uno o varios dispositivos a la máxima velocidad posible. Implementar un algoritmo que permita detectar movimiento y que sea capaz de registrar y capturar eventos para su posterior revisión. Implementar una interfaz gráfica de usuario que permita visualizar en tiempo real la imagen adquirida por cada una de las cámaras conectadas al sistema, así como los eventos registrados mediante los algoritmos de detección de movimiento. 1.3. Metodología La metodología utilizada para la realización del trabajo fue la siguiente: Se definen los objetivos y los alcances del proyecto, con el fin de estructurar el plan de trabajo a realizar. Se realiza una investigación bibliográfica sobre GNU/Linux y la interfaz de programación de Video4Linux, con el fin de conocer las características del sistema. Además se investiga sobre las principales técnicas y algoritmos para llevar a cabo la detección de movimiento. Se inicia el desarrollo de las rutinas de captura de video, capturando primero imágenes fijas y posteriormente secuencias de imágenes. Se investiga como optimizar el proceso de captura con el fin de obtener la mayor cantidad de cuadros por segundo posibles. Una vez implementadas las rutinas de captura de video se realizan pruebas utilizando varios dispositivos, con el fin de evaluar el desempeño obtenido. 3 Se decide utilizar el protocolo TCP/IP para llevar a cabo la comunicación entre la interfaz gráfica de usuario y el sistema de captura y procesamiento. Se desarrolla un sistema de mensajería, así como un método para enviar los cuadros de video para su visualización. Se implementa el algoritmo de detección de movimiento y se desarrolla un sistema de almacenamiento de las imágenes con base en los eventos de movimiento. Se realizan pruebas con el fin de evaluar el desempeño del sistema de detección de movimiento y el almacenamiento a disco duro. Paralelamente a cada uno de estos pasos, se lleva a cabo la documentación del trabajo realizado y la redacción del informe final. 1.4. Herramientas Utilizadas 1.4.1. Hardware Dispositivos de video El desarrollo y las pruebas del sistema implementado se llevó a cabo utilizando dos dispositivos de adquisición de video compatibles con Video4Linux: 1. Cámara USB marca Genius, modelo VideoCAM Express V2. 2. Tarjeta de televisión y adquisición de video marca Haupage, modelo TVPhone 98. 1.4.2. Software Lenguaje de programación y compilador El desarrollo del sistema se llevó a cabo utilizando el lenguaje de programación C. El compilador utilizado fue gcc1 , el cual forma parte del proyecto GNU. Se utilizaron las funciones de la biblioteca estándar C de GNU/Linux (libc), además de otras bibliotecas que forman parte de este sistema operativo, tales como pthreads. 1 http://gcc.gnu.org/ 4 Editor de texto La edición del programa, así como la este informe, se llevó utilizando el editor de texto Vim2 , tanto en su versión de consola como en su versión gráfica (gvim). Sistema operativo El desarrollo se llevó a cabo utilizando el sistema operativo GNU/Linux. La distribución empleada fue Debian3 «Sid» (versión inestable). Procesamiento tipográfico Este documento fue preparado utilizando el sistema de procesamiento tipográfico LATEX4 . 2 http://www.vim.org/ http://www.debian.org/ 4 http://www.latex-project.org/ 3 CAPÍTULO 2: Desarrollo Teórico 2.1. El sistema operativo GNU/Linux Linux es un kernel1 tipo UNIX, creado en 1991 por el finlandés Linus Torvalds. Linux se caracteriza por ser una implementación libre del estándar POSIX, con extensiones SYSV y BSD. Si bien es cierto, es compatible en muchos aspectos con UNIX, todo el código fue escrito de nuevo y no contiene partes de ninguna versión o variante de UNIX existente. Linux fue escrito inicialmente para funcionar en procesadores Intel 386 y compatibles, sin embargo hoy en día ha sido portado a un gran número de plataformas, entre las que se encuentran Alpha, PowerPC, Motorola 68K y Sparc. Un aspecto que es importante resaltar es que Linux es solamente el kernel o núcleo del sistema operativo, o sea, el que se encarga de realizar las tareas de más bajo nivel, como la gestión del hardware, el acceso a memoria o el manejo de los sistemas de archivos. Para poder utilizar el sistema es necesario contar con aplicaciones tales como un intérprete de comandos (conocido como shell), compiladores, herramientas para el manejo de archivos, procesadores de texto, entre otras. En el caso de Linux, la mayoría de estas aplicaciones forman parte del proyecto GNU, iniciado por la Fundación del Software Libre (FSF), el tiene como fin crear un sistema operativo completo libre. El conjunto de estas aplicaciones GNU y el kernel Linux es conocido generalmente como GNU/Linux. Desde el punto de vista técnico, algunas de las características principales de Linux son las siguientes: Mutitareas. Multiusario. Soporte para múltiples arquitecturas. Soporte para sistemas multiprocesador. Funciona en modo protegido en los procesadores Intel 386 y compatibles. 1 Núcleo de un sistema operativo. Componente de software responsable de proveer acceso seguro al hardware de la máquina y a los procesos que están siendo ejecutados[9]. 5 6 Posee protección de memoria entre procesos. Esto impide que un programa pueda provocar una falla en el sistema. Soporte para memoria virtual con paginación en el disco duro, con el fin de proveer más memoria al sistema en caso de ser necesaria (Esto se conoce como área de intercambio o swap). Soporte para una gran cantidad de sistemas de archivos, entre ellos ReiserFS, XFS, Ext2, Ext3, MSDOS, FAT16, FAT32 y NTFS (lectura, el soporte para escritura es limitado y aún se encuentra en desarrollo). Soporte para una gran cantidad de protocolos de red, entre ellos TCP, IPv4, IPv6, IPX, AppleTalk y SMB. 2.2. Acceso a dispositivos y funciones de entrada y salida En Linux, al igual que en todos los sistemas tipo UNIX, la mayoría de los dispositivos pueden ser accedidos como si se tratara de archivos. Esto permite llevar a cabo todas las operaciones de entrada y salida a través de un pequeño conjunto de llamadas al sistema, las cuales se encuentran definidas en el estándar POSIX. A continuación se brinda una descripción general de las llamadas más utilizadas. 2.2.1. open() La llamada al sistema open() se encarga de abrir un archivo y asignarlo a una variable conocida como descriptor de archivo. El descriptor de archivo se utiliza para referirse al archivo a lo largo del programa, y es utilizado como argumento para las otras funciones de entrada y salida. La sintaxis de open() es la siguiente: #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> int open(const char *pathname, int flags). int open(const char *pathname, int flags, mode_t mode); 7 donde pathname corresponde al nombre del archivo, flags especifica las condiciones en que se abrirá el archivo, y mode define los permisos que se utilizarán cuando se crea un nuevo archivo. Por ejemplo, para abrir el dispositivo /dev/ttyS0 (primer puerto serial) para lectura se debe utilizar la llamada int fd; /* Descriptor de archivo que se utilizará para referirse al dispositivo */ fd = open("/dev/ttyS0", O_RDONLY); 2.2.2. close() La llamada close() se encarga de cerrar un archivo que ha sido abierto con anterioridad, una vez que no se va a utilizar más. close() recibe como argumento el descriptor de archivo correspondiente al archivo que se quiere cerrar, y retorna 0 en caso de éxito, o −1 si se produjo algún error. La sintaxis de esta llamada es la siguiente: #include <unistd.h> int close(int fd); 2.2.3. read() La llamada al sistema read() se utiliza para leer datos desde un archivo. la sintaxis es la siguiente: #include <unistd.h> ssize_t read(int fd, void *buf, size_t count); donde fd es el descriptor de archivo, buf es un puntero al sector de memoria donde se almacenarán los datos y count corresponde a la cantidad de información —en bytes— que será leída. El valor retornado por read es el número de bytes leídos, o −1 en caso de que se presente un error. 8 2.2.4. write() La llamada al sistema write() permite escribir datos a un archivo. La sintaxis de write() es la siguiente: #include <unistd.h> ssize_t write(int fd, const void *buf, size_t count); El parámetro fd es el descriptor de archivo, buf corresponde a un puntero dirigido al sector de memoria en el cual se encuentran los datos que se desean escribir al archivo y count es el número de bytes que se desean escribir. La llamada write() retorna el número de bytes escritos, o −1 en caso de que ocurra algún error. 2.2.5. ioctl() La llamada al sistema ioctl() es utilizada casi exclusivamente con los dispositivos. Esta llamada se encarga de llevar a cabo operaciones sobre un archivo, o bien definir parámetros asociados a un archivo en particular. Estas operaciones y parámetros dependen del archivo, y corresponden generalmente a características del dispositivo. Por ejemplo, ioctl() se puede utilizar para definir la frecuencia de muestreo, el número de canales o la cantidad de bits de una tarjeta de sonido. La sintaxis de ioctl() es la siguiente: #include <sys/ioctl.h> int ioctl(int d, int request, ...) donde d corresponde al descriptor de archivo y request denota la operación que se quiere realizar. La llamada ioctl() también puede recibir otros argumentos requeridos por alguna operación en particular. 2.3. Programación con múltiples hilos de procesamiento La programación con múltiples hilos de procesamiento es un esquema que permite desarrollar aplicaciones que ejecuten varios flujos de procesamiento dentro de un mismo proceso. De esta forma, cada uno de los flujos o hilos se ejecuta de forma independiente, sin interferir 9 con los otros. Además, cada uno de los hilos tiene acceso a los distintos recursos del proceso, tales como las variables globales y el entorno. Cada uno de los hilos de procesamiento es administrado por el planificador del sistema de archivos. De esta forma se obtiene un esquema similar a programación multiproceso tradicional de Linux, con la ventaja de que es más sencillo compartir recursos entre los flujos de procesamiento, sin necesidad de recurrir a recursos tales como colas (queues) o tuberías (pipes). Utilizando hilos múltiples de procesamiento es posible obtener ejecución paralela en sistemas multiprocesador, lo cual incrementa el desempeño de una aplicación de forma significativa. En el caso de los sistemas monoprocesador, se obtiene un pseudo-paralelismo debido a la planificación llevada a cabo por el sistema de archivos, lo cual trae consigo también mejoras en el desempeño, así como una simplificación del diseño de la aplicación, debido a que es posible separar las tareas que deben ejecutarse simultáneamente y dejar que el sistema operativo se encargue de su ejecución. La implementación de hilos múltiples de procesamiento en Linux es conocida como pthreads, o POSIX threads. Esta implementación es utilizada en la mayoría de los sistemas UNIX actuales. Algunas de las rutinas principales de esta biblioteca se describen a continuación. 2.3.1. pthread_create() La función pthread_create() se encarga de crear un nuevo hilo de procesamiento y hacer que el sistema operativo programe su ejecución. La sintaxis de esta función se muestra a continuación: #include <pthread.h> int pthread_create(pthread_t *thread, pthread_attr_t *attr, void *(*start_routine)(void *), void *arg); donde thread es la variable que apunta al nuevo hilo creado, con los atributos attr. Este nuevo hilo ejecutará la función start_routine la cual debe retornar un puntero nulo. Además, esta función puede recibir un argumento arg, el cual debe convertirse a un puntero nulo antes de ser enviado. 10 2.3.2. pthread_exit() Esta función es llamada por las funciones ejecutadas dentro de un hilo de procesamiento para indicar su finalización. La sintaxis de pthread_exit() se muestra a continuación: #include <pthread.h> void pthread_exit(void *retval); La variable retval es el valor de retorno de la función. Esta función es equivalente a la función exit() utilizada en las aplicaciones de un solo hilo. 2.3.3. pthread_join() La rutina pthread_join() detiene la ejecución del hilo actual hasta que otro hilo finalice. La sintaxis de esta función es la siguiente: #include <pthread.h> int pthread_join(pthread_t th, void **thread_return); donde th es el hilo por el cual se esperará. El valor de retorno de este hilo (retornado por la función pthread_exit()) es almacenado en la variable apuntada por thread_return. 2.3.4. pthead_mutex_init() Esta función inicializa una variable mutex. Esta variable permite controlar el acceso a un recurso compartido, evitando que dos hilos puedan manipularlo al mismo tiempo. La sintaxis de esta función es la siguiente: #include <pthread.h> int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutex_attr_t *mutexattr); donde mutex es la nueva variable de control de acceso y mutexattr contiene los atributos de esta nueva variable. 11 2.3.5. pthread_mutex_lock() La función pthread_mutex_lock() coloca un bloqueo sobre una variable mutex. Esta operación es llevada a cabo por un hilo cuando desea acceder a alguno de los recursos compartidos. Si la variable ya está bloqueada el recurso está siendo utilizado por otro hilo y la ejecución del hilo actual se detendrá hasta que la variable sea desbloqueada. Una variante de esta función es la rutina pthread_mutex_trylock(), la cual no detendrá la ejecución del hilo si la variable se encuentra bloqueada. La sintaxis de pthread_mutex_lock se muestra a continuación: #include <pthread.h> int pthread_mutex_lock(pthread_mutex_t *mutex); donde mutex es la variable de control a bloquear. 2.3.6. pthread_mutex_unlock() Esta rutina se encarga de desbloquear una variable mutex, con el fin de permitir que otros hilos puedan tener acceso al recurso compartido. La sintaxis de esta función se muestra a continuación: #include <pthread.h> int pthread_mutex_unlock(pthread_mutex_t *mutex); 2.3.7. pthread_mutex_destroy() La rutina pthread_mutex_destroy() se encarga de liberar los recursos ocupados por una variable mutex, una vez que su utilización ha finalizado. La sintaxis de esta rutina es la siguiente: #include <pthread.h> int pthread_mutex_destroy(pthread_mutex_t *mutex); 12 2.4. El sistema Video4Linux Video4Linux es un sistema de acceso a dispositivos de video que agrupa a varios controladores bajo una interfaz de programación común. Esto permite desarrollar programas con una interfaz de acceso al hardware única, que funcionan con una gran cantidad de dispositivos. Además, el programador puede concentrarse en los aspectos funcionales de su programa sin preocuparse por las rutinas de bajo nivel del controlador. Existe una amplia gama de dispositivos soportados por Video4Linux, incluyendo tarjetas de captura de video, sintonizadores de televisión, cámaras USB y de puerto paralelo, además de decodificadores de teletexto. Video4Linux (V4L) fue introducido al final del ciclo de desarrollo del kernel 2.1.x. A partir del kernel 2.5.x se introdujo Video4Linux 2 (V4L2). Esta nueva generación corrige muchos de los problemas de diseño de la versión anterior, además de que presenta nuevas características tales como funciones para el manejo de streaming de video y métodos optimizados de acceso de memoria. Si bien es cierto la recomendación es utilizar V4L2, aún muchos controladores no soportan esta nueva especificación. 2.4.1. La interfaz de programación de Video4Linux Los dispositivos de captura de video V4L son accesibles a través del archivo /dev/video[n], donde [n] es un número entre 0 y 63 que corresponde al identificador del dispositivo y se asigna de forma sucesiva al registrar el dispositivo en el kernel. Una vez abierto este archivo es posible acceder a la mayoría de las funciones del dispositivo utilizando la llamada al sistema ioctl(). Los controles disponibles son los siguientes: VIDIOCGCAP: Permite obtener la información básica del dispositivo, tal como el tipo de dispositivo, el número de canales y la resolución máxima. Recibe como argumento una estructura del tipo video_capability, en la cual se almacena la información retornada por la llamada. La información contenida por esta estructura se muestra en el cuadro 2.1. VIDIOCSFBUF: Permite fijar los parámetros para la escritura directa al framebuffer de la tarjeta de video. No todos los dispositivos soportan esta característica. Además, el 13 Cuadro 2.1 Información contenida por la estructura video_capability. Campo name[32] type channels audios maxwidth maxheight minwidth minheight Descripción Nombre del dispositivo Tipo de dispositivo Número de canales Número de dispositivos de audio Ancho máximo posible del cuadro capturado Altura máxima posible del cuadro capturado Ancho mínimo posible del cuadro capturado Altura mínima posible del cuadro capturado acceso a framebuffer no es posible en algunos sistemas. Esta llamada recibe como argumento una estructura del tipo video_buffer, la cual contiene los parámetros de acceso al framebuffer. El contenido de esta estructura se muestra en el cuadro 2.2. Cuadro 2.2 Información contenida por la estructura video_buffer. Campo void *base int height int width int depth int bytesperline Descripción Dirección física base del buffer Altura del buffer Ancho del buffer Profundidad del buffer Número de bytes entre el inicio de dos líneas adyacentes VIDIOCGWIN: Obtiene la información del área de captura. Recibe como argumento una estructura del tipo video_window, en la cual se escribe la información. El contenido de esta estructura se describe en el cuadro 2.3. VIDIOCSWIN: Permite definir la información del área de captura requerida. Recibe como argumento una estructura video_window la cual debe contener los parámetros deseados. 14 Cuadro 2.3 información contenida por la estructura video_window. Campo x y width height chromakey flags clips clipcount Descripción Coordenada x del área de captura Coordenada y del área de captura Ancho del área de captura Altura del área de captura Valor RGB32 del chroma Banderas de captura adicionales Lista de rectángulos que se requiere extraer (sólo VIDIOCSWIN) Número de rectángulos que se desea extraer (sólo VIDIOCSWIN) VIDIOCCAPTURE: Permite activar y desactivar la captura en modo overlay2 . VDIOCGCHAN: Retorna la información de los canales del dispositivo. Almacena la información en la estructura del tipo video_channel que recibe como argumento. Los contenidos se esta estructura se muestran en el cuadro 2.4. Cuadro 2.4 Información contenida por la estructura video_channel. Campo Descripción channel Número del canal name Nombre del canal tuners Número de sintonizadores en el canal flags Propiedades del sintonizador type Tipo de entrada norm Norma que utiliza el canal VIDIOCSCHAN: Selecciona el canal del cual se va a capturar. Recibe un entero con el número del canal como argumento. VIDIOCGPICT: Retorna las características (brillo, saturación, etc.) de la imagen. Almacena la información en la estructura de tipo video_picture que recibe como argumento. Los componentes de esta estructura se muestran en el cuadro 2.5. 2 Transferencia directa desde la memoria del dispositivo de captura hasta la memoria de la tarjeta de video. Este modo incrementa la velocidad y reduce el procesamiento necesario cuando sólo se requiere desplegar el video capturado, sin efectuar ninguna operación intermedia. 15 Cuadro 2.5 Información contenida por la estructura video_picture. Campo brightness hue colour contrast whiteness depth palette Descripción Brillo Tonalidad (sólo imágenes a color) Balance de color (sólo imágenes a color) Contraste de la imagen Nivel de blancura (sólo imágenes en escala de grises) Nivel de profundidad de la imagen Paleta que debe usarse para la imagen VIDIOCSPICT: Permite definir las características de la imagen que será capturada. Recibe como argumento una estructura del tipo video_picture, la cual debe contener los nuevos valores requeridos. VIDIOCGTUNER: Obtiene las características del sintonizador. Escribe la información en la estructura de tipo video_tuner que recibe como argumento. En el cuadro 2.6 puede verse la información almacenada en esta estructura. No todos los canales ni todos los dispositivos tienen sintonizador, sólo los que corresponden a captura de televisión o de radio. Cuadro 2.6 Información contenida por la estructura video_tuner. Campo tuner name rangelow rangehigh flags mode signal Descripción Número del sintonizador Nombre canónico del sintonizador Mínima frecuencia sintonizable Máxima frecuencia sintonizable Banderas que describen el sintonizador Modo de la señal de video Intensidad de la señal, si se conoce (entre 0 y 65535) VIDIOCSTUNER: Permite seleccionar cual sintonizador se va a utilizar. Recibe un entero con el número de sintonizador como argumento. VIDIOCGFREQ: Obtiene la frecuencia en la cual se encuentra ajustado el sintonizador. VIDIOCSFREQ: Permite definir una nueva frecuencia del sintonizador. 16 VIDIOCGMBUF: Permite obtener el tamaño de la memoria del dispositivo, así como la cantidad de cuadros que puede contener. La llamada almacena esta información en la estructura video_mbuf que recibe como argumento, la cual es descrita en el cuadro 2.7. Cuadro 2.7 Información contenida por la estructura video_mbuf. Campo Descripción size Tamaño de la memoria del dispositivo frames Número de cuadros que puede contener la memoria offsets Posición de cada cuadro dentro de la memoria VIDIOCMCAPTURE: Inicia la captura hacia uno de los cuadros de la memoria de video. Recibe como argumento una estructura del tipo video_mmap donde se especifican varios parámetros tales como el cuadro que se desea capturar, el tamaño del cuadro y el formato de la imagen. La descripción de esta estructura se presenta en el cuadro 2.8. Cuadro 2.8 Información contenida por la estructura video_mmap. Campo Descripción frame Número de cuadro que se desea capturar height Altura del cuadro width Ancho del cuadro format Formato de la imagen VIDIOCSYNC: Espera a que finalice la captura de un cuadro, el cual se especifica a través de la estructura del tipo video_mmap que recibe como parámetro. Además de estas llamadas, existen otras que se encargan de controlar las funciones de audio asociadas con algunos de los dispositivos. 2.5. Algoritmos de detección de movimiento El análisis del movimiento es una de las áreas de estudio más importantes en el campo del procesamiento y análisis de imágenes, debido a que existe una gran cantidad de aplicaciones, como por ejemplo el estudio del movimiento en seres vivos o el análisis del tráfico vehicular. En los últimos años se ha dado un auge en la investigación desarrollada en esta área, 17 principalmente debido a los avances en la tecnología informática y al desarrollo de nuevos y eficientes algoritmos. La tarea más básica dentro de esta disciplina consiste en determinar cuando se da movimiento en un escenario específico. Existen varias técnicas que permiten alcanzar este objetivo; la elección de una de ellas depende de los requerimientos específicos de la aplicación, así como de los recursos disponibles. La forma más intuitiva y sencilla de analizar el movimiento consiste en evaluar las diferencias entre dos imágenes de una secuencia. Estas diferencias pueden estudiarse analíticamente sustrayendo una imagen de la otra, de acuerdo con la ecuación 2.1. O(x, y) = I1 (x, y) − I2 (x, y) (2.1) En este método se utilizan imágenes en escala de grises, debido a que sólo es necesario evaluar los cambios en la intensidad de los pixeles. Al sustraer una imagen de la otra se remueven de la imagen resultante todas las características que no han cambiado, y se resaltan aquellas que sí. Si la iluminación y la geometría del escenario son consistentes entre ambas imágenes, las únicas diferencias en los pixeles donde no ha ocurrido ningún cambio se deben a variaciones estadísticas, provocadas por ruido electrónico o de la cámara[6]. De acuerdo con esto, el movimiento provoca cambios en los niveles de grises entre las imágenes de una secuencia. En el caso ideal, cualquier cambio en uno o más pixeles puede considerarse como movimiento. Sin embargo, en los sistemas reales existen muchos factores que pueden producir estos cambios. Algunos de estos factores son los cambios en el nivel de iluminación y el ruido, tal como se mencionó anteriormente. Si bien es posible utilizar técnicas de filtrado para reducir su influencia, no es posible eliminarla completamente. Además, en muchas ocasiones, no todos los eventos de movimiento que se presentan en una escena son de interés. Por ejemplo, una cortina movida por el viento probablemente no sea de interés cuando lo que se desea es detectar la presencia de una persona en movimiento en un escenario. Debido a estas razones, se utilizan algunos valores de umbral cuando se lleva a cabo la detección. Sea D(x, y) la diferencia, pixel por pixel de dos imágenes, I1 (x, y) y I2 (x, y), definida de acuerdo a la ecuación 2.2 0 si | I (x, y) − I (x, y) |≤ ² 2 1 D(x, y) = 1 si | I2 (x, y) − I1 (x, y) |> ² (2.2) 18 donde ² es el valor de umbral de sensibilidad. Esto significa que la diferencia de intensidad en un pixel tiene que estar por encima de cierto valor para que esta diferencia sea significativa. Esto permite eliminar la influencia del ruido que consiste en cambios pequeños de intensidad. Un evento de movimiento se da cuando la ecuación 2.3 es válida: X D(x, y) > δ (2.3) donde δ es el valor de umbral de evento. De esta forma, la cantidad de pixeles con diferencias significativas debe estar por encima de este valor de umbral para que se considere que se produjo movimiento. Existen otros métodos más complejos para llevar a cabo la detección de movimiento, sin embargo, el método descrito anteriormente proporciona buenos resultados cuando se desea realizar la detección en un escenario estacionario, lo que lo hace apropiado para una gran cantidad de aplicaciones. Además, este algoritmo es significativamente más rápido que los otros, lo que es muy importante en una aplicación de tiempo real como esta. 2.6. Reducción de ruido en las imágenes Como se explicó en la sección anterior, el ruido presente en las imágenes puede afectar significativamente el desempeño de los algoritmos de detección de movimiento. Debido a esto, se acostumbra aplicar algún filtro para reducir los niveles de ruido antes de llevar a cabo la sustracción. Existen muchas técnicas de filtrado que permiten reducir el ruido de una imagen. La elección de una técnica en particular depende de los requerimientos particulares de cada aplicación. Sin embargo existe un filtro muy utilizado, debido a su efectividad y su simplicidad. Este filtro es el filtro paso bajos, o filtro de media. 2.6.1. Filtro de media El filtro de media asigna a cada pixel un promedio calculado con base en su propio valor y el valor de los pixeles cercanos. Esto permite atenuar las transiciones rápidas de intensidad que se dan de un pixel a otro; debido a esto, este filtro también es conocido como filtro paso bajos, dado que solamente conserva las transiciones suaves (o frecuencias bajas). Debido a que la mayoría del ruido aleatorio existente en las imágenes presenta estas características, 19 este filtro es bastante efectivo para reducirlo. El funcionamiento del filtro de media puede expresarse matemáticamente de la siguiente forma: +m X ∗ Px,y = Wi,j · Px+i,y+j i,j=−m +m X (2.4) Wi,j i,j=−m donde P es la matriz de pixeles de la imagen, P ∗ es la matriz resultante una vez aplicado el filtro y W es una matriz cuadrada de dimensión 2m + 1, la cual contiene los pesos que se asignarán a cada uno de los pixeles del vecindario del pixel que está siendo calculado. El tamaño de este vecindario es 3 × 3, 5 × 5 o 7 × 7, pero también podrían utilizarse vecindarios más grandes si se desea obtener un filtrado mejor. También es posible utilizar regiones no cuadradas en esta clase de filtrado[6]. La forma más sencilla de este filtro consiste en una matriz W 3 × 3 en la que todos los pesos son 1: W = 1 1 1 1 1 1 1 1 1 También es posible escoger valores diferentes para la matriz W , de manera que cada uno de los pixeles tiene un peso diferente en el cálculo del promedio. Generalmente se trata de que la matriz tenga una distribución similar a la curva Gausiana, con los pesos mayores asignados al pixel que está siendo calculado y a los pixeles cercanos, y los menores a los pixeles más alejados. Este filtro presenta problemas en los bordes de la imagen, debido a que la región que rodea a los pixeles no es simétrica. Aunque es posible utilizar un vecindario asimétrico en estos casos, la mayoría de las ocasiones estos pixeles se deja sin procesar y se les asigna un valor de cero (color negro). CAPÍTULO 3: Descripción general del sistema de captura de video y detección de movimiento 3.1. Estructura de la aplicación y aspectos generales La aplicación desarrollada está dividida en dos partes principales: un servidor, que se encarga de capturar del dispositivo de video y llevar a cabo las rutinas de detección de movimiento, y un cliente, a través del cual se realiza la visualización en tiempo real del video capturado por el servidor, y que permite controlar algunos de los parámetros del servidor. La comunicación entre ambas partes se lleva a cabo utilizando el conjunto de protocolos TCP/IP, a través de una interfaz de red. Esto permite implementar una aplicación distribuida, en la cual, la captura y el procesamiento puedan llevarse a cabo en una computadora y la visualización y el control puedan ejecutarse de forma remota desde otro equipo. Figura 3.1 Partes principales de la aplicación Tanto el servidor como el cliente fueron desarrollados en lenguaje C, utilizando funciones de la biblioteca estándar de Linux (conocida como libc). La aplicación fue desarrollada utilizado múltiples hilos de procesamiento utilizando la implementación POSIX (conocida como pthreads). Esto permite ejecutar en paralelo varias de las rutinas, como es el caso de la captura del video y de la detección de movimiento en el servidor. 20 21 3.2. Estructura del servidor El servidor está dividido en cuatro partes, cada una de las cuales es ejecutada en un hilo de procesamiento diferente. Estas partes son: Inicialización y comunicación con el cliente: Es el primer hilo que se ejecuta y el que se encarga de crear y administrar a los otros. Se encarga de inicializar el dispositivo de video y de crear un socket TCP, el cual espera conexiones del cliente. A través de esta rutina se controlan todos los procesos del servidor, de acuerdo con las instrucciones enviadas por el cliente. Captura de video: Se encarga de leer las imágenes del dispositivo de video y colocarlas en un área de memoria, la cual es accesible por las otras rutinas del programa. Puede iniciarse y detenerse bajo demanda, según las instrucciones enviadas por el cliente. Detección de movimiento: Analiza la secuencia de imágenes obtenida por el hilo de captura con el fin de detectar movimiento en el video. En caso de que esto ocurra se encarga de almacenar el video en el disco duro, y notificar al cliente que se dio un evento de movimiento. También es activado o desactivado bajo demanda por el cliente a través del canal de instrucciones TCP. Envío del video: Crea un socket UDP y envía el video para su despliegue en tiempo real en el cliente. Es creado por el cliente una vez iniciada la captura y puede detenerse cuando no se desee recibir más video. 3.2.1. Inicialización y comunicación con el cliente Como se mencionó anteriormente, éste es el hilo principal del programa, debido a que se encarga de administrar los distintos componentes de acuerdo con las instrucciones recibidas del cliente. Este hilo se ejecuta al iniciar el programa, y todos los demás son creados desde aquí. Una vez creado, su primera función es la inicialización del dispositivo de video. Posteriormente, crea un socket TCP y lo registra para que espere conexiones en un puerto determinado. Cuando se establece una conexión con el cliente ejecuta las instrucciones que este envía y una vez finalizada la sesión espera a que se establezca de nuevo una conexión. En la figura 3.2 se muestra el diagrama de flujo de esta rutina. 22 Figura 3.2 Diagrama de flujo del hilo de inicialización y comunicación con el cliente. 3.2.2. Captura de video Esta rutina se encarga de reservar un sector de memoria con el fin de proporcionar un buffer circular para almacenar los cuadros capturados del dispositivo de video. Este buffer permite a los otros hilos acceder los últimos cuadros capturados, con el fin de llevar a cabo el procesamiento necesario para la detección de movimiento y de enviar los cuadros al cliente para su despliegue en tiempo real. Una vez hecho esto, se mapea la memoria del dispositivo de video y se inicia el ciclo que copia secuencialmente cada uno de los cuadros de la memoria de video al buffer. Este ciclo se repite hasta que se reciba una orden del cliente. En la figura 3.3 se muestra el diagrama de flujo de la rutina de captura de video. 23 Figura 3.3 Diagrama de flujo del hilo de captura de video. 3.2.3. Detección de movimiento El hilo de detección de movimiento se encarga de determinar cuando se produce algún evento de movimiento en el escenario observado y de almacenar estos eventos en el disco duro. La detección se lleva a cabo analizando las diferencias que existen entre un cuadro y otro. Si las diferencias se encuentran por encima de cierto valor y se mantienen por algún tiempo se considera que se está dando un evento de movimiento y se graban los cuadros capturados al disco duro. Una vez que el evento finaliza, las imágenes almacenadas se combinan en un archivo de video y se notifica al usuario el registro del evento. El diagrama de flujo de la rutina de detección de movimiento se muestra en la figura 3.4. 3.2.4. Envío del video La rutina de envío de video se encarga de crear, bajo pedido del cliente, un socket UDP para enviar los cuadros de video capturados para su visualización en tiempo real. Una vez 24 Figura 3.4 Diagrama de flujo del hilo de detección de movimiento. creado el socket espera por un mensaje del cliente que le informe que está listo para recibir el video. Una vez recibido este mensaje inicia un ciclo en el cual toma un cuadro del buffer, lo fragmenta en paquetes de 4096 bytes con el fin de cumplir con los requerimientos de capacidad del protocolo UDP y lo envía al cliente. Esto se repite hasta que el cliente solicite que se detenga el Envío, lo que provoca que el ciclo finalice y que el hilo de procesamiento se detenga. En la figura 3.5 se muestra el diagrama de flujo para esta rutina. 25 Figura 3.5 Diagrama de flujo del hilo de envío del video. 3.3. Estructura del cliente La aplicación cliente consiste en una interfaz gráfica de usuario que permite visualizar en tiempo real el video capturado por el servidor. Además, es posible manipular muchas de las funciones del servidor, como por ejemplo iniciar o detener la captura de video. El cliente además es notificado por el servidor cada vez que se registra un evento del movimiento. La interfaz gráfica de usuario se implementó utilizando la biblioteca GTK 2.4 para crear las ventanas y demás elementos visuales, así como para manejar la interacción con el usuario y con el administrador de ventanas. Al igual que el servidor, este programa también se dividió en múltiples hilos de procesamiento, con el fin de ejecutar en forma paralela las rutinas correspondientes a la recepción de los cuadros de video y lo referente a la visualización y la interacción con el usuario. En la figura 3.6 pueden verse las partes principales del programa, así como su interacción con el servidor. 26 Figura 3.6 Estructura de la aplicación cliente. 3.3.1. Interfaz gráfica de usuario y mensajería TCP La rutina principal del programa cliente se encarga de crear e inicializar la interfaz gráfica, así como de establecer la comunicación con el servidor a través de un socket TCP. Una vez iniciado el programa, este envía mensajes al servidor para que inicie la captura y la transmisión del video. Además solicita al servidor las características de los cuadros de video con el fin de poder reconstruirlos adecuadamente a partir de los datos recibidos a través del socket UDP. Una vez llevada a cabo la inicialización, la rutina principal lanza el hilo que se va a encargar de recibir los paquetes UDP que contienen el video. Por último, la rutina configura y despliega los elementos de la interfaz gráfica y llama a la rutina de manejo de eventos GTK, la cual se encarga de la interacción con el usuario y con el manejador de ventanas. Este hilo de procesamiento (y el programa completo) finaliza cuando la ventana es destruida (el usuario presiona el botón de cerrar de la ventana) o cuando el usuario selecciona en el menú la acción correspondiente. En la figura 3.7 puede verse el diagrama de flujo de este hilo de procesamiento. 3.3.2. Recepción de los cuadros de video La recepción de los cuadros de video para su despliegue en tiempo real es llevada a cabo por un hilo de procesamiento independiente que crea un socket UDP, envía un mensaje al servidor indicando que está listo para recibir la información y posteriormente inicia un ciclo en el cual recibe la ráfaga de paquetes que contiene los cuadros de video. Como se indicó anteriormente, el servidor envía cada cuadro fragmentado en varios paquetes de 4096 bytes debido a los requerimientos del protocolo UDP, por lo que la rutina de recepción debe reconstruir cada imagen. Para esto, se calcula el número de paquetes por cuadro con base en las características del video capturado solicitadas al servidor a través del canal TCP. Además, 27 Figura 3.7 Diagrama de flujo del hilo encargado de la interfaz gráfica y la mensajería TCP en el cliente cada vez que el servidor finaliza el envío de un cuadro envía un paquete de sincronización de 4 bytes, que permite a la rutina de recepción verificar si ha recibido el número correcto de paquetes de datos. Si hay alguna inconsistencia, el cuadro es desechado y se espera el siguiente. Cuando un cuadro es recibido satisfactoriamente, este es colocado en una posición de memoria que es leída periódicamente por el hilo encargado de la interfaz gráfica. De esta forma, el usuario puede ver un flujo constante de video. En la figura 3.8 se muestra el diagrama de flujo para este hilo de procesamiento. 28 Figura 3.8 Diagrama de flujo del hilo de recepción de video. CAPÍTULO 4: Rutinas de captura de video 4.1. Inicialización del sistema de video El primer paso necesario para acceder el dispositivo de video consiste en abrir el dispositivo para lectura y escritura, y asignarlo a un descriptor de archivo. Este descriptor de archivo se utiliza durante el resto del programa para referirse al dispositivo y efectuar todas las operaciones necesarias. if((fd = open(video_dev, O_RDWR)) == -1) { fprintf(stderr, "Error abriendo el dispositivo %s\n", video_dev); return -1; } En el fragmento de código mostrado, fd es el descriptor de archivo asignado al dispositivo de video. La variable video_dev que se pasa como argumento a open() contiene una cadena de carácteres con el nombre del dispositivo de video que se desea abrir (por ejemplo /dev/video0). Una vez abierto el dispositivo se utiliza la llamada al sistema ioctl() para obtener las de las características del dispositivo, así como para definir algunos parámetros necesarios para la captura. /* Obtención de las capacidades de captura */ if(ioctl(fd, VIDIOCGCAP, &cap) == -1) { fprintf(stderr, "Error al realizar VIDIOCGCAP\n"); return -1; } /* Información de los Buffers */ if((ioctl(fd, VIDIOCGMBUF, &buf_info)) == -1) { printf("Error adquiriendo los buffers\n"); return -1; } 29 30 La llamada a VIDIOCGCAP solicita al dispositivo las características del dispositivo, las cuales son almacenadas en la variable cap —del tipo video_capability— que se pasa como argumento a ioctl(). Estas características incluyen el nombre del dispositivo y el número de canales, así como los tamaños máximos y mínimos posibles para el cuadro a capturar (ver cuadro 2.1). Posteriormente, la llamada a VIDIOCGMBUF se encarga de obtener la información de la memoria del dispositivo. Esta información es almacenada en la variable buf_info, una estructura del tipo video_mmap, y es utilizada por la función mmap() para asignar este bloque de memoria a una posición direccionable por el sistema operativo. VIDIOCGMBUF permite obtener además la cantidad de cuadros que puede almacenar la memoria de video, que puede ir desde un solo cuadro hasta 32 cuadros, dependiendo del dispositivo. map = mmap(0, buf_info.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if(map == NULL) { printf("Error en el mapeo de la memoria\n"); return -1; } De esta forma, la memoria del dispositivo es accesible a través del puntero map. Esto proporciona un método de captura que resulta más eficiente que efectuar llamadas a read() sobre el dispositivo. El último paso que se debe llevar a cabo antes de iniciar la captura consiste en definir cual será el canal del cual se va a capturar la imagen. Esto se realiza mediante la llamada a VIDIOCSCHAN, la cual toma como argumento un entero con el canal que se desea. int set_chan(int fd, int chan) { if(ioctl(fd, VIDIOCSCHAN, chan) == -1) return -1; else return 0; } 31 4.2. Ciclo de captura Tal como se mencionó en el capítulo 3, el ciclo de captura es llevado a cabo por un hilo de ejecución independiente. Esto es implementado utilizado la biblioteca pthreads, la cual forma parte de la biblioteca estándar del lenguaje C para Linux. pthread_t capture_thread; ... pthread_create(&capture_thread, &attr, capture_loop, NULL); De esta forma se crea un nuevo hilo que llama a la función capture_loop. Una vez que inicia la ejecución de la función se reserva memoria para el buffer circular que va a contener los cuadros capturados. El tamaño del buffer depende del número de cuadros que se requiera almacenar, así como del tamaño de cada cuadro. framesize = video_buf.width * video_buf.height * 3; ... main_buf = (char *)malloc(BUF_FRAME_NUM * framesize); Para llevar a cabo la captura de un cuadro se deben llevar a cabo dos llamadas, mediante ioctl(), al dispositivo de video. La primera llamada, conocida como VIDIOCMCAPTURE, se encarga de iniciar la captura de uno de los cuadros de la memoria de video. La otra llamada, VIDIOCSYNC, se encarga de sincronizar un cuadro capturado, y no retorna hasta que la captura del cuadro finalice. De esta forma, es posible preparar uno de los cuadros mientras se sincroniza otro, lo cual aumenta la eficiencia del proceso de captura. La forma más sencilla de implementar este método consiste en utilizar dos cuadros y sincronizar uno de ellos mientras el otro se prepara, sin embargo es posible llevar esto más allá y utilizar la totalidad de la memoria de video. Tal como se mencionó en la sección anterior, el número de cuadros con que se cuenta depende del dispositivo utilizado. El algoritmo necesario para realizar la captura utilizando n cuadros se muestra en la figura 4.1. Al realizar la lectura utilizando este método es posible obtener la máxima velocidad posible de captura permitida por el dispositivo. 32 Figura 4.1 Diagrama del algoritmo de captura de video utilizado. 33 Tal como se muestra en el diagrama de flujo de la figura 4.1, el primer paso consiste en preparar los cuadros iniciando la captura en cada uno de ellos. El cuadro sobre el cual se va a efectuar la acción se define utilizando el miembro frame, de la estructura del tipo video_mbuf. for(i = 0; i < buf_info.frames; i++) { video_buf.frame = i; ioctl(vfd, VIDIOCMCAPTURE, &video_buf); } Una vez hecho esto, se entra en el ciclo de captura, el cual recorrerá todos los cuadros de la memoria del dispositivo secuencialmente. En este caso, una vez que el cuadro se encuentra disponible, es copiado a la siguiente posición disponible del buffer principal del programa, con el fin de hacerlo disponible para el resto de las rutinas. 34 framecounter = 0; ... while(capture) { /* Si llegó al fin de la memoria del dispositivo */ if(i == buf_info.frames) i = 0; video_buf.frame = i; ioctl(vfd, VIDIOCSYNC, &video_buf); // Sincroniza ioctl(vfd, VIDIOCMCAPTURE, &video_buf); // Prepara para la siguiente // lectura /* Si llegó al final del buffer vuelve a empezar desde el inicio */ if(framecounter == BUF_FRAME_NUM) { framecounter = 0; ... } /* Copia el cuadro al buffer pricipal */ memcpy(main_buf + framecounter * framesize, map + buf_info.offsets[i], framesize); /* Incrementa ambos contadores */ i++; framecounter++; } Este ciclo se va a ejecutar hasta que el valor de la variable global capture sea 0. Esto le permite al hilo principal del programa iniciar o detener la captura de acuerdo con las solicitudes del cliente. Una vez que se sale del ciclo de captura, se libera la memoria utilizada por el buffer de video y se sale del hilo de ejecución. 35 free(main_buf); pthread_exit(NULL); Cuando el hilo principal ordena que se detenga la captura, debe asegurarse que el hilo sea destruido correctamente, con el fin de que se liberen todos los recursos correspondientes. Esto lo hace mediante una llamada a la función pthread_join(). Esta función detiene el flujo normal hasta que el hilo retorne. if(capture) { capture = 0; pthread_join(capture_thread, NULL); printf("Captura detenida\n"); } CAPÍTULO 5: Rutinas de comunicación con el cliente y transmisión de video sobre la red 5.1. Creación del socket TCP en el servidor Como se mencionó en el capítulo 3, el hilo de ejecución principal del programa, que se encarga de crear y administrar los otros hilos de ejecución, crea un socket TCP, una vez inicializado el dispositivo de video, con el fin de responder a las solicitudes del cliente. Esto brinda la posibilidad de controlar remotamente las funciones realizadas por el sistema de captura, y además monitorear su estado. El código necesario para crear el socket y esperar por conexiones del cliente se muestra a continuación: /* Creación del socket */ if((sd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { fprintf(stderr, "Problemas creando el socket\n"); pthread_exit((void *)-1); } /* Almacenamiento de los parámetros de conexión en la estructura sockaddr_in */ bzero((char *)&server, sizeof(struct sockaddr_in)); server.sin_family = AF_INET; server.sin_port = htons(PORT); server.sin_addr.s_addr = htonl(INADDR_ANY); /* Enlace del socket */ if(bind(sd, (struct sockaddr *)&server, sizeof(server)) == -1) { fprintf(stderr, "Error al enlazar el socket\n"); pthread_exit((void *)-1); } /* El socket espera conexiones */ listen(sd, 5); 36 37 /* Ciclo infinito de atención de conexiones */ while(1) { /* Acepta la conexión entrante */ client_len = sizeof(client); if((sd2 = accept(sd, (struct sockaddr *)&client, &client_len)) == -1) { fprintf(stderr, "No se puede aceptar la conexion\n"); pthread_exit((void *)-1); } ... close(sd2); } En primer lugar se crea el socket utilizando la llamada al sistema socket(). La combinación de los parámetros AF_INET y SOCK_STREAM indican al sistema operativo que se desea utilizar el protocolo TCP. Esta llamada retorna un descriptor de socket, el cual se utilizará para referirse al socket en el resto de la rutina. A continuación se almacenan los parámetros de la conexión, tales como el puerto, el protocolo y la dirección en la cual se esperaran las conexiones en la estructura sockaddr_in. Esta estructura se pasa como argumento a la llamada bind(), la cual se encarga de enlazar el socket. Esto provoca que el sistema operativo reserve el puerto para el proceso que lo solicitó, evitando que otro proceso pueda utilizarlo. Una vez llevado a cabo el enlace, se utiliza la llamada listen() para indicar al sistema que el programa va a manejar todas las conexiones entrantes por el socket sd. El segundo argumento de listen() corresponde al número de conexiones que el sistema operativo debe colocar en cola, en caso de que el programa no pueda atenderlas. En este caso, se pueden colocar en espera un máximo de 5 conexiones. Si existe una sexta solicitud, esta será rechazada por el sistema operativo. Posteriormente, el programa inicia un ciclo infinito para atender consecutivamente las conexiones entrantes. La llamada accept() hace que el programa duerma hasta que haya una solicitud de conexión. Cuando esta se presenta se crea un nuevo descriptor exclusivo para atender esta conexión (esto debido a que el envío de los datos al cliente se lleva a cabo a través de un puerto diferente, asignado de manera aleatoria por el sistema operativo). Una 38 vez finalizada la comunicación con el cliente, este descriptor es cerrado, y el programa vuelve a dormir, hasta que se de una nueva conexión. 5.2. Envío y recepción de datos El envío y la recepción de los datos se realizan utilizando las llamadas read() y write(), debido a que el descriptor del socket puede verse como si fuera un descriptor de archivos. De esta forma pueden enviarse y recibirse datos fácilmente, sin tener que recurrir a rutinas de bajo nivel, y sin necesidad de conocer a profundidad el funcionamiento del protocolo TCP/IP. El sistema operativo es el que se encarga de fragmentar la información en paquetes y de colocar los encabezados necesarios para su transmisión. Una vez establecida la conexión, el servidor envía un mensaje inicial al cliente, con el fin de indicarle que está listo para recibir peticiones. En este caso, el mensaje enviado es simplemente el nombre y la versión del programa: char out_buf[BUF_SIZE]; ... /* Envía mensaje de bienvenida */ strcpy(out_buf,"Telescreen v0.3"); write(sd2, out_buf, BUF_SIZE); Una vez enviado este mensaje, se inicia un ciclo infinito en el cual espera que el cliente haga una petición y la procesa. En este ciclo se llama a read() con el fin de leer el mensaje enviado por el cliente: char *buf_ptr; int bytes_left, n_size, n_read; while(1) { /* Para que el ciclo no ocupe todo el procesador */ usleep(100); /* Lectura de los datos enviados por el cliente */ bytes_left = BUF_SIZE; buf_ptr = in_buf; 39 while((n_read = read(sd2, buf_ptr, bytes_left)) > 0) { buf_ptr += n_read; bytes_left -= n_read; } /* Si no hay datos disponibles reinicia el ciclo */ if(n_read < 0) continue; ... Una vez que un mensaje es leído, este es identificado y procesado. Los mensajes implementados actualmente se muestran en el cuadro 5.1. Cuadro 5.1 Mensajes implementados para la comunicación entre el cliente y el servidor Mensaje CAPTURE NOCAPTURE STREAM NOSTREAM MOTION NOMOTION VIDEOPROP CLOSE Acción Inicia el hilo de captura Detiene la ejecución del hilo de captura Inicia el hilo encargado de enviar el video capturado al cliente Detiene el envío del video al cliente Inicia el hilo encargado de llevar a cabo la detección de movimiento Detiene la detección de movimiento en el video capturado Solicita el envío de las propiedades del cuadro de video capturado Cierra la conexión con el servidor La mayoría de los mensajes se encargan de iniciar o detener los hilos de procesamiento de las distintas partes que componen el sistema. A manera de ejemplo se muestra a continuación el código para manejar los mensajes CAPTURE y NOCAPTURE: if((strcmp(in_buf,"CAPTURE")) == 0) { if(!capture) { // Inicio de la captura capture = 1; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_create(&capture_thread, &attr, capture_loop, NULL); } 40 strcpy(out_buf, "OK"); write(sd2, out_buf, BUF_SIZE); } else if((strcmp(in_buf, "NOCAPTURE")) == 0) { if(capture) { capture = 0; pthread_join(capture_thread, NULL); } strcpy(out_buf, "OK"); write(sd2, out_buf, BUF_SIZE); } // Fin de la captura En el caso de CAPTURE, se asigna 1 a la variable global capture, y se crea el hilo de procesamiento que llama a la función capture_loop(). Posteriormente se envía el mensaje «OK» al cliente, indicándole que el comando ha sido ejecutado satisfactoriamente. En lo que respecta a NOCAPTURE, la variable capture se pone en 0 lo que provoca que la función capture_loop() finalice. Por último se espera que el hilo de procesamiento finalice con la función pthread_join() y se envía el mensaje de confirmación al cliente. Los otros mensajes son implementados de forma similar, con excepción de VIDEOPROP. En el caso de este mensaje, el servidor debe enviar los datos del cuadro capturado, con el fin de que el programa cliente pueda desplegarlo. Estos datos son enviados en la estructura video_prop: /* Propiedades del cuadro enviado */ struct video_prop { int width; // Ancho int height; // Altura }; El código que atiende esta solicitud se muestra a continuación: /* Envío de las propiedades del cuadro capturado */ } else if((strcmp(in_buf, "VIDEOPROP")) == 0) { struct video_prop prop; char *prop_ptr = &prop; prop.width = video_buf.width; 41 prop.height = video_buf.height; write(sd2, prop_ptr, sizeof(struct video_prop)); printf("Propiedades de video enviadas\n"); strcpy(out_buf, "OK"); write(sd2, out_buf, BUF_SIZE); } 5.3. Envío del video capturado al cliente 5.3.1. Creación del socket UDP Como se mencionó en el capítulo 3, el envío de los cuadros de video capturados se lleva a cabo utilizando el protocolo UDP. Debido a esto, el primer paso para enviar los cuadros consiste en crear un socket que utilice este protocolo: /* Creación del socket UDP */ if((sd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) { fprintf(stderr, "Problemas creando el socket\n"); pthread_exit((void *)-1); } /* Información de la conexión */ bzero((char *)&server, sizeof(server)); server.sin_family = AF_INET; server.sin_port = htons(PORT); server.sin_addr.s_addr = htonl(INADDR_ANY); /* Enlace del socket */ if(bind(sd, (struct sockaddr *)&server, sizeof(server)) == -1) { fprintf(stderr, "Problemas al enlazar el socket\n"); pthread_exit((void *)-1); } /* Espera que el cliente solicite los datos */ client_len = sizeof(client); if((n = recvfrom(sd, buf, BUF_SIZE, 0, (struct sockaddr *)&client, &client_len)) < 0) { 42 fprintf(stderr, "Problemas recibiendo datagramas del cliente\n"); pthread_exit((void *)-1); } El proceso de creación del socket UDP es muy similar a la del socket TCP. La principal diferencia se da al utilizar la llamada socket(), a la cual se le pasa como parámetro la constante SOCK_DGRAM. Además, debido a que UDP es un protocolo no orientado a conexión, no se utilizan las llamadas listen() ni accept(). Una vez enlazado el socket ya se pueden enviar o recibir datos. Para llevar a cabo la comunicación es necesario únicamente utilizar las llamadas recvfrom() para el envío y sendto() para la recepción. En este caso, el servidor espera que el cliente envíe un paquete que le informe que esta listo para recibir el video. 5.3.2. Fragmentación y envío de los cuadros de video Una vez creado el socket, el siguiente paso consiste en el envío secuencial de los cuadros adquiridos por el hilo de captura. Debido a que el tamaño máximo de la carga útil de un paquete UDP es de aproximadamente 5200 bytes, cada cuadro de video debe fragmentarse en varias porciones para su envío. La rutina de envío se encarga de calcular el número de fragmentos necesarios de acuerdo al tamaño del cuadro, y de enviar la secuencia de fragmentos. Además, con el fin de facilitar la reconstrucción del cuadro por parte del cliente, se inserta un paquete de sincronización entre cada cuadro. Esto permite que el cliente pueda determinar el final de un cuadro y determinar si se perdieron fragmentos durante la transmisión. El código necesario para enviar los cuadros de video se incluye a continuación: while(stream) { /* Envía el cuadro anterior al que está siendo capturado */ if(framecounter) fc = framecounter - 1; else fc = BUF_FRAME_NUM; if(prev_fc == fc) continue; 43 prev_fc = fc; int fp = main_buf + framesize * fc; /* Se divide el frame en paquetes UDP de 4096 bytes */ int n_packets = framesize / 4096; int i; for(i = 0; i <= n_packets; i++) { if(sendto(sd, fp + i*4096, 4096, 0, (struct sockaddr *)&client, client_len) == -1) printf("Error enviando el paquete #%d\n", i); /* Para que no se pierdan paquetes en interfaces muy rápidas (ej. loopback) */ usleep(10); } /* Envío del paquete de sincronización */ int sync = n_packets; // Valor arbitrario, lo que importa es el tamaño if(sendto(sd, (char *)&sync, sizeof(int), 0, (struct sockaddr *)&client, client_len) == -1) printf("Error enviando paquete de sincronización\n"); counter++; } En este caso, el tamaño de cada paquete se establece en 4096 bytes. El paquete de sincronización es un entero, que tiene un tamaño de 4 bytes. De esta forma, el cliente puede determinar cual es el paquete de sincronización con base en la cantidad de bytes recibidos. CAPÍTULO 6: Rutinas de detección de movimiento y escritura a disco duro 6.1. Algoritmo de detección de movimiento El algoritmo utilizado para llevar a cabo la detección de movimiento consiste en tomar un cuadro, restarle el cuadro anterior y evaluar el resultado. Si la cantidad de pixeles diferentes entre un cuadro y el otro está por encima de cierto valor de umbral, puede considerarse que alguno de los elementos del cuadro cambió de posición, y por lo tanto se presentó un evento de movimiento. Si bien es cierto este algoritmo es uno de los más sencillos, funciona bastante bien para la aplicación implementada, dado se pretende realizar la detección en un escenario estacionario, donde las únicas perturbaciones corresponden a los eventos que se desean registrar. Uno de los principales problemas de este algoritmo es que es muy susceptible al ruido que se presenta durante la captura, principalmente con cámaras de baja calidad. Debido a esto es necesario aplicar un filtro a las imágenes con el fin de reducir este ruido y obtener mejores resultados. En la próxima sección se explica cual fue el filtro utilizado en este sistema, y como se llevó a cabo su implementación. El código que se encarga de realizar la detección de movimiento entre dos cuadros se muestra a continuación: /* Toma el cuadro anterior al cuadro que está siendo capturado */ fc = framecounter - 1; if(fc < 0) fc = 0; if(fc == prevfc) continue; else prevfc = fc; ... /* Convierte el cuadro actual y el anterior a escala de grises */ 44 45 grayscale(main_buf + fc * framesize, framesize, curr); grayscale(main_buf + (fc?(fc - 1):0) * framesize, framesize, prev); /* Aplica filtro a ambos cuadros */ mean_filter(curr, video_buf.width, video_buf.height); mean_filter(prev, video_buf.width, video_buf.height); /* Resta ambos cuadros y almacena la diferencia en dif */ int i; for(i = 0; i < framesize / 3; i++) { dif[i] = abs(curr[i] - prev[i]); /* Si hay diferencia entre los pixeles incrementa el contador */ if(dif[i] > ith) ndif++; } /* Calcula el porcentaje de pixeles diferentes */ pdif = (float)ndif/((float)framesize/3)*100; if(pdif > threshold) /* Hay movimiento */ ... La rutina toma los dos cuadros anteriores al que está siendo capturado y los convierte a escala de grises. Posteriormente aplica un filtro a ambos cuadros con el fin de reducir el ruido presente. Se trabaja en escala de grises con el fin de facilitar el procesamiento y aumentar la velocidad. Además, para detectar los cambios de posición sólo es necesario evaluar los cambios de intensidad de los pixeles, y no la diferencia de colores. La conversión a escala de grises se realiza utilizando la siguiente ecuación: I = 0, 30R + 0, 59G + 0, 11B (6.1) Donde I representa el valor de intensidad del pixel (escala de grises), R representa el valor de rojo del pixel de la imagen original, G el valor de verde y B el valor de azul. Una vez hecho esto, se realiza la resta de los cuadros, pixel por pixel. El resultado se almacena en el arreglo dif. Si la diferencia entre dos pixeles es mayor que cierto nivel de intensidad entonces, se considera el pixel como diferente y se incrementa la variable ndif, la 46 cual almacena la cantidad de pixeles diferentes. La razón por la cual no se considera cualquier diferencia entre los pixeles es que existen muchas oscilaciones pequeñas de intensidad entre dos cuadros, debido principalmente al ruido, que no son corregidas por el filtro. Por último, una vez analizada toda la imagen, se calcula el porcentaje de pixeles diferentes y se compara con el valor de umbral, almacenado en la variable threshold. Si este porcentaje es mayor que el valor de umbral, se considera que hubo movimiento entre los cuadros. Se utilizan valores porcentuales con el fin de simplificar la manipulación de las variables. De esta forma no es necesario conocer la cantidad de pixeles que componen una imagen. 6.2. Filtrado de las imágenes Como se mencionó anteriormente, el ruido afecta de manera significativa la detección de movimiento. Debido a esto, antes de realizar la resta de los cuadros se aplica un filtro paso bajos a las imágenes con el fin de reducir el nivel de ruido presente. El filtro paso bajos se encarga de atenuar los cambios drásticos de intensidad que existan entre un pixel y los pixeles cercanos. Esto se logra asignando al pixel el valor promedio de los pixeles que lo rodean, tal como se explica en el capítulo 2. En este caso, el filtro implementado es un filtro de media, que asigna a cada pixel el mismo peso, y utiliza la matriz de pesos que se muestra a continuación: W = 1/9 1/9 1/9 1/9 1/9 1/9 1/9 1/9 1/9 El código necesario para implementar el filtro se muestra a continuación: void mean_filter(unsigned char *frame, int x, int y) { int i, j; unsigned char *new_frame; /* Matriz de pesos */ float weights[9] = {0.11, 0.11, 0.11, 0.11, 0.11, 0.11, 0.11, 0.11, 0.11}; 47 /* Almacenamiento temporal para la imagen procesada */ new_frame = malloc(x * y); /* Aplica el filtro pixel por pixel for(i = 1; i < (y - 1); i++) for(j = 1; j < (x - 1); j++) { new_frame[i*x+j] = weights[0] * weights[1] * weights[2] * weights[3] * weights[4] * weights[5] * weights[6] * weights[7] * weights[8] * */ frame[(i-1)*x+(j-1)] + frame[(i-1)*x+j] + frame[(i-1)*x+(j+1)] + frame[i*x+(j-1)] + frame[i*x+j] + frame[i*x+(j+1)] + frame[(i+1)*x+(j-1)] + frame[(i+1)*x+j] + frame[(i+1)*x+(j+1)]; } /* Coloca pixeles negros en el borde de la imagen */ for(i = 0; i < y; i++) { new_frame[i*x] = 0; new_frame[i*x+(x-1)] = 0; } for(i = 0; i < x; i++) { new_frame[i] = 0; new_frame[(y-1)*x+i] = 0; } /* copia la imagen procesada sobre la imagen original y libera la memoria temporal */ memcpy(frame, new_frame, x * y); free(new_frame); } El filtro es aplicado a todos los pixeles, con excepción de los bordes, a los cuales se les asigna un 0 (color negro). Aunque esto trae consigo pérdida de información, el área de los bordes no es muy significativa en comparación con el área total de la imagen. Además, al asignar el mismo valor en todas las imágenes, la rutina de detección de movimiento no se ve afectada. 48 6.3. Determinación de eventos de movimiento Una diferencia entre dos cuadros por encima del nivel de umbral no es suficiente criterio para asegurar que se dio un evento de movimiento. Esta diferencia pudo ser provocada por un cambio repentino en la iluminación de la escena o por ruido que no pudo ser eliminado por el filtro. Es necesario que las diferencias entre los cuadros se mantenga por algún tiempo para que puedan considerarse un evento de movimiento real. Debido a esto se diseñó un algoritmo que determina cuando se presenta un evento real de movimiento. El algoritmo define un tiempo inicial durante el cual deben mantenerse las diferencias entre los cuadros para que se declare un evento de movimiento. Además se define un tiempo al final del evento durante el cual no debe haber movimiento para que el evento finalice. Si se presenta movimiento durante este periodo se reinicia el temporizador y el evento continua. La implementación de este algoritmo se llevó a cabo mediante una máquina de estados, cuyo diagrama se muestra en la figura 6.1. Los estados definidos para esta máquina se muestran en la tabla 6.1. Cuadro 6.1 Estados necesarios para el algoritmo de detección de eventos de movimiento Estado IDLE MSTARTED MNORMAL MSTOPED Significado En espera, no se ha detectado movimiento En el periodo de tiempo inicial En un evento de movimiento En el periodo de tiempo final Los cuadros que deben almacenarse al disco duro son los que se capturan en los estados MSTARTED, MNORMAL y MSTOPED. Además, a cada evento de movimiento se le añaden al inicio varios cuadros capturados antes de que empiece el movimiento, con el fin de que el usuario pueda ver como se encontraba el escenario antes de que se diera la perturbación. El fragmento de código que implementa la máquina de estados se muestra a continuación. Las partes que se encargan del almacenamiento han sido removidas, debido a que lo que interesa en este caso es la estructura de la máquina de estados. Las rutinas de almacenamiento serán explicadas posteriormente. 49 Figura 6.1 Diagrama de la máquina de estados encargada de detectar los eventos de movimiento. 50 /* Maquina de estados para almacenar los eventos capturados al disco */ switch(estado) { case IDLE: /* Si hay movimiento */ if(pdif > threshold) { estado = MSTARTED; gettimeofday(&start_time, &tz); } break; case MSTARTED: gettimeofday(&temp_time, &tz); /* Almacenamiento de los cuadros */ ... /* Si se cumplió el tiempo inicial */ if((temp_time.tv_sec - start_time.tv_sec)*1000 + (temp_time.tv_usec - temp_time.tv_usec)/1000 >= mstart_time) { if(pdif > threshold) { // Si hay movimiento estado = MNORMAL; printf("Evento de movimiento iniciado...\n"); /* Lanza el hilo de almacenamiento al disco duro */ ... } else { // Si no hay movimiento estado = IDLE; /* Destruye los cuadros almacenados en memoria */ ... } } break; case MNORMAL: 51 /* Almacenamiento del cuadro */ ... if(pdif < threshold) { // Si no hay movimiento estado = MSTOPED; gettimeofday(&stop_time, &tz); } break; case MSTOPED: /* Almacenamiento del cuadro */ ... if(pdif > threshold) // Si hay movimiento estado = MNORMAL; else { // Si no hay movimiento gettimeofday(&temp_time, &tz); /* Si se cumplió el tiempo final */ if((temp_time.tv_sec - stop_time.tv_sec)*1000 + (temp_time.tv_usec - temp_time.tv_usec)/1000 >= mstop_time) { ... printf("Evento de movimiento finalizado.\n"); } } break; } La temporización se lleva a cabo mediante la llamada al sistema gettimeofday(), que retorna la cantidad de segundos y de microsegundos desde epoch1 . Esta llamada proporciona una mayor precisión que time(), la cual solamente retorna segundos. 1 00:00:00 UTC del 1 de enero de 1970. Esta fecha se utiliza como referencia para el sistema de manejo de tiempo en la mayoría de los sistemas UNIX. 52 6.4. Rutinas de escritura a disco duro El almacenamiento a disco duro de los eventos de movimiento se lleva a cabo almacenando cada cuadro individualmente, como una imagen en formato JPEG. Esta imagen se genera utilizando la biblioteca de manipulación de imágenes imagemagick2 . Posteriormente se utiliza el programa mencoder3 para crear un archivo de video MPEG4 a partir de estas imágenes individuales. Debido al retardo que trae consigo la escritura a disco duro, los cuadros capturados son colocados en un buffer temporal en la memoria, y no son escritos inmediatamente. La escritura es llevada a cabo por un hilo de procesamiento diferente, que se ejecuta de manera paralela al hilo de detección de movimiento. Otra razón para utilizar almacenamiento temporal en memoria es que es necesario almacenar cuadros que no necesariamente van a formar parte de un evento. Esto se da cuando el mecanismo de detección se encuentra en el estado MSTARTED (ver sección anterior). En este caso, es posible que se detenga el movimiento antes de que se cumpla el tiempo inicial, lo que cancelaría el evento de movimiento. Es más sencillo y eficiente borrar estos cuadros de la memoria que del disco duro. La estructura de almacenamiento utilizada para esta memoria temporal consiste de una lista enlazada. Esto permite una mayor eficiencia, dado que permite agregar y eliminar elementos del de manera dinámica. En esta lista, cada elemento contiene un puntero a un cuadro de video, y además un puntero al siguiente elemento de la lista. En el caso del elemento final, este puntero se encuentra indefinido (apunta a NULL). Cada celda de la lista es implementada mediante una estructura: /* Lista enlazada para almacenar los cuadros */ typedef struct le { unsigned char *frame; // Puntero al cuadro struct le *next; // Puntero a la siguiente celda } list; Como se mencionó en la sección anterior, en cada evento de movimiento se almacenan, además de los cuadros propios del evento, varios cuadros anteriores al inicio del movimiento. Estos cuadros se toman de un buffer temporal y son colocados en la lista enlazada la primera vez que se entra al estado MSTARTED. 2 3 http://www.imagemagick.org/ http://www.mplayerhq.hu/ 53 /* Si no existe la lista enlazada */ if(start == NULL) { /* Crea la primera celda de la lista */ start = (list *)malloc(sizeof(list)); start->frame = (char *)malloc(framesize); memcpy(start->frame, nomotion + nmc * framesize, framesize); start->next = NULL; current = start; /* Copia los cuadros previos a la lista */ int i; for(i = nmc + 1; i < nmsize + nmc; i++) { temp = (list *)malloc(sizeof(list)); temp->frame = (char *)malloc(framesize); if(i >= nmsize) memcpy(temp->frame, nomotion + (i - nmsize) * framesize, framesize); else memcpy(temp->frame, nomotion + i * framesize, framesize); temp->next = NULL; current->next = temp; current = temp; } } La variable start es un puntero al primer elemento de la lista enlazada. Al inicializar este puntero se crea la primera celda, en la cual se almacena el cuadro más antiguo del buffer nomotion. Este buffer es un arreglo circular de tamaño nmsize en el cual se almacenan los cuadros que están siendo procesados. El último cuadro almacenado se encuentra en la posición nmc − 1, por lo que el cuadro más antiguo se encuentra en la posición nmc. Posteriormente se almacenan el resto de los cuadros. Para cada uno de ellos se crea una celda nueva utilizando la variable temporal temp. Posteriormente se hace que el puntero current, el cual indicaba la última celda apunte hacia este nuevo elemento. La rutina permanecerá en el estado MSTARTED hasta que se cumpla el tiempo inicial. Durante este periodo, todas las imágenes capturadas deben agregarse a la lista: temp = (list *)malloc(sizeof(list)); temp->frame = (char *)malloc(framesize); 54 memcpy(temp->frame, main_buf + fc * framesize, framesize); temp->next = NULL; current->next = temp; current = temp; Al igual que antes, se crea la nueva celda utilizando el puntero temp, y luego se mueve current hacia este nuevo elemento. Este mismo procedimiento se utiliza en los estados MNORMAL y MSTOPED para agregar los nuevos cuadros capturados a las lista. Si se llega al estado MNORMAL, hay un evento de movimiento real, lo que significa que los cuadros almacenados en la lista deben ser escritos a disco duro. Para esto se crea un nuevo hilo de procesamiento que se encargará de realizar la escritura. Este hilo ejecuta la función save_frames(), que recibe un puntero al primer elemento de la lista que se desea salvar como argumento. estado = MNORMAL; /* Lanza el hilo de almacenamiento al disco duro */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_create(&save_thread, &attr, save_frames, (void *)start); pthread_attr_destroy(&attr); La función save_frames() crea un directorio para almacenar las imágenes, el cual tiene como nombre la fecha y la hora a la cual inicia el evento. Posteriormente la rutina recorre la lista, empezando por el primer elemento, y guarda cada uno de los cuadros en el disco duro. Una vez que un cuadro es almacenado, la memoria donde se encontraba es liberada y la celda es destruida. void *save_frames(void *list_start) { char timestamp[30]; char filename[50]; list *start = (list *)list_start; list *temp = NULL; 55 int i = 0; /* Determina la hora y la fecha actual */ time_t tptr; tptr = time(NULL); struct tm *tsptr; tsptr = localtime(&tptr); strftime(timestamp, 30, "%Y%m%d-%H%M%S", tsptr); /* Crea el directorio para almacenar las imágenes */ mkdir(timestamp, 0777); /* Bloquea el mutex */ pthread_mutex_lock(&mutexsave); while(1) { /* Guarda el cuadro */ snprintf(filename, 50, "%s/%04d.jpg", timestamp, i); save_image(start->frame, filename, video_buf.width, video_buf.height, "BGR"); /* Si llegó al final de la lista */ while(start->next == NULL) { /* Si no se van a agregar cuadros a la lista */ if(save_end) { /* libera la memoria */ free(start->frame); free(start); /* Desbloquea el mutex */ pthread_mutex_unlock(&mutexsave); /* Genera el archivo de video con mencoder */ printf("Generando archivo de video...\n"); char mencoder_line[150]; snprintf(mencoder_line, 150, "mencoder \"mf://%s/*.jpg\" -mf fps=%f:w=%d:h=%d:type=jpeg -ovc divx4 -o %s/%s.avi", timestamp, fps, video_buf.width, video_buf.height, timestamp, timestamp); system(mencoder_line); 56 /* Finaliza el hilo de ejecución */ pthread_exit(NULL); } /* Espera que se añada otro cuadro a la lista */ usleep(100); continue; } /* mueve start y libera la memoria */ temp = start; start = temp->next; free(temp->frame); free(temp); i++; } } Una de las cosas más importantes de esta función es la utilización de una variable mutex, con el fin de controlar el acceso a los recursos compartidos. En este caso, el mutex se utiliza para evitar que dos hilos de procesamiento guarden imágenes a la vez. Esto fue necesario debido a que la biblioteca imagemagick presentó problemas cuando se daba esta situación. Al utilizar el mutex, el primer hilo que se ejecute coloca un bloqueo sobre la variable utilizando la función pthread_mutex_lock(). Si otro hilo trata de ejecutar esta función sobre el mutex bloqueado será detenida hasta que el bloqueo sea eliminado. Una vez que la función termina de escribir las imágenes, esta elimina el bloqueo con la función pthread_mutex_unlock(), permitiendo que los otros hilos puedan llevar a cabo la escritura. La escritura de las imágenes es llevada a cabo por la función save_image(). Como se mencionó anteriormente, se utiliza la biblioteca imagemagick para llevar a cabo la creación y la escritura de la imagen. /* Crea una imagen y la salva al disco duro */ void save_image(unsigned char *data, char *filename, int width, int height, char *colorspace) { ExceptionInfo exception; Image *image; ImageInfo *image_info; 57 ... InitializeMagick((char *)NULL); GetExceptionInfo(&exception); image_info = CloneImageInfo((ImageInfo *) NULL); image = ConstituteImage(width, height, colorspace, CharPixel, data, &exception); (void)strcpy(image->filename, filename); WriteImage(image_info, image); DestroyImage(image); DestroyExceptionInfo(&exception); DestroyImageInfo(image_info); DestroyMagick(); } CAPÍTULO 7: Rutinas de comunicación y despliegue de video en el cliente 7.1. Envío de mensajes al servidor El envío de mensajes al servidor se lleva a cabo utilizando el protocolo TCP. Una vez iniciado el programa cliente, este llama a la función open_conn(), la cual se encarga de crear el socket y realizar la conexión al servidor, dejando al sistema listo para el envío de los mensajes. int open_conn(char *addr, int port) { struct hostent *hp; struct sockaddr_in server; char *buf_ptr, in_buf[BUF_SIZE]; int bytes_left; int n_read; /* Creación del socket */ if((sd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { fprintf(stderr, "No se puede abrir el socket\n"); return -1; } /* Información de la conexión */ memset((char *)&server, 0, sizeof(struct sockaddr_in)); server.sin_family = AF_INET; server.sin_port = htons(port); if((hp = gethostbyname(addr)) == NULL) { fprintf(stderr, "No se puede resolver el nombre del servidor\n"); return -1; } memcpy((char *)&server.sin_addr.s_addr, hp->h_addr, hp->h_length); /* Conexión con el servidor */ if(connect(sd, (struct sockaddr *)&server, sizeof(server)) == -1) { fprintf(stderr, "No se puede establecer la conexión 58 59 con el servidor\n"); return -1; } ... return 0; } El código es similar al estudiado en el capítulo 5, sin embargo presenta algunas diferencias importantes. En primer lugar, es necesario crear una estructura sockaddr_in con la información del servidor. La dirección del servidor se obtiene utilizando la función gethostbyname(), la cual recurre a las herramientas de resolución de nombres del sistema operativo. Otra diferencia con respecto al servidor es que utilizan las llamadas bind() o listen(), debido a que no es necesario esperar por conexiones. El cliente utiliza la llamada connect() para establecer la conexión con el servidor. Una vez establecido el enlace, es posible enviar o recibir mensajes, utilizando read() y write(). El envío de los mensajes es llevado a cabo por la función send_tcp_msg(): int send_tcp_msg(char *msg, void *retdata, int size) { char *buf_ptr, in_buf[BUF_SIZE], out_buf[BUF_SIZE]; int bytes_left, n_read; /* Envía el mensaje */ strcpy(out_buf, msg); write(sd, out_buf, BUF_SIZE); /* Recibe los datos, si hay algo que recibir */ if(retdata != NULL) { bytes_left = size; printf("bytes_left = %d\n", bytes_left); buf_ptr = retdata; while((n_read = read(sd, buf_ptr, bytes_left)) > 0) { buf_ptr += n_read; bytes_left -= n_read; } 60 } /* Recepción del mensaje de confirmación */ bytes_left = BUF_SIZE; buf_ptr = in_buf; while((n_read = read(sd, buf_ptr, bytes_left)) > 0) { buf_ptr += n_read; bytes_left -= n_read; } /* Verifica que el comando haya sido ejecutado satisfactoriamente */ if(strcmp(in_buf, "OK") == 0) return 0; else return -1; } Esta función envía el mensaje al servidor. Si el servidor debe retornar algo (como en el caso de VIDEOPROP), los datos son leídos y almacenados en la variable retdata. Por último, la función espera que el servidor envíe un mensaje de confirmación y con base en el contenido de este mensaje determina si el comando fue ejecutado de manera satisfactoria. Por ejemplo, a continuación se muestra el código necesario para enviar los mensajes CAPTURE y VIDEOPROP: /* Solicitud de inicio de captura */ if((msg_status = send_tcp_msg("CAPTURE", NULL, 0)) != 0) { fprintf(stderr, "Problemas solicitando el inicio de la captura\n"); exit(EXIT_FAILURE); } /* Petición de envío de las propiedades de video */ if((msg_status = send_tcp_msg("VIDEOPROP", (void *)&prop, sizeof(struct video_prop))) != 0) { fprintf(stderr, "Error obteniendo propiedades de video\n"); exit(EXIT_FAILURE); } 61 En el caso de CAPTURE, el comando no retornará datos, por lo tanto se envía NULL como segundo argumento. En VIDEOPROP, el comando retornará una estructura, del tipo video_prop, por lo tanto se le pasa a la función la variable prop para que almacene los datos, así como el tamaño de esta variable. 7.2. Recepción de los cuadros de video La recepción del video es realizada por un hilo de procesamiento diferente, el cual es creado después de solicitar al servidor el envío de los datos. /* Solicita al servidor el envío de los cuadros */ if((msg_status = send_tcp_msg("STREAM", NULL, 0)) != 0) { fprintf(stderr, "Error obteniendo el frame\n"); exit(EXIT_FAILURE); } /* Datos de la conexión */ strmdata.addr = "localhost"; strmdata.port = 24001; strmdata.width = prop.width; strmdata.height = prop.height; /* Crea el hilo de recepción de video */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_create(&stream_thread, &attr, start_vid_stream, (void *)&strmdata); printf("Stream Iniciado\n"); Este hilo ejecuta la función start_vid_stream(), la cual recibe como argumento la variable strmdata, una estructura del tipo stream_data: /* Información de la conexión UDP */ struct stream_data { char *addr; // Dirección del servidor int port; // Puerto de conexión int width; // Ancho del cuadro 62 int height; }; // Altura del cuadro Una vez dentro de start_vid_stream(), primer paso para leer estos datos consiste en crear el socket correspondiente. /* Creación del socket UDP */ if((sdu = socket(AF_INET, SOCK_DGRAM, 0)) == -1) { fprintf(stderr, "Error creando el socket UDP\n"); exit(-1); } /* Información del servidor */ memset((char *)&server, 0, sizeof(server)); server.sin_family = AF_INET; server.sin_port = htons(sdata->port); if((hp = gethostbyname(sdata->addr)) == NULL) { fprintf(stderr, "Error resolviendo la dirección del servidor\n"); exit(-1); } memcpy((char *)&server.sin_addr.s_addr, hp->h_addr, hp->h_length); /* Información del cliente */ memset((char *)&client, 0, sizeof(client)); client.sin_family = AF_INET; client.sin_port = htons(0); client.sin_addr.s_addr = htonl(INADDR_ANY); /* Enlace del socket */ if(bind(sdu, (struct sockaddr *)&client, sizeof(client)) == -1) { fprintf(stderr, "Error enlazando el socket\n"); exit(-1); } 63 Una vez creado el socket, el cliente envía un paquete al servidor indicándole que está listo para recibir los datos: server_len = sizeof(server); strcpy(buf, "telescreen"); if(sendto(sdu, buf, BUF_SIZE, 0, (struct sockaddr *)&server, server_len) == -1) { fprintf(stderr, "Problemas enviando datagrama al servidor\n"); exit(-1); } El siguiente paso consiste en iniciar un ciclo en el cual se leerán los datos enviados por el servidor. Tal como se mencionó en el capítulo 5, cada cuadro debe fragmentarse en segmentos de 4096 bytes debido a las limitaciones del paquete UDP. El cliente debe leer cada uno de estos paquetes y reconstruir el cuadro para su despliegue: /* Número de paquetes */ int n_packets = framesize / 4096; /* Cantidad de bytes sobrantes */ int leftover = framesize % 4096; int pc = 0; int p_size; char buf2[4096]; /* Reserva memoria para los cuadros */ temp_frame = malloc(framesize); frame = malloc(framesize); /* Recibe los paquetes UDP con el cuadro */ while(1) { p_size = recvfrom(sdu, buf2, 4096, 0, (struct sockaddr *)&server, &server_len); if(p_size < 0) { // Error en la recepción fprintf(stderr, "Error recibiendo el paquete %d\n", pc); continue; } else if(p_size == sizeof(int)) { // Paquete de sincronización 64 if(pc == n_packets + 1) { memcpy(frame, temp_frame, framesize); } else { fprintf(stderr, "Imagen con información incorrecta\n"); } pc = 0; } else if(p_size == 4096) { // Paquete de datos if(pc == n_packets) memcpy(temp_frame + pc*4096, buf2, leftover); else memcpy(temp_frame + pc*4096, buf2, 4096); pc++; } } La rutina lee los paquetes que recibe a través del socket utilizando la llamada recvfrom(). Si el tamaño del paquete es incorrecto lo descarta y lee el paquete siguiente. Cuando recibe el paquete de sincronización verifica que número de paquetes recibidos sea correcto, o sea, que la imagen este completa y la copia en la posición apuntada por la variable global frame. Esta posición es leída por las rutinas de la interfaz gráfica para llevar a cabo el despliegue. Si el número de paquetes es incorrecta, la imagen completa se descarta y se continúa con la siguiente. 7.3. Despliegue de la imagen Como se explicó en el capítulo 3, se utilizó la biblioteca GTK 2.4 para crear la interfaz gráfica de usuario, así como para desplegar los cuadros de video recibidos del cliente. Las imágenes se muestran utilizando el widget image. Este widget permite desplegar una imagen dentro de una ventana, ya sea leída desde un archivo o contenida en un objeto GdkPixbuf. Estos objetos están diseñados para contener y administrar imágenes, y pueden ser inicializados a partir de un arreglo de bytes que contenga los pixeles de la imagen. En el cliente, la función refresh() se encarga de crear el GdkPixbuf a partir de la información contenida en frame. Posteriormente crea un widget image a partir de este objeto y lo despliega. 65 /* Despliega la imagen recibida */ void refresh(void) { if(frame != NULL) { /* Crea el objeto GdkPixbuf */ video_pixbuf = gdk_pixbuf_new_from_data((const guchar *)frame, GDK_COLORSPACE_RGB, FALSE, 8, prop.width, prop.height, prop.width * 3, NULL, NULL); /* Inicializa image a partir de video_pixbuf */ gtk_image_set_from_pixbuf(image, video_pixbuf); /* Despliega image */ gtk_widget_show(image); } } Esta rutina es llamada periódicamente por el ciclo de manejo de la interfaz gráfica. Esto se logra registrándola mediante la función g_timeout_add(): g_timeout_add(10, refresh, NULL); Esto le indica al ciclo principal de GTK que ejecute la rutina cada 10 milisegundos. CAPÍTULO 8: Resultados 8.1. Captura de video Se llevaron a cabo pruebas para determinar la velocidad de captura (tasa de cuadros por segundo) máxima de la aplicación. Estas pruebas se realizaron utilizando dos dispositivos: 1. Cámara USB marca Genius, modelo VideoCAM Express V2, controlador V4L spca50x. 2. Tarjeta de adquisición de video marca Avermedia, modelo TVPhone 98, controlador V4L bt848. Los resultados obtenidos en las pruebas de velocidad, al realizar la captura al buffer principal de la aplicación se muestran en el cuadro 8.1 Cuadro 8.1 Cuadros por segundo capturados. Dispositivo 1 2 Tasa (cuadros por segundo) 8,89 29.97 En ambos casos se alcanzó la tasa de captura máxima permitida por el dispositivo. La cámara USB es una cámara de baja calidad, por lo tanto no es posible capturar a una velocidad alta. Por otro lado, la tarjeta de captura permite una tasa máxima que va de acuerdo a los estándares de video profesional (alrededor de 30 cuadros por segundo). 8.2. Reducción de ruido Como se mencionó en la sección 6.2, se aplicó un filtro de media para atenuar el ruido presente en las imágenes capturadas y reducir su efecto en las rutinas de detección de movimiento. En la figura 8.1 se muestra una imagen capturada con el dispositivo 1 antes y después de aplicar el filtro de media para la reducción de ruido. En los recuadros se muestran dos casos particulares de pixeles con ruido. Puede verse como en ambos casos, este ruido ha sido atenuado de forma significativa, lo que permite eliminarlo al aplicar el umbral de sensibilidad durante de determinación de la cantidad de 66 67 (a) Antes de aplicar el filtro (b) Después de aplicar el filtro Figura 8.1 Aplicación del filtro de media para reducir el ruido en las imágenes capturadas pixeles con cambios. También puede verse como la imagen ha sido suavizada al aplicar el filtro. Esto es una característica que se presenta siempre que se aplica este tipo de filtros, debido a que se atenúan las transiciones fuertes (como es el caso de los bordes de los objetos) presentes en la imagen. Este suavizado no afecta el desempeño de la rutina de detección de movimiento, debido a que el efecto se presenta por igual en todas las imágenes y no altera la comparación. 8.3. Determinación de eventos de movimiento Otra de las partes de la aplicación que fue sometida a pruebas fue la rutina de determinación de eventos de movimiento. Estas pruebas se llevaron a cabo en distintos escenarios, con distintas condiciones de iluminación para evaluar la respuesta del sistema en un conjunto amplio de situaciones. En todas las pruebas el objeto en movimiento fue una persona, debido a que la aplicación principal de este programa es la vigilancia. 68 En todos los casos, fue posible detectar el movimiento y determinar de forma adecuada la presencia del evento, una vez ajustados los distintos parámetros del sistema: Umbral de sensibilidad Umbral de evento Tiempo inicial Tiempo final Al alterar estos valores es posible ajustar el sistema para que responda satisfactoriamente en distintas situaciones, siempre que las condiciones de luz permitan que la cámara capture una imagen nítida. En la figura 8.2 se muestra un gráfico del porcentaje de pixeles con diferencia por cuadro analizado, durante un evento de movimiento. Este evento consistió de una persona caminando a velocidad normal frente a la cámara. La distancia entre la persona y la cámara fue de aproximadamente 3 m y el escenario presentaba una iluminación normal (luz de día). Los parámetros del sistema de detección durante este evento se muestran en el cuadro 8.2. Cuadro 8.2 Parámetros del sistema de detección de eventos de movimiento utilizados durante la prueba Parámetro Umbral de sensibilidad Umbral de evento Tiempo inicial Tiempo final Valor 8 5% 50 ms 5s El evento que se registró durante la prueba tuvo una duración de 8 segundos, incluyendo el tiempo inicial y el final, así como los cuadros capturados antes que iniciara el evento. El movimiento real se mantiene por aproximadamente 1,5 s. Otra prueba que se realizó fue la respuesta del sistema ante un cambio rápido de iluminación. La figura 8.3 muestra la respuesta del sistema al encender y apagar la luz de una habitación. Los parámetros utilizados durante esta prueba son los mismos que se utilizaron en la prueba anterior (cuadro 8.2). En este caso, el sistema no consideró estas diferencias como un evento de movimiento, lo que muestra la importancia del tiempo inicial para eliminar las falsas alarmas que se pueden producir por alteraciones de esta clase. 69 35 r rrr r Porcentaje de pixeles con diferencias 30 25 r r 20 15 r r 10 r Umbral de evento 5 r r r rr 0 rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr 0 50 100 150 200 Cuadro analizado 250 Figura 8.2 Porcentaje de pixeles con diferencias durante un evento de movimiento 70 60 r Porcentaje de pixeles con diferencias r 50 40 30 r r 20 10 Umbral de evento r r 0 rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr 0 50 100 150 200 250 Cuadro analizado Figura 8.3 Respuesta del sistema ante un cambio rápido en la iluminación CAPÍTULO 9: Conclusiones y Recomendaciones 9.1. Conclusiones La utilización de múltiples hilos de ejecución (threads) permite que cada uno de los procesos se dedique a una tarea específica. Cada hilo trabaja de forma paralela a los otros, sin ser afectado significativamente por los demás, lo que trae consigo un mejor desempeño y facilita el desarrollo de los sistemas. La utilización de múltiples hilos de procesamiento permite además explotar al máximo sistemas de multiprocesamiento, en los cuales es posible obtener un procesamiento paralelo real. Se logró capturar video a la máxima tasa de cuadros por segundo al utilizar todos los cuadros de la memoria del dispositivo de video. Esta técnica permite capturar uno de los cuadros al mismo tiempo que los otros están siendo preparados, lo cual aumenta significativamente la eficiencia en la captura. Debido a la gran cantidad de ruido presente en las imágenes adquiridas, principalmente en el caso de las cámaras web fue necesario aplicar un filtro de media con el fin de reducir esta fuente de error. El filtro funcionó adecuadamente, reduciendo significativamente el ruido aleatorio presente en los cuadros capturados. La modificación de los valores de umbral durante el proceso de detección de movimiento permite ajustar la sensibilidad del sistema de una manera precisa, reduciendo la cantidad de eventos falsos, y permitiendo adaptar el sistema a una gran cantidad de escenarios. Se obtuvieron buenos resultados al utilizar el algoritmo de determinación de eventos de movimiento. La variación de los parámetros de tiempo permitió eliminar la influencia de los cambios repentinos en la intensidad de luz y de otros fenómenos que podían ocasionar el registro de un evento falso. La utilización de un hilo de procesamiento independiente para realizar la escritura de los cuadros capturados al disco duro redujo la influencia del retraso en la escritura a este medio sobre el desempeño del sistema. 71 72 Se obtuvieron buenos resultados al utilizar el protocolo UDP para la transmisión hacia el cliente de los cuadros de video capturados. Aunque hay una mayor pérdida de paquetes, este protocolo brinda una latencia menor, lo cual es fundamental en una aplicación de transmisión en tiempo real. La interfaz gráfica de usuario implementada permite visualizar en tiempo real el video adquirido por el sistema. Esta interfaz puede ser modificada para incorporar funciones adicionales y extender su capacidad. Esta aplicación constituye una plataforma de desarrollo que puede ser utilizada como componente de otros proyectos, debido a que sus características permiten adaptarla a una gran cantidad de aplicaciones. 9.2. Recomendaciones Es necesario realizar algún tipo de compresión en los datos que son enviados al cliente sobre la red. En la actualidad los cuadros son enviados tal como son capturados, lo cual hace que el volumen de datos sea muy grande. Esto hace que sea difícil utilizar la característica de video en tiempo real cuando la red es lenta o tiene mucho tráfico. Entre los métodos de compresión que se podrían utilizar se encuentran el sistema de compresión de video MPEG4 o los algoritmos de compresión LZO. Una forma de mejorar el desempeño durante el registro de los eventos de movimiento sería crear el archivo de video que contiene el evento en la memoria utilizando funciones de alguna biblioteca de codificación, en vez de escribir cada uno de los cuadros capturados y generar el archivo de video al final. El diseño del programa podría ser modificado para que sea posible la inclusión de otros filtros o rutinas de procesamiento, no sólo al realizar la detección de movimiento sino también durante la captura del video. Esto permitiría adaptar el sistema para otras aplicaciones, tales como rastreo de objetos o procesos de control de calidad. BIBLIOGRAFÍA [1] Baxes, G. «Digital Image Processing. Principles and Applications», primera edición, John Wiley & Sons, Estados Unidos, 1994. [2] Jähne, B. «Digital Image Processing. Concepts, Algorithms and Scientific Applications.», cuarta edición, Springer, Alemania, 1997. [3] Johnson, M. «Linux Information Sheet», The Linux Documentation Project. http://www.tldp.org/HOWTO/INFO-SHEET.html, 1998. [4] Kernighan, B. y Ritchie, D. «The C Programming Language», segunda edición. Prentice Hall, Estados Unidos, 1988. [5] Ondrik, M. et al. «Motion Detection Tecnologies», Canberra, http://www.canberra.com/pdf/Literature/motion.pdf, 1998. [6] Russ, J. «The Image Processing Handbook», CRC Press, Estados Unidos, 1992. [7] Wall, M. et al. «Linux Programming Unleashed», primera edición, Sams, Estados Unidos, 1999. [8] León-García, A. y Widjaja, I. «Redes de Comunicación. Conceptos Fundamentales y Arquitecturas Básicas», McGraw-Hill, España, 2002. [9] Wikipedia. «Kernel (Computer Science)», Wikipedia, http://en.wikipedia.org/wiki/kernel_(computer_science), julio, 2005. [10] Wikipedia. «POSIX», Wikipedia, http://en.wikipedia.org/wiki/POSIX, julio, 2005. [11] — «Video4Linux API». http://linux.bytesex.org/v4l2/API.html, marzo, 2005. [12] — «POSIX Threads Programming», http://www.llnl.gov/computing/tutorials/pthreads/, junio, 2005. 73 APÉNDICE A: Código fuente de la aplicación servidor global.h: Declaraciones y definiciones globales 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 /* * Telescreen v0.3 * Programa de captura de video y detección de movimiento utilizando V4L * global.h: Declaraciones y Definiciones globales * Copyright (C) 2005 Andrés Díaz Soto <adiaz@eie.ucr.ac.cr> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #include #include #include #include #include #include <linux/videodev.h> <stdio.h> <pthread.h> <assert.h> <sys/types.h> <sys/stat.h> #ifndef GLOBAL_H #define GLOBAL_H /* Variables Globales */ unsigned char *main_buf; // Buffer principal unsigned char *map; // Mapeo de la memoria del dispositivo struct video_capability cap; // Caracaterísticas del dispositivo de video struct video_mbuf buf_info; // Información de la memoria de video struct video_mmap video_buf; // Características de los cuadros de la memoria de video int vfd; // Descriptor de archivo del dispositivo de video int capture; // Estado del hilo de captura int stream; // Estado del hilo de envío de video int motion; // Estado del hilo de detección de movimiento int framecounter; // Contador de cuadro capturado int framesize; // Tamaño del cuadro (3bytes/pixel) float fps; // Cuadros por segundo #endif /* GLOBAL_H */ main.c: Rutina principal del servidor 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 /* * * * * * * * * * * * * * * Telescreen v0.3 Programa de captura de video y detección de movimiento utilizando V4L main.c: Implementación de la rutina principal Copyright (C) 2005 Andrés Díaz Soto <adiaz@eie.ucr.ac.cr> This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. 74 75 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #include "global.h" #include "video.h" #include "sockets.h" int main(int argc, char **argv) { /* Inicialización de variables globales */ main_buf = NULL; map = NULL; vfd = -1; capture = 0; stream = 0; motion = 0; printf("Telescreen v0.3\n"); /* Inicializa el dispositivo de video */ vfd = init_video(VIDEO_DEV); /* Verifica la existencia del dispositivo */ assert(vfd != -1); /* Define el canal */ set_chan(vfd, CHAN); /* Define propiedades de captura */ set_video_prop(cap.maxwidth, cap.maxheight, VIDEO_PALETTE_RGB24); /* Inicia el servidor */ tcpsocket(); } video.h: Declaraciones y definiciones para las rutinas de inicialización y captura de video 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 /* * Telescreen v0.3 * Programa de captura de video y detección de movimiento utilizando V4L * video.h: Declaraciones y definiciones para las rutinas de inicialización y * captura de video * Copyright (C) 2005 Andrés Díaz Soto <adiaz@eie.ucr.ac.cr> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #include #include #include #include #include #include #include <stdlib.h> <string.h> <fcntl.h> <sys/time.h> <sys/ioctl.h> <sys/mman.h> "global.h" 76 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 #ifndef VIDEO_H #define VIDEO_H /* Definiciones */ #define VIDEO_DEV "/dev/video0" #define CHAN 0 #define BUF_FRAME_NUM 50 // Dispositivo de video // Canal // Número de cuadros del buffer principal /* Declaraciones de las funciones */ /* init_video: Inicialización del dispositivo de video */ int init_video(char *video_dev); /* set_chan: Definición del canal de captura */ int set_chan(int fd, int chan); /* set_video_prop: Definición de las propiedades de captura */ int set_video_prop(int width, int height, int format); /* capture_loop: Ciclo de captura de video */ void *capture_loop(void *null); #endif /* VIDEO_H */ video.c: Implementación de las rutinas de inicialización y captura de video 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 /* * Telescreen v0.3 * Programa de captura de video y detección de movimiento utilizando V4L * video.c: Implementación de las rutinas de inicialización y captura de video * Copyright (C) 2005 Andrés Díaz Soto <adiaz@eie.ucr.ac.cr> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #include "video.h" /* init_video: Inicialización del dispositivo de video */ int init_video(char *video_dev) { int fd; /* Apertura del dispositivo */ if((fd = open(video_dev, O_RDWR)) == -1) { fprintf(stderr, "Error abriendo el dispositivo %s\n", video_dev); return -1; } /* Obtención de las capacidades de captura */ if(ioctl(fd, VIDIOCGCAP, &cap) == -1) { fprintf(stderr, "Error al realizar VIDIOCGCAP\n"); return -1; } /* Información de los Buffers */ if((ioctl(fd, VIDIOCGMBUF, &buf_info)) == -1) { printf("Error adquiriendo los buffers\n"); return -1; } 77 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 printf("Tamanno del buffer del dispositivo: %d\n", buf_info.size); map = mmap(0, buf_info.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); if(map == NULL) { printf("Error en el mapeo de la memoria\n"); return -1; } return fd; } /* set_chan: Definición del canal de captura */ int set_chan(int fd, int chan) { if(ioctl(fd, VIDIOCSCHAN, chan) == -1) return -1; else return 0; } /* set_video_prop: Definición de las propiedades de captura */ int set_video_prop(int width, int height, int format) { video_buf.width = width; video_buf.height = height; video_buf.format = format; return 0; } /* capture_loop: Ciclo de captura de video */ void *capture_loop(void *null) { struct timeval time1, time2; struct timezone tz; int i = 0; framesize = video_buf.width * video_buf.height * 3; /* Reserva de memoria para el buffer */ printf("Tamanno del buffer principal: %d\n", framesize * BUF_FRAME_NUM); main_buf = (char *)malloc(BUF_FRAME_NUM * framesize); framecounter = 0; gettimeofday(&time1, &tz); /* Ciclo de captura - Usando todos los buffers */ /* Prepara todos los cuadros para captura */ for(i = 0; i < buf_info.frames; i++) { video_buf.frame = i; ioctl(vfd, VIDIOCMCAPTURE, &video_buf); } i = 0; /* Para calcular la tasa de captura (fps) */ gettimeofday(&time1, &tz); /* Loop infinito de captura */ while(capture) { /* Si llegó al fin de la memoria del dispositivo */ if(i == buf_info.frames) i = 0; video_buf.frame = i; ioctl(vfd, VIDIOCSYNC, &video_buf); ioctl(vfd, VIDIOCMCAPTURE, &video_buf); // Sincroniza // Prepara para la siguiente lectura /* Si llegó al final del buffer vuelve a empezar desde el incio */ if(framecounter == BUF_FRAME_NUM) { framecounter = 0; gettimeofday(&time2, &tz); /* Calcula la tasa de captura */ fps = BUF_FRAME_NUM / ((float)(time2.tv_sec-time1.tv_sec) + (float)(time2.tv_usec-time1.tv_usec) / 1000000.0); printf("Tasa de captura: %f fps\n", fps); gettimeofday(&time1, &tz); 78 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 } /* Copia el cuadro al buffer principal */ memcpy(main_buf + framecounter * framesize, map + buf_info.offsets[i], framesize); /* Incrementa ambos contadores */ i++; framecounter++; } pthread_exit(NULL); } motion.h: Declaraciones y definiciones para las rutinas de detección de movimiento y escritura a disco duro 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 /* * Telescreen v0.3 * Programa de captura de video y detección de movimiento utilizando V4L * motion.h: Declaraciones y definiciones para las rutinas de detección de movimiento y * escritura a disco duro * Copyright (C) 2005 Andrés Díaz Soto <adiaz@eie.ucr.ac.cr> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #include #include #include #include #include #include "global.h" <string.h> <stdlib.h> <unistd.h> <sys/time.h> <magick/api.h> #ifndef MOTION_H #define MOTION_H /* Valores de umbral Estos valores varían según las condiciones del escenario */ #define THRESHOLD 5 // Umbral de evento #define ITH 8 // Umbral de sensibilidad #define NMSIZE 20 /* Estados de captura */ #define #define #define #define IDLE 0 // No se ha detecctado movimiento MSTARTED 1 // Tiempo inicial MNORMAL 2 // Evento de movimiento MSTOPED 3 // Tiempo final /* Lista enlazada para almacenar los cuadros */ typedef struct le { unsigned char *frame; // Puntero al cuadro struct le *next; // Puntero a la siguiente celda } list; /* Declaraciones de las funciones */ /* motion_detect: Rutina de detección de movimiento y determinación de eventos */ 79 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 void *motion_detect(void *null); /* mean_filter: Filtro de media para la reducción de ruido */ void mean_filter(unsigned char *frame, int x, int y); /* grayscale: Conversión de la imagen a escala de grises (intensidad) */ void grayscale(unsigned char *frame, int size, char *new_frame); /* save_frames: Almacenamiento de las imágenes a disco duro y generación del archivo de video */ void *save_frames(void *list_start); /* save_image: Almacenamiento de una imágen a disco duro utilizando ImageMagick */ void save_image(unsigned char *data, char *filename, int width, int height, char *colorspace); #endif /* MOTION_H */ motion.c: Implementación de las rutinas de detección de movimiento y escritura a disco duro 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 /* * Telescreen v0.3 * Programa de captura de video y detección de movimiento utilizando V4L * motion.c: Implementación las rutinas de detección de movimiento y * escritura a disco duro * Copyright (C) 2005 Andrés Díaz Soto <adiaz@eie.ucr.ac.cr> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #include "motion.h" /* Variables globales */ static int nmsize; static pthread_mutex_t mutexsave; static int save_end; void *motion_detect(void *null) { int fc = -1, prevfc = -1; unsigned char *dif, *curr, *prev; int ndif; int save = 1; float threshold = THRESHOLD; int ith = ITH; float pdif; unsigned char *nomotion; nmsize = NMSIZE; int nmc = 0; int estado = IDLE; int mstart_time, mstop_time, seqn; struct timeval start_time, temp_time, stop_time; struct timezone tz; pthread_t save_thread; pthread_attr_t attr; 80 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 list *start = NULL, *current = NULL, *temp = NULL; save_end = 0; seqn = nmsize; mstart_time = 50; mstop_time = 5000; dif = malloc(framesize / 3); curr = malloc(framesize / 3); prev = malloc(framesize / 3); nomotion = malloc(nmsize * framesize); FILE *stats = fopen("stats", "w"); int sframe = 0; FILE *estados = fopen("estados", "w"); pthread_mutex_init(&mutexsave, NULL); while(motion) { /* Toma el cuadro anterior al que está siendo caoturado */ fc = framecounter - 1; if(fc < 0) fc = 0; if(fc == prevfc) continue; else prevfc = fc; ndif = 0; memcpy(nomotion + nmc * framesize, main_buf + fc * framesize, framesize); nmc++; if(nmc == nmsize) nmc = 0; /* Convierte el cuadro actual y el anterior a escala de grises */ grayscale(main_buf + fc * framesize, framesize, curr); grayscale(main_buf + (fc?(fc - 1):0) * framesize, framesize, prev); //DEBUG if(save) { save_image(curr, "current_gray.jpg", video_buf.width, video_buf.height, "I"); save_image(prev, "previous_gray.jpg", video_buf.width, video_buf.height, "I"); } /* Aplica filtro a ambos cuadros */ mean_filter(curr, video_buf.width, video_buf.height); mean_filter(prev, video_buf.width, video_buf.height); //DEBUG if(save) { save_image(curr, "current.jpg", video_buf.width, video_buf.height, "I"); save_image(prev, "previous.jpg", video_buf.width, video_buf.height, "I"); save = 0; } /* Resta ambos cuadros y almacena la diferencia en dif */ int i; for(i = 0; i < framesize / 3; i++) { dif[i] = abs(curr[i] - prev[i]); if(dif[i] > ith) ndif++; } /* Calcula el porcentaje de pixeles diferentes */ pdif = (float)ndif/((float)framesize/3)*100; fprintf(stats, "%d\t%f\n", sframe, pdif); sframe++; /* Maquina de estados para almacenar los eventos capturados al disco */ switch(estado) { case IDLE: fprintf(estados, "Estado: IDLE, fc = %d\n", fc); if(pdif > threshold) { estado = MSTARTED; gettimeofday(&start_time, &tz); } 81 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 break; case MSTARTED: fprintf(estados, "Estado: MSTARTED, fc = %d, ", fc); gettimeofday(&temp_time, &tz); /* Almacenamiento de los cuadros */ if(start == NULL) { // Si no existe la lista enlazada fprintf(estados, "start = NULL"); /* Crea la primera celda de la lista */ start = (list *)malloc(sizeof(list)); start->frame = (char *)malloc(framesize); memcpy(start->frame, nomotion + nmc * framesize, framesize); start->next = NULL; current = start; /* Copia los cuadros previos a la lista */ int i; for(i = nmc + 1; i < nmsize + nmc; i++) { temp = (list *)malloc(sizeof(list)); temp->frame = (char *)malloc(framesize); if(i >= nmsize) memcpy(temp->frame, nomotion + (i - nmsize) * framesize, framesize); else memcpy(temp->frame, nomotion + i * framesize, framesize); temp->next = NULL; current->next = temp; current = temp; } } else { temp = (list *)malloc(sizeof(list)); temp->frame = (char *)malloc(framesize); memcpy(temp->frame, main_buf + fc * framesize, framesize); temp->next = NULL; current->next = temp; current = temp; } /* Si se cumplió el tiempo inicial */ if((temp_time.tv_sec - start_time.tv_sec)*1000 + (temp_time.tv_usec - temp_time.tv_usec)/1000 >= mstart_time) { if(pdif > threshold) { // Si hay movimiento estado = MNORMAL; printf("Evento de movimiento iniciado...\n"); /* Lanza el hilo de almacenamiento al disco duro */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_create(&save_thread, &attr, save_frames, (void *)start); pthread_attr_destroy(&attr); } else { // Si no hay movimiento estado = IDLE; seqn = nmsize; /* Destruye los cuadros almacenados en memoria */ while(start != NULL) { temp = start; start = temp->next; free(temp->frame); free(temp); } temp = NULL; current = NULL; } } fprintf(estados, "\n"); break; case MNORMAL: fprintf(estados, "Estado: MNORMAL, fc = %d\n", fc); /* Almacenamiento del cuadro */ temp = (list *)malloc(sizeof(list)); temp->frame = (char *)malloc(framesize); memcpy(temp->frame, main_buf + fc * framesize, framesize); temp->next = NULL; current->next = temp; current = temp; if(pdif < threshold) { // Si no hay movimiento estado = MSTOPED; gettimeofday(&stop_time, &tz); } break; case MSTOPED: fprintf(estados, "Estado: MSTOPED, fc = %d\n", fc); /* Almacenamiento del cuadro */ temp = (list *)malloc(sizeof(list)); temp->frame = (char *)malloc(framesize); memcpy(temp->frame, main_buf + fc * framesize, framesize); temp->next = NULL; current->next = temp; current = temp; if(pdif > threshold) // Si hay moviento 82 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 estado = MNORMAL; else { // Si no hay movimiento gettimeofday(&temp_time, &tz); /* Si se cumplió el tiempo final */ if((temp_time.tv_sec - stop_time.tv_sec)*1000 + (temp_time.tv_usec - temp_time.tv_usec)/1000 >= mstop_time) { estado = IDLE; /* Inicializa los punteros de la lista */ start = NULL; current = NULL; temp = NULL; save_end = 1; printf("Evento de movimiento finalizado.\n"); } } break; } } /* Libera memoria */ free(dif); free(curr); free(prev); fclose(stats); fclose(estados); pthread_mutex_destroy(&mutexsave); pthread_exit(NULL); } /* mean_filter: Filtro de media para la reducción de ruido */ void mean_filter(unsigned char *frame, int x, int y) { int i, j; unsigned char *new_frame; /* Matriz de pesos */ float weights[9] = {0.11, 0.11, 0.11, 0.11, 0.11, 0.11, 0.11, 0.11, 0.11}; /* Almacenamiento temporal para la imagen procesada */ new_frame = malloc(x * y); /* Aplica el filtro pixel por pixel for(i = 1; i < (y - 1); i++) for(j = 1; j < (x - 1); j++) { new_frame[i*x+j] = weights[0] * weights[1] * weights[2] * weights[3] * weights[4] * weights[5] * weights[6] * weights[7] * weights[8] * */ frame[(i-1)*x+(j-1)] + frame[(i-1)*x+j] + frame[(i-1)*x+(j+1)] + frame[i*x+(j-1)] + frame[i*x+j] + frame[i*x+(j+1)] + frame[(i+1)*x+(j-1)] + frame[(i+1)*x+j] + frame[(i+1)*x+(j+1)]; } /* Coloca pixeles negros en el borde de la imagen */ for(i = 0; i < y; i++) { new_frame[i*x] = 0; new_frame[i*x+(x-1)] = 0; } for(i = 0; i < x; i++) { new_frame[i] = 0; new_frame[(y-1)*x+i] = 0; } /* Copia la imagen procesada sobre la imagen actual y libera la memoria temporal */ memcpy(frame, new_frame, x * y); free(new_frame); } /* grayscale: Conversión de la imagen a escala de grises (intensidad) */ void grayscale(unsigned char *frame, int size, char *new_frame) { int i, j; float temp; for(i = 0, j = 0; i < size; i += 3, j++) { temp = 0.11*frame[i] + 0.59*frame[i+1] + 0.3*frame[i+2]; if(temp >= 255) new_frame[j] = 254; else new_frame[j] = temp; 83 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 } } /* save_frames: Almacenamiento de las imágenes a disco duro y generación del archivo de video */ void *save_frames(void *list_start) { char timestamp[30]; char filename[50]; list *start = (list *)list_start; list *temp = NULL; int i = 0; /* Determina la hora y la fecha actual */ time_t tptr; tptr = time(NULL); struct tm *tsptr; tsptr = localtime(&tptr); strftime(timestamp, 30, "%Y%m%d-%H%M%S", tsptr); /* Crea el direcctorio para almacenar las imágenes */ mkdir(timestamp, 0777); /* Bloquea el mutex */ pthread_mutex_lock(&mutexsave); while(1) { /* Guarda el cuadro */ snprintf(filename, 50, "%s/%04d.jpg", timestamp, i); save_image(start->frame, filename, video_buf.width, video_buf.height, "BGR"); /* Si llegó al final de la lista */ while(start->next == NULL) { /* Si no se van a agregar cuadros a la lista */ if(save_end) { /* Libera la memoria */ free(start->frame); free(start); /* Desbloquea el mutex */ pthread_mutex_unlock(&mutexsave); /* Genera el archivo de video con memcoder */ printf("Generando archivo de video...\n"); char mencoder_line[150]; snprintf(mencoder_line, 150, "mencoder \"mf://%s/*.jpg\" -mf fps=%f:w=%d:h=%d:type=jpeg -ovc divx4 -o %s/%s.avi", timestamp, fps, video_buf.width, video_buf.height, timestamp, timestamp); system(mencoder_line); /* Finaliza el hilo de ejecución */ pthread_exit(NULL); } /* Espera a que se añada otro cuadro a la lista */ usleep(100); continue; } /* mueve start y libera la memoria */ temp = start; start = temp->next; free(temp->frame); free(temp); i++; } } /* save_image: Almacenamiento de una imágen a disco duro utilizando ImageMagick */ void save_image(unsigned char *data, char *filename, int width, int height, char *colorspace) { ExceptionInfo exception; Image *image; ImageInfo *image_info; /* Bug? de imagemagick: 255 -> 0 si la imagen está en valores de intensidad*/ if(strcmp(colorspace, "I") == 0) { int i; for(i = 0; i < width * height; i++) if(data[i] == 255) data[i] = 254; } InitializeMagick((char *)NULL); 84 395 396 397 398 399 400 401 402 403 404 405 406 407 408 GetExceptionInfo(&exception); image_info = CloneImageInfo((ImageInfo *) NULL); image = ConstituteImage(width, height, colorspace, CharPixel, data, &exception); (void)strcpy(image->filename, filename); WriteImage(image_info, image); DestroyImage(image); DestroyExceptionInfo(&exception); DestroyImageInfo(image_info); DestroyMagick(); } sockets.h: Declaraciones y definiciones para las rutinas de comunicación con el cliente y transmisión de video 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 /* * Telescreen v0.3 * Programa de captura de video y detección de movimiento utilizando V4L * sockets.h: Declaraciones y definiciones para las rutinas de comunicación con * el cliente y transmisión de video * Copyright (C) 2005 Andrés Díaz Soto <adiaz@eie.ucr.ac.cr> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #include #include #include #include #include #include #include <sys/socket.h> <netinet/in.h> <string.h> <unistd.h> "global.h" "video.h" "motion.h" #ifndef SOCKETS_H #define SOCKETS_H /* Definiciones */ #define PORT 24001 // Puerto del servidor #define BUF_SIZE 256 // Tamaño del buffer de datos /* Propiedades del cuadro enviado */ struct video_prop { int width; // Ancho int height; // Altura }; /* Declaración de funciones */ /* tcpsocket: Servidor TCP para el hilo principal */ void tcpsocket(void); /* udpsocket: Envío de los cuadros de video al cliente */ void *udpsocket(void *); #endif /* SOCKETS_H */ 85 sockets.c: Implementación de las rutinas de comunicación con el cliente y transmisión de video 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 /* * Telescreen v0.3 * Programa de captura de video y detección de movimiento utilizando V4L * sockets.c: Implementación de las rutinas de comunicación con * el cliente y transmisión de video * Copyright (C) 2005 Andrés Díaz Soto <adiaz@eie.ucr.ac.cr> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #include "sockets.h" /* tcpsocket: Servidor TCP para el hilo principal */ void tcpsocket(void) { int sd, sd2, client_len; struct sockaddr_in server, client; char *buf_ptr, out_buf[BUF_SIZE], in_buf[BUF_SIZE]; pthread_t capture_thread, udp_thread, motion_thread; pthread_attr_t attr; /* Creación del socket */ if((sd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { fprintf(stderr, "Problemas creando el socket\n"); pthread_exit((void *)-1); } /* Almacenamiento de los parámetros de conexión en la estructura sockaddr_in */ memset((char *)&server, 0, sizeof(struct sockaddr_in)); server.sin_family = AF_INET; server.sin_port = htons(PORT); server.sin_addr.s_addr = htonl(INADDR_ANY); /* Enlace del socket */ if(bind(sd, (struct sockaddr *)&server, sizeof(server)) == -1) { fprintf(stderr, "Error al enlazar el socket\n"); pthread_exit((void *)-1); } /* El socket espera conexiones */ listen(sd, 5); /* Ciclo infinito de atención de conexiones */ while(1) { /* Acepta la conexión entrante */ client_len = sizeof(client); if((sd2 = accept(sd, (struct sockaddr *)&client, &client_len)) == -1) { fprintf(stderr, "No se puede aceptar la conexion\n"); pthread_exit((void *)-1); } /* Envía mensaje de bienvenida */ strcpy(out_buf,"Telescreen v0.1"); write(sd2, out_buf, BUF_SIZE); int n_read, bytes_left; while(1) { /* Para que el ciclo no ocupe todo el procesador */ usleep(100); /* Lectura de los datos enviados por el cliente */ bytes_left = BUF_SIZE; buf_ptr = in_buf; 86 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 while((n_read = read(sd2, buf_ptr, bytes_left)) > 0) { buf_ptr += n_read; bytes_left -= n_read; } if(n_read < 0) continue; if((strcmp(in_buf,"CAPTURE")) == 0) { // Inicio de la captura if(!capture) { capture = 1; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_create(&capture_thread, &attr, capture_loop, NULL); printf("Captura Iniciada\n"); } strcpy(out_buf, "OK"); write(sd2, out_buf, BUF_SIZE); } else if((strcmp(in_buf, "NOCAPTURE")) == 0) { // Fin de la captura if(capture) { capture = 0; pthread_join(capture_thread, NULL); printf("Captura detenida\n"); } strcpy(out_buf, "OK"); write(sd2, out_buf, BUF_SIZE); } else if((strcmp(in_buf, "VIDEOPROP")) == 0) { // Envío de las propiedades del video capturado struct video_prop prop; char *prop_ptr = (char *)&prop; prop.width = video_buf.width; prop.height = video_buf.height; write(sd2, prop_ptr, sizeof(struct video_prop)); printf("Propiedades de video enviadas\n"); strcpy(out_buf, "OK"); write(sd2, out_buf, BUF_SIZE); } else if(strcmp(in_buf, "STREAM") == 0) { // Inicio del envío del video al cliente if(!stream) { stream = 1; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_create(&udp_thread, &attr, udpsocket, NULL); printf("Transmisión del video iniciada\n"); } strcpy(out_buf, "OK"); write(sd2, out_buf, BUF_SIZE); } else if(strcmp(in_buf, "NOSTREAM") == 0) { // Fin del envío del video if(stream) { stream = 0; pthread_join(udp_thread, NULL); } strcpy(out_buf, "OK"); write(sd2, out_buf, BUF_SIZE); } else if(strcmp(in_buf, "MOTION") == 0) { // Inicio de la detección de movimiento if(!motion) { motion = 1; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_create(&motion_thread, &attr, motion_detect, NULL); printf("Detección de movimiento iniciada\n"); } strcpy(out_buf, "OK"); write(sd2, out_buf, BUF_SIZE); } else if(strcmp(in_buf, "NOMOTION") == 0) { // Fin de la detección de movimiento if(motion) { motion = 0; pthread_join(motion_thread, NULL); } strcpy(out_buf, "OK"); write(sd2, out_buf, BUF_SIZE); } else if(strcmp(in_buf, "CLOSE") == 0) { // Finalización de la conexión printf("Conexión finalizada\n"); strcpy(out_buf, "OK"); write(sd2, out_buf, BUF_SIZE); break; } else { // Comando desconocido printf("Comando desconocido\n"); strcpy(out_buf, "UNKNOWN"); write(sd2, out_buf, BUF_SIZE); } } printf("Conexión con el cliente finalizada.\n"); close(sd2); } 87 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 close(sd); } /* udpsocket: Envío de los cuadros de video al cliente */ void *udpsocket(void *null) { int sd, client_len; char buf[BUF_SIZE]; struct sockaddr_in server, client; int fc = 0, prev_fc = -1; int counter = 0; /* Creación del socket UDP */ if((sd = socket(AF_INET, SOCK_DGRAM, 0)) == -1) { fprintf(stderr, "Problemas creando el socket\n"); pthread_exit((void *)-1); } /* Información de la conexión */ memset((char *)&server, 0, sizeof(server)); server.sin_family = AF_INET; server.sin_port = htons(PORT); server.sin_addr.s_addr = htonl(INADDR_ANY); /* Enlace del socket */ if(bind(sd, (struct sockaddr *)&server, sizeof(server)) == -1) { fprintf(stderr, "Problemas al enlazar el socket\n"); pthread_exit((void *)-1); } int n; /* Espera que el cliente solicite los datos */ client_len = sizeof(client); if((n = recvfrom(sd, buf, BUF_SIZE, 0, (struct sockaddr *)&client, &client_len)) < 0) { fprintf(stderr, "Problemas recibiendo datagramas del ciente\n"); pthread_exit((void *)-1); } while(stream) { /* Envía el cuadro anterior al que está siendo capturado */ if(framecounter) fc = framecounter - 1; else fc = BUF_FRAME_NUM; if(prev_fc == fc) continue; prev_fc = fc; unsigned char *fp = main_buf + framesize * fc; /* Se divide el frame en paquetes UDP de 4096 bytes */ int n_packets = framesize / 4096; int i; for(i = 0; i <= n_packets; i++) { if(sendto(sd, (void *)(fp + i*4096), 4096, 0, (struct sockaddr *)&client, client_len) == -1) printf("Error enviando el paquete #%d\n", i); /* Para que no se pierdan paquetes en interfaces muy rápidas (ej. loopback) */ usleep(10); } /* Envío del paquete de sincronización */ int sync = n_packets; // Valor arbitrario, lo que importa es el tamaño if(sendto(sd, (char *)&sync, sizeof(int), 0, (struct sockaddr *)&client, client_len) == -1) printf("Error enviando paquete de sincronización\n"); counter++; } close(sd); pthread_exit(NULL); } APÉNDICE B: Código fuente de la aplicación cliente main.c: Rutina principal del cliente 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 /* * Telescreen v0.3 * Programa de captura de video y detección de movimiento utilizando V4L * main.c: Rutina principal del cliente * Copyright (C) 2005 Andrés Díaz Soto <adiaz@eie.ucr.ac.cr> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #include #include #include #include #include static static static extern <stdio.h> <stdlib.h> <gtk/gtk.h> <pthread.h> "net.h" GtkWidget *image; GdkPixbuf *video_pixbuf; struct video_prop prop; unsigned char *frame; /* refresh: Despliega la imagen recibida */ void refresh(void) { printf("En refresh()\n"); if(frame != NULL) { /* Crea el objeto GdkPixbuf */ video_pixbuf = gdk_pixbuf_new_from_data((const guchar *)frame, GDK_COLORSPACE_RGB, FALSE, 8, prop.width, prop.height, prop.width * 3, NULL, NULL); /* Inicializa image a partir de video_pixbuf */ gtk_image_set_from_pixbuf(image, video_pixbuf); /* Despliega image */ gtk_widget_show(image); } } int main(int argc, char *argv[]) { GtkWidget *window; int msg_status = -1; char *frame = NULL; struct stream_data strmdata; pthread_t stream_thread; pthread_attr_t attr; int trc; /* Inicialización GTK */ gtk_init(&argc, &argv); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); /* Manejo de señales GTK */ g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(gtk_widget_destroy), NULL); g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); /* Establecimiento de la conexión */ if(open_conn("localhost", 24001) != 0) { fprintf(stderr, "Error iniciando la conexión con el servidor.\n"); exit(EXIT_FAILURE); } 88 89 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 /* Solicitud de inicio de captura */ if((msg_status = send_tcp_msg("CAPTURE", NULL, 0)) != 0) { fprintf(stderr, "Problemas solicitando el inicio de la captura\n"); exit(EXIT_FAILURE); } /* Petición de envío de las propiedades de video */ if((msg_status = send_tcp_msg("VIDEOPROP", (void *)&prop, sizeof(struct video_prop))) != 0) { fprintf(stderr, "Error obteniendo propiedades de video\n"); exit(EXIT_FAILURE); } sleep(5); /* Solicita el inicio de la detección de movimiento */ if((msg_status = send_tcp_msg("MOTION", NULL, 0)) != 0) { fprintf(stderr, "Error iniciando detección de movimiento\n"); exit(EXIT_FAILURE); } /* Solicita al servidor el envío de los cuadros */ if((msg_status = send_tcp_msg("STREAM", NULL, 0)) != 0) { fprintf(stderr, "Error obteniendo el frame\n"); exit(EXIT_FAILURE); } /* Datos de la conexión UDP */ strmdata.addr = "localhost"; strmdata.port = 24001; strmdata.width = prop.width; strmdata.height = prop.height; /* Crea el hilo de recepción de video */ pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE); pthread_create(&stream_thread, &attr, start_vid_stream, (void *)&strmdata); printf("Stream Iniciado\n"); /* Inicialización widgets GTK */ image = gtk_image_new(); gtk_container_add(GTK_CONTAINER(window), image); gtk_widget_show(window); gtk_widget_show(image); /* refresh se ejecuta cada 10 ms */ g_timeout_add(10, refresh, NULL); /* Ciclo principal GTK */ gtk_main(); /* Al finalizar el programa */ if((msg_status = send_tcp_msg("NOSTREAM", NULL, 0)) != 0) { fprintf(stderr, "Error iniciando detección de movimiento\n"); exit(EXIT_FAILURE); } if((msg_status = send_tcp_msg("NOMOTION", NULL, 0)) != 0) { fprintf(stderr, "Error iniciando detección de movimiento\n"); exit(EXIT_FAILURE); } if((msg_status = send_tcp_msg("NOCAPTURE", NULL, 0)) != 0) { fprintf(stderr, "Error iniciando detección de movimiento\n"); exit(EXIT_FAILURE); } if((msg_status = send_tcp_msg("CLOSE", NULL, 0)) != 0) { fprintf(stderr, "Error cerrando la conexión\n"); exit(EXIT_FAILURE); } close_conn(); return 0; } 90 net.h: Declaraciones y definiciones de las rutinas para la comunicación y la recepción del video en el cliente 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 /* * Telescreen v0.3 * Programa de captura de video y detección de movimiento utilizando V4L * net.h: Declaraciones y definiciones para la comunicación y la recepción * de video en el cliente * Copyright (C) 2005 Andrés Díaz Soto <adiaz@eie.ucr.ac.cr> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #include #include #include #include #include #include #include #include #include <stdio.h> <sys/types.h> <sys/socket.h> <netinet/in.h> <netdb.h> <fcntl.h> <unistd.h> <stdlib.h> <string.h> #ifndef NET_H #define NET_H /* Definiciones */ #define BUF_SIZE 256 // Tamaño del buffer para el envío de datos /* Propiedades del cuadro recibido */ struct video_prop { int width; // Ancho int height; // Altura }; /* Información de la conexión UDP */ struct stream_data { char *addr; // Dirección del servidor int port; // Puerto de conexión int width; // Ancho del cuadro int height; // Altura del cuadro }; /* Declaración de funciones */ /* open_conn: Inicia la conexión con el servidor */ int open_conn(char *addr, int port); /* close_conn: Finaliza la conexión con el servidor */ int close_conn(void); /* send_tcp_msg: Envía mensaje al servidor */ int send_tcp_msg(char *msg, void *retdata, int size); /* start_vid_stream: Inicia recepción de los cuadros de video */ void *start_vid_stream(void *strmdata); #endif /* NET_H */ 91 net.c: Implementación de las rutinas para la comunicación y la recepción del video en el cliente 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 /* * Telescreen v0.3 * Programa de captura de video y detección de movimiento utilizando V4L * net.c: Implementación de las rutinas para la comunicación y la recepción * de video en el cliente * Copyright (C) 2005 Andrés Díaz Soto <adiaz@eie.ucr.ac.cr> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. * */ #include "net.h" static int sd; unsigned char *frame; /* open_conn: Inicia la conexión con el servidor */ int open_conn(char *addr, int port) { struct hostent *hp; struct sockaddr_in server; char *buf_ptr, in_buf[BUF_SIZE]; int bytes_left; int n_read; /* Creación del socket */ if((sd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { fprintf(stderr, "No se puede abrir el socket\n"); return -1; } /* Información de la conexión */ memset((char *)&server, 0, sizeof(struct sockaddr_in)); server.sin_family = AF_INET; server.sin_port = htons(port); if((hp = gethostbyname(addr)) == NULL) { fprintf(stderr, "No se puede resolver el nombre del servidor\n"); return -1; } memcpy((char *)&server.sin_addr.s_addr, hp->h_addr, hp->h_length); /* Conexión con el servidor */ if(connect(sd, (struct sockaddr *)&server, sizeof(server)) == -1) { fprintf(stderr, "No se puede establecer la conexión con el servidor\n"); return -1; } printf("Conexión establecida con %s\n", hp->h_name); /* Recepción del mensaje de bienvenida */ bytes_left = BUF_SIZE; buf_ptr = in_buf; while((n_read = read(sd, buf_ptr, bytes_left)) > 0) { buf_ptr += n_read; bytes_left -= n_read; } return 0; } /* close_conn: Finaliza la conexión con el servidor */ int close_conn(void) { close(sd); printf("Conexión finalizada.\n"); 92 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 return 0; } /* send_tcp_msg: Envía mensaje al servidor */ int send_tcp_msg(char *msg, void *retdata, int size) { char *buf_ptr, in_buf[BUF_SIZE], out_buf[BUF_SIZE]; int bytes_left, n_read; /* Envía el mensaje */ strcpy(out_buf, msg); write(sd, out_buf, BUF_SIZE); /* Recepción de datos */ if(retdata != NULL) { bytes_left = size; buf_ptr = retdata; while((n_read = read(sd, buf_ptr, bytes_left)) > 0) { buf_ptr += n_read; bytes_left -= n_read; } } /* Recepción del mensaje de confirmación */ bytes_left = BUF_SIZE; buf_ptr = in_buf; while((n_read = read(sd, buf_ptr, bytes_left)) > 0) { buf_ptr += n_read; bytes_left -= n_read; } /* Verifica que el comando haya sido ejecutado satisfactoriamente */ if(strcmp(in_buf, "OK") == 0) return 0; else return -1; } /* start_vid_stream: Inicia recepción de los cuadros de video */ void *start_vid_stream(void *strmdata) { struct sockaddr_in server, client; struct hostent *hp; int sdu, server_len, n; char buf[BUF_SIZE]; unsigned char *temp_frame; struct stream_data *sdata = (struct stream_data *)strmdata; int framesize = sdata->width * sdata->height * 3; /* Creación del socket UDP */ if((sdu = socket(AF_INET, SOCK_DGRAM, 0)) == -1) { fprintf(stderr, "Error creando el socket UDP\n"); exit(-1); } /* Información del servidor */ memset((char *)&server, 0, sizeof(server)); server.sin_family = AF_INET; server.sin_port = htons(sdata->port); if((hp = gethostbyname(sdata->addr)) == NULL) { fprintf(stderr, "Error resolviendo la dirección del servidor\n"); exit(-1); } memcpy((char *)&server.sin_addr.s_addr, hp->h_addr, hp->h_length); /* Información del cliente */ memset((char *)&client, 0, sizeof(client)); client.sin_family = AF_INET; client.sin_port = htons(0); client.sin_addr.s_addr = htonl(INADDR_ANY); /* Enlace del socket */ if(bind(sdu, (struct sockaddr *)&client, sizeof(client)) == -1) { fprintf(stderr, "Error enlazando el socket\n"); exit(-1); } sleep(1); /* Espera a que el UDP en el servidor esté listo */ server_len = sizeof(server); strcpy(buf, "2+2=5"); if(sendto(sdu, buf, BUF_SIZE, 0, (struct sockaddr *)&server, server_len) == -1) { fprintf(stderr, "Problemas enviando datagrama al servidor\n"); 93 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 exit(-1); } /* Número de paquetes */ int n_packets = framesize / 4096; /* Cantidad de bytes sobrantes */ int leftover = framesize % 4096; int pc = 0; int p_size; char buf2[4096]; /* Reserva memoria para los cuadros */ temp_frame = malloc(framesize); frame = malloc(framesize); /* Recibe los paquetes UDP con el cuadro */ while(1) { p_size = recvfrom(sdu, buf2, 4096, 0, (struct sockaddr *)&server, &server_len); if(p_size < 0) { // Si hay error en la recepción fprintf(stderr, "Error recibiendo el paquete %d\n", pc); continue; } else if(p_size == sizeof(int)) { // Paquete de sincronización if(pc == n_packets + 1) { memcpy(frame, temp_frame, framesize); } else { fprintf(stderr, "Imagen con información incorrecta\n"); } pc = 0; } else if(p_size == 4096) { // Paquete con datos if(pc == n_packets) memcpy(temp_frame + pc*4096, buf2, leftover); else memcpy(temp_frame + pc*4096, buf2, 4096); pc++; } } /* Libera memoria */ free(temp_frame); free(frame); close(sdu); pthread_exit(NULL); }