Upload
others
View
1
Download
0
Embed Size (px)
Citation preview
PROYECTO FIN DE CARRERA PLAN 2000
ETSIS TELECOMUNICACIÓN
RESUMEN DEL PROYECTO:
TEMA:
TÍTULO:
AUTOR:
TUTOR: Vº Bº.
DEPARTAMENTO:
Miembros del Tribunal Calificador:
PRESIDENTE:
VOCAL:
VOCAL SECRETARIO:
DIRECTOR:
Fecha de lectura:
Calificación: El Secretario,
Formateo de imágenes para TV3D autoestereoscópica
Diseño y test VHDL de un cambiador de formato side by side HD a xyZ
David Cervantes Caballero
Matías Javier Garrido González
INGENIERÍA TELEMÁTICA Y ELECTRÓNICA
Francisco Javier Estaire Estaire
Matías Javier Garrido González
Fernando Pescador del Oso
Matías Javier Garrido González
19 de junio de 2017
La televisión 3D (TV3D) se ha introducido en los hogares gracias a los monitores estereoscópicos. Estostelevisores presentan las imágenes correspondientes a ambos ojos, mediante el control de unas gafas deobturación que permiten que cada imagen llegue solo al ojo que le corresponde, dando la sensación alusuario de que está observando una imagen tridimensional.El siguiente salto tecnológico viene dado por los monitores autoestereoscópicos, ya que estos monitorespermiten ver el efecto 3D mediante un sistema de lentes en el monitor, por lo que no existe la necesidadde utilizar gafas para conseguir el efecto tridimensional. Además, permiten la visualización de diferentesvistas en función del punto de observación. En el laboratorio del Grupo de Diseño Electrónico yMicroelectrónico (GDEM) se dispone de un monitor autoestereoscópico de la marca xyZ, usado en el PFC,Desarrollo de aplicaciones para la visualización de contenidos 3D en un monitor autoestereoscópico, queimplementó un algoritmo que genera el formato requerido por el monitor partiendo de cuatro pares devistas, tanto en lenguaje C para realizar la conversión en un PC, como posteriormente para poder sercargado en un DSP.Los sistemas de difusión de TV3D actual utilizan una sola vista (side by side) compuesta por dosimágenes, una para cada ojo. En este PFC se ha realizado un programa en C para ejecutar en un PC, eldiseño del sistema completo en VHDL sintetizable para el kit de desarrollo Cyclone III y suscorrespondientes tests en VHDL del circuito que convierte en tiempo real el formato side by side conresolución HD al formato requerido por el monitor de la marca xyZ. De esta forma se podrán ver lasemisiones 3D actuales en dicho monitor. La tecnología de referencia que se utilizará serán las FPGAs.
UNIVERSIDAD POLITECNICA DE MADRID
ESCUELA TECNICA SUPERIOR DE INGENIERIA
Y SISTEMAS DE TELECOMUNICACION
INGENIERIA TECNICA DE TELECOMUNICACION
ESPECIALIDAD SISTEMAS ELECTRONICOS
PROYECTO FIN DE CARRERA
Diseno y test VHDL de un cambiadorde formato side by side HD a xyZ
Autor: Tutor:
David Cervantes Caballero Matıas Javier Garrido Gonzalez
Junio 2017
Abstract
The 3D television (TV3D) has been introduced into homes thanks to stereoscopic mo-
nitors. These televisions present the images corresponding to both eyes and control a
shutter glasses that allow each image to reach only the eye that corresponds to it, giving
the sensation to the user that he is seeing a three-dimensional image.
The next technological leap is given by the autoestereoscopic displays, as these displays
allow to see the three-dimensional effect through a system of lenses in the display so
there is no need to use glasses to achieve the three-dimensional effect. In addition, they
allow the visualization of different views according to the point of observation. In the
laboratory of the Group of Electronic and Microelectronic Design (GDEM) has a self-
stereoscopic display of the brand xyZ, used in the PFC, Development of applications
for the visualization of 3D contents in a autoestereoscopic display, that implemented an
algorithm that generates the format required by the display from the four views, in C
language for PC and later for a DSP.
The current three-dimensional television broadcast systems use a single view (Side by
side) composed of two images, one for each eye. In this PFC has been developed a C
program to execute in a PC and a design of a complete system synthesizable for a Cyclone
III development board. Also its corresponding VHDL tests of the system that converts
the format Side by side with HD resolution to the format required by the display of the
brand xyZ in real time. So the the current 3D emissions can be seen in this display. The
reference technology used are FPGAs.
iii
Indice general
Abstract III
Indice de figuras IX
Indice de cuadros XI
Acronimos XIII
1. Introduccion 1
1.1. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2. Objetivos del PFC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3. Metodologıa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.4. Flujo de diseno . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.5. Herramientas utilizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.6. Contenido . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2. TV3D 7
2.1. Principios de TV3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2. Formatos utilizados en broadcasting . . . . . . . . . . . . . . . . . . . . . . 8
2.2.1. Frame packing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.2.2. Frame secuencial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.3. Top and bottom . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.4. Side by side . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
v
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
2.2.5. Line by line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.6. Simultaneo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.3. Monitores estereoscopicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4. Monitores autoestereoscopicos . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.4.1. Parallax Barrier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.4.2. Lenticular Lens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.4.3. Clasificacion de monitores autoestereoscopicos por numero de vistas 13
2.5. Monitor autoestereoscopico xyZ . . . . . . . . . . . . . . . . . . . . . . . . . 14
3. Planteamiento del problema 17
3.1. Descripcion del algoritmo original . . . . . . . . . . . . . . . . . . . . . . . . 18
3.2. Descripcion del algoritmo implementado . . . . . . . . . . . . . . . . . . . . 19
4. Implementacion VHDL 23
4.1. Arquitectura . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.1.1. CVI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4.1.2. CVO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
4.1.3. Scaler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
4.1.4. PLL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.1.5. Sbs2xyz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.1.6. Nios II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.1.7. Onchip Memory . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.2. Conversion en periferico NIOS II . . . . . . . . . . . . . . . . . . . . . . . . 31
4.2.1. CVI + CVO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.2.2. CVI + Scaler + CVO . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4.2.3. CVI + Scaler + Sbs2xyz + CVO . . . . . . . . . . . . . . . . . . . . 34
4.2.4. Integracion de Nios II . . . . . . . . . . . . . . . . . . . . . . . . . . 34
4.3. Sistema completo basado en NIOS II . . . . . . . . . . . . . . . . . . . . . . 35
4.4. Pruebas realizadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
vi
Universidad Politecnica de Madrid
4.4.1. Bancos de test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.4.2. Comparacion de imagenes en Linux . . . . . . . . . . . . . . . . . . 37
4.4.3. Recursos utilizados en kit Altera Cyclone III EP3C25 . . . . . . . . 39
5. Conclusiones y lıneas futuras de trabajo 41
5.1. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
5.2. Lıneas futuras de trabajo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Bibliografıa 43
A. Algoritmo de entrelazado original 45
A.1. Explicacion del algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
A.2. Codigo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
B. Algoritmo de entrelazado implementado 67
B.1. Explicacion del algoritmo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
B.2. Codigo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
C. Como implementar un periferico para el bus Avalon-ST 81
C.1. Avalon-ST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
C.2. Plantilla VHDL de periferico Avalon-ST . . . . . . . . . . . . . . . . . . . . 83
D. Codigo VHDL 89
D.1. Implementacion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
D.2. Uso del testbech . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
D.3. Testbench con un solo BMP . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
D.4. Testbench con multiples BMP . . . . . . . . . . . . . . . . . . . . . . . . . . 100
vii
Indice de figuras
2.1. Formato de transmision Frame packing. . . . . . . . . . . . . . . . . . . . . 8
2.2. Formato de transmision Frame secuencial. . . . . . . . . . . . . . . . . . . . 9
2.3. Formato de transmision Top and bottom. . . . . . . . . . . . . . . . . . . . 9
2.4. Formato de transmision Side by side. . . . . . . . . . . . . . . . . . . . . . . 10
2.5. Formato de transmision Line by line. . . . . . . . . . . . . . . . . . . . . . . 10
2.6. Formato de transmision Simultaneo. . . . . . . . . . . . . . . . . . . . . . . 10
2.7. Modos de implementar las pantallas autoestereoscopicas. (a) Parallax Ba-
rrier y (b) Lenticular Lens. . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.8. Efecto autoesteroscopico del monitor xyZ. . . . . . . . . . . . . . . . . . . . 14
3.1. Entrelazado de imagen en formato 9x9 a xyZ. . . . . . . . . . . . . . . . . . 18
3.2. Entrelazado de imagen en formato Side by side a xyZ. . . . . . . . . . . . . 19
3.3. Correspondencia del primer pıxel (0,0) del formato Side by side al formato
xyZ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
3.4. Correspondencia del pıxel (640,0) del formato Side by side al formato xyZ. . 20
3.5. Repeticion de patron en el formato xyZ en el bloque de las tres lıneas
siguientes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.1. Vista diagonal de kit de desarrollo Altera Cyclone III EP3C25. . . . . . . . 24
4.2. Parametro temporales del formato 31 (1920x1080 50Hz). . . . . . . . . . . . 25
4.3. Configuracion del componente CVI. . . . . . . . . . . . . . . . . . . . . . . 26
4.4. Configuracion del componente CVO. . . . . . . . . . . . . . . . . . . . . . . 27
ix
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
4.5. Configuracion del componente Scaler. . . . . . . . . . . . . . . . . . . . . . 28
4.6. Configuracion del componente Sbs2xyz. . . . . . . . . . . . . . . . . . . . . 29
4.7. Configuracion del componente Nios II. . . . . . . . . . . . . . . . . . . . . . 30
4.8. Configuracion del componente Onchip memory. . . . . . . . . . . . . . . . . 31
4.9. Sistema formado por CVI y CVO. . . . . . . . . . . . . . . . . . . . . . . . 32
4.10. Sistema formado por CVI, Scaler y CVO. . . . . . . . . . . . . . . . . . . . 33
4.11. Sistema formado por CVI, Scaler, Sbs2xyz y CVO. . . . . . . . . . . . . . . 34
4.12. Sistema completo formado por CVI, Scaler, Sbs2xyz, CVO, PLL, Onchip
Memory y Nios II. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.13. Imagen de test en formato Side by side. . . . . . . . . . . . . . . . . . . . . 36
4.14. Imagen de test en formato xyZ. . . . . . . . . . . . . . . . . . . . . . . . . . 37
A.1. Secuencia de procesos que sigue en el algoritmo original. . . . . . . . . . . . 45
B.1. Secuencia de procesos que sigue en el algoritmo implementado. . . . . . . . 67
x
Indice de cuadros
2.1. Especificaciones de monitor xyZ de 24” . . . . . . . . . . . . . . . . . . . . 15
4.1. Especificaciones de Cyclone III FPGA Starter Kit (EP3C25 FPGA) . . . . 24
4.2. Formatos del estandar de la EIA para una frecuencia de refresco de 50Hz . 25
4.3. Numero de bytes y su desviacion comparando dos imagenes entrelazadas de
maneras diferentes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.4. Especificaciones de Cyclone III FPGA Starter Kit (EP3C25 FPGA) . . . . 40
C.1. Paquete de control del bus Avalon-ST . . . . . . . . . . . . . . . . . . . . . 81
C.2. Paquete de control del bus Avalon-ST para un frame de 1920x1200 . . . . . 82
xi
Acronimos
3D: 3 Dimensions, tres dimensiones.
3DTV: 3D Television, Television 3D.
BMP: Bitmap, Mapa de bits.
Avalon-ST: Avalon Streaming, Transmision Avalon.
CAD: Computer Aided Design, Diseno asistido por Ordenador.
CPU: Central Processing Unit, Unidad central de proceso.
CVI: Clocked Video Input, Entrada de video sıncrona.
CVO: Clocked Video Output, Salida de video sıncrona.
DTV: Digital Television, Television digital.
DSP: Digital Signal Processor, Procesador de senal digital.
EDS: Embedded Design Suite, Suite de diseno empotrado.
EIA: Electronic Industries Alliance, Alianza de industrias electronicas.
EOP: End Of Packet, Fin del paquete.
FPGA: Field Programmable Gate Array.
GDEM: Grupo de Diseno Electronico y Microelectronico.
HD: High Definition, Alta definicion.
HEX: Hexadecimal.
HSMC: High Speed Mezzanine Card, Tarjeta de alta velocidad Mezzanine.
ID: Identifier, Identificador.
xiii
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
IO: Input Output, Entrada salida.
LCD: Liquid Crystal Display, Pantalla de cristal lıquido.
LCS: Liquid Crystal Shutter, Obturador de cristal lıquido.
PC: Personal Computer, Ordenador personal.
PFC: Proyecto Fin de Carrera.
PLL: Phase Locked Loop, Bucle de enganche de fase.
TCL: Tool Command Language.
TFT: Thin Film Transistor, Transistor de pelıcula fina.
RAM: Random Access Memory, Memoria de acceso aleatorio.
RGB: Red Green Blue, Rojo verde azul.
RTL: Register Transfer Level, Nivel de transferencia de registro.
VHDL: VHSIC Hardware Description Language, Lenguaje de descripcion Hardware
de VHSIC.
VHSIC: Very High Speed Integrated Circuit, Circuitos integrados de muy alta velo-
cidad.
SbS: Side By Side.
SDK: Software Development Kit, Kit de desarrollo software.
SOP: Start Of Packet, Comienzo del paquete.
YUV: Y: Luminancia, U: Crominancia Azul, V: Crominancia Roja.
xiv
Capıtulo 1
Introduccion
En este capıtulo se hara un resumen del Proyecto Fin de Carrera, los objetivos que se
han propuesto para el mismo. Ademas se explicara la metodologıa y el flujo de diseno que
se ha utilizado en el desarrollo.
Tambien se listaran las diferentes herramientas utilizadas para la realizacion del PFC y
el contenido del que versara el mismo.
1
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
1.1. Resumen
La television 3D (TV3D) se ha introducido en los hogares gracias a los monitores es-
tereoscopicos. Estos televisores presentan las imagenes correspondientes a ambos ojos,
mediante el control de unas gafas de obturacion que permiten que cada imagen llegue
solo al ojo que le corresponde, dando la sensacion al usuario de que esta observando una
imagen tridimensional.
El siguiente salto tecnologico viene dado por los monitores autoestereoscopicos, ya que
estos monitores permiten ver el efecto 3D mediante un sistema de lentes en el monitor,
por lo que no existe la necesidad de utilizar gafas para conseguir el efecto tridimensional.
Ademas, permiten la visualizacion de diferentes vistas en funcion del punto de observa-
cion. En el laboratorio del Grupo de Diseno Electronico y Microelectronico (GDEM ) se
dispone de un monitor autoestereoscopico de la marca xyZ, usado en el PFC, Desarrollo de
aplicaciones para la visualizacion de contenidos 3D en un monitor autoestereoscopico[1],
que implemento un algoritmo que genera el formato requerido por el monitor partiendo
de cuatro pares de vistas, tanto en lenguaje C para realizar la conversion en un PC, como
posteriormente para poder ser cargado en un DSP.
Los sistemas de difusion de TV3D actual utilizan una sola vista (side by side) compuesta
por dos imagenes, una para cada ojo. En este PFC se ha realizado un programa en C para
ejecutar en un PC, el diseno del sistema completo en VHDL sintetizable para el kit de
desarrollo Cyclone III y sus correspondientes tests en VHDL del circuito que convierte en
tiempo real el formato side by side con resolucion HD al formato requerido por el monitor
de la marca xyZ. De esta forma se podran ver las emisiones 3D actuales en dicho monitor.
La tecnologıa de referencia que se utilizara seran las FPGAs.
1.2. Objetivos del PFC
Comprender el algoritmo de entrelazado de imagenes para el monitor xyZ.
Desarrollar en lenguaje C un conversor de Side by side a xyZ.
Realizar el diseno VHDL sintetizable y testbech del cambiador de formato para que
pueda ser utilizado como periferico de un sistema basado en el procesador NIOS II
(Altera).
Disenar un banco de test que incluya: el conversor, un procesador NIOS II y los
circuitos de adaptacion de entrada y salida de vıdeo.
2
Universidad Politecnica de Madrid
Ademas se ha creado la documentacion necesaria para poder realizar el desarrollo de
futuros trabajos relacionados con la television en 3D y el tratamiento de imagenes
a tiempo real con FPGAs.
1.3. Metodologıa
El proyecto se planifico en tres fases. Las dos primeras discurrieron en paralelo, aunque
tambien podrıan haberse realizado de manera secuencial, ya que no se solapan hasta la
realizacion de la fase 3.
Fase 1: Diseno de un sistema basico basado en NIOS II.
• Fase 1.A: Aprendizaje del entorno de desarrollo para NIOS II. Realizacion de
tutoriales.
• Fase 1.B: Desarrollo de un sistema que incluya: el NIOS II, las interfaces de
entrada y salida del vıdeo, un escalador y un conversor de formato que no realice
la algoritmia de conversion.
• Fase 1.C: Creacion de un banco de test VHDL para el sistema.
Fase 2: Estudio y comprension del algoritmo de formateo de imagenes utilizado
en Desarrollo de aplicaciones para la visualizacion de contenidos 3D en un monitor
autoestereoscopico [1].
• Fase 2.A: Estudio del algoritmo en C del formateo utilizado en Desarrollo de
aplicaciones para la visualizacion de contenidos 3D en un monitor autoeste-
reoscopico[1].
• Fase 2.B: Adaptacion del algoritmo para formatos de entrada side by side,
implementacion en lenguaje C y pruebas funcionales.
• Fase 2.C: Diseno de la arquitectura del conversor e implementacion en VHDL
sintetizable.
• Fase 2.D: Banco de test VHDL del conversor aislado.
Fase 3: Integracion de los resultados de las fases 1 y 2.
• Fase 3.A: Incorporacion de la algoritmia al conversor disenado en la fase 1.
• Fase 3.B: Pruebas funcionales en el banco de test disenado en la fase 1.
• Fase 3.C: Resolucion de problemas, diseno final VHDL del conversor sinteti-
zable y el banco de test.
3
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
1.4. Flujo de diseno
El flujo de diseno del PFC siguio la siguiente estructura, en primer lugar se realizo un
estudio detallado del algoritmo de entrelazado en C desarrollado en el proyecto anterior[1],
que consistıa en entrelazar un vıdeo 9x9 al formato requerido por el monitor xyZ. Una
vez comprendido dicho algoritmo se realizo un programa en C que entrelazaba un vıdeo
side by side, generado desde el propio vıdeo 9x9 usando tan solo la primera vista que esta
conformada por dos imagenes, a formato xyZ.
Para comprobar que el programa en C era correcto se genero un vıdeo 9x9 basado solo
en dos vistas y se entrelazo el vıdeo en formato xyZ. Ambos vıdeos resultantes debıan
ser exactamente iguales por lo que se ejecuto una comparativa para demostrar que eran
identicos. Tras esta comprobacion se confirmo que el programa realizado era correcto y
que el estudio del algoritmo era exitoso.
En paralelo a este desarrollo se creo un sistema basico en Quartus II con Qsys que
contenıa los siguientes componentes: PLL, NIOS II, CVI y CVO, estos ultimos conectados
mediante un interfaz Avalon-ST. Para confirmar que su funcionamiento era correcto se creo
un banco de test que cogiendo un imagen BMP como entrada generaba una simulacion
del formato DTV de broadcasting como entrada al sistema y de la salida del sistema,
que tambien es en formato DTV, se generaba un BMP de salida, ambos BMP debıan ser
exactamente iguales ya que no se hacıa ningun cambio en la imagen.
Una vez realizada con exito esta prueba se amplio gradualmente los componentes del
sistema hasta llegar al sistema completo formado por: PLL, NIOS II, CVI, Scaler, Memo-
ria, Entrelazador y CVO todos ellos conectados mediante el interfaz Avalon-ST. En todo
momento el sistema se desarrollo para una tarjeta Cyclone III FPGA Starter Kit (EP3C25
FPGA).
Los BMPs resultantes del sistema completo se compararon con imagenes entrelazadas en
el programa del proyecto anterior para confirmar el correcto funcionamiento del sistema.
1.5. Herramientas utilizadas
Para la realizacion del proyecto se utilizaron las siguientes herramientas:
Software:
• CAD ModelSim (Mentor Graphics): Desarrollo y simulacion del componente
VHDL entrelazador y bancos de test.
4
Universidad Politecnica de Madrid
• Quartus II y NIOS II EDS (Altera): Desarrollo del sistema completo para
la tarjeta Cyclone III FPGA Starter Kit (EP3C25 FPGA)
• Dev-C++: Desarrollo de los programas en C para el estudio del algoritmo de
entrelazado.
• Virtualbox: Para crear una maquina virtual en la que tener instaladas todas
las herramientas necesarias para realizar el PFC.
• Precision RTL Synthesis: Para confirmar que el entrelazador realizado es
sintetizable.
• FFmpeg: Para extraccion de frames de vıdeo para su posterior comparativa.
• Distintos comandos de Linux para realizar las comparativas finales: cmp, cat y
awk.
Hardware:
• Tarjeta Cyclone III FPGA Starter Kit (EP3C25 FPGA). Esta tarjeta
y la FPGA que contiene se utilizo como referencia para el diseno del sistema
completo.
1.6. Contenido
Este proyecto versara sobre los fundamentos de 3DTV, los tipos de broadcasting uti-
lizados ademas de los monitores estereoscopicos y autoestereoscopicos y en concreto del
monitor autoestereoscopico xyZ para el que se ha desarrollado el sistema de entrelazado de
formato side by side. Tambien se explicara el sistema completo de entrelazado en VHDL el
cual integra un NIOS II y las pruebas realizadas para confirmar su correcto funcionamien-
to. Como informacion adicional se incluiran la explicacion del codigo en C del proyecto
anterior y del codigo en C desarrollado para un formato side by side. Tambien se explicara
como se implementa un sistema basado en el bus Avalon-ST y el codigo de entrelazado
VHDL del entrelazador y sus correspondientes bancos de test para simular el formato de
broadcasting DTV partiendo de una imagen BMP.
5
Capıtulo 2
TV3D
En este capıtulo se definiran los principios de la TV3D. Ademas se explicaran los for-
matos utilizados en broadcasting, las tecnologıas de television en 3D, tanto estereoscopicas
como autoesteroscopicas.
Tambien se expondra el funcionamiento del monitor autoestereoscopico xyZ para el que
se ha desarrollado el proyecto.
7
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
2.1. Principios de TV3D
La Television 3D o TV3D hace referencia a un televisor que permite visualizar imagenes
en 3 dimensiones, utilizando diversas tecnicas para lograr la ilusion de profundidad.
Todo proceso que permite crear imagenes en 3D a partir de un par estereo se conoce
con el nombre de estereoscopıa, y principalmente se basa en el principio natural de la
vision humana, en donde cada ojo capta en un mismo instante una imagen ligeramente
diferente a la del otro ojo, debido a la distancia que los separa. Ambas imagenes son
procesadas por nuestro cerebro, permitiendonos ver en 3D, tal como lo conocemos. Si
bien la television comercial en 3D es relativamente nueva, las tecnicas de visualizacion
estereoscopicas son tan antiguas como los orıgenes de la fotografıa. Las imagenes de vıdeo
proyectadas por un televisor en 3D (ası como otros sistemas estereoscopicos como el Cine
3D), son creadas con el mismo principio: una escena es capturada a traves de 2 camaras
separadas, posteriormente es proyectada, utilizando lentes especiales de manera que cada
imagen solo sea vista por uno de nuestros ojos.
2.2. Formatos utilizados en broadcasting
Existen diferentes formatos para las transmision de imagenes 3D, a continuacion expli-
caremos cada uno de ellos y sus caracterısticas.
2.2.1. Frame packing
Figura 2.1: Formato de transmision Frame packing.
En el formato Frame packing las imagenes del ojo izquierdo y derecho se transmiten en
el mismo frame manteniendo la resolucion de cada una tal y como es.
8
Universidad Politecnica de Madrid
2.2.2. Frame secuencial
Figura 2.2: Formato de transmision Frame secuencial.
En el formato Frame secuencial las imagenes son transmitidas de manera alterna, de
esta manera la resolucion por imagen es igual pero la frecuencia de refresco se ve reducida
a la mitad.
2.2.3. Top and bottom
Figura 2.3: Formato de transmision Top and bottom.
En el formato Top and bottom las imagenes del ojo izquierdo y derecho se transmiten
en el mismo frame, de esta manera la resolucion vertical se ve reducida a la mitad.
9
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
2.2.4. Side by side
Figura 2.4: Formato de transmision Side by side.
En el formato Side by side las imagenes del ojo izquierdo y derecho se transmiten en el
mismo frame, de esta manera la resolucion horizontal se ve reducida a la mitad.
2.2.5. Line by line
Figura 2.5: Formato de transmision Line by line.
En el formato Line by line las imagenes del ojo izquierdo y derecho se transmiten en
el mismo frame de manera entrelazada en lıneas pares en impares, de esta manera la
resolucion vertical se ve reducida a la mitad.
2.2.6. Simultaneo
Figura 2.6: Formato de transmision Simultaneo.
10
Universidad Politecnica de Madrid
En el formato Simultaneo las imagenes del ojo izquierdo y derecho se transmiten por
diferentes canales, de esta forma ni la resolucion ni la frecuencia de refresco se ve afectada.
2.3. Monitores estereoscopicos
Son los mas extendidos hasta el momento y requieren el uso de gafas especiales por
parte del observador. Las dos imagenes necesarias para crear el efecto 3D se representan
en el mismo plano de la pantalla, siendo las gafas las encargadas de filtrar las imagenes de
forma que cada ojo perciba una de ellas, proporcionando de esta manera la vision estereo.
Existen diversas tecnologıas para su implementacion:
El metodo anaglifo: En este metodo la componente derecha de la imagen, que nor-
malmente es de color rojo, se superpone a la componente izquierda que posee un
color distinto al rojo, como verde o azul. El efecto 3D se consigue cuando el espec-
tador mira la pantalla a traves de filtros de color que se encuentran en la gafas. La
calidad es mala y no se usa habitualmente.
Proyectando las dos imagenes con polarizaciones distintas: La pantalla proyecta dos
imagenes con polarizaciones ortogonales. Cada lente de las gafas polarizadas tiene
un filtro que bloquea una de las imagenes y deja pasar la otra.
Mediante dos pantallas tradicionales: Esta tecnologıa radica en hacer coplanares las
dos pantallas con un espejo semiplateado, cuya mision es dividir el haz de luz en dos
haces de forma que uno se refleja y otro se transmite.
Mediante dos proyectores: Cada uno de ellos proyecta la luz con distinta polaridad
a una pantalla. Las gafas necesarias usan lentes con diferentes polarizaciones.
Con pantalla al doble de frecuencia de refresco: Este tipo de pantalla va mostrando
alternativamente las imagenes, la imagen izquierda al ojo izquierdo y la imagen
derecha al derecho. Es necesario el uso de gafas LCS (Liquid Crystal Shutter), que
bloquean la luz recibida por cada ojo de forma sincronizada con la pantalla.
2.4. Monitores autoestereoscopicos
Los monitores autoestereoscopicas no necesitan el uso de gafas especiales para pro-
porcionar la vision estereo. La autoesteresocopıa es el metodo para reproducir imagenes
tridimensionales que puedan ser visualizadas sin la necesidad de utilizar ningun dispositi-
vo especial (como gafas o cascos especiales) y sin necesitar condiciones especiales de luz.
11
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
Gracias a este metodo, el observador puede apreciar profundidad, aunque la imagen este
producida por un dispositivo plano.
En la implementacion de las pantallas autoestereoscopicas se usan los metodos: parallax
barriers (barreras de paralaje) y lenticular lens (pelıcula de lentes).
Figura 2.7: Modos de implementar las pantallas autoestereoscopicas. (a) Parallax Barriery (b) Lenticular Lens.
En la figura 2.7 muestra estas dos tecnologıas que se caracterizan por presentar las vistas
multiplexadas en el espacio. Si por ejemplo se emiten dos vistas, la resolucion horizontal
se divide en dos, de modo que un ojo capta las columnas pares y el otro las impares.
2.4.1. Parallax Barrier
El estereograma de paralaje consiste en colocar una rejilla vertical fina delante de la
imagen especialmente disenada. La rejilla se hace normalmente con material opaco con
fracturas verticales transparentes y finas, separadas de manera regular. Cada ranura trans-
parente actua como ventana a un trozo vertical de la imagen puesta detras de ella. El trozo
que se ve depende de la posicion del ojo del observador.
La imagen del estereograma de paralaje esta hecha interpolando las columnas a partir
de dos imagenes. Esta imagen y la rejilla vertical estan alineadas de modo que el ojo
izquierdo solo puede ver las columnas de la imagen para el ojo izquierdo, y el ojo derecho
solo las columnas de la imagen del ojo derecho.
12
Universidad Politecnica de Madrid
2.4.2. Lenticular Lens
En el metodo lenticular lens se coloca una pelıcula de lentes cilındricas moldeadas en un
sustrato plastico delante de la pantalla. Esto permite redirigir la luz emitida por los pıxeles
a diferentes ranuras de vision a una distancia tal que, al situarse en ella el espectador,
observarıa en cada ojo los pıxeles correspondientes de cada columna. La clave para la
creacion de las imagenes basadas en este metodo es la calidad y la uniformidad de las
lentes. A diferencia del metodo anterior, la superficie entera de la lente irradia luz, por lo
que no hay zonas opacas.
2.4.3. Clasificacion de monitores autoestereoscopicos por numero de vis-
tas
Las pantallas autoestereoscopicas se pueden clasificar segun el numero de vistas y la
posicion de estas, en tres tipos: Two-view displays, Head-tracked displays y Multiview
displays.
2.4.3.1. Two-view displays
Las dos imagenes que emite la pantalla pueden ser observadas en multiples zonas del
espacio. Cuando el observador se situa a la distancia y en la posicion correcta, percibe la
imagen estereoscopica. Sin embargo, existe una probabilidad alta de que el espectador se
situe incorrectamente.
2.4.3.2. Head-tracked displays
La pantalla es capaz de detectar y seguir la posicion de la cabeza del espectador, y
ası, puede emitir las imagenes izquierda y derecha en la zona apropiada. En una de sus
implementaciones, la pantalla lleva asociada unas camaras que detectan donde esta el
espectador.
2.4.3.3. Multiview displays
El espectador percibe la imagen estereoscopica cuando se situa en alguno de los puntos
de vision. Al tener varios puntos de vision, puede tener varios espectadores. La pantalla
produce un numero de vistas, en posiciones fijas, y las vistas adyacentes forman pares
estereo, de modo que si el observador se mueve, le resulta facil posicionarse de nuevo para
captar otro par estereo.
13
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
2.5. Monitor autoestereoscopico xyZ
Figura 2.8: Efecto autoesteroscopico del monitor xyZ.
El monitor 3D xyZ hace posible distinguir una cierta profundidad sobre la pantalla gra-
cias a la tecnologıa lenticular lens (pelıcula de lentes). Estas lentes manejan la asignacion
de la imagen sobre el nivel de subpıxel. El monitor utiliza un sistema de 8 vistas (8 cama-
ras). Los ojos solo podran visualizar 2 vistas al mismo tiempo, haciendo posible mirar los
objetos que son proyectados en el monitor.
La pantalla que se ha empleado es un monitor TFT de 24”, que utiliza la tecnologıa
Lenticular Lens para crear el efecto 3D. Segun las especificaciones, el rango de distancias
para visualizar el efecto 3D, oscila entre los 0,3 y los 5 metros. La resolucion del monitor
es 1920x1200 Full HD.
14
Universidad Politecnica de Madrid
Tecnologıa TFT / Lenticular Lens
Rango de efecto 3D apprx. 0,3 a 5 metros
Ratio de contraste 70.000:1
Colores 16,7 Millones
Tiempo de respuesta 8 ms
Resolucion 1920x1200 Full HD
Cuadro 2.1: Especificaciones de monitor xyZ de 24”
Como comentamos anteriormente este monitor tiene un sistema de 8 vistas, aunque la
resolucion total es de 1920x1200 pıxels cada vista tiene una resolucion de 640x400 pıxels.
15
Capıtulo 3
Planteamiento del problema
En este proyecto se realizara el entrelazamiento a tiempo real del formato Side by side
para que pueda ser reproducido en el monitor xyZ.
Para poder desarrollar este algoritmo primero tendremos que comprender el funciona-
miento del algoritmo desarrollado en el PFC anterior [1], que realizaba el entrelazamiento
de un vıdeo en formato 9x9 a xyZ.
A continuacion se explicara como funcionan ambos entrelazamientos, esto sentara las
bases para el desarrollo del componente VHDL que realizara el entrelazado del formato
Side by side a xyZ.
17
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
3.1. Descripcion del algoritmo original
El entrelazamiento de un vıdeo en formato 9x9 a xyZ se realiza a nivel de subpıxel. En
primer lugar tenemos que tener en cuenta que el monitor xyZ utiliza 8 vistas, por lo tanto
del formato 9x9 se descarta la novena vista para realizar el entrelazado.
Cada vista tiene una resolucion de 640x400 y la salida del entrelazado que va al monitor
xyZ tiene una resolucion de 1920x1200.
Figura 3.1: Entrelazado de imagen en formato 9x9 a xyZ.
Como podemos ver en la figura 3.1 la imagen entrelazada esta intercalada a nivel de
subpıxel de manera secuencial, empezando por la vista 1. Ademas las tres primeras lıneas
del entrelazado estan compuestas por la primera lınea de cada una de las vistas.
El primer pıxel (0,0) de la imagen entrelazada esta compuesto por el subpıxel R de
la vista 1, el subpıxel G de la vista 2 y el subpıxel B de la vista 3. Cada uno de estos
subpıxeles se extraen del pıxel (0,0) de cada una de las vistas. Este intercalado continua
de manera secuencial hasta el pıxel (1919,0). Que esta compuesto por el subpıxel R de la
vista 6 , el subpıxel G de la vista 7 y el subpıxel B de la 8. Todos ellos corresponden a
pıxel (639,0) de cada una de las vistas.
La segunda lınea de la imagen entrelazada empezara por el mismo subpıxel de la vista
en la que acabo la lınea anterior. En este caso la vista 8, y continua de nuevo de manera
secuencial hasta el ultimo subpıxel que se extrae de la vista 7.
18
Universidad Politecnica de Madrid
La tercera lınea de la imagen entrelazada empezara por el mismo subpıxel de la vista
en la que acabo la lınea anterior. En este caso la vista 7, y continua de nuevo de manera
secuencial hasta el ultimo subpıxel que se extrae de la vista 6.
Una vez entrelazadas estas tres primeras lıneas el patron de entrelazado cambia, la cuarta
lınea comienza por el subpıxel de la siguiente vista en el que acabo la lınea anterior. En
este caso es la vista 6. La quinta lınea y la sexta siguen el mismo patron que las lıneas 2
y 3 ambas empezando por el subpıxel de la vista en la que acabo la lınea anterior.
Este patron en bloque de tres lıneas continua de manera cıclica. Por lo tanto cada tres
lıneas hay una correccion en la secuencia de subpıxels.
De esta manera se genera el vıdeo entrelazado partiendo de un formato 9x9 a xyZ.
3.2. Descripcion del algoritmo implementado
El algoritmo realizado para este proyecto convertira imagenes en formato Side by side
a xyZ. A diferencia del algoritmo original, este parte de dos vistas que seran replicadas
para las 8 que forman la imagen del formato xyZ. Por lo tanto, las vistas 1-2, 3-4, 5-6 y
7-8 seran iguales.
Como vimos en el algoritmo original, el entrelazado se produce de manera secuencial
durante la primera lınea, empezando por la vista 1. En la segunda lınea empieza por el
subpıxel de la misma vista con la que acabo la primera lınea. La tercera lınea vuelve a
empezar por el subpıxel de la misma vista por el que acabo la segunda lınea. En la cuarta
lınea se vuelve a reproducir el mismo patron de la primera lınea. En la quinta la de la
segunda y en la sexta en el de la tercera. Este patron es igual a lo largo de toda la imagen.
Las tres primeras lıneas de la imagen entrelazada estan compuestas por la primera lınea
de cada vista de la imagen original. A continuacion explicaremos como se realiza este
entrelazado paso a paso.
Figura 3.2: Entrelazado de imagen en formato Side by side a xyZ.
19
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
En este caso como partimos de una imagen Side by side por lo tanto la primera lınea
contiene la primera lınea de la vista izquierda y la vista derecha.
Figura 3.3: Correspondencia del primer pıxel (0,0) del formato Side by side al formatoxyZ.
Como vemos en la figura 3.3 el primer pıxel (0,0), primer pıxel de la vista 1, del formato
Side by side contiene parte de los subpıxels necesarios para formar los tres primeros pıxels
de las tres primeras lıneas del formato xyZ. El resto de los subpıxels necesarios estan en
el primer pıxel de la vista 2 como podemos ver en la figura 3.4.
Una vez entrelazadas las tres primeras lıneas el patron de entrelazado se repite para las
tres siguientes lıneas tal y como vemos en la figura 3.5.
Figura 3.4: Correspondencia del pıxel (640,0) del formato Side by side al formato xyZ.
20
Universidad Politecnica de Madrid
Figura 3.5: Repeticion de patron en el formato xyZ en el bloque de las tres lıneas siguientes.
En el tercer bloque de tres lıneas, que corresponden a la septima, octava y novena lınea,
se vuelve a repite el patron, ası sucesivamente. Por lo que para formatear la imagen existen
dos tipos de patrones intercalados a lo largo de toda la imagen para generar el formato
necesario para el monitor xyZ.
21
Capıtulo 4
Implementacion VHDL
En este capıtulo se describira el proceso de creacion del sistema en VHDL desarrollado
en Quartus II, sus requisitos definidos tanto por el hardware para el que se ha disenado
como por el formato de transmision DTV.
Ademas se explicara de la descripcion y configuracion de cada unos de los componentes
utilizados, la integracion del procesador NIOS II en el sistema y las pruebas realizadas
para confirmar su correcto funcionamiento.
23
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
4.1. Arquitectura
Figura 4.1: Vista diagonal de kit de desarrollo Altera Cyclone III EP3C25.
El sistema desarrollado en este proyecto esta disenado para funcionar en la tarjeta
Cyclone III FPGA Starter Kit (EP3C25 FPGA). La tarjeta Cyclone III proporciona una
plataforma hardware que permite crear un desarrollo personalizado ampliable mediante
puertos de expansion y tarjetas HSMC. En el cuadro 4.1 podemos ver sus especificaciones.
Elementos logicos (LEs) 24,624
Numero de bloques M9K 66
Bits de RAM total 608,256
Multiplicadores 18x18 16
PLLs 4
Red de relojes globales 20
Reloj interno 50MHz
Maximas I/Os de usuario 214
Cuadro 4.1: Especificaciones de Cyclone III FPGA Starter Kit (EP3C25 FPGA)
En cuanto al formato de transmision en el que nos basaremos para definir parametros
de vıdeo, utilizaremos el estandar de la EIA. En concreto utilizaremos el formato 31 del
cuadro 4.2 que muestra los diferentes formatos para una frecuencia de refresco de 50Hz.
24
Universidad Politecnica de Madrid
Formato V active Lın.Totales V blanking V Freq(Hz) H Freq(KHz) Pıxel Freq(MHz) H total H active H blanking Aspecto
17,18 576 625 49.0 50.000 31.250 27.000 864 720 144 4x3,16x9
19 712 750 30.0 50.000 37.500 74.250 1980 1280 700 16x9
20 1080 1125 22.5 50.000 28.125 74.250 2640 1920 720 16x9
21,22 576 625 24.5 50.000 15.625 27.000 1728 1440 276 4x3,16x9
23,24 288 312 24.0 50.080 15.625 27.000 1728 1440 276 4x3,16x9
23,24 288 313 25.0 49.920 15.625 27.000 1728 1440 276 4x3,16x9
23,24 288 314 26.0 49.761 15.625 27.000 1728 1440 276 4x3,16x9
25,26 576 625 24.5 50.000 15.625 54.000 3456 2880 556 4x3,16x9
27,28 288 312 24.0 50.080 15.625 54.000 3456 2880 556 4x3,16x9
27,28 288 313 25.0 49.920 15.625 54.000 3456 2880 556 4x3,16x9
27,28 288 314 26.0 49.761 15.625 54.000 3456 2880 556 4x3,16x9
29,30 576 625 49.0 50.000 31.250 54.000 1728 1440 288 4x3,16x9
31 1080 1125 45.0 50.000 56.250 148.500 2640 1920 720 16x9
Cuadro 4.2: Formatos del estandar de la EIA para una frecuencia de refresco de 50Hz
Figura 4.2: Parametro temporales del formato 31 (1920x1080 50Hz).
Todos estos datos son necesarios para la correcta configuracion de cada uno de los
modulos que componen el sistema a desarrollar. A continuacion describiremos cada uno
de los componentes utilizados y su configuracion.
25
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
4.1.1. CVI
Figura 4.3: Configuracion del componente CVI.
EL componente CVI, Clocked Video Input, se encarga de transformar la entrada del
estandar DTV al formato del bus Avalon-ST. Los aspectos de su configuracion vienen
determinados por el formato 31 del estandar proporcionado por la EIA que podemos ver
en el cuadro 4.2.
26
Universidad Politecnica de Madrid
4.1.2. CVO
Figura 4.4: Configuracion del componente CVO.
EL componente CVO, Clocked Video Output, se encarga de transformar la entrada del
formato del bus Avalon-ST al estandar DTV. Los aspectos de su configuracion vienen
determinados por el formato 31 del estandar proporcionado por la EIA que podemos ver
en el cuadro 4.2.
27
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
4.1.3. Scaler
Figura 4.5: Configuracion del componente Scaler.
Dado que la entrada de vıdeo tiene una resolucion de 1920x1080 tenemos que escalarla
a 1280x400 ya que como el monitor xyZ necesita una resolucion de 640x400 por vista y al
ser un formato Side by side 1280x400 es la resolucion adecuada.
28
Universidad Politecnica de Madrid
4.1.4. PLL
La FPGA Cyclone III contiene un reloj de 50Mhz, pero como podemos ver en el cuadro
4.2, la frecuencia de pıxel es de 148.500Mhz por lo que necesitaremos generar esta fre-
cuencia de reloj para nuestro sistema. Esto lo conseguimos mediante el uso de uno de los
cuatro PLLs disponibles en la FPGA.
4.1.5. Sbs2xyz
Figura 4.6: Configuracion del componente Sbs2xyz.
El entrelazador encargado de convertir la imagen en formato Side by side a xyZ esta
formado por tres archivos VHDL: Una memoria con capacidad de almacenamiento de 2
lıneas, un formateador que hara el entrelazado de Side by side a xyZ y contendra la logica
necesaria para la comunicacion con el bus Avalon-ST y un componente top que conectara
los componentes anteriores. El funcionamiento de este componente se explicara con mas
detalle en el apendice D.
29
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
4.1.6. Nios II
Figura 4.7: Configuracion del componente Nios II.
El procesador Nios II cuenta con una arquitectura de 32-bits y esta disenado especıfica-
mente para la familia de FPGAs de Altera. El Nios II esta desarrollado para realizar un
gran rango de tareas computacionales desde funcionar como un DSP a sistemas de control.
30
Universidad Politecnica de Madrid
4.1.7. Onchip Memory
Figura 4.8: Configuracion del componente Onchip memory.
Para poder integrar un Nios II en el sistema es necesario dotarle de una memoria en la que
se cargaran los programas, por lo tanto es imprescindible para el correcto funcionamiento
del procesador.
4.2. Conversion en periferico NIOS II
Antes de integrar el procesador Nios II se fueron generando diferentes sistemas que
aumentaban su complejidad de manera gradual. De esta forma se podıa garantizar el
31
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
funcionamiento correcto de los componentes que se iban integrando al sistema. A con-
tinuacion veremos los diferentes sistemas creados hasta llegar al sistema completo que
integra el procesador Nios II.
4.2.1. CVI + CVO
Figura 4.9: Sistema formado por CVI y CVO.
Este sistema cuenta tan solo con un CVI y un CVO interconectados mediante el bus
Avalon-ST. La entrada y la salida son exactamente iguales y ayudo a establecer un sis-
tema basico para el correcto desarrollo de un banco de test y sentar las bases para la
incorporacion de mas modulos asegurandonos que estos componentes estaban perfecta-
mente configurados y eran funcionales.
32
Universidad Politecnica de Madrid
4.2.2. CVI + Scaler + CVO
Figura 4.10: Sistema formado por CVI, Scaler y CVO.
A diferencia del sistema anterior en este caso la salida del sistema es diferente a la
entrada, por lo que el CVO se tuvo que configurar para que la salida tuviera en cuenta el
cambio de la resolucion respecto de la entrada. El uso del scaler se debe a que el monitor
xyZ no necesita una resolucion mayor a 640x400 por vista, al ser un formato Side by side
la resolucion necesaria sera de 1280x400. Por lo tanto en este caso para una entrada de
1920x1080 obtenemos una salida de 1280x400.
33
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
4.2.3. CVI + Scaler + Sbs2xyz + CVO
Figura 4.11: Sistema formado por CVI, Scaler, Sbs2xyz y CVO.
Siguiendo la progresion hacia el sistema completo en este caso se integro el entrelazador
encargado de cambiar el formato Side by side a xyZ. Por lo tanto la salida ya serıa la
definitiva, que cuenta con una resolucion de 1920x1200 para una entrada de 1920x1080 y
que antes de ser tratada por el entrelazador es escalada a 1280x400.
4.2.4. Integracion de Nios II
Para integrar el procesador Nios II tambien es necesario dotarle de memoria por lo que
no solo se incluye el componente Nios II sino que tambien se anadira el componente Onchip
Memory. Ademas el procesador Nios II estara conectado mediante las senales data master
y instruction master a los componentes CVI, CVO, Scaler y Onchip memory. Mediante
estas senales el procesador Nios II puede cambiar la configuracion de dichos componentes.
34
Universidad Politecnica de Madrid
4.3. Sistema completo basado en NIOS II
Figura 4.12: Sistema completo formado por CVI, Scaler, Sbs2xyz, CVO, PLL, Onchip
Memory y Nios II.
Finalmente el sistema completo esta formado por CVI, Scaler, Sbs2xyz, CVO, PLL,
Onchip Memory y Nios II. Este sistema genera un componente mediante la herramienta
Qsys llamado VIP SYS que se instanciara en el archivo top del proyecto de la herramienta
35
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
Quartus II. Dicho proyecto estara configurado para poder ser integrado en la tarjeta de
desarrollo Altera Cyclone III EP3C25.
4.4. Pruebas realizadas
Como vimos anteriormente el proyecto fue creciendo por fases y a cada paso se fueron
realizando pruebas para confirmar que el sistema realizaba las funciones requeridas de
manera satisfactoria. A continuacion explicaremos las pruebas realizadas y los resultados
obtenidos.
4.4.1. Bancos de test
Se han creado varios bancos de test para comprobar que las imagenes generadas por los
diferentes sistemas eran correctas. Estos bancos de test se han utilizado reproduciendolos
en la herramienta Modelsim. Su funcionamiento es el siguiente, partiendo de una imagen
en formato BMP de formato Side by side el banco de test la lee y genera el formato de
difusion DTV para que la simulacion del sistema la procese, una vez procesada el banco
de test genera un nuevo BMP a partir de las senales DTV de la salida del sistema.
Figura 4.13: Imagen de test en formato Side by side.
36
Universidad Politecnica de Madrid
El primer test lee una imagen BMP con una resolucion de 1920x1080 y su salida es
tambien de 1920x1080. Por lo que la imagen no se ve modificada en ningun momento al
pasar por la simulacion del sistema.
El segundo test lee una imagen BMP con una resolucion de 1920x1080 y su salida es de
1280x400. Este test comprueba que el componente scaler funciona correctamente.
El tercer y ultimo test lee varias imagenes BMP en formato Side by side, las pasa por
la simulacion una a una y genera un BMP por cada una de ellas en formato xyZ.
Figura 4.14: Imagen de test en formato xyZ.
4.4.2. Comparacion de imagenes en Linux
Para confirmar de manera mas exhaustiva que en el entrelazador VHDL funciona de
manera adecuada se han comparado dos imagenes BMP, una generada por el entrelazador
VHDL mediante la simulacion y la otra se extrajo de la salida de un vıdeo creado con
un solo frame y entrelazado con el codigo del proyecto anterior [1]. Ambas imagenes se
compararon byte a byte mediante instrucciones en la consola de Linux.
1 // Generar archivo con los bytes diferentes.
2 cmp -l FILE_A FILE_B > cmp.txt;
3
37
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
4 // Generar archivo con los valores en octal para poder
convertirlos a decimal.
5 cat cmp.txt |awk ’{printf "0 %i 0 %i\n", $2 , $3}’ > cmp.
octal_2_dec_c.txt;
6
7 // Coversion de octal a decimal de las columnas 2 y 3.
8 cat cmp.octal_2_dec_c.txt |awk --non -decimal -data ’{printf " %i %i
\n", $2 , $3}’ > cmp.octal_2_dec_f.txt;
9
10 // Diferencia del valor en decimal de los bytes diferentes.
11 cat cmp.octal_2_dec_f.txt |awk ’{print ($1 -$2)}’ |sed ’s/-//g’ >
mod_diff.txt
12
13 // Agrupacion por el numero de veces que se repite la diferencia
(Ordenado de menor diferencia [1] a mayor)
14 cat mod_diff.txt | awk ’{lineas[$0 ]++}; END{for (i in lineas)
print lineas[i], i}’ | awk ’{print $2" "$1}’| sort -n >
grupos_diff_ordenado.txt
15
16 //Total
17 cat cmp.txt |awk ’{printf "0 %i 0 %i\n", $2 , $3}’ |awk ’{printf "0 %
i 0 %i\n", $2 , $3}’ |awk ’{print ($1-$2)}’ |sed ’s/-//g’ | awk
’{lineas[$0]++}; END{for (i in lineas) print lineas[i], i}’ |
awk ’{print $2" "$1}’| sort -n >grupos_diff_ordenado.txt
Como podemos ver en el cuadro 4.3 la gran mayorıa de bytes comparados son exacta-
mente iguales, en concreto el 96,2 %. Con una diferencia de 1 hay un 3,49 %. Y a medida
que la diferencia es mayor el porcentaje afectado es cada vez menor. Estas pequenas di-
ferencias se deben a que en el codigo en C del proyecto anterior hace una conversion de
formato YUV a RGB, lo entrelazada y lo vuelve a convertir a formato YUV, esto provoca
pequenas desviaciones en los valores RGB con respecto al entrelazado en VHDL, pero son
practicamente inapreciables por el ojo humano.
38
Universidad Politecnica de Madrid
Valor absoluto de la desviacion Numero de bytes
0 6649594
1 241546
2 14356
3 3784
4 1431
5 622
6 272
7 143
8 93
9 43
10 34
11 32
12 13
13 5
14 2
15 3
16 1
17 13
18 2
19 4
20 4
21 1
22 2
Cuadro 4.3: Numero de bytes y su desviacion comparando dos imagenes entrelazadas de
maneras diferentes
4.4.3. Recursos utilizados en kit Altera Cyclone III EP3C25
Para confirmar que el sistema creado no necesita mas recursos de los que dispone la
FPGA Altera Cyclone III EP3C25, hemos generado un informe con Quartus II para ver
el porcentaje de recursos utilizados. Este nos confirma que un gran porcentaje de los
recursos quedan libres para realizar futuros proyectos con la posibilidad de ampliar el
sistema anadiendole otras funcionalidades.
39
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
Familia Cyclone III
Dispositivo EP3C25F324C8
Elementos logicos totales 6.428\24.624 (26 %)
Funciones combinacionales totales 5.041\24.624 (20 %)
Registros logicos dedicados 4.463\24.624 (18 %)
Registros totales 4463
Pines totales 63\216 (29 %)
Bits de memoria total 244.816\608.256 (40 %)
Elemento multiplicadores empotrados de 9 bits 25\132 (19 %)
PLLs totales 1\4 (25 %)
Cuadro 4.4: Especificaciones de Cyclone III FPGA Starter Kit (EP3C25 FPGA)
40
Capıtulo 5
Conclusiones y lıneas futuras de
trabajo
Este ultimo capıtulo finaliza con las conclusiones extraıdas del proyecto. Se incluye una
vision general del trabajo realizado, el problema propuesto, la solucion planteada, resultados
obtenidos y los problemas encontrados en la realizacion del mismo.
Finalmente se proponen las futuras lıneas de trabajo que derivan de la realizacion de
este Proyecto de Fin de Carrera.
41
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
5.1. Conclusiones
El objetivo principal del PFC se ha cumplido, ya que se ha conseguido realizar un codigo
en C capaz de hacer el entrelazado de Side by side a xyZ, un sistema en VHDL que realiza
el entrelazado a tiempo real del formato DTV en formato Side by side para para que pueda
ser reproducido en el monitor autoestereoscopico xyZ y los bancos de test necesarios para
confirmar el correcto funcionamiento del mismo. Ademas este sistema se ha creado para
poder ser cargado en la tarjeta Cyclone III FPGA Starter Kit (EP3C25 FPGA), por lo
que se ha comprobado que es sintetizable.
La mayor problematica encontrada en el proyecto ha sido el desarrollo del componente
de entrelazado en VHDL, como periferico compatible con el bus Avalon-ST, ya que como
requisito para su correcto funcionamiento con la tarjeta Cyclone III FPGA Starter Kit
(EP3C25 FPGA) era necesario no solo que funcionase en las simulaciones sino que tambien
fuera sintetizable.
Ademas los procesos de simulacion en formato DTV en los bancos de test para confirmar
el correcto funcionamiento del sistema tardan varias horas por cada frame, haciendo el
proceso de creacion del sistema de manera progresiva extremadamente lento.
Finalmente el sistema completo funciona de manera satisfactoria y deja libres la mayorıa
de los recursos de la tarjeta Cyclone III FPGA Starter Kit (EP3C25 FPGA) para poder
ampliar el sistema con mas funcionalidades. Ademas se han creado diferentes bancos de
test que utilizan imagenes reales en formato BMP.
5.2. Lıneas futuras de trabajo
Este proyecto abre diferentes vıas de trabajo para futuros desarrollos que desglosaremos
a continuacion.
Creacion de nuevos componentes compatibles con el bus Avalon-ST para procesar
vıdeo a tiempo real en una FPGA.
Utilizacion del procesador Nios II en sistemas de vıdeo a tiempo real para disponer
de diferentes componentes compatibles con el bus Avalon-ST y poder reconfigurar
los modulos que componen los sistemas sin necesidad de volver a cargarlos en la
FPGA.
Reutilizar los bancos de test con imagenes reales en BMP para la simulacion de
sistemas de procesamiento de vıdeo a tiempo real en formato DTV.
42
Bibliografıa
[1] L. A. A. y Angel Luis Dıaz Fernandez, Desarrollo de aplicaciones para la visualizacion
de contenidos 3D en un monitor autoestereoscopico, Noviembre 2010. Descripcion y
uso del algoritmo de entrelazado del monitor autoestereoscopico xyZ. 2, 3, 4, 17, 37
[2] Altera, My First FPGA Design Tutorial, Julio 2008. Este tutorial se centra en el
entorno del Quartus II, empezando por la creacion de un proyecto nuevo, aprendiendo
a realizar sımbolos (ya sean desde el MegaWizard o a partir de un archivo VHDL)
asignando pines y compilarlo para su posterior programacion en la FPGA.
[3] Altera, My First Nios II Software Tutorial, Julio 2008. Este tutorial se realiza con
el software Nios II Embedded Design Suite. De manera que podemos programar en
C/C++ el procesador Nios II, depurar el software y cargarlo a la FPGA.
[4] Altera, Nios II Hardware Development Tutorial, Mayo 2011. Creacion de un sistema
sencillo con procesador Nios II que se comunicara con el ordenador para controlar la
logica de la FPGA. Perfecto para aprender a instaciar un Nios II por primera vez.
[5] Altera, Nios II System Architect Design Tutorial, Mayo 2011. Este tutorial es indicado
para entender el flujo de diseno en un sistema con Nios II usando Qsys, Quartus II y
Nios II Embedded Design Suite.
[6] Altera, Quartus II Handbook Version 11.0, vol. 1, ch. 5. Altera Corporation, Mayo
2011. Descripcion y uso de la herramienta Quartus II.
[7] Altera, Qsys System Design Tutorial, Abril 2011. Este tutorial es indicado para el
desarrollo de sistemas mediante la herramienta Qsys.
[8] Altera, Avalon Interface Specifications, Mayo 2011. Este manual describe las especi-
ficaciones y uso del bus Avalon-ST.
[9] E. I. Alliance, A DTV Profile for Uncompressed High Speed Digital Interfaces, Ma-
yo 2002. En este documento encontramos los estandares de transmision de DTV
utilizados en el PFC.
43
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
[10] Altera, Video and Image Processing Suite User Guide, Mayo 2011. Este manual
describe las especificaciones y uso de los componentes necesarios para la realizacion
del sistema de procesado de vıdeo.
[11] A. Corporation, Cyclone III FPGA Starter Board Reference Manual, Abril 2012.
Manual de referencia del kit de desarrollo Cyclone III FPGA Starter Board.
[12] J. K. Bekkeng, Quartus II setup and use for the Modelsim–Altera simulator, Agosto
2010. Manual de configuracion para la simulacion de sistemas creados en Quartus II
mediante la herramienta Modelsim.
44
Apendice A
Algoritmo de entrelazado original
A.1. Explicacion del algoritmo
El algoritmo original esta desarrollado en lenguaje C y se encarga de convertir un vıdeo
YUV en formato 3x3 a un vıdeo YUV en el formato entrelazado xyZ. A continuacion
explicaremos el proceso que sigue el algoritmo original.
Figura A.1: Secuencia de procesos que sigue en el algoritmo original.
1. Lectura de un vıdeo YUV en formato 3x3.
2. Conversion del formato YUV a RGB.
3. Separacion de las 9 vistas que forman el vıdeo, descartando la novena ya que no se
necesita.
4. Entrelazamiento de vistas para el correcto funcionamiento en el monitor xyZ.
5. Conversion del formato entrelazado en RGB a formato YUV.
6. Escritura del vıdeo en formato YUV.
45
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
A.2. Codigo
1 #include <stdio.h>
2 #include <math.h>
3 #include <stdlib.h>
4 #include <windows.h>
5 #include <string.h>
6 #include <malloc.h>
7
8 #define COLUMNAS_L 1920 // Resolucion horizontal de la luminancia
9 #define FILAS_L 1200 // Resolucion vertical de la luminancia
10 #define num_cameras 8 // Numero de vistas
11 #define MAXF 5 // numero maximo de videos a convertir
12 #define MAXNOM 35 // numero maximo de caracteres del nombre del
fichero de entrada
13
14 /* Variables globales */
15 int FILAS_C; // Resolucion vertical de la crominancia
16 int COLUMNAS_C; // Resolucion horizontal de la crominancia
17 int altura_vista; // altura de una vista
18 int ancho_vista; // ancho de una vista
19 unsigned char luminancia[FILAS_L ][ COLUMNAS_L ]; //Array para
luminancia de una imagen
20 unsigned char ** c_azul; //Array para crominancia
azul de una imagen
21 unsigned char ** c_rojo; //Array para crominancia
roja de una imagen
22 unsigned char RGB[FILAS_L ][ COLUMNAS_L *3]; //Array para valores
RGB de una imagen
23 unsigned char *** RGB_by_view; //Array para valores RGB
de cada vista de una imagen
24 FILE * report;
25 /* Prototipos de funciones */
26 void leerImagenYUV(FILE * videoIN);
27 void YUV_to_RGB(int opcion);
28 void separarEnVistasRGB(int definition);
29 void entrelazarVistas(int definition);
30 void RGB_to_YUV(int opcion);
31 void escribirImagenYUV(FILE * videoOUT);
32
33 void gestionNombres(char nomb[MAXNOM*MAXF+4],char nombIN[MAXF][
MAXNOM],char nombOUT[MAXF][ MAXNOM +4+1], int *num);
46
Universidad Politecnica de Madrid
34 int reconcerOpciones(char name[MAXNOM],int *opcion ,int *
definition);
35 void reservarMemoria(int opcion ,int definition);
36 void liberarMemoria(void);
37 double performancecounter_diff(LARGE_INTEGER *a, LARGE_INTEGER *b
);
38
39 int main(void)
40 {
41 LARGE_INTEGER t_ini , t_fin; // Guarda el valor de los tiempos
atrapados iniciales y finales
42 double secs; // tiempo transcurrido en segundos
43 FILE * videoIN; // manejador fichero de lectura
44 FILE * videoOUT; // manejador fichero de escritura
45 char permiso; // variable para salir
46 char nombfichIN[MAXF][ MAXNOM ]; // todos los nombres de
entrada
47 char nombfichOUT[MAXF][ MAXNOM +4+1]; // todos los nombres de
salida. nota: +4 por "_out"
48 char nomb[MAXNOM*MAXF +4]; // guarda la linea introducida por
pantalla , nota: +4 por los espacios entre nombres de
videos
49 int n=0; // indice para el numero de videos a convertir
50 int nVideos; // Numero de videos a convertir introducidos , de
1 a 5
51 int opcion =0; //1 si 4:2:2 , 2 si 4:2:0
52 int definition =0; //1 si 3x3 , 2 si 2x4 , 3 si 8T
53
54 //Leer nombres de videos a convertir por pantalla
55 printf (" Video/s a convertir :");
56 gets(nomb);
57
58 // Gestionar los nombres introducidos
59 gestionNombres(nomb ,nombfichIN ,nombfichOUT ,& nVideos);
60
61 // Procedimiento
62 for(n=0;n<nVideos;n++)
63 {
64 // Capturar el tiempo antes de convertir un video
65 QueryPerformanceCounter (& t_ini);
66
67 videoIN = fopen(nombfichIN[n],"rb");
68 if(videoIN != NULL)
47
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
69 {
70 if(reconcerOpciones(nombfichIN[n],&opcion ,& definition
)==0) // Reconocer caracteristicas del video
71 {
72 reservarMemoria(opcion ,definition);
73
74 videoOUT = fopen(nombfichOUT[n],"wb");
75 if(videoOUT != NULL)
76 {
77 printf ("\n\tConvirtiendo ...\n\t\tIn: %s\n\t\
tOut: %s",nombfichIN[n],nombfichOUT[n]);
78 do
79 {
80 //Leer una imagen del video original en
YUV
81 leerImagenYUV(videoIN);
82
83 if(!feof(videoIN))
84 {
85 //Paso de la imagen leida a RGB
86 YUV_to_RGB(opcion);
87
88 // Seperar la imagen RGB en vistas RGB
89 separarEnVistasRGB(definition);
90
91 // Practicar entrelazado de una imagen
92 entrelazarVistas(definition);
93
94 //Paso de la imagen entrelazada de
RGB a YUV
95 RGB_to_YUV(opcion);
96
97 // Escribir la imagen final en el
video de salida
98 escribirImagenYUV(videoOUT);
99 }
100 }while (!feof(videoIN));// mientras no se ha
llegado al final del video
101 }
102 else
103 fprintf(stdout ,"\n\t\tError al crear fichero
destino %s .", nombfichOUT[n]);
104 fclose(videoOUT);
48
Universidad Politecnica de Madrid
105 }
106 else
107 printf ("\ nNo se reconoce peculiaridades del video
%s .", nombfichIN[n]);
108 }
109 else
110 fprintf(stdout ,"\ nError al abrir fichero origen %s
.", nombfichIN[n]);
111 fclose(videoIN);
112
113 // Capturar el tiempo despues del proceso completo
114 QueryPerformanceCounter (& t_fin);
115
116 secs = performancecounter_diff (&t_fin , &t_ini); //
calcular diferencia entre los tiempos capturados
117 if(secs >60)
118 {
119 secs=secs /60.0;
120 printf ("\n\t\tFinalizado! Tiempo transcurrido %f
minutos\n", secs);
121 }
122 else
123 printf ("\n\t\tFinalizado! Tiempo transcurrido %f
segundos\n", secs);
124
125 liberarMemoria (); // libera la memoria de matrices
globales
126 }
127
128 printf ("\ nPulsa Enter para salir .");
129 fscanf(stdin ," %c",&permiso);
130 fflush(stdin);
131 }
132
133 /*
134 Funcion : void gestionNombres(void)
135 Separa la ristra de nombres de los videos de entrada a
convertir guardandolos en la matriz "nombIN",
136 crea los nombres que se les daran a los videos
resultantes en la matriz "nombOUT" y devuelve el
numero
137 total de videos introducidos en "num".
138 */
49
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
139 void gestionNombres(char nomb[MAXNOM*MAXF+4],char nombIN[MAXF][
MAXNOM],char nombOUT[MAXF][ MAXNOM +4+1], int *num)
140 {
141 int i;
142 int m=0;
143 int n=0;
144
145 // Seperar los nombres de videos de entrada
146 nombIN [0][0]= ’. ’;
147 nombIN [0][1]= ’\\ ’;
148 for(i=0;i<strlen(nomb);i++)
149 {
150 switch(n)
151 {
152 case 0:
153 nombIN[n][i-m+2]= nomb[i];
154 break;
155 case 1:
156 nombIN[n][i-m+2]= nomb[i];
157 break;
158 case 2:
159 nombIN[n][i-m+2]= nomb[i];
160 break;
161 case 3:
162 nombIN[n][i-m+2]= nomb[i];
163 break;
164 case 4:
165 nombIN[n][i-m+2]= nomb[i];
166 break;
167 }
168 if(nomb[i]==’ ’)
169 {
170 nombIN[n][i-m+2]= ’\0 ’;
171 m=i+1;
172 n++;
173 if(n<5){
174 nombIN[n][0]=’. ’;
175 nombIN[n][1]= ’\\ ’;}
176 else
177 i=strlen(nomb);
178 }
179 }
180 nombIN[n][i-m+2]= ’\0 ’;
50
Universidad Politecnica de Madrid
181
182 // Preparar nombres de videos de salida
183 *num=n+1;
184 for(n=0;n<*num;n++)
185 {
186 strcpy(nombOUT[n],nombIN[n]);
187 nombOUT[n][ strlen(nombOUT[n]) -4]=’\0’;
188 strcat(nombOUT[n],"_out.yuv");
189 }
190 }
191
192 /*
193 Funcion : void reconcerOpciones ()
194 Obtiene del nombre del archivo las caracteristicas de
este , es decir si el formato de
195 muestro es 4:2:2 o 4:2:0 y si la distribucion de las
vistas se encuentran en 3x3 , 2x4 o
196 8 Tile. Estas caracteristicas quedan reflejadas en las
variables "opcion" y "definition"
197 respectivamente.
198 Devuelve error = 1 si no se reconoce algo del nombre
alojado en "name"
199 */
200 int reconcerOpciones(char name[MAXNOM],int *opcion ,int *
definition)
201 {
202 int error =0;
203
204 // Reconocimiento de los videos de entrada
205 if((name[strlen(name) -8]==’2’)&&( name[strlen(name) -9]==’2’)
&&( name[strlen(name) -10]==’4’)) // formato 4:2:2
206 *opcion =1;
207 else if((name[strlen(name) -8]==’0’)&&( name[strlen(name)
-9]==’2’)&&( name[strlen(name) -10]==’4’)) // formato4 :2:0
208 *opcion =2;
209 else
210 error =1;
211
212
213 if((name[strlen(name) -5]==’3’)&&( name[strlen(name) -6]==’3’))
// distribucion 3x3
214 *definition =1;
51
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
215 else if((name[strlen(name) -5]==’4’)&&( name[strlen(name)
-6]==’2’)) // distribucion 2x4
216 *definition =2;
217 else if((name[strlen(name) -5]==’T’)&&( name[strlen(name)
-6]==’8’)) // distribucion 8 Tile
218 *definition =3;
219 else
220 error =1;
221
222 return error;
223 }
224
225 /*
226 Funcion : void leerImagenYUV(void)
227 Retorna la diferencia entre a y b en segundos
228 */
229 double performancecounter_diff(LARGE_INTEGER *a, LARGE_INTEGER *b
)
230 {
231 LARGE_INTEGER freq;
232
233 QueryPerformanceFrequency (&freq);
234 return (double)(a->QuadPart - b->QuadPart) / (double)freq.
QuadPart;
235 }
236
237 /*
238 Funcion : void reservarMemoria(int opcion)
239 Reserva memoria para las matrices globales utilizadas
en el programa.
240 Estas son:
241 unsigned char ** c_azul;
242 unsigned char ** c_rojo;
243 unsigned char *** RGB_by_view;
244 */
245 void reservarMemoria(int opcion ,int definition)
246 {
247 int i,j;
248 int plus=definition;
249 int t=0;
250 int a=3;
251
252 FILAS_C = FILAS_L / opcion;
52
Universidad Politecnica de Madrid
253 COLUMNAS_C = COLUMNAS_L /2;
254
255 if(definition ==3){ //el video esta en 8T
256 plus --;
257 t=1;}
258 if(definition ==2) //el video esta en 2x4
259 a=2;
260
261 altura_vista = (FILAS_L /(2+ plus))+(( FILAS_L /8)*t);
262 ancho_vista = COLUMNAS_L/a;
263
264 // Reservamos el espacio para las filas de la matriz
265 c_azul = (unsigned char **) malloc(sizeof(unsigned char*) *
FILAS_C);
266 for (i = 0; i < FILAS_C ; i++)
267 // Reservamos el espacio para las columnas por cada fila
268 c_azul[i] = (unsigned char*) malloc(sizeof(unsigned char)
* COLUMNAS_C);
269
270 // Reservamos el espacio para las filas de la matriz
271 c_rojo = (unsigned char **) malloc(sizeof(unsigned char*) *
FILAS_C);
272 for (i = 0; i < FILAS_C ; i++)
273 // Reservamos el espacio para las columnas por cada fila
274 c_rojo[i] = (unsigned char*) malloc(sizeof(unsigned char)
* COLUMNAS_C);
275
276 // Reservamos el espacio para las filas de la matriz
277 RGB_by_view = (unsigned char ***) malloc(sizeof(unsigned char
**) * altura_vista);
278 for (i = 0; i < altura_vista ; i++)
279 { // Reservamos el espacio para las columnas por cada fila
280 RGB_by_view[i] = (unsigned char **) malloc(sizeof(unsigned
char*) * ancho_vista *3);
281 for (j = 0; j < ancho_vista *3 ; j++)
282 // Reservamos el espacio para las vistas por cada (
filas x columnas)
283 RGB_by_view[i][j] = (unsigned char*) malloc(sizeof(
unsigned char) * num_cameras);
284 }
285 }
286
287 /*
53
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
288 Funcion : void leerImagenYUV(void)
289 Lee una imagen completa de un video de entrada que se
encuentre en YUV.
290 Guarda estos datos en las matrices "luminancia", "
c_azul" y "c_rojo" en
291 correspondencia con la luminancia y crominancias de la
imagen .
292 */
293 void leerImagenYUV(FILE * videoIN)
294 {
295 int filas;
296
297 // luminancia
298 for(filas =0;filas <FILAS_L;filas ++)
299 {
300 fread(& luminancia[filas ][0], sizeof(char),COLUMNAS_L ,
videoIN);
301 }
302
303 // crominancia azul
304 for(filas =0;filas <FILAS_C;filas ++)
305 {
306 fread(& c_azul[filas ][0], sizeof(char),COLUMNAS_C ,videoIN);
307 }
308
309 // crominancia roja
310 for(filas =0;filas <FILAS_C;filas ++)
311 {
312 fread(& c_rojo[filas ][0], sizeof(char),COLUMNAS_C ,videoIN);
313 }
314 }
315
316 /*
317 Funcion : void YUV_to_RGB(void)
318 Convierte la imagen YUV almacenada entre las matrices "
luminancia", "c_azul" y "c_rojo" a
319 RGB guardando sus datos en "RGB".
320 La matriz bidimensional "RGB" contiene los datos por
pixel de la siguiente manera:
321
322 [R_0][G_0][B_0],[R_1][G_1][B_1],...,[ R_1920x1200
][ G_1920x1200 ][ B_1920x1200]
323
54
Universidad Politecnica de Madrid
324 Los tres componentes de un pixel indexados uno a
continuacion del otro y asi
325 sucesivamente hasta el ultimo de los pixeles.
326 */
327 void YUV_to_RGB(int opcion)
328 {
329 int filas;
330 int columnas;
331 int C;
332 int D;
333 int E;
334 int R;
335 int G;
336 int B;
337
338 for(filas =0;filas <FILAS_L;filas ++)
339 {
340 for(columnas =0; columnas <COLUMNAS_L;columnas ++)
341 {
342 C = luminancia[filas ][ columnas] - 16;
343 D = c_azul [(filas)/opcion ][( columnas)/2] - 128;
344 E = c_rojo [(filas)/opcion ][( columnas)/2] - 128;
345
346 R = (( 298 * C + 409 * E + 128) >> 8);
347 G = (( 298 * C - 100 * D - 208 * E + 128) >> 8);
348 B = (( 298 * C + 516 * D + 128) >> 8);
349
350 if(R<0)
351 R=0;
352 if(R >255)
353 R=255;
354 if(G<0)
355 G=0;
356 if(G >255)
357 G=255;
358 if(B<0)
359 B=0;
360 if(B >255)
361 B=255;
362
363 RGB[filas][ columnas *3]= R;
364 RGB[filas][ columnas *3 + 1]= G;
365 RGB[filas][ columnas *3 + 2]= B;
55
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
366 }
367 }
368 }
369
370 /*
371 Funcion : void separarEnVistasRGB(void)
372 Obtiene las ocho vistas dividiendo la imagen almacenada
en "RGB". Para una correcta separacion
373 se tiene en cuenta como se encuentran distribuidas , es
decir , 3x3 , 2x4 u 8T.
374 Las vistas se guardan en la matriz tridimensional "
RGB_by_view"
375 */
376 void separarEnVistasRGB(int definition)
377 {
378 int filas;
379 int columnas;
380 int x,y;
381
382 switch(definition)
383 {
384 case 1: //3x3
385
386 for(filas =0;filas <FILAS_L;filas ++)
387 {
388 for(columnas =0; columnas <COLUMNAS_L *3; columnas ++)
389 {
390 if((columnas >=0) &&( columnas <= COLUMNAS_L -1))
391 {
392 if((filas >=0) &&(filas <=( FILAS_L /3) -1))
393 RGB_by_view[filas ][ columnas ][0]= RGB[filas
][ columnas ];
394 if((filas >= FILAS_L /3) &&(filas <=(( FILAS_L /3)
*2) -1))
395 {
396 y=filas -FILAS_L /3;
397 RGB_by_view[y][ columnas ][3]= RGB[filas ][
columnas ];
398 }
399 if((filas >=( FILAS_L /3) *2) &&(filas <=FILAS_L -1)
)
400 {
401 y=filas -( FILAS_L /3)*2;
56
Universidad Politecnica de Madrid
402 RGB_by_view[y][ columnas ][6]= RGB[filas ][
columnas ];
403 }
404 }
405 if((columnas >= COLUMNAS_L)&&( columnas <=( COLUMNAS_L
*2) -1))
406 {
407 x=columnas -COLUMNAS_L;
408
409 if((filas >=0) &&(filas <=( FILAS_L /3) -1))
410 RGB_by_view[filas ][x][1]= RGB[filas ][
columnas ];
411 if((filas >= FILAS_L /3) &&(filas <=(( FILAS_L /3)
*2) -1))
412 {
413 y=filas -FILAS_L /3;
414 RGB_by_view[y][x][4]= RGB[filas ][ columnas
];
415 }
416 if((filas >=( FILAS_L /3) *2) &&(filas <=FILAS_L -1)
)
417 {
418 y=filas -( FILAS_L /3)*2;
419 RGB_by_view[y][x][7]= RGB[filas ][ columnas
];
420 }
421 }
422 if((columnas >= COLUMNAS_L *2) &&( columnas <=(
COLUMNAS_L *3) -1))
423 {
424 x=columnas -COLUMNAS_L *2;
425
426 if((filas >=0) &&(filas <=( FILAS_L /3) -1))
427 RGB_by_view[filas ][x][2]= RGB[filas ][
columnas ];
428 if((filas >= FILAS_L /3) &&(filas <=( FILAS_L /3*2)
-1))
429 {
430 y=filas -FILAS_L /3;
431 RGB_by_view[y][x][5]= RGB[filas ][ columnas
];
432 }
433 }
57
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
434 }
435 }
436
437 break;
438 case 2: //2x4
439
440 for(filas =0;filas <FILAS_L;filas ++)
441 {
442 for(columnas =0; columnas <COLUMNAS_L *3; columnas ++)
443 {
444 if((columnas >=0) &&( columnas <= ancho_vista *3-1))
445 {
446 if((filas >=0) &&(filas <= altura_vista -1))
447 RGB_by_view[filas ][ columnas ][0]= RGB[filas
][ columnas ];
448 if((filas >= altura_vista)&&(filas <=
altura_vista *2-1))
449 {
450 y=filas -altura_vista;
451 RGB_by_view[y][ columnas ][2]= RGB[filas ][
columnas ];
452 }
453 if((filas >= altura_vista *2) &&(filas <=
altura_vista *3-1))
454 {
455 y=filas -altura_vista *2;
456 RGB_by_view[y][ columnas ][4]= RGB[filas ][
columnas ];
457 }
458 if((filas >= altura_vista *3) &&(filas <=FILAS_L
-1))
459 {
460 y=filas -altura_vista *3;
461 RGB_by_view[y][ columnas ][6]= RGB[filas ][
columnas ];
462 }
463 }
464 if((columnas >= ancho_vista *3) &&( columnas <=(
COLUMNAS_L *3) -1))
465 {
466 x=columnas -ancho_vista *3;
467
468 if((filas >=0) &&(filas <= altura_vista -1))
58
Universidad Politecnica de Madrid
469 RGB_by_view[filas ][x][1]= RGB[filas ][
columnas ];
470 if((filas >= altura_vista)&&(filas <=
altura_vista *2-1))
471 {
472 y=filas -altura_vista;
473 RGB_by_view[y][x][3]= RGB[filas ][ columnas
];
474 }
475 if((filas >= altura_vista *2) &&(filas <=
altura_vista *3-1))
476 {
477 y=filas -altura_vista *2;
478 RGB_by_view[y][x][5]= RGB[filas ][ columnas
];
479 }
480 if((filas >= altura_vista *3) &&(filas <=FILAS_L
-1))
481 {
482 y=filas -altura_vista *3;
483 RGB_by_view[y][x][7]= RGB[filas ][ columnas
];
484 }
485 }
486 }
487 }
488
489 break;
490 case 3: //8T
491
492 for(filas =0;filas <FILAS_L;filas ++)
493 {
494 for(columnas =0; columnas <COLUMNAS_L *3; columnas ++)
495 {
496 if((columnas >=0) &&( columnas <= ancho_vista *3-1))
497 {
498 if((filas >=0) &&(filas <= altura_vista -1))
499 RGB_by_view[filas ][ columnas ][0]= RGB[filas
][ columnas ];
500 if((filas >= altura_vista)&&(filas <=
altura_vista *2-1))
501 {
502 y=filas -altura_vista;
59
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
503 RGB_by_view[y][ columnas ][3]= RGB[filas ][
columnas ];
504 }
505 if((filas >= altura_vista *2) &&(filas <=FILAS_L
-1))
506 {
507 y=filas -( altura_vista *2)+(( FILAS_L -
altura_vista *2) /2);
508 RGB_by_view[y][ columnas ][6]= RGB[filas ][
columnas ];
509 }
510 }
511 if((columnas >= ancho_vista *3) &&( columnas <=
ancho_vista *3*2 -1))
512 {
513 x=columnas -ancho_vista *3;
514
515 if((filas >=0) &&(filas <= altura_vista -1))
516 RGB_by_view[filas ][x][1]= RGB[filas ][
columnas ];
517 if((filas >= altura_vista)&&(filas <=
altura_vista *2-1))
518 {
519 y=filas -altura_vista;
520 RGB_by_view[y][x][4]= RGB[filas ][ columnas
];
521 }
522 if((filas >= altura_vista *2) &&(filas <=(
altura_vista *2+(( FILAS_L -altura_vista *2)
/2)) -1))
523 {
524 y=filas -altura_vista *2;
525 RGB_by_view[y][x][6]= RGB[filas ][ columnas
];
526 }
527 if((filas >=( altura_vista *2+(( FILAS_L -
altura_vista *2) /2)))&&(filas <=FILAS_L -1))
528 {
529 y=filas -( altura_vista *2) -((FILAS_L -
altura_vista *2) /2)+(FILAS_L -
altura_vista *2);
530 RGB_by_view[y][x][7]= RGB[filas ][ columnas
];
60
Universidad Politecnica de Madrid
531 }
532 }
533 if((columnas >= ancho_vista *3*2) &&( columnas <=
COLUMNAS_L *3-1))
534 {
535 x=columnas -ancho_vista *3*2;
536
537 if((filas >=0) &&(filas <= altura_vista -1))
538 RGB_by_view[filas ][x][2]= RGB[filas ][
columnas ];
539 if((filas >= altura_vista)&&(filas <=
altura_vista *2-1))
540 {
541 y=filas -altura_vista;
542 RGB_by_view[y][x][5]= RGB[filas ][ columnas
];
543 }
544 if((filas >= altura_vista *2) &&(filas <=FILAS_L
-1))
545 {
546 y=filas -altura_vista *2;
547 RGB_by_view[y][x][7]= RGB[filas ][ columnas
];
548 }
549 }
550 }
551 }
552
553 break;
554 }
555 }
556
557 /*
558 Funcion : void entrelazarVistas(void)
559 En esta funcion se va a crear una imagen en RGB a
partir de la leida anteriormente pero
560 con los pixeles entrelazados y teniendo en cuenta la
distribucion de las vistas.
561 Los subpixeles (R,G,B) de cada pixel de la imagen
resultante se obtienen de los subpixeles
562 de coordenadas equivalentes de diferentes vistas. Por
ejemplo , para una distribucion de
61
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
563 vistas de 3x3 , un pixel de coordenada (6,6) se compone
de los valores R, G y B
564 de coordenadas (3,3) de las vistas 4, 5 y 6
respectivamente.
565 La imagen entrelazada se vuelve a almacenar en la
matriz "RGB".
566 */
567 void entrelazarVistas(int definition)
568 {
569 int x; // coordenada x para un pixel de la imagen resultante
570 int y; // coordenada y para un pixel de la imagen resultante
571 int xvista; // coordenada x para un pixel de una vista
572 int yvista; // coordenada y para un pixel de una vista
573 int viewID; // numero de vista de 0 a 7
574 int razonx =3; // valor por el cual se divide la coordenada x
de la imagen resultante
575 //para obtener la coordenada x equivalente en
la vista
576 int razony =3; // valor por el cual se divide la coordenada y
de la imagen resultante
577 //para obtener la coordenada y equivalente en
la vista
578
579 if(definition ==2){ //si el video es 2x4
580 razonx =2;
581 razony =4;}
582 report = fopen(" report_file ","wb");
583 for(y=0;y<FILAS_L;y++)
584 {
585 for(x=0;x<COLUMNAS_L;x++)
586 {
587 if(definition !=3){ //si el video es 3x3 o 2x4
588 xvista = x / razonx;
589 yvista = y / razony;
590 }
591 else{ //si el video es 8T
592 xvista = x/3;
593 yvista = (y*3) /8;}
594
595 /*// Calculo de procedencia de componente Red (0) del
pixel con coordenadas (x,y) de la imagen final
596 viewID = (int)(fmod((x*3 + 0 + num_cameras -(y -1200) +
(int)(floor ((y -1200) /3))),num_cameras));
62
Universidad Politecnica de Madrid
597 RGB[y][x*3] = RGB_by_view[yvista ][ xvista *3][ viewID ];
598 // Calculo de procedencia de componente Green (1) del
pixel con coordenadas (x,y) de la imagen final
599 viewID = (int)(fmod((x*3 + 1 + num_cameras -(y -1200) +
(int)(floor ((y -1200) /3))),num_cameras));
600 RGB[y][x*3+1] = RGB_by_view[yvista ][ xvista *3+1][
viewID ];
601 // Calculo de procedencia de componente Blue (2) del
pixel con coordenadas (x,y) de la imagen final
602 viewID = (int)(fmod((x*3 + 2 + num_cameras -(y -1200) +
(int)(floor ((y -1200) /3))),num_cameras));
603 RGB[y][x*3+2] = RGB_by_view[yvista ][ xvista *3+2][
viewID ];*/
604
605 // Calculo de procedencia de componente Red (0) del
pixel con coordenadas (x,y) de la imagen final
606 viewID = (x*3 + 0 + num_cameras -(y -1200) + (int)(
floor ((y -1200) /3.0))) % num_cameras;
607 if(x==0){
608 fprintf(report ,"y= %i \n", y);
609 fprintf(report ,"view= %i \n",
viewID +1);
610 }
611 RGB[y][x*3] = RGB_by_view[yvista ][ xvista *3][ viewID ];
612 // Calculo de procedencia de componente Green (1) del
pixel con coordenadas (x,y) de la imagen final
613 viewID = (x*3 + 1 + num_cameras -(y -1200) + (int)(
floor ((y -1200) /3.0))) % num_cameras;
614 RGB[y][x*3+1] = RGB_by_view[yvista ][ xvista *3+1][
viewID ];
615 // Calculo de procedencia de componente Blue (2) del
pixel con coordenadas (x,y) de la imagen final
616 viewID = (x*3 + 2 + num_cameras -(y -1200) + (int)(
floor ((y -1200) /3.0))) % num_cameras;
617 RGB[y][x*3+2] = RGB_by_view[yvista ][ xvista *3+2][
viewID ];
618 }
619 }
620 fclose(report);
621 }
622
623 /*
624 Funcion : void RGB_to_YUV(void)
63
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
625 Convierte la imagen RGB almacenada en "RGB" a YUV
guardando
626 sus datos entre "luminancia", "c_azul" y "c_rojo ".
627 */
628 void RGB_to_YUV(int opcion)
629 {
630 int filas;
631 int columnas;
632 int Y;
633 int U;
634 int V;
635
636 //paso a YUV
637 for(filas =0;filas <FILAS_L;filas ++)
638 {
639 for(columnas =0; columnas <COLUMNAS_L *3; columnas=columnas +3)
640 {
641 Y = (( 66 * RGB[filas ][ columnas] + 129 * RGB[filas ][
columnas +1] + 25 * RGB[filas ][ columnas +2] + 128)
>> 8) + 16;
642 U = (( -38 * RGB[filas ][ columnas] - 74 * RGB[filas ][
columnas +1] + 112 * RGB[filas ][ columnas +2] + 128)
>> 8) + 128;
643 V = ((112 * RGB[filas ][ columnas] - 94 * RGB[filas ][
columnas +1] - 18 * RGB[filas ][ columnas +2] + 128)
>> 8) + 128;
644
645 if(Y<0)
646 Y=0;
647 if(Y >255)
648 Y=255;
649 if(U<0)
650 U=0;
651 if(U >255)
652 U=255;
653 if(V<0)
654 V=0;
655 if(V >255)
656 V=255;
657
658 //Y (luminancia), U (Cb), V(Cr)
659 luminancia[filas ][ columnas /3] = Y;
660 c_azul [( filas)/opcion ][( columnas /3) /2] = U;
64
Universidad Politecnica de Madrid
661 c_rojo [(filas)/opcion ][( columnas /3) /2] = V;
662 }
663 }
664 }
665
666 /*
667 Funcion : void escribirImagenYUV(void)
668 Escribe una imagen YUV en el video de salida.
669 */
670 void escribirImagenYUV(FILE * videoOUT)
671 {
672 int filas;
673
674 for(filas =0;filas <FILAS_L;filas ++)
675 {
676 fwrite (& luminancia[filas ][0], sizeof(char),COLUMNAS_L ,
videoOUT);
677 }
678 for(filas =0;filas <FILAS_C;filas ++)
679 {
680 fwrite (& c_azul[filas ][0], sizeof(char),COLUMNAS_C ,videoOUT
);
681 }
682 for(filas =0;filas <FILAS_C;filas ++)
683 {
684 fwrite (& c_rojo[filas ][0], sizeof(char),COLUMNAS_C ,videoOUT
);
685 }
686 }
687
688 /*
689 Funcion : void liberarMemoria(void)
690 Libera la memoria reservada para las matrices "c_azul",
691 "c_rojo" y "RGB_by_view"
692 */
693 void liberarMemoria(void)
694 {
695 free(c_azul);
696 free(c_rojo);
697 free(RGB_by_view);
698 }
65
Apendice B
Algoritmo de entrelazado
implementado
B.1. Explicacion del algoritmo
El algoritmo implementado esta desarrollado en lenguaje C y se encarga de convertir
un vıdeo YUV en formato Side by side a un vıdeo YUV en el formato entrelazado xyZ. A
continuacion explicaremos el proceso que sigue el algoritmo implementado.
Figura B.1: Secuencia de procesos que sigue en el algoritmo implementado.
1. Lectura de un vıdeo YUV en formato Side by side.
2. Conversion del formato YUV a RGB.
3. Separacion de las 2 vistas que forman el vıdeo.
4. Entrelazamiento de vistas para el correcto funcionamiento en el monitor xyZ.
5. Conversion del formato entrelazado en RGB a formato YUV.
6. Escritura del vıdeo en formato YUV.
67
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
B.2. Codigo
1 #include <stdio.h>
2 #include <math.h>
3 #include <stdlib.h>
4 #include <string.h>
5 #include <malloc.h>
6
7 /* Constantes globales */
8 #define COLUMNAS 1920
9 #define FILAS 1200
10
11 #define COLUMNAS_LUMINANCIA 1920
12 #define FILAS_LUMINANCIA 1200
13
14 #define COLUMNAS_SBS 1280
15 #define FILAS_SBS 400
16
17
18 /* Prototipos de funciones */
19 int menu (void);
20 void leerImagenYUV(FILE * videoIN);
21 void YUV_to_RGB ();
22 void sidebyside2xyz ();
23 void sbs3x3 ();
24 void RGB_to_YUV ();
25 void escribirImagenRGB(FILE * videoOUT);
26 void escribirImagenYUV(FILE * videoOUT);
27
28 /* Variables globales */
29 unsigned char luminancia[FILAS_LUMINANCIA ][ COLUMNAS_LUMINANCIA ];
//Array para luminancia de una imagen
30 unsigned char c_azul[FILAS_LUMINANCIA ][ COLUMNAS_LUMINANCIA /2];
//Array para crominancia azul de una imagen
31 unsigned char c_rojo[FILAS_LUMINANCIA ][ COLUMNAS_LUMINANCIA /2]; //
Array para crominancia roja de una imagen
32
33 unsigned char luminancia_S[FILAS_LUMINANCIA ][ COLUMNAS_LUMINANCIA
]; // Array para luminancia de una imagen
34 unsigned char c_azul_S[FILAS_LUMINANCIA ][ COLUMNAS_LUMINANCIA /2];
//Array para crominancia azul de una imagen
68
Universidad Politecnica de Madrid
35 unsigned char c_rojo_S[FILAS_LUMINANCIA ][ COLUMNAS_LUMINANCIA /2];
// Array para crominancia roja de una imagen
36
37
38
39
40 unsigned char RGB[FILAS ][ COLUMNAS *3]; //Array para valores RGB de
una imagen
41
42 unsigned char RGB_SBS[FILAS_SBS ][ COLUMNAS_SBS *3]; //Array para
valores RGB de cada vista de una imagen
43
44 int main(void)
45 {
46 FILE *videoIN;
47 FILE *videoOUT;
48 char ENTRADA [40];
49 char SALIDA [40];
50 int opcion;
51 printf ("\n\nArchivo de entrada\n(Ej:entrada.yuv)\n");
52 gets(ENTRADA);
53 printf ("\n\nArchivo de salida\n(Ej:salida.yuv)\n");
54 gets(SALIDA);
55 printf ("\n\nComenzando conversion ...\n\n");
56 opcion=menu();
57
58 if(( videoIN = fopen(ENTRADA ,"rb"))!= NULL)
59 {
60 if(( videoOUT = fopen(SALIDA ,"wb"))!= NULL)
61 {
62 do
63 {
64 leerImagenYUV(videoIN);
65 if(!feof(videoIN))
66 {
67 YUV_to_RGB ();
68 switch (opcion)
69 {
70 case 1:
71 sbs3x3 ();
72 RGB_to_YUV ();
73 escribirImagenYUV(videoOUT);
74 break;
69
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
75 case 2:
76 sidebyside2xyz ();
77 RGB_to_YUV ();
78 escribirImagenYUV(videoOUT);
79 break;
80 case 3:
81 sidebyside2xyz ();
82 escribirImagenRGB(videoOUT);
83 break;
84 default :
85 printf ("\ nERROR: Opcion incorrecta
...");
86 }
87 }
88 }while(!feof(videoIN));
89 }
90 else
91 printf (" Error al crear fichero destino ");
92 fclose(videoOUT);
93 }
94 else
95 printf (" Error al abrir fichero origen ");
96 fclose(videoIN);
97
98 printf ("\n\nConversion finalizada ...\n\n");
99
100 return (0);
101 }
102
103 int menu (void)
104 {
105 int op;
106 printf ("\n+---------------------------+");
107 printf ("\n| Opciones |");
108 printf ("\n+---------------------------+");
109 printf ("\n 1.- Side -by -Side a 3x3");
110 printf ("\n 2.- Side -by -Side a XYZ");
111 printf ("\ nSelecciona una opcion: ");
112 fflush(stdin);
113 scanf(" %d",&op);
114 return op;
115 }
116
70
Universidad Politecnica de Madrid
117 void leerImagenYUV(FILE * videoIN)
118 {
119 int filas;
120
121 // luminancia
122 for(filas =0;filas <FILAS_SBS;filas ++)
123 {
124 fread (& luminancia[filas ][0], sizeof(char),COLUMNAS_SBS ,
videoIN);
125 }
126
127 // crominancia azul
128 for(filas =0;filas <FILAS_SBS;filas ++)
129 {
130 fread (& c_azul[filas ][0], sizeof(char),COLUMNAS_SBS /2,
videoIN);
131 }
132
133 // crominancia roja
134 for(filas =0;filas <FILAS_SBS;filas ++)
135 {
136 fread (& c_rojo[filas ][0], sizeof(char),COLUMNAS_SBS /2,
videoIN);
137 }
138 }
139
140 void YUV_to_RGB ()
141 {
142 int filas;
143 int columnas;
144 int C;
145 int D;
146 int E;
147 int R;
148 int G;
149 int B;
150
151 for(filas =0;filas <FILAS_SBS;filas ++)
152 {
153 for(columnas =0; columnas <COLUMNAS_SBS;columnas ++)
154 {
155 C = luminancia[filas ][ columnas] - 16;
156 D = c_azul [(filas)][( columnas)/2] - 128;
71
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
157 E = c_rojo [( filas)][( columnas)/2] - 128;
158
159 R = (( 298 * C + 409 * E + 128) >> 8);
160 G = (( 298 * C - 100 * D - 208 * E + 128) >> 8);
161 B = (( 298 * C + 516 * D + 128) >> 8);
162
163 if(R<0)
164 R=0;
165 if(R >255)
166 R=255;
167 if(G<0)
168 G=0;
169 if(G >255)
170 G=255;
171 if(B<0)
172 B=0;
173 if(B >255)
174 B=255;
175
176 RGB_SBS[filas][ columnas *3]=( char) R;
177 RGB_SBS[filas][ columnas *3 + 1]=( char) G;
178 RGB_SBS[filas][ columnas *3 + 2]=( char) B;
179 }
180 }
181 }
182
183 void sidebyside2xyz (){
184 int filas;
185 int columnas;
186
187 for(filas =0;filas <FILAS_SBS;filas ++)
188 {
189 for(columnas =0; columnas <( COLUMNAS_SBS /2);columnas ++)
190 {
191 if(( columnas) %2==0){
192 RGB[filas *3][ columnas *9 + 0] = RGB_SBS[
filas ][ columnas *3 + 0]; //RED
193 RGB[filas *3][ columnas *9 + 1] = RGB_SBS[
filas ][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 1]; // GREEN
194 RGB[filas *3][ columnas *9 + 2] = RGB_SBS[
filas ][ columnas *3 + 2]; //BLUE
195
72
Universidad Politecnica de Madrid
196 RGB[filas *3+1][ columnas *9 + 0] = RGB_SBS[
filas][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 0];// RED
197 RGB[filas *3+1][ columnas *9 + 1] = RGB_SBS[
filas][ columnas *3 + 1]; // GREEN
198 RGB[filas *3+1][ columnas *9 + 2] = RGB_SBS[
filas][ columnas *3 + (COLUMNAS_SBS /2)*3
+2];
199
200 RGB[filas *3+2][ columnas *9 + 0] = RGB_SBS[
filas][ columnas *3 + 0];// RED
201 RGB[filas *3+2][ columnas *9 + 1] = RGB_SBS[
filas][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 1 ]; //GREEN
202 RGB[filas *3+2][ columnas *9 + 2] = RGB_SBS[
filas][ columnas *3 + 2]; //BLUE
203
204 RGB[filas *3][ columnas *9+3 + 0] = RGB_SBS[
filas][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 0];// RED
205 RGB[filas *3][ columnas *9+3 + 1] = RGB_SBS[
filas][ columnas *3 + 1];// GREEN
206 RGB[filas *3][ columnas *9+3 + 2] = RGB_SBS[
filas][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 2];
207
208 RGB[filas *3+1][ columnas *9+3 + 0] =
RGB_SBS[filas][ columnas *3 + 0];// RED
209 RGB[filas *3+1][ columnas *9+3 + 1] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 + 1 ];// GREEN
210 RGB[filas *3+1][ columnas *9+3 + 2] =
RGB_SBS[filas][ columnas *3 + 2]; //BLUE
211
212 RGB[filas *3+2][ columnas *9+3 + 0] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 + 0];// RED
213 RGB[filas *3+2][ columnas *9+3 + 1] =
RGB_SBS[filas][ columnas *3 + 1]; //
GREEN
214 RGB[filas *3+2][ columnas *9+3 + 2] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 + 2];
73
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
215
216
217 RGB[filas *3][ columnas *9+6 + 0] = RGB_SBS[
filas ][ columnas *3 + 0];// RED
218 RGB[filas *3][ columnas *9+6 + 1] = RGB_SBS[
filas ][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 1]; // GREEN
219 RGB[filas *3][ columnas *9+6 + 2] = RGB_SBS[
filas ][ columnas *3 + 2]; //BLUE
220
221 RGB[filas *3+1][ columnas *9+6 + 0] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 + 0];// RED
222 RGB[filas *3+1][ columnas *9+6 + 1] =
RGB_SBS[filas][ columnas *3 + 1]; //
GREEN
223 RGB[filas *3+1][ columnas *9+6 + 2] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 +2];
224
225 RGB[filas *3+2][ columnas *9+6 + 0] =
RGB_SBS[filas][ columnas *3 + 0];// RED
226 RGB[filas *3+2][ columnas *9+6 + 1] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 + 1 ]; // GREEN
227 RGB[filas *3+2][ columnas *9+6 + 2] =
RGB_SBS[filas][ columnas *3 + 2]; //BLUE
228 }
229 else{
230
231 RGB[filas *3][ columnas *9 + 0] = RGB_SBS[
filas ][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 0];// RED
232 RGB[filas *3][ columnas *9 + 1] = RGB_SBS[
filas ][ columnas *3 + 1]; //GREEN
233 RGB[filas *3][ columnas *9 + 2] = RGB_SBS[
filas ][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 2];
234
235 RGB[filas *3+1][ columnas *9 + 0] = RGB_SBS[
filas ][ columnas *3 + 0];// RED
74
Universidad Politecnica de Madrid
236 RGB[filas *3+1][ columnas *9 + 1] = RGB_SBS[
filas][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 1 ];// GREEN
237 RGB[filas *3+1][ columnas *9 + 2] = RGB_SBS[
filas][ columnas *3 + 2]; //BLUE
238
239 RGB[filas *3+2][ columnas *9 + 0] = RGB_SBS[
filas][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 0];// RED
240 RGB[filas *3+2][ columnas *9 + 1] = RGB_SBS[
filas][ columnas *3 + 1]; // GREEN
241 RGB[filas *3+2][ columnas *9 + 2] = RGB_SBS[
filas][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 2];
242
243
244 RGB[filas *3][ columnas *9+3 + 0] = RGB_SBS[
filas][ columnas *3 + 0];// RED
245 RGB[filas *3][ columnas *9+3 + 1] = RGB_SBS[
filas][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 1 ]; //GREEN
246 RGB[filas *3][ columnas *9+3 + 2] = RGB_SBS[
filas][ columnas *3 + 2]; //BLUE
247
248 RGB[filas *3+1][ columnas *9+3 + 0] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 + 0]; //RED
249 RGB[filas *3+1][ columnas *9+3 + 1] =
RGB_SBS[filas][ columnas *3 + 1]; //
GREEN
250 RGB[filas *3+1][ columnas *9+3 + 2] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 + 2];
251
252 RGB[filas *3+2][ columnas *9+3 + 0] =
RGB_SBS[filas][ columnas *3 + 0];// RED
253 RGB[filas *3+2][ columnas *9+3 + 1] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 + 1 ]; // GREEN
254 RGB[filas *3+2][ columnas *9+3 + 2] =
RGB_SBS[filas][ columnas *3 + 2]; //BLUE
255
256
75
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
257 RGB[filas *3][ columnas *9+6 + 0] = RGB_SBS[
filas ][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 0]; //RED
258 RGB[filas *3][ columnas *9+6 + 1] = RGB_SBS[
filas ][ columnas *3 + 1]; //GREEN
259 RGB[filas *3][ columnas *9+6 + 2] = RGB_SBS[
filas ][ columnas *3 + (COLUMNAS_SBS /2)*3
+ 2];
260
261 RGB[filas *3+1][ columnas *9+6 + 0] =
RGB_SBS[filas][ columnas *3 + 0]; //RED
262 RGB[filas *3+1][ columnas *9+6 + 1] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 + 1 ]; // GREEN
263 RGB[filas *3+1][ columnas *9+6 + 2] =
RGB_SBS[filas][ columnas *3 + 2]; //BLUE
264
265 RGB[filas *3+2][ columnas *9+6 + 0] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 + 0]; //RED
266 RGB[filas *3+2][ columnas *9+6 + 1] =
RGB_SBS[filas][ columnas *3 + 1]; //
GREEN
267 RGB[filas *3+2][ columnas *9+6 + 2] =
RGB_SBS[filas][ columnas *3 + (
COLUMNAS_SBS /2)*3 + 2];
268
269 }
270
271
272
273 }
274 }
275 }
276
277 void sbs3x3 ()
278 {
279 int filas;
280 int columnas;
281
282 for(filas =0;filas <FILAS_SBS;filas ++)
283 {
284 for(columnas =0; columnas <( COLUMNAS_SBS /2);columnas ++)
76
Universidad Politecnica de Madrid
285 {
286 RGB[filas][ columnas *3] = RGB_SBS[filas][ columnas
*3];
287 RGB[filas][ columnas *3 + 1] = RGB_SBS[filas][
columnas *3 + 1];
288 RGB[filas][ columnas *3 + 2] = RGB_SBS[filas][
columnas *3 + 2];
289
290 RGB[filas][ columnas *3 + 3* COLUMNAS_SBS /2] = RGB_SBS
[filas ][ columnas *3 + 3* COLUMNAS_SBS /2];
291 RGB[filas][ columnas *3 + 3* COLUMNAS_SBS /2 + 1] =
RGB_SBS[filas][ columnas *3 + 3* COLUMNAS_SBS /2 +
1];
292 RGB[filas][ columnas *3 + 3* COLUMNAS_SBS /2 + 2] =
RGB_SBS[filas][ columnas *3 + 3* COLUMNAS_SBS /2 +
2];
293
294 RGB[filas][ columnas *3 + 3* COLUMNAS_SBS] = RGB_SBS[
filas ][ columnas *3];
295 RGB[filas][ columnas *3 + 3* COLUMNAS_SBS + 1] =
RGB_SBS[filas][ columnas *3 + 1];
296 RGB[filas][ columnas *3 + 3* COLUMNAS_SBS + 2] =
RGB_SBS[filas][ columnas *3 + 2];
297
298
299
300 RGB[filas + FILAS_SBS ][ columnas *3] = RGB_SBS[filas
][3* columnas + 3* COLUMNAS_SBS /2];
301 RGB[filas + FILAS_SBS ][ columnas *3 + 1] = RGB_SBS[
filas ][3* columnas + 3* COLUMNAS_SBS /2 + 1];
302 RGB[filas + FILAS_SBS ][ columnas *3 + 2] = RGB_SBS[
filas ][3* columnas + 3* COLUMNAS_SBS /2 + 2];
303
304 RGB[filas + FILAS_SBS ][ columnas *3 + 3* COLUMNAS_SBS
/2] = RGB_SBS[filas ][3* columnas ];
305 RGB[filas + FILAS_SBS ][ columnas *3 + 3* COLUMNAS_SBS
/2 + 1] = RGB_SBS[filas ][3* columnas + 1];
306 RGB[filas + FILAS_SBS ][ columnas *3 + 3* COLUMNAS_SBS
/2 + 2] = RGB_SBS[filas ][3* columnas + 2];
307
308 RGB[filas + FILAS_SBS ][ columnas *3 + 3* COLUMNAS_SBS]
= RGB_SBS[filas ][3* columnas + 3* COLUMNAS_SBS
/2];
77
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
309 RGB[filas + FILAS_SBS ][ columnas *3 + 3* COLUMNAS_SBS
+ 1] = RGB_SBS[filas ][3* columnas + 3*
COLUMNAS_SBS /2 + 1];
310 RGB[filas + FILAS_SBS ][ columnas *3 + 3* COLUMNAS_SBS
+ 2] = RGB_SBS[filas ][3* columnas + 3*
COLUMNAS_SBS /2 + 2];
311
312
313
314 RGB[filas + FILAS_SBS *2][ columnas *3] = RGB_SBS[
filas][ columnas *3];
315 RGB[filas + FILAS_SBS *2][ columnas *3 + 1] = RGB_SBS[
filas][ columnas *3 + 1];
316 RGB[filas + FILAS_SBS *2][ columnas *3 + 2] = RGB_SBS[
filas][ columnas *3 + 2];
317
318 RGB[filas + FILAS_SBS *2][ columnas *3 + 3*
COLUMNAS_SBS /2] = RGB_SBS[filas][ columnas *3 + 3*
COLUMNAS_SBS /2];
319 RGB[filas + FILAS_SBS *2][ columnas *3 + 3*
COLUMNAS_SBS /2 + 1] = RGB_SBS[filas][ columnas *3
+ 3* COLUMNAS_SBS /2 + 1];
320 RGB[filas + FILAS_SBS *2][ columnas *3 + 3*
COLUMNAS_SBS /2 + 2] = RGB_SBS[filas][ columnas *3
+ 3* COLUMNAS_SBS /2 + 2];
321
322 RGB[filas + FILAS_SBS *2][ columnas *3 + 3*
COLUMNAS_SBS] = RGB_SBS[filas][ columnas *3];
323 RGB[filas + FILAS_SBS *2][ columnas *3 + 3*
COLUMNAS_SBS + 1] = RGB_SBS[filas][ columnas *3 +
1];
324 RGB[filas + FILAS_SBS *2][ columnas *3 + 3*
COLUMNAS_SBS + 2] = RGB_SBS[filas][ columnas *3 +
2];
325 }
326 }
327
328 }
329
330 void RGB_to_YUV ()
331 {
332 int filas;
333 int columnas;
78
Universidad Politecnica de Madrid
334 int Y;
335 int U;
336 int V;
337
338 //paso a YUV
339 for(filas =0;filas <FILAS;filas ++)
340 {
341 for(columnas =0; columnas <COLUMNAS *3; columnas=columnas +3)
342 {
343 Y = (( 66 * RGB[filas ][ columnas] + 129 * RGB[filas ][
columnas +1] + 25 * RGB[filas ][ columnas +2] + 128)
>> 8) + 16;
344 U = (( -38 * RGB[filas ][ columnas] - 74 * RGB[filas ][
columnas +1] + 112 * RGB[filas ][ columnas +2] + 128)
>> 8) + 128;
345 V = ((112 * RGB[filas ][ columnas] - 94 * RGB[filas ][
columnas +1] - 18 * RGB[filas ][ columnas +2] + 128)
>> 8) + 128;
346
347 if(Y<0)
348 Y=0;
349 if(Y >255)
350 Y=255;
351 if(U<0)
352 U=0;
353 if(U >255)
354 U=255;
355 if(V<0)
356 V=0;
357 if(V >255)
358 V=255;
359
360 //Y (luminancia), U (Cb), V(Cr)
361 luminancia_S[filas][ columnas /3] = Y;
362 c_azul_S [(filas)][( columnas /3)/2] = U;
363 c_rojo_S [(filas)][( columnas /3)/2] = V;
364 }
365 }
366 }
367
368 /*
369 Funcion : void escribirImagenYUV(void)
370 Escribe una imagen YUV en el video de salida.
79
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
371 */
372 void escribirImagenYUV(FILE * videoOUT)
373 {
374 int filas;
375
376 for(filas =0;filas <FILAS;filas ++)
377 fwrite (& luminancia_S[filas ][0], sizeof(char),COLUMNAS ,
videoOUT);
378 for(filas =0;filas <FILAS;filas ++)
379 fwrite (& c_azul_S[filas ][0], sizeof(char),COLUMNAS/2,
videoOUT);
380 for(filas =0;filas <FILAS;filas ++)
381 fwrite (& c_rojo_S[filas ][0], sizeof(char),COLUMNAS/2,
videoOUT);
382 }
383
384 /*
385 Funcion : void escribirImagenRGB(void)
386 Escribe una imagen RGB en el video de salida.
387 */
388 void escribirImagenRGB(FILE * videoOUT)
389 {
390 int filas;
391
392 for(filas =0;filas <FILAS;filas ++){
393 fwrite (&RGB[filas ][0], sizeof(char),COLUMNAS*3,videoOUT);
394 }
395 }
80
Apendice C
Como implementar un periferico
para el bus Avalon-ST
C.1. Avalon-ST
Para desarrollar un periferico compatible con el bus Avalon-ST es necesario crear dos
automatas, uno de entrada y otro de salida. Ambos automatas reciben o transmiten,
dependiendo de si es de entrada o salida, dos tipos de paquetes de datos. El primero de
los paquetes contiene informacion de la altura, anchura y entrelazado del frame que se va
a transmitir. El segundo paquete es el frame.
R X 3 6 9
G X 2 5 8
B ID 1 4 7
Cuadro C.1: Paquete de control del bus Avalon-ST
Como vemos en el cuadro C.1 este paquete se transmitira en el bus de datos RGB y
tendra una duracion de 4 ciclos. Por lo tanto el paquete se divide en cuatro fragmentos, el
primer fragmento contiene un identificador para diferenciar si se trata de un paquete de
control o el frame del vıdeo. Los otros tres fragmentos contienen la informacion relativa al
frame en cuanto a altura, anchura y entrelazado.
Cuando el valor de ID es F (hex) indica que es un paquete de control, cuando es 0 indica
que es una paquete de datos.
Los bytes 1, 2, 3 y 4 contienen la anchura del frame, por ejemplo para una anchura de
1920 pıxels tendran los valores 0, 7, 8, 0 en hexadecimal respectivamente.
81
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
Los bytes 5, 6, 7 y 8 contienen la altura del frame, por ejemplo para una altura de 1200
pıxels tendran los valores 0, 4, B, 0 en hexadecimal respectivamente
Por ultimo el byte 9 contiene informacion del entrelazado y puede tener los siguientes
valores en hexadecimal, 0 para sincronizacion en flanco de bajada, 1 para sincronizacion
en flanco de subida, 2 cuando no se sabe y 3 cuando no importa.
R 0 8 4 2
G 0 7 0 0
B F 0 0 B
Cuadro C.2: Paquete de control del bus Avalon-ST para un frame de 1920x1200
Ademas tenemos que tener en cuenta las siguientes senales:
Ready: Esta senal nos indica que el componente al que vamos a transmitir lo datos
esta listo para recibirlos.
Valid: Esta senal esta a 1 para confirmar que los datos que estamos transmitiendo
son validos, en caso contrario se pondra a cero y los datos no se tienen que tener en
cuenta.
SOP: Esta senal se pone a uno durante un ciclo de reloj, en concreto cuando se
empieza a transmitir un paquete. Coincide con el envıo del fragmento identificador
del paquete. Tambien es conocido como Start of Packet.
EOP: Esta senal se pone a uno durante un ciclo de reloj, en concreto cuando se
termina de transmitir un paquete. Coincide con el envıo del ultimo fragmento del
paquete. Tambien es conocido como End of Packet.
En la siguiente seccion se incluye una plantilla de un periferico del bus Avalon-ST que
incluye los automatas de entrada y salida de un componente compatible con el bus Avalon-
ST.
82
Universidad Politecnica de Madrid
C.2. Plantilla VHDL de periferico Avalon-ST
1 ------------------------------------------------------
2 -- Nombre: avalon -st-template.vhd
3 -- Autor: David Cervantes Caballero
4 -- Fecha: Mayo 2017
5 -- Descripcion:
6 -- Plantilla de componente compatible con el bus Avalon -ST.
7 ------------------------------------------------------
8 library ieee;
9 use IEEE.std_logic_1164.all;
10 use IEEE.numeric_std.all;
11 use ieee.std_logic_unsigned.all;
12 use ieee.std_logic_arith.all;
13
14 entity formateador is
15 port( clk : in std_logic;
16 -- Avalon -ST IN
17 in_ready : buffer std_logic;
18 in_valid : in std_logic;
19 in_sop : in std_logic;
20 in_eop : in std_logic;
21 in_data : in std_logic_vector (23 downto 0);
22 -- AVALON -ST OUT
23 out_ready : in std_logic;
24 out_valid : buffer std_logic;
25 out_sop : buffer std_logic;
26 out_eop : buffer std_logic;
27 out_data : buffer std_logic_vector (23 downto 0);
28 --
29 reset : in std_logic);
30 end formateador;
31
32 architecture RTL of formateador is
33 -- CONSTANTES
34 constant HALF_LINE : std_logic_vector (11 downto 0) := x
"280"; -- 640 PIXELS
35 constant MAX_PIX_IN : std_logic_vector (11 downto 0) := x
"A00"; -- 2560 PIXELS
36 constant MAX_PIX_IN_HALF : std_logic_vector (11 downto 0) := x
"500"; -- 1280 PIXELS
83
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
37 constant MAX_PIX_OUT : std_logic_vector (11 downto 0) := x
"780"; -- 1920 PIXELS
38 constant MAX_LINE_IN : std_logic_vector (11 downto 0) := x
"190"; -- 400 LINES
39 constant MAX_LINE_OUT : std_logic_vector (11 downto 0) := x
"4B0"; -- 1200 LINES
40
41 type avalon_st_in is (ini , pkg1 , pkg2 , pkg3 , data);
42 type avalon_st_out is (ini , id_control , pkg1 , pkg2 , pkg3 ,
wait_data , id_data , pkg_data);
43
44 signal ast_in: avalon_st_in;
45 signal ast_out: avalon_st_out;
46
47 signal s_data_in : std_logic;
48 signal in_cnt_pixel : std_logic_vector (11 downto 0) := (
others => ’0’);
49
50 signal mem_a_full : std_logic := ’0’;
51 signal mem_b_full : std_logic := ’0’;
52 signal mem_ready : std_logic := ’0’;
53
54 signal rd_valid : std_logic := ’0’;
55 signal out_ready_check : std_logic := ’0’;
56 signal rd_cnt_pixel : std_logic_vector (11 DOWNTO 0):= (
others => ’0’);
57 signal rd_cnt_line : std_logic_vector (2 DOWNTO 0):= (
others => ’0’);
58 signal rd_cnt_pix_i : std_logic_vector (1 DOWNTO 0):= (
others => ’0’);
59 signal s_rd_cnt_pix_i : std_logic_vector (1 DOWNTO 0):= (
others => ’0’);
60
61 signal out_cnt_line : std_logic_vector (11 DOWNTO 0):= (
others => ’0’);
62 signal s_out_cnt_line : std_logic_vector (11 DOWNTO 0):= (
others => ’0’);
63 signal s_rd_cnt_line : std_logic_vector (2 DOWNTO 0):= (
others => ’0’);
64 signal out_cnt_pixel : std_logic_vector (11 DOWNTO 0):= (
others => ’0’);
65 signal s_out_cnt_pixel : std_logic_vector (11 DOWNTO 0):= (
others => ’0’);
84
Universidad Politecnica de Madrid
66 signal bf_out_data : std_logic_vector (23 DOWNTO 0):= (
others => ’0’);
67 signal s_rdaddress_red : std_logic_vector (11 DOWNTO 0):= (
others => ’0’);
68 signal s_rdaddress_green : std_logic_vector (11 DOWNTO 0):= (
others => ’0’);
69 signal s_rdaddress_blue : std_logic_vector (11 DOWNTO 0):= (
others => ’0’);
70 signal bf_out_valid : std_logic := ’0’;
71 signal s_data_out : std_logic := ’0’;
72 signal fin : std_logic := ’0’;
73
74 begin
75
76 ---------------------------------------------------------------
77 -- AVALON -ST IN
78 ---------------------------------------------------------------
79 process(clk , reset)
80 begin
81 if(reset = ’1’) then
82 ast_in <= ini;
83 elsif(clk ’event and clk = ’1’) then
84 case ast_in is
85 when ini =>
86 if (in_sop = ’1’ and in_data = x"00000F") then
87 ast_in <= pkg1;
88 elsif (in_sop = ’1’ and in_data = x"000000") then
89 ast_in <= data;
90 end if;
91 when pkg1 => ast_in <= pkg2;
92 when pkg2 => ast_in <= pkg3;
93 when pkg3 => ast_in <= ini;
94 when data =>
95 if (in_eop = ’1’) then
96 ast_in <= ini;
97 end if;
98 end case;
99 end if;
100 end process;
101
102 process(ast_in)
103 begin
104 case ast_in is
85
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
105 when data => s_data_in <= ’1’;
106 when others => s_data_in <= ’0’;
107 end case;
108 end process;
109
110 ------------------------------------------------------
111 -- READY IN/OUT
112 ------------------------------------------------------
113 in_ready <= out_ready;
114
115 ---------------------------------------------------------------
116 -- AVALON -ST OUT
117 ---------------------------------------------------------------
118 process(clk , reset)
119 begin
120 if(reset = ’1’) then
121 ast_out <= ini;
122 elsif(clk ’event and clk = ’1’) then
123 if out_ready = ’1’then
124 case ast_out is
125 when ini =>
126 if s_data_in = ’1’ then
127 ast_out <= id_control;
128 end if;
129 when id_control => ast_out <= pkg1;
130 when pkg1 => ast_out <= pkg2;
131 when pkg2 => ast_out <= pkg3;
132 when pkg3 => ast_out <= wait_data;
133 when wait_data =>
134 if s_data_in =’1’ then
135 ast_out <= id_data;
136 end if;
137 when id_data => ast_out <= pkg_data;
138 when pkg_data =>
139 if out_eop = ’1’ then
140 ast_out <= ini;
141 end if;
142 end case;
143 end if;
144 end if;
145 end process;
146
147 process(ast_out , fin)
86
Universidad Politecnica de Madrid
148 begin
149 case ast_out is
150 when ini =>
151 s_data_out <= ’0’;
152 bf_out_valid <= ’0’;
153 out_sop <= ’0’;
154 out_eop <= ’0’;
155 bf_out_data <= x"000000";
156 when id_control =>
157 s_data_out <= ’0’;
158 bf_out_valid <= ’1’;
159 out_sop <= ’1’;
160 out_eop <= ’0’;
161 bf_out_data <= x"00000F";
162 when pkg1 =>
163 s_data_out <= ’0’;
164 bf_out_valid <= ’1’;
165 out_sop <= ’0’;
166 out_eop <= ’0’;
167 bf_out_data <= x"080700";
168 when pkg2 =>
169 s_data_out <= ’0’;
170 bf_out_valid <= ’1’;
171 out_sop <= ’0’;
172 out_eop <= ’0’;
173 bf_out_data <= x"040000";
174 when pkg3 =>
175 s_data_out <= ’0’;
176 bf_out_valid <= ’1’;
177 out_sop <= ’0’;
178 out_eop <= ’1’;
179 bf_out_data <= x"02000B";
180 when wait_data =>
181 s_data_out <= ’0’;
182 bf_out_valid <= ’0’;
183 out_sop <= ’0’;
184 out_eop <= ’0’;
185 bf_out_data <= x"000000";
186 when id_data =>
187 s_data_out <= ’1’;
188 bf_out_valid <= ’1’;
189 out_sop <= ’1’;
190 out_eop <= ’0’;
87
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
191 bf_out_data <= x"000000";
192 when pkg_data =>
193 bf_out_valid <= ’0’;
194 bf_out_data <= x"000000";
195 if fin = ’1’ then
196 s_data_out <= ’1’;
197 out_sop <= ’0’;
198 out_eop <= ’1’;
199 else
200 s_data_out <= ’1’;
201 out_sop <= ’0’;
202 out_eop <= ’0’;
203 end if;
204 end case;
205 end process;
206
207 out_valid <= in_valid when s_data_out = ’1’ else ’0’;
208 out_data <= in_data when s_data_out = ’1’ and out_sop = ’0’ else
bf_out_data;
209
210 end RTL;
88
Apendice D
Codigo VHDL
D.1. Implementacion
El componente sbs2xyz esta compuesto por los siguientes submodulos:
Automata de entrada: encargado de comunicarse mediante el bus Avalon-ST con el
modulo anterior de sistema, que es un scaler.
Tres memorias de 2560 Bytes: una por cada componente RGB. Cada componente
se guarda por separado para facilitar la tarea de entrelazado ya que como vimos
anteriormente se realiza a nivel de subpıxel.
Control de memoria: gestiona que la memoria esta disponible para que se pueda
escribir en ella o que esta llena por lo que se puede realizar la labores de entrelazado.
Entrelazador: lee los subpıxels de la memoria en el orden necesario para realizar el
entrelazado dependiendo el pıxel y la lınea que se va a transmitir en ese instante.
Automata de salida: se encarga de transmitirle tanto los paquetes de control como
los paquetes de datos al siguiente modulo del sistema, en este caso el CVO.
Ademas tambien se dispone de diferentes contadores de pıxels de entrada, de veces
que se ha leıdo cada memoria y de pıxels de salida para establecer la logica de los
modulos anteriores.
A continuacion explicaremos de manera secuencial como se comporta el entrelazador
desde que le llega un frame, lo entrelaza y lo envıa al siguiente modulo.
1. El automata de entrada detecta un paquete de control con la informacion del frame
que va a recibir a continuacion. Espera hasta que empiece la transmision del frame.
89
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
2. una vez empieza a llegar el frame la memoria empiezan a llenarse guardando los
valores de los subpıxels. Una vez se ha guardado la primera lınea del frame entera
el control de memoria indica que ya se puede empezar ha realizar el entrelazado.
Mientras tanto la segunda lınea se va guardando en memoria.
3. Cuando el control de memoria indica que se puede empezar el entrelazado el entre-
lazador lee los subpıxels de la memoria en funcion del pıxel de salida que se tenga
en ese momento, si acaba de empezar sera el (0,0) formando el pıxel entrelazado que
enviara al automata de salida que a su vez se dedicara a enviarlo al siguiente modulo
del sistema.
4. Cuando la memoria se ha leıdo tres veces queda liberada para volver a escribir encima
ya que no se necesitaran mas esos pixels porque ya se han transmitido las tres lıneas
entrelazadas en la salida.
5. Este proceso continua hasta que se recibe y envıa el ultimo pixel del frame, quedando
los automatas de nuevo a la espera de un nuevo frame.
D.2. Uso del testbech
Para poder utilizar el testbech es necesario crear un entorno de simulacion del sistema
mediante la herramienta Qsys de Quartus II.
Sustituimos el testbench que genero automaticamente Qsys por el que hemos desarro-
llado y en el mismo directorio dejamos el BMP que queremos usar en la simulacion, con
el nombre entrada.bmp.
A continuacion abrimos la herramienta Modelsim, seleccionamos la ruta en la que se ha
generado la simulacion y ejecutamos un script tcl que genero Qsys y cargamos el sistema
en Modelsim.
Anadimos las diferentes senales que queramos ver y arrancamos la simulacion.
Ahora solo queda esperar hasta que el sistema simulado por Modelsim genere el BMP
entrelazado, que tendra el nombre salida.bmp, en el mismo directorio en el que dejamos
el BMP original.
90
Universidad Politecnica de Madrid
D.3. Testbench con un solo BMP
1 ------------------------------------------------------
2 -- Nombre: VIP_SYS_tb.vhd
3 -- Autor: David Cervantes Caballero
4 -- Fecha: Mayo 2017
5 -- Descripcion:
6 -- Test del formateador SbS2xyz con una sola imagen.
7 ------------------------------------------------------
8 library IEEE;
9 use IEEE.std_logic_1164.all;
10 use IEEE.numeric_std.all;
11 use ieee.std_logic_unsigned.all;
12 use work.bmp_pack.all;
13
14 entity VIP_SYS_tb is
15 end entity VIP_SYS_tb;
16
17 architecture rtl of VIP_SYS_tb is
18 component VIP_SYS_tb_VIP_SYS_inst is
19 port ( clk_1 : in std_logic
:= ’X’; -- clk
20 vid_data_to_the_cvi : in std_logic_vector (23
downto 0) := (others => ’X’); -- vid_data
21 overflow_from_the_cvi : out std_logic;
-- overflow
22 vid_datavalid_to_the_cvi : in std_logic
:= ’X’; --
vid_datavalid
23 vid_locked_to_the_cvi : in std_logic
:= ’X’; -- vid_locked
24 vid_v_sync_to_the_cvi : in std_logic
:= ’X’; -- vid_v_sync
25 vid_h_sync_to_the_cvi : in std_logic
:= ’X’; -- vid_h_sync
26 vid_f_to_the_cvi : in std_logic
:= ’X’; -- vid_f
27 clk_0 : in std_logic
:= ’X’; -- clk
28 reset_reset_n : in std_logic
:= ’X’; -- reset_n
91
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
29 vid_data_from_the_cvo : out std_logic_vector (23
downto 0); -- vid_data
30 underflow_from_the_cvo : out std_logic;
-- underflow
31 vid_datavalid_from_the_cvo : out std_logic;
--
vid_datavalid
32 vid_v_sync_from_the_cvo : out std_logic;
-- vid_v_sync
33 vid_h_sync_from_the_cvo : out std_logic;
-- vid_h_sync
34 vid_f_from_the_cvo : out std_logic;
-- vid_f
35 vid_h_from_the_cvo : out std_logic;
-- vid_h
36 vid_v_from_the_cvo : out std_logic);
-- vid_v
37 end component VIP_SYS_tb_VIP_SYS_inst;
38
39 component altera_avalon_clock_source is
40 generic ( CLOCK_RATE : positive := 10);
41 port ( clk : out std_logic); --clk
42 end component altera_avalon_clock_source;
43
44 component altera_avalon_reset_source is
45 generic ( ASSERT_HIGH_RESET : integer := 1;
46 INITIAL_RESET_CYCLES : integer := 0);
47 port ( reset : out std_logic; -- reset_n
48 clk : in std_logic := ’X’); --clk
49 end component altera_avalon_reset_source;
50
51 ------------------------------------
52 -- RELOJES Y RESET
53 ------------------------------------
54 signal basico_inst_clk_1_clk_in_bfm_clk_clk : std_logic;
55 signal basico_inst_clk_0_clk_in_bfm_clk_clk : std_logic;
56 signal basico_inst_reset_bfm_reset_reset : std_logic;
57
58 signal reset_n : std_logic;
59 signal clk_50 : std_logic;
60 signal clk_148_5 : std_logic :=’0’;
61
62 ------------------------------------
92
Universidad Politecnica de Madrid
63 -- CONTADORES
64 ------------------------------------
65 signal cnt_row : std_logic_vector (11 downto 0) := (
others => ’0’);
66 signal cnt_col : std_logic_vector (11 downto 0) := (
others => ’0’);
67 signal cnt_data : std_logic_vector (11 downto 0) := (
others => ’0’);
68 signal cnt_row_in : std_logic_vector (11 downto 0) := (
others => ’0’);
69 signal cnt_col_in : std_logic_vector (11 downto 0) := (
others => ’0’);
70 signal cnt_row_out : std_logic_vector (11 downto 0) := (
others => ’0’);
71 signal cnt_col_out : std_logic_vector (11 downto 0) := (
others => ’0’);
72 signal FIN : std_logic := ’0’;
73
74 ------------------------------------
75 -- ENTRADAS
76 ------------------------------------
77 signal R_rx : std_logic_vector (7 downto 0);
78 signal G_rx : std_logic_vector (7 downto 0);
79 signal B_rx : std_logic_vector (7 downto 0);
80 signal dataRGB_rx : std_logic_vector (23 downto 0);
81 signal rx_vid_h_sync : std_logic;
82 signal rx_vid_v_sync : std_logic;
83 signal rx_vid_dataEnable : std_logic;
84 signal rx_overflow : std_logic;
85
86 ------------------------------------
87 -- SALIDAS
88 ------------------------------------
89 signal R_tx : std_logic_vector (7 downto
0);
90 signal G_tx : std_logic_vector (7 downto
0);
91 signal B_tx : std_logic_vector (7 downto
0);
92 signal dataRGB_tx : std_logic_vector (23 downto 0);
93 signal tx_vid_h_sync : std_logic;
94 signal tx_vid_v_sync : std_logic;
95 signal tx_vid_dataEnable : std_logic;
93
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
96 signal tx_vid_h : std_logic;
97 signal tx_vid_v : std_logic;
98 signal tx_vid_mode_change : std_logic;
99 signal tx_vid_std : std_logic;
100 signal tx_underflow : std_logic;
101
102 ------------------------------------
103 -- TESTBENCH CONFIG
104 ------------------------------------
105 constant TCLK_50 : time := 20.000 ns;
106 constant TCLK_148_5 : time := 6.734 ns;
107 -- PIC SIZE
108 constant PIC_WIDTH : std_logic_vector (11 downto 0) := x"A50";
--2640
109 constant PIC_HEIGHT : std_logic_vector (11 downto 0) := x"465";
--1125
110 -- VERTICAL OUT SYNC
111 constant VS_START : std_logic_vector (11 downto 0) := x"004";
-- 4
112 constant VS_STOP : std_logic_vector (11 downto 0) := x"009";
-- 9
113 constant V_NADA : std_logic_vector (11 downto 0) := x"02D";
-- 45
114 -- HORIZONTAL OUT SYNC
115 constant HS_START : std_logic_vector (11 downto 0) := x"210";
--1
116 constant HS_STOP : std_logic_vector (11 downto 0) := x"23C";
--14h
117 constant H_NADA : std_logic_vector (11 downto 0) := x"2D0";
-- 720 -- 280
118 -- ACTIVE IN SIZE
119 signal ACTIVE_W : std_logic_vector (31 downto 0) := x
"00000780"; --1920
120 signal ACTIVE_H : std_logic_vector (31 downto 0) := x
"00000438"; --1080
121 -- ACTIVE OUT SIZE
122 signal ACTIVE_W_OUT : std_logic_vector (31 downto 0) := x
"00000780"; --1920
123 signal ACTIVE_H_OUT : std_logic_vector (31 downto 0) := x
"000004 B0"; --1200
124
125 begin
126
94
Universidad Politecnica de Madrid
127 VIP_SYS_inst : component VIP_SYS_tb_VIP_SYS_inst
128 port map ( clk_1 =>
basico_inst_clk_1_clk_in_bfm_clk_clk , -- clk_1_clk_in.
clk
129 vid_data_to_the_cvi => dataRGB_rx ,
-- cvi_clocked_video.
vid_data
130 overflow_from_the_cvi => rx_overflow ,
-- .
overflow
131 vid_datavalid_to_the_cvi => rx_vid_dataEnable ,
-- .
vid_datavalid
132 vid_locked_to_the_cvi => ’1’,
--
.vid_locked
133 vid_v_sync_to_the_cvi => rx_vid_v_sync ,
-- .
vid_v_sync
134 vid_h_sync_to_the_cvi => rx_vid_h_sync ,
-- .
vid_h_sync
135 vid_f_to_the_cvi => ’0’,
--
.vid_f
136 clk_0 =>
basico_inst_clk_0_clk_in_bfm_clk_clk , --
clk_0_clk_in.clk
137 reset_reset_n =>
basico_inst_reset_bfm_reset_reset , --
reset.reset_n
138 vid_data_from_the_cvo => dataRGB_tx ,
-- cvo_clocked_video.
vid_data
139 underflow_from_the_cvo => tx_underflow ,
-- .
underflow
140 vid_datavalid_from_the_cvo => tx_vid_dataEnable ,
-- .
vid_datavalid
141 vid_v_sync_from_the_cvo => tx_vid_v_sync ,
-- .
vid_v_sync
95
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
142 vid_h_sync_from_the_cvo => tx_vid_h_sync ,
-- .
vid_h_sync
143 vid_f_from_the_cvo => open ,
--
.vid_f
144 vid_h_from_the_cvo => tx_vid_h ,
-- .
vid_h
145 vid_v_from_the_cvo => tx_vid_v);
-- .
vid_v
146
147 basico_inst_clk_1_clk_in_bfm : component
altera_avalon_clock_source
148 generic map ( CLOCK_RATE => 148)
149 port map ( clk => basico_inst_clk_1_clk_in_bfm_clk_clk); --
clk.clk
150
151 basico_inst_clk_0_clk_in_bfm : component
altera_avalon_clock_source
152 generic map ( CLOCK_RATE => 50)
153 port map ( clk => basico_inst_clk_0_clk_in_bfm_clk_clk); --
clk.clk
154
155 basico_inst_reset_bfm : component altera_avalon_reset_source
156 generic map ( ASSERT_HIGH_RESET => 0,
157 INITIAL_RESET_CYCLES => 50)
158 port map ( reset => basico_inst_reset_bfm_reset_reset , --
reset.reset_n
159 clk => basico_inst_clk_1_clk_in_bfm_clk_clk); --
clk.clk
160
161 ------------------------------------
162 -- PROCESO PRINCIPAL
163 ------------------------------------
164 process
165 begin
166 ReadBMP (" entrada.bmp");
167 SetWidthHeigth(ACTIVE_W_OUT ,ACTIVE_H_OUT);
168 report "Procesando ...";
169 wait until FIN = ’1’;
170 WriteBMP (" salida.bmp");
96
Universidad Politecnica de Madrid
171 report "Simulacion Completada ";
172 wait;
173 end process;
174 -------------------------------------------
175 -- CONTADOR DE ENTRADA
176 ------------------------------------------
177 process(clk_148_5 , reset_n)
178 begin
179 if(reset_n = ’0’) then
180 cnt_row <= (others => ’0’);
181 cnt_col <= (others => ’0’);
182 cnt_data <= (others => ’0’);
183 elsif(clk_148_5 ’event and clk_148_5 = ’1’) then
184 if(rx_vid_dataEnable = ’1’) then
185 if(cnt_col_in = ACTIVE_W -1) then
186 cnt_col_in <= (others => ’0’);
187 if(cnt_row_in = ACTIVE_H -1) then
188 cnt_row_in <= (others => ’0’);
189 else
190 cnt_row_in <= cnt_row_in + ’1’;
191 end if;
192 else
193 cnt_col_in <= cnt_col_in + ’1’;
194 end if;
195 end if;
196
197 if(cnt_col = PIC_WIDTH -1) then
198 cnt_col <= (others => ’0’);
199 if(cnt_row = PIC_HEIGHT -1) then
200 cnt_row <= (others => ’0’);
201 else
202 cnt_row <= cnt_row + ’1’;
203 end if;
204 else
205 cnt_col <= cnt_col + ’1’;
206 end if;
207 GetPixel(conv_integer(cnt_col_in),conv_integer(cnt_row_in),
dataRGB_rx);
208 end if;
209 end process;
210
211 ---------------------------------------
212 -- GENERADOR DE VIDEO
97
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
213 ---------------------------------------
214 rx_vid_v_sync <= ’1’ after 1 ns when cnt_row >= VS_START and
cnt_row <= VS_STOP else ’0’ after 1 ns;
215 rx_vid_h_sync <= ’1’ after 1 ns when cnt_col >= HS_START and
cnt_col <= HS_STOP else ’0’ after 1 ns;
216 rx_vid_dataEnable <= ’1’ after 1 ns when cnt_col >= H_NADA and
cnt_col < H_NADA+ACTIVE_W and cnt_row >= V_NADA else ’0’
after 1 ns;
217 ---------------------------------------
218 -- CONTADOR DE SALIDA
219 ---------------------------------------
220 process(clk_148_5 , reset_n)
221 begin
222 if(reset_n = ’0’) then
223 cnt_row_out <= (others => ’0’);
224 cnt_col_out <= (others => ’0’);
225 elsif(now > 20000000 ps and clk_148_5 ’event and clk_148_5 =
’1’) then
226 if(tx_vid_dataEnable = ’1’) then
227 if(cnt_col_out = ACTIVE_W_OUT -1) then
228 cnt_col_out <= (others => ’0’);
229 if(cnt_row_out = ACTIVE_H_OUT -1) then
230 cnt_row_out <= (others => ’0’);
231 else
232 cnt_row_out <= cnt_row_out + ’1’;
233 end if;
234 else
235 cnt_col_out <= cnt_col_out + ’1’;
236 end if;
237 SetPixel(conv_integer(cnt_col_out),conv_integer(cnt_row_out),
dataRGB_tx);
238 end if;
239 end if;
240 end process;
241 FIN <= ’1’ after 1 ns when cnt_col_out = ACTIVE_W_OUT -1 and
cnt_row_out = ACTIVE_H_OUT -1 else ’0’ after 1 ns;
242
243 ------------------------------------
244 -- RELOJES Y RESET
245 ------------------------------------
246 clk_148_5 <= basico_inst_clk_1_clk_in_bfm_clk_clk;
247 clk_50 <= basico_inst_clk_0_clk_in_bfm_clk_clk;
248 reset_n <= basico_inst_reset_bfm_reset_reset;
98
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
D.4. Testbench con multiples BMP
1 ------------------------------------------------------
2 -- Nombre: VIP_SYS_tb_multiple.vhd
3 -- Autor: David Cervantes Caballero
4 -- Fecha: Mayo 2017
5 -- Descripcion:
6 -- Test del formateador SbS2xyz con varias imagenes.
7 ------------------------------------------------------
8 library IEEE;
9 use IEEE.std_logic_1164.all;
10 use IEEE.numeric_std.all;
11 use ieee.std_logic_unsigned.all;
12 use work.bmp_pack.all;
13
14 entity VIP_SYS_tb is
15 end entity VIP_SYS_tb;
16
17 architecture rtl of VIP_SYS_tb is
18 component VIP_SYS_tb_VIP_SYS_inst is
19 port ( clk_1 : in std_logic
:= ’X’; -- clk
20 vid_data_to_the_cvi : in std_logic_vector (23
downto 0) := (others => ’X’); -- vid_data
21 overflow_from_the_cvi : out std_logic;
-- overflow
22 vid_datavalid_to_the_cvi : in std_logic
:= ’X’; --
vid_datavalid
23 vid_locked_to_the_cvi : in std_logic
:= ’X’; -- vid_locked
24 vid_v_sync_to_the_cvi : in std_logic
:= ’X’; -- vid_v_sync
25 vid_h_sync_to_the_cvi : in std_logic
:= ’X’; -- vid_h_sync
26 vid_f_to_the_cvi : in std_logic
:= ’X’; -- vid_f
27 clk_0 : in std_logic
:= ’X’; -- clk
28 reset_reset_n : in std_logic
:= ’X’; -- reset_n
100
Universidad Politecnica de Madrid
29 vid_data_from_the_cvo : out std_logic_vector (23
downto 0); -- vid_data
30 underflow_from_the_cvo : out std_logic;
-- underflow
31 vid_datavalid_from_the_cvo : out std_logic;
--
vid_datavalid
32 vid_v_sync_from_the_cvo : out std_logic;
-- vid_v_sync
33 vid_h_sync_from_the_cvo : out std_logic;
-- vid_h_sync
34 vid_f_from_the_cvo : out std_logic;
-- vid_f
35 vid_h_from_the_cvo : out std_logic;
-- vid_h
36 vid_v_from_the_cvo : out std_logic);
-- vid_v
37 end component VIP_SYS_tb_VIP_SYS_inst;
38
39 component altera_avalon_clock_source is
40 generic ( CLOCK_RATE : positive := 10);
41 port ( clk : out std_logic); --clk
42 end component altera_avalon_clock_source;
43
44 component altera_avalon_reset_source is
45 generic ( ASSERT_HIGH_RESET : integer := 1;
46 INITIAL_RESET_CYCLES : integer := 0);
47 port ( reset : out std_logic; -- reset_n
48 clk : in std_logic := ’X’); --clk
49 end component altera_avalon_reset_source;
50
51 ------------------------------------
52 -- RELOJES Y RESET
53 ------------------------------------
54 signal basico_inst_clk_1_clk_in_bfm_clk_clk : std_logic;
55 signal basico_inst_clk_0_clk_in_bfm_clk_clk : std_logic;
56 signal basico_inst_reset_bfm_reset_reset : std_logic;
57
58 signal reset_n : std_logic;
59 signal clk_50 : std_logic;
60 signal clk_148_5 : std_logic :=’0’;
61
62 ------------------------------------
101
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
63 -- CONTADORES
64 ------------------------------------
65 signal cnt_row : std_logic_vector (11 downto 0) := (
others => ’0’);
66 signal cnt_col : std_logic_vector (11 downto 0) := (
others => ’0’);
67 signal cnt_data : std_logic_vector (11 downto 0) := (
others => ’0’);
68 signal cnt_row_in : std_logic_vector (11 downto 0) := (
others => ’0’);
69 signal cnt_col_in : std_logic_vector (11 downto 0) := (
others => ’0’);
70 signal cnt_row_out : std_logic_vector (11 downto 0) := (
others => ’0’);
71 signal cnt_col_out : std_logic_vector (11 downto 0) := (
others => ’0’);
72 signal FIN : std_logic := ’0’;
73
74 ------------------------------------
75 -- ENTRADAS
76 ------------------------------------
77 signal R_rx : std_logic_vector (7 downto 0);
78 signal G_rx : std_logic_vector (7 downto 0);
79 signal B_rx : std_logic_vector (7 downto 0);
80 signal dataRGB_rx : std_logic_vector (23 downto 0);
81 signal rx_vid_h_sync : std_logic;
82 signal rx_vid_v_sync : std_logic;
83 signal rx_vid_dataEnable : std_logic;
84 signal rx_overflow : std_logic;
85
86 ------------------------------------
87 -- SALIDAS
88 ------------------------------------
89 signal R_tx : std_logic_vector (7 downto
0);
90 signal G_tx : std_logic_vector (7 downto
0);
91 signal B_tx : std_logic_vector (7 downto
0);
92 signal dataRGB_tx : std_logic_vector (23 downto 0);
93 signal tx_vid_h_sync : std_logic;
94 signal tx_vid_v_sync : std_logic;
95 signal tx_vid_dataEnable : std_logic;
102
Universidad Politecnica de Madrid
96 signal tx_vid_h : std_logic;
97 signal tx_vid_v : std_logic;
98 signal tx_vid_mode_change : std_logic;
99 signal tx_vid_std : std_logic;
100 signal tx_underflow : std_logic;
101
102 ------------------------------------
103 -- TESTBENCH CONFIG
104 ------------------------------------
105 constant TCLK_50 : time := 20.000 ns;
106 constant TCLK_148_5 : time := 6.734 ns;
107 -- PIC SIZE
108 constant PIC_WIDTH : std_logic_vector (11 downto 0) := x"A50";
--2640
109 constant PIC_HEIGHT : std_logic_vector (11 downto 0) := x"465";
--1125
110 -- VERTICAL OUT SYNC
111 constant VS_START : std_logic_vector (11 downto 0) := x"004";
-- 4
112 constant VS_STOP : std_logic_vector (11 downto 0) := x"009";
-- 9
113 constant V_NADA : std_logic_vector (11 downto 0) := x"02D";
-- 45
114 -- HORIZONTAL OUT SYNC
115 constant HS_START : std_logic_vector (11 downto 0) := x"210";
--1
116 constant HS_STOP : std_logic_vector (11 downto 0) := x"23C";
--14h
117 constant H_NADA : std_logic_vector (11 downto 0) := x"2D0";
-- 720 -- 280
118 -- ACTIVE IN SIZE
119 signal ACTIVE_W : std_logic_vector (31 downto 0) := x
"00000780"; --1920
120 signal ACTIVE_H : std_logic_vector (31 downto 0) := x
"00000438"; --1080
121 -- ACTIVE OUT SIZE
122 signal ACTIVE_W_OUT : std_logic_vector (31 downto 0) := x
"00000780"; --1920
123 signal ACTIVE_H_OUT : std_logic_vector (31 downto 0) := x
"000004 B0"; --1200
124
125 begin
126
103
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
127 VIP_SYS_inst : component VIP_SYS_tb_VIP_SYS_inst
128 port map ( clk_1 =>
basico_inst_clk_1_clk_in_bfm_clk_clk , -- clk_1_clk_in.
clk
129 vid_data_to_the_cvi => dataRGB_rx ,
-- cvi_clocked_video.
vid_data
130 overflow_from_the_cvi => rx_overflow ,
-- .
overflow
131 vid_datavalid_to_the_cvi => rx_vid_dataEnable ,
-- .
vid_datavalid
132 vid_locked_to_the_cvi => ’1’,
--
.vid_locked
133 vid_v_sync_to_the_cvi => rx_vid_v_sync ,
-- .
vid_v_sync
134 vid_h_sync_to_the_cvi => rx_vid_h_sync ,
-- .
vid_h_sync
135 vid_f_to_the_cvi => ’0’,
--
.vid_f
136 clk_0 =>
basico_inst_clk_0_clk_in_bfm_clk_clk , --
clk_0_clk_in.clk
137 reset_reset_n =>
basico_inst_reset_bfm_reset_reset , --
reset.reset_n
138 vid_data_from_the_cvo => dataRGB_tx ,
-- cvo_clocked_video.
vid_data
139 underflow_from_the_cvo => tx_underflow ,
-- .
underflow
140 vid_datavalid_from_the_cvo => tx_vid_dataEnable ,
-- .
vid_datavalid
141 vid_v_sync_from_the_cvo => tx_vid_v_sync ,
-- .
vid_v_sync
104
Universidad Politecnica de Madrid
142 vid_h_sync_from_the_cvo => tx_vid_h_sync ,
-- .
vid_h_sync
143 vid_f_from_the_cvo => open ,
--
.vid_f
144 vid_h_from_the_cvo => tx_vid_h ,
-- .
vid_h
145 vid_v_from_the_cvo => tx_vid_v);
-- .
vid_v
146
147 basico_inst_clk_1_clk_in_bfm : component
altera_avalon_clock_source
148 generic map ( CLOCK_RATE => 148)
149 port map ( clk => basico_inst_clk_1_clk_in_bfm_clk_clk); --
clk.clk
150
151 basico_inst_clk_0_clk_in_bfm : component
altera_avalon_clock_source
152 generic map ( CLOCK_RATE => 50)
153 port map ( clk => basico_inst_clk_0_clk_in_bfm_clk_clk); --
clk.clk
154
155 basico_inst_reset_bfm : component altera_avalon_reset_source
156 generic map ( ASSERT_HIGH_RESET => 0,
157 INITIAL_RESET_CYCLES => 50)
158 port map ( reset => basico_inst_reset_bfm_reset_reset , --
reset.reset_n
159 clk => basico_inst_clk_1_clk_in_bfm_clk_clk); --
clk.clk
160
161 ------------------------------------
162 -- PROCESO PRINCIPAL
163 ------------------------------------
164 process
165 begin
166 ReadBMP (" entrada1.bmp");
167 SetWidthHeigth(ACTIVE_W_OUT ,ACTIVE_H_OUT);
168 report "Procesando imagen 1...";
169 wait until FIN = ’1’;
170 WriteBMP (" salida1.bmp");
105
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
171
172 wait for 100 ns;
173
174 ReadBMP (" entrada2.bmp");
175 SetWidthHeigth(ACTIVE_W_OUT ,ACTIVE_H_OUT);
176 report "Procesando imagen 2...";
177 wait until FIN = ’1’;
178 WriteBMP (" salida2.bmp");
179
180 wait for 100 ns;
181
182 ReadBMP (" entrada3.bmp");
183 SetWidthHeigth(ACTIVE_W_OUT ,ACTIVE_H_OUT);
184 report "Procesando imagen 3...";
185 wait until FIN = ’1’;
186 WriteBMP (" salida3.bmp");
187
188 wait for 100 ns;
189
190 ReadBMP (" entrada4.bmp");
191 SetWidthHeigth(ACTIVE_W_OUT ,ACTIVE_H_OUT);
192 report "Procesando imagen 4...";
193 wait until FIN = ’1’;
194 WriteBMP (" salida4.bmp");
195
196 wait for 100 ns;
197
198 ReadBMP (" entrada5.bmp");
199 SetWidthHeigth(ACTIVE_W_OUT ,ACTIVE_H_OUT);
200 report "Procesando imagen 5...";
201 wait until FIN = ’1’;
202 WriteBMP (" salida5.bmp");
203
204 report "Simulacion Completada ";
205 wait;
206 end process;
207 --------------------------------------------
208 -- CONTADOR DE ENTRADA
209 -------------------------------------------
210 process(clk_148_5 , reset_n)
211 begin
212 if(reset_n = ’0’) then
213 cnt_row <= (others => ’0’);
106
Universidad Politecnica de Madrid
214 cnt_col <= (others => ’0’);
215 cnt_data <= (others => ’0’);
216 elsif(clk_148_5 ’event and clk_148_5 = ’1’) then
217 if(rx_vid_dataEnable = ’1’) then
218 if(cnt_col_in = ACTIVE_W -1) then
219 cnt_col_in <= (others => ’0’);
220 if(cnt_row_in = ACTIVE_H -1) then
221 cnt_row_in <= (others => ’0’);
222 else
223 cnt_row_in <= cnt_row_in + ’1’;
224 end if;
225 else
226 cnt_col_in <= cnt_col_in + ’1’;
227 end if;
228 end if;
229
230 if(cnt_col = PIC_WIDTH -1) then
231 cnt_col <= (others => ’0’);
232 if(cnt_row = PIC_HEIGHT -1) then
233 cnt_row <= (others => ’0’);
234 else
235 cnt_row <= cnt_row + ’1’;
236 end if;
237 else
238 cnt_col <= cnt_col + ’1’;
239 end if;
240 GetPixel(conv_integer(cnt_col_in),conv_integer(cnt_row_in),
dataRGB_rx);
241 end if;
242 end process;
243
244 ----------------------------------------
245 -- GENERADOR DE VIDEO
246 ----------------------------------------
247 rx_vid_v_sync <= ’1’ after 1 ns when cnt_row >= VS_START and
cnt_row <= VS_STOP else ’0’ after 1 ns;
248 rx_vid_h_sync <= ’1’ after 1 ns when cnt_col >= HS_START and
cnt_col <= HS_STOP else ’0’ after 1 ns;
249 rx_vid_dataEnable <= ’1’ after 1 ns when cnt_col >= H_NADA and
cnt_col < H_NADA+ACTIVE_W and cnt_row >= V_NADA else ’0’
after 1 ns;
250 ---------------------------------------
251 -- CONTADOR DE SALIDA
107
Diseno y test VHDL de un cambiador de formato side by side HD a xyZ
252 ---------------------------------------
253 process(clk_148_5 , reset_n)
254 begin
255 if(reset_n = ’0’) then
256 cnt_row_out <= (others => ’0’);
257 cnt_col_out <= (others => ’0’);
258 elsif(now > 20000000 ps and clk_148_5 ’event and clk_148_5 =
’1’) then
259 if(tx_vid_dataEnable = ’1’) then
260 if(cnt_col_out = ACTIVE_W_OUT -1) then
261 cnt_col_out <= (others => ’0’);
262 if(cnt_row_out = ACTIVE_H_OUT -1) then
263 cnt_row_out <= (others => ’0’);
264 else
265 cnt_row_out <= cnt_row_out + ’1’;
266 end if;
267 else
268 cnt_col_out <= cnt_col_out + ’1’;
269 end if;
270 SetPixel(conv_integer(cnt_col_out),conv_integer(cnt_row_out),
dataRGB_tx);
271 end if;
272 end if;
273 end process;
274 FIN <= ’1’ after 1 ns when cnt_col_out = ACTIVE_W_OUT -1 and
cnt_row_out = ACTIVE_H_OUT -1 else ’0’ after 1 ns;
275
276 ------------------------------------
277 -- RELOJES Y RESET
278 ------------------------------------
279 clk_148_5 <= basico_inst_clk_1_clk_in_bfm_clk_clk;
280 clk_50 <= basico_inst_clk_0_clk_in_bfm_clk_clk;
281 reset_n <= basico_inst_reset_bfm_reset_reset;
282
283 end architecture rtl;
108