14.5 Video processing part 3: memory management

Introduction

In this project, you will learn how to combine the use of the external and internal memory systems of the IDK, as well as how to use the TI-supplied library functions. It may seem daunting, but fear not, there are only a few commands to learn. The key is to know how to use them well.

The project assignment will involve copying a portion of the input image and displaying it in a different area of the screen. The area copied to should be quickly and easily adjustable in the code. In addition to this, we will filter this copied portion and display it as well.

And you must refer to the following TI manuals available on the class website under the Projects section. The sections mentioned in Video Processing Lab 1 are also important.

• IDK Video Device Drivers User's Guide The Display and Capture systems are important – the figures on pages 2-7 and 3-8 are useful too.
• IDK Programmer's Guide . Sections 2 and 5 are the ones needed. Section 2 is very important here. Keep a printout if necessary, it is useful as a reference.

Memory - the basics

As explained in the previous lab, there are two sections of memory, internal and external. The internal is small but fast, whereas the external is large but slow. An estimate of the sizes: 25K for the internal, 16M for the external, in bytes.

As seen earlier, this necessitates a system of transferring memory contents between the two memory systems. For example, an input color screen is in YCbCr format. This consists of 640 X 480 pixels with 8 bits per pixel. This results in 300 Kbytes, which cannot be stored in internal memory. This same problem applies for the output buffer.

Thus it is best to use the external memory for storage of large chunks of data, and the internal memory for processing of smaller chunks. An example of this, as seen in the previous lab, was color conversion. In that system, we brought in the input frame line-by-line into internal memory. We then converted the color space and stored the results in internal memory as well. Following this, we transferred the results to external memory.

This is the basic overview of the need for the two memory systems. Next we will discuss the setup and use of memory spaces, explaining the workings of the color conversion program

Memory - setup

Firstly, please copy the directory below to your account so you can follow the code as we go along.

V:\ece320\projects\colorcool

The program in this directory is a basic color conversion program which outputs the input frame to the display.

Allocating memory space

The first step in using memory is to declare it, i.e. tell the compiler to setup some space for it. This is done at the very beginning of the ‘main.c’ file.

• 1. Declare the type of memory space and it’s name. Use the #pragma DATA_SECTION command. There are two parameters :
  • a) the name of the memory spaces
  • b) and the type – internal or external
• 2. Then specify the byte alignment using the #pragma DATA_ALIGN command. This is similar to the byte alignment in the C54x. So, to store black and white images, you would use 8 bits. But for RGB, you would use 16 bits. // specifies name of mem space – ext_mem // and type as internal memory – ".image:ext_sect" // the data_align specification is the byte alignment – ours is // 8 bits #pragma DATA_SECTION(ext_mem,".image:ext_sect"); #pragma DATA_ALIGN(ext_mem,8); // specifies name of mem space – int_mem // and type as internal memory – ".image:int_sect" // the data_align specification is the byte alignment – ours is // 8 bits #pragma DATA_SECTION(int_mem,".chip_image:int_sect"); #pragma DATA_ALIGN(int_mem, 16);
• We then specify the size of the memory space. We use a variable for the basic unit size (e.g. unsigned char for 1 byte) and a length for the number of basic units needed. Please note, the memory space is not delineated by ‘image’ rows or columns, The system thinks it is one long array of data, it is up to us to process this as separate lines of ‘image’ data. // specify size as width 640 // height 480 // and 8 bytes per pixel // which could represent an RGB screen of 640 X 480 with // 2 bytes per pixel. Unsigned char = 8 bytes unsigned char ext_mem[640 * 480 * 2]; // here we create 6 lines of RGB data of 640 columns each, // 2 bytes per pixel unsigned char int_mem[6 * 2 * 640];