OCTANE Compression has two independent JPEG codecs. When an application opens a compressor or decompressor, one of these codecs is allocated to the application.

The control CL_IMPACT_VIDEO_INPUT_CONTROL is used by the application to determine which codec was allocated; when CL_EXTERNAL_DEVICE is used, it specifies the CL_CODEC node to be used by the VL.

Values for this control are CL_IMPACT_VIDEO_CHANNEL0 and CL_IMPACT_VIDEO_CHANNEL1; they depend upon which codec was allocated. There is no default value for this parameter.

An application can query this parameter at any time, but can set it only before a call to a data-processing routine, such as clCompress() or clDecompress(). Since the codec channels are identical, it is not usually necessary to select a specific channel.

Although you can try to set the value of this parameter to the other possible value, success is not guaranteed; another application might have the other codec allocated. Example 4-1 shows use of this control.

channel = clGetParam(clHandle,CL_IMPACT_VIDEO_INPUT_CONTROL); 
...
vlGetNode(videoServer,VL_DRN,VL_CODEC,channel);

An application can control compression or decompression with the CL parameter CL_IMPACT_CODEC_CONTROL. The default value of this parameter is CL_IMPACT_START.

If this value of CL_IMPACT_CODEC_CONTROL is CL_IMPACT_START, the operation begins immediately when clCompress() or clDecompress() is called. If the value is CL_IMPACT_STOP, the CL configures and initializes the hardware necessary for the operation, but does not begin the operation until the value is set to CL_IMPACT_START. This feature allows more precise control over the time that the operation begins.

After a codec has begun operation, setting the parameter CL_IMPACT_CODEC_CONTROL to the value CL_IMPACT_STOP halts the compression or decompression operation. If clCompress() or clDecompress() was called with CL_CONTINUOUS_BLOCK, the function returns. If clCompress() or clDecompress() was called with CL_CONTINUOUS_NONBLOCK, the associated thread terminates.

Setting the value to CL_IMPACT_START on a codec that is already processing data has no effect, nor does setting the value to CL_IMPACT_STOP on a codec that is not processing data.

To compress frames into memory using OCTANE Compression:

When compressing images from memory into a buffer, OCTANE Compression supports image widths of 16–4080 (in multiples of 16 pixels) and image heights of 16–4088 (in multiples of 8 pixels). Images may be scaled down to one half horizontally and/or one half vertically. Images may also have black padding regions added to the image prior to the scaling operation.

The CL parameters CL_IMAGE_WIDTH and CL_IMAGE_HEIGHT specify the original uncompressed image size, and the parameters CL_INTERNAL_IMAGE_WIDTH and CL_INTERNAL_IMAGE_HEIGHT specify the final compressed image size.

The uncompressed data format must be 32-bit RGB (CL_RGBX) or YUV 4:2:2 (CL_YUV), and the uncompressed image size cannot be larger than 4080 × 4088 pixels.

NTSC video frames have a height of 243 lines, but OCTANE Compression supports only input image heights that are multiples of 8. For NTSC, you must specify an image height of either 240 (causing the image to be cropped 3 lines from the bottom) or 248 (causing the image to be padded with 5 extra lines of black).

Example 4-2 demonstrates memory-to-memory compression of NTSC video.

#include <dmedia/cl.h>
...
    int pbuf[][2] = {
        CL_IMAGE_WIDTH,  0,
        CL_IMAGE_HEIGHT, 0,
        CL_COMPRESSED_BUFFER_SIZE, 0
    };
     ...
    scheme = clQuerySchemeFromName (CL_ALG_VIDEO, "impact");
    if (scheme < 0) {
	        fprintf(stderr, "compression scheme ;'impact' is"
                        " not configured\n");
        return;
    }
    clOpenCompressor (scheme, &handle);

    /* set parameters */
    pbuf[0][1] = 640;
    pbuf[1][1] = 240;
    clSetParams(handle, (int *)pbuf, 3);

    /* allocate the required size buffer */
    clGetParams(handle, (int *)pbuf, 6);
    compressedBuffer = malloc(pbuf[2][1]);

    for(i = 0; i < numberOfFrames; i++)
    {
        /* Get a frame from somewhere */
        ...
        clCompress(handle, 1, frameBuffer,
                   &compressedBufferSize, compressedBuffer);
        /* Write the compressed data to somewhere else. */
        ...
    }
    clCloseCompressor(handle);

After compressing the images, you can use mvInsertCompressedImage() to insert the compressed images into a movie file, as described in Chapter 5 of the Digital Media Programming Guide (007-1799-060 or later).

To decompress JPEG images from memory using OCTANE Compression, follow these steps:

You can shrink the images as they are decompressed, which is useful for displaying thumbnail images. When decompressing images from memory into a buffer, OCTANE Compression supports image widths of 16 to 768 and image heights of 16 to 336.

Scaling can be arbitrary, that is, you can scale the image dimensions down by any amount, and the output image dimensions do not have to be multiples of 8. To shrink images as they are decompressed, make the uncompressed image dimensions (CL_IMAGE_WIDTH and CL_IMAGE_HEIGHT) less than the corresponding compressed image dimensions (CL_INTERNAL_IMAGE_WIDTH and CL_INTERNAL_IMAGE_HEIGHT).

For information on padding and scaling images on capture, see “Padding and Scaling” in Chapter 3.

OCTANE Compression supports interleaving fields as they are being decompressed to memory, and deinterleaving as the fields are compressed from memory. This functionality is useful, for example, for taking field-captured media such as that captured from a video source and converting it to a frame medium, such as for display on the graphics monitor.

The interleaving and deinterleaving capability is available only in the memory-to-memory modes of operation. In other modes, use VL controls to select interleaving; see “Using VL_CAP_TYPE and VL_RATE” in Chapter 3.

The CL parameters that control interleaving are CL_IMPACT_FRAME_INTERLEAVE and CL_IMPACT_INTERLEAVE_MODE:

When CL_IMPACT_FRAME_INTERLEAVE is TRUE, the CL_IMPACT_INTERLEAVE_MODE parameter specifies which of the two fields occupies the top line of the uncompressed region of memory:

---

Note: The width and height of each field to be interleaved must be the same. During compression, the width has the same value as CL_IMAGE_WIDTH; during decompression, the width has the same value as CL_INTERNAL_IMAGE_WIDTH.

---

To capture video from an external video device using OCTANE Compression, follow these steps:

---

Note: Instead of using CL_CONTINUOUS_NONBLOCK, you can call clCompress() from a separate thread with the value CL_CONTINUOUS_NONBLOCK. In this case, clCompress() does not return until the transfer is complete.

---

See capture.c in /usr/share/src/dmedia/dmrecord/dmrecord.cosmo/ for an example of capturing external video through OCTANE Compression.

Video fields entering OCTANE Compression from the direct video connection are captured into an array of field buffers. The field buffers support field widths from 640 to 768 and field heights from 16 to 336. Field dimensions depend on the video timing, as shown in Table 4-2.

When the compressed image's height is less than the height of the incoming video fields, the video fields are clipped from the bottom before they are sent to the compressor. When the compressed image's height is greater than the height of the incoming video fields, additional lines of black data are appended to the valid video data before the data is sent to the compressor.

---

Note: NTSC fields have a height (243 pixels) that is not a multiple of 8. For NTSC capture, you can choose to have your application either throw away 3 lines from the bottom of each field (giving a 240 pixel height) or append 5 extra blank lines to the bottom of each field (giving a 248 pixel height) before compression.

---

You can scale the captured image to half-size before compressing it. This allows for an additional increase in data compression by factor of 4.

Specify vertical decimation by setting the compressed image height (CL_INTERNAL_IMAGE_HEIGHT) to half the size of the uncompressed image height (CL_IMAGE_HEIGHT). Compressed image heights can range from 16 to 168, and uncompressed image heights can range from 32 to 336.

Specify horizontal decimation by setting the compressed image width (CL_INTERNAL_IMAGE_WIDTH) to half the size of the uncompressed image width (CL_IMAGE_WIDTH) as indicated in Table 4-3.

---

Note: When CCIR(525) or CCIR(625) images are decimated to one half, they are 360 pixels wide, which is not a multiple of 16 pixels. It is for this reason that one-half horizontal decimation is not available for these image sizes.

---

During video compression from an external device, CLimageInfo.imagecount is initialized to 1 when the first field is received by the compressor after calling clCompress(). The count advances when a new field arrives. If the compression data buffer fills up, then a field will be dropped, but the imagecount continues to increase. An application can thus detect a dropped field by noticing a jump in the imagecount field of more than one. The ustime indicates the time the uncompressed field entered the compressor.

To select the fields to capture, the application can modify the video parameters associated with the VL_CODEC node. It is here that the application specifies the capture type (any fields, paired fields, odd or even fields only) and the rate at which they should be captured (30/60 fields per second, 10/30 frames per second). See “Setting Parameters for Data Transfer to or From Memory or Codec Nodes” in Chapter 3.

The connections for decompressing from memory to an external video are set up similarly to those for capturing video, except that a decompressor is opened. See clInit.c in /usr/share/src/examples/dmedia/dmplay/dmplay.cosmo/ for example code that initializes the CL for JPEG decompression (optionally through OCTANE Compression) from memory to external video.

Video and audio playback of the decompressed frames require media synchronization. See dmplay.c and streamDecompress.c in /usr/share/src/examples/dmedia/dmplay for more information.

Uncompressed fields leaving the JPEG decompressor can optionally be scaled up by a factor of 2 in the horizontal and/or vertical dimensions. NTSC, PAL or CCIR(525)/CCIR(625) fields are then scanned out of the array of field buffers. Horizontal scaling is performed by pixel replication; vertical scaling is performed by line doubling.

If the uncompressed fields leaving the decompressor have fewer lines than the field height required by the NTSC/PAL or CCIR(525)/CCIR(625) connection (after optional pistoling), additional lines of black data are added at the bottom of the uncompressed images. If the uncompressed fields leaving the decompressor have more lines than the NTSC/PAL/CCIR(525)/CCIR(625) field height (after optional pistoling), lines are clipped from the bottom of the uncompressed images.

If the uncompressed image is too narrow (less than 640 pixels wide for square-pixel NTSC), the OCTANE Compression board adds extra (black) pixels to make the image the correct width. For example, if the image is 400 pixels wide, the OCTANE Compression board adds 240 black pixels.

Specify horizontal scaling by setting the uncompressed image width (CL_IMAGE_WIDTH) that is twice the compressed image width (CL_INTERNAL_IMAGE_WIDTH) as indicated in Table 4-4.

Specify vertical scaling by setting the uncompressed image height (CL_IMAGE_HEIGHT) to twice the size of the compressed image height (CL_INTERNAL_IMAGE_HEIGHT). Compressed image heights can range from 16 to 168, and uncompressed image heights can range from 32 to 336.

During video decompression to an external device, CLimageInfo.imagecount reflects the count of fields sent by the application to the decompressor. The ustime indicates the time that field left the decompressor. In certain situations, fields are repeated on output, in which case the imagecount remains the same, but the ustime increases.

Use the CL parameter CL_IMPACT_CODEC_CONTROL to control compression or decompression. When a codec is opened, this parameter is initialized with the value CL_IMPACT_START. If this value is CL_IMPACT_START when clCompress() or clDecompress() is called, the operation begins immediately. If the value is CL_IMPACT_STOP, the operation configures and initializes the hardware necessary for the operation, but does not begin the operation until the value is set to CL_IMPACT_START.

After a codec has begun operation, setting CL_IMPACT_CODEC_CONTROL to the value CL_IMPACT_STOP halts the compression or decompression operation. If clCompress() or clDecompress() was called with CL_CONTINUOUS_BLOCK, the function returns. If clCompress() or clDecompress() was called with CL_CONTINUOUS_NONBLOCK, the associated thread terminates.

For video-to-memory compression and memory-to-video decompression, use the control DM_IMAGE_INTERLACING to set interlacing for NTSC or PAL video data:

Even and odd fields are compressed as separate images.