PROYECTO FIN DE CARRERA PLAN 2000 - Archivo Digital...

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


Fernando Pescador del Oso


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

Diseno y test VHDL de un cambiador de formato side by side HD a xyZ

ii

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


iv

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


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


viii

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


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


xii

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


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


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


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


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


• 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


6

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


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


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


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


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


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


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


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


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


16

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


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


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


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


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


22

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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


[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


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


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


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


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


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:


157 break;

158 case 2:


160 break;

161 case 3:


163 break;

164 case 4:


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


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


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


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


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


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


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


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


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


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


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


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



columnas ];

403 }

404 }

405 if((columnas >= COLUMNAS_L)&&( columnas <=( COLUMNAS_L

*2) -1))

406 {

407 x=columnas -COLUMNAS_L;

408


410 RGB_by_view[filas ][x][1]= RGB[filas ][

columnas ];

411 if((filas >= FILAS_L /3) &&(filas <=(( FILAS_L /3)

*2) -1))

412 {


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;


];

420 }

421 }

422 if((columnas >= COLUMNAS_L *2) &&( columnas <=(

COLUMNAS_L *3) -1))

423 {

424 x=columnas -COLUMNAS_L *2;

425



columnas ];

428 if((filas >= FILAS_L /3) &&(filas <=( FILAS_L /3*2)

-1))

429 {



];

432 }

433 }

57


434 }

435 }

436

437 break;

438 case 2: //2x4

439


441 {


443 {

444 if((columnas >=0) &&( columnas <= ancho_vista *3-1))

445 {

446 if((filas >=0) &&(filas <= altura_vista -1))


][ columnas ];

448 if((filas >= altura_vista)&&(filas <=

altura_vista *2-1))

449 {

450 y=filas -altura_vista;


columnas ];

452 }

453 if((filas >= altura_vista *2) &&(filas <=

altura_vista *3-1))

454 {

455 y=filas -altura_vista *2;


columnas ];

457 }

458 if((filas >= altura_vista *3) &&(filas <=FILAS_L

-1))

459 {



columnas ];

462 }

463 }

464 if((columnas >= ancho_vista *3) &&( columnas <=(

COLUMNAS_L *3) -1))

465 {

466 x=columnas -ancho_vista *3;

467


58



columnas ];


altura_vista *2-1))

471 {



];

474 }

475 if((filas >= altura_vista *2) &&(filas <=

altura_vista *3-1))

476 {



];

479 }


-1))

481 {



];

484 }

485 }

486 }

487 }

488

489 break;

490 case 3: //8T

491


493 {


495 {

496 if((columnas >=0) &&( columnas <= ancho_vista *3-1))

497 {



][ columnas ];


altura_vista *2-1))

501 {


59



columnas ];

504 }


-1))

506 {

507 y=filas -( altura_vista *2)+(( FILAS_L -

altura_vista *2) /2);


columnas ];

509 }

510 }

511 if((columnas >= ancho_vista *3) &&( columnas <=

ancho_vista *3*2 -1))

512 {

513 x=columnas -ancho_vista *3;

514



columnas ];


altura_vista *2-1))

518 {



];

521 }

522 if((filas >= altura_vista *2) &&(filas <=(

altura_vista *2+(( FILAS_L -altura_vista *2)

/2)) -1))

523 {



];

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);


];

60


531 }

532 }

533 if((columnas >= ancho_vista *3*2) &&( columnas <=

COLUMNAS_L *3-1))

534 {

535 x=columnas -ancho_vista *3*2;

536



columnas ];


altura_vista *2-1))

540 {



];

543 }


-1))

545 {



];

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


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


597 RGB[y][x*3] = RGB_by_view[yvista ][ xvista *3][ viewID ];

598 // Calculo de procedencia de componente Green (1) del




600 RGB[y][x*3+1] = RGB_by_view[yvista ][ xvista *3+1][

viewID ];

601 // Calculo de procedencia de componente Blue (2) del





viewID ];*/

604

605 // Calculo de procedencia de componente Red (0) del


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





viewID ];

615 // Calculo de procedencia de componente Blue (2) del





viewID ];

618 }

619 }

620 fclose(report);

621 }

622

623 /*

624 Funcion : void RGB_to_YUV(void)

63


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


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 ][


>> 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


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


675 {

676 fwrite (& luminancia[filas ][0], sizeof(char),COLUMNAS_L ,

videoOUT);

677 }


679 {

680 fwrite (& c_azul[filas ][0], sizeof(char),COLUMNAS_C ,videoOUT

);

681 }


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


66

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


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


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 ();


74 break;

69


75 case 2:

76 sidebyside2xyz ();

77 RGB_to_YUV ();


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


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


129 {

130 fread (& c_azul[filas ][0], sizeof(char),COLUMNAS_SBS /2,

videoIN);

131 }

132

133 // crominancia roja


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


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


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


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


filas ][ columnas *3 + (COLUMNAS_SBS /2)*3

+ 1]; // GREEN


filas ][ columnas *3 + 2]; //BLUE

195

72


196 RGB[filas *3+1][ columnas *9 + 0] = RGB_SBS[

filas][ columnas *3 + (COLUMNAS_SBS /2)*3

+ 0];// RED


filas][ columnas *3 + 1]; // GREEN



+2];

199


filas][ columnas *3 + 0];// RED



+ 1 ]; //GREEN


filas][ columnas *3 + 2]; //BLUE

203

204 RGB[filas *3][ columnas *9+3 + 0] = RGB_SBS[


+ 0];// RED


filas][ columnas *3 + 1];// GREEN



+ 2];

207

208 RGB[filas *3+1][ columnas *9+3 + 0] =

RGB_SBS[filas][ columnas *3 + 0];// RED


RGB_SBS[filas][ columnas *3 + (

COLUMNAS_SBS /2)*3 + 1 ];// GREEN


RGB_SBS[filas][ columnas *3 + 2]; //BLUE

211



COLUMNAS_SBS /2)*3 + 0];// RED


RGB_SBS[filas][ columnas *3 + 1]; //

GREEN



COLUMNAS_SBS /2)*3 + 2];

73


215

216


filas ][ columnas *3 + 0];// RED



+ 1]; // GREEN


filas ][ columnas *3 + 2]; //BLUE

220



COLUMNAS_SBS /2)*3 + 0];// RED



GREEN



COLUMNAS_SBS /2)*3 +2];

224





COLUMNAS_SBS /2)*3 + 1 ]; // GREEN



228 }

229 else{

230



+ 0];// RED


filas ][ columnas *3 + 1]; //GREEN



+ 2];

234


filas ][ columnas *3 + 0];// RED

74




+ 1 ];// GREEN



238



+ 0];// RED


filas][ columnas *3 + 1]; // GREEN



+ 2];

242

243


filas][ columnas *3 + 0];// RED



+ 1 ]; //GREEN



247



COLUMNAS_SBS /2)*3 + 0]; //RED



GREEN




251








255

256

75




+ 0]; //RED


filas ][ columnas *3 + 1]; //GREEN



+ 2];

260


RGB_SBS[filas][ columnas *3 + 0]; //RED






264



COLUMNAS_SBS /2)*3 + 0]; //RED



GREEN




268

269 }

270

271

272

273 }

274 }

275 }

276

277 void sbs3x3 ()

278 {

279 int filas;

280 int columnas;

281


283 {

284 for(columnas =0; columnas <( COLUMNAS_SBS /2);columnas ++)

76


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 ];


/2 + 1] = RGB_SBS[filas ][3* columnas + 1];


/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



+ 1] = RGB_SBS[filas ][3* columnas + 3*

COLUMNAS_SBS /2 + 1];


+ 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];


COLUMNAS_SBS /2 + 1] = RGB_SBS[filas][ columnas *3

+ 3* COLUMNAS_SBS /2 + 1];


COLUMNAS_SBS /2 + 2] = RGB_SBS[filas][ columnas *3

+ 3* COLUMNAS_SBS /2 + 2];

321


COLUMNAS_SBS] = RGB_SBS[filas][ columnas *3];


COLUMNAS_SBS + 1] = RGB_SBS[filas][ columnas *3 +

1];


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


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 ][


>> 8) + 16;

344 U = (( -38 * RGB[filas ][ columnas] - 74 * RGB[filas ][


>> 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


371 */

372 void escribirImagenYUV(FILE * videoOUT)

373 {

374 int filas;

375


377 fwrite (& luminancia_S[filas ][0], sizeof(char),COLUMNAS ,

videoOUT);


379 fwrite (& c_azul_S[filas ][0], sizeof(char),COLUMNAS/2,

videoOUT);


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


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


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


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


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


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


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’;


159 out_sop <= ’1’;

160 out_eop <= ’0’;

161 bf_out_data <= x"00000F";

162 when pkg1 =>

163 s_data_out <= ’0’;


165 out_sop <= ’0’;

166 out_eop <= ’0’;

167 bf_out_data <= x"080700";

168 when pkg2 =>

169 s_data_out <= ’0’;


171 out_sop <= ’0’;

172 out_eop <= ’0’;

173 bf_out_data <= x"040000";

174 when pkg3 =>

175 s_data_out <= ’0’;


177 out_sop <= ’0’;

178 out_eop <= ’1’;

179 bf_out_data <= x"02000B";

180 when wait_data =>

181 s_data_out <= ’0’;


183 out_sop <= ’0’;

184 out_eop <= ’0’;

185 bf_out_data <= x"000000";

186 when id_data =>

187 s_data_out <= ’1’;


189 out_sop <= ’1’;

190 out_eop <= ’0’;

87


191 bf_out_data <= x"000000";

192 when pkg_data =>


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


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


D.3. Testbench con un solo BMP

1 ------------------------------------------------------

2 -- Nombre: VIP_SYS_tb.vhd



5 -- Descripcion:

6 -- Test del formateador SbS2xyz con una sola imagen.

7 ------------------------------------------------------

8 library IEEE;




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


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;


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


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


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


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


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





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


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


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 ---------------------------------------


221 begin


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


229 if(cnt_row_out = ACTIVE_H_OUT -1) then


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 ------------------------------------


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


249

250 end architecture rtl;

99


D.4. Testbench con multiples BMP

1 ------------------------------------------------------

2 -- Nombre: VIP_SYS_tb_multiple.vhd



5 -- Descripcion:

6 -- Test del formateador SbS2xyz con varias imagenes.

7 ------------------------------------------------------

8 library IEEE;




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


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 ------------------------------------


53 ------------------------------------



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


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


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


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


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





clk.clk

150





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");


168 report "Procesando imagen 1...";


170 WriteBMP (" salida1.bmp");

105


171

172 wait for 100 ns;

173






179


181






187


189






195


197






203

204 report "Simulacion Completada ";

205 wait;

206 end process;

207 --------------------------------------------

208 -- CONTADOR DE ENTRADA

209 -------------------------------------------


211 begin


213 cnt_row <= (others => ’0’);

106


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


252 ---------------------------------------


254 begin




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


262 if(cnt_row_out = ACTIVE_H_OUT -1) then


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 ------------------------------------


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

PROYECTO FIN DE CARRERA PLAN 2000 - Archivo Digital...

Documents

Transcript of PROYECTO FIN DE CARRERA PLAN 2000 - Archivo Digital...