Unibrain ubCore 4.0 1394b 64 bit Drivers Installation Guide

June 2005

Unibrain introduces to IEEE-1394 users a complete FireWire (IEEE-1394) driver suite, ubCore, that fully supports the 1394b standard for the Texas Instruments 1394b chipset. The drivers provide the physical interface to various 1394 devices and include the following advantageous features: Full 1394b support at 800Mbps. Complete 1394a and 1394b SBP2 disk support for Windows XP 64-bit. Complete support of 1394a / 1394b IIDC compliant cameras.
Software Compatibility Windows XP 64-bit Windows 2003 SP1 64-bit
Hardware Compatibility Intel EM64t and AMD Athlon-64 CPUs All 1394a or 1394b OHCI PCI/PCMCIA compliant adapters Any Desktop/Portable PC with built-in 1394a or 1394b OHCI support.

Table of Contents

TABLE OF CONTENTS.... 3 FEATURES OF THE UNIBRAIN 1394 DRIVERS.. 4 DRIVERS INSTALLATION.... 5 DRIVERS INSTALLATION PROCEDURE... 5 INSTALLATION OF SBP-2 DRIVER FOR EXTERNAL HDD... 9 INSTALLATION STEPS FOR IIDC CAMERA DRIVER... 13
Features of the Unibrain 1394 drivers
Unibrains innovative 1394 drivers provide the following advantageous features: 1). Full 1394b support at 800Mbps speed rate. This driver platform provides full support of the latest 1394b standard. 2). Complete SBP2 support for 1394a and 1394b SBP2 hard disks. SBP-2 ("Serial Bus Protocol", 2nd version) is the best model for computer peripherals. 3). IIDC 1394 Digital Cameras Specification 1.31 support Full IIDC 1394 stack to control and display 1394 digital cameras. 4). Complete hardware support. The drivers stack supports any 1394a or 1394b OHCI PCI/PCMCIA compliant adapter or any Desktop/Portable PC with built-in 1394a or 1394b OHCI support.

Drivers Installation

Drivers installation procedure
The first step is to verify that your system is equipped with the required 1394 hardware. To do so, open Device Manager and an IEEE 1394 Bus host controller entity will appear with the Microsoft 1394 stack installed in your system.
Important Note: Make sure that no 1394 device is connected to your adapter during driver installation
Locate ubCore64.zip file and extract all the contents in a folder somewhere in your hard disk.
Open Device Manager and expand IEEE 1394 Bus Host Controllers. Right click on Texas Instruments OHCI Compliant IEEE 1394 Host Controller and choose Update Driver.
Select No, not this time and click on Next.
Select Install from a list or specific location (Advanced) and click on Next.
On the following screen select Dont search. I will choose the driver to install and click on Next
Select Have Disk and browse to ubCore64 folder
Select ub1394.inf file and click on Open
Select Unibrain driver / S800 OHCI Compatible Board and click on Next
Select Yes and click on Finish.
NOTE: It is recommended to reboot your system after complete installation of the driver suite
The complete driver stack is installed. If you monitor Device Manager you can observe the newly created entry 1394 Bus Host Controllers that contains the driver for the 1394b interface card.
Installation of SBP-2 driver for external HDD
Plug an external 1394 disk on your adapter and the following screen will appear as soon as you turn it ON. Click on No at this time and then click on Next.
Click on Next when the wizard will detect the existence of an SBP2 device and keep the second option selected (Advanced).
Select Dont search. I will choose the driver to install and click on Next

Click on Have Disk

Browse to ubCore64 folder, select ubsbp2.inf file and click Open
Select SBP2 Compliant IEEE 1394 device and click on Next
Click on Yes to begin installation
On the following screen click on Finish
To verify the installation of the SBP2 driver, open Device Manager and you will notice that another entry has been created called SBP2 IEEE 1394 Devices which shows that the SBP2 driver is correctly installed.
The external HDD will appear in the file explorer as shown in the adjacent picture.
Installation Steps for IIDC camera driver
Plug your camera in one of the available 1394 ports and the Found New Hardware wizard will appear
Check the third option (No, not this time) and click on Next
Select Advanced installation and click on Next
Select Imaging Devices from the Hardware Type list and click on Next
Browse to ubCore64 folder, select ubdcam.inf file and click on Open
Select Unibrain driver/IIDC Spec 1.04 compliant camera and click on Next
Click on Continue Anyway to begin installation of the camera driver
After installation is complete click on Finish
You can verify the driver installation by expanding Imaging Devices entry in Device Manager

1. Introduction

The Fire-iAPI (ubCore) and Fire-iAPI (MS Stack) Application Program Interfaces are two distinct and completely different approaches to a Development Toolkit for camera control using the IEEE-1394 bus. A quick summary of the differences is as follows (specific details follow). Hardware/Locking: The Fire-iAPI (ubCore) operates ONLY by using Unibrain's FireBoard 400 or FireBoard400-OHCI or FireCompact400. It can be also used on ANY third party 1394 OHCI compliant Desktop/Portable PC WITH the use of Unibrains USB Key. It does NOT operate on 1394 PCMCIA cards. If you will be using the above Unibrain boards the actual hardware protection key is the board itself and you need NO USB key. If you will be using ANY third party 1394 OHCI compliant Desktop/Portable PC then you need Unibrains USB key. The Fire-iAPI (MS Stack) operates ONLY by using Unibrain's FireBoardRed or FireCard400. It can be also used on ANY third party 1394 OHCI compliant Desktop/Portable PC (including PCMCIA cards) WITH the use of Unibrains USB Key. If you will be using the above Unibrain devices the actual hardware protection key is the device itself and you need NO USB key. If you will be using ANY third party 1394 OHCI compliant Desktop/Portable PC then you need Unibrains USB key. Low-level (Driver) software: The Fire-iAPI (ubCore) uses Unibrains 1394 stack (ubCore - needs separate installation) The Fire-iAPI (MS Stack) uses Microsofts 1394 stack (build-in on Windows Me/2000/XP) Other 3rd party software requirements: Fire-iAPI (MS Stack) depends strongly upon Microsofts DirectX 8.0; Fire-iAPI (ubCore) depends on DirectX 3.0; The Fire-iAPI (ubCore) and Fire-iAPI (MS Stack) are NOT compatible, meaning that an application written using the Fire-iAPI (ubCore) will not run under Fire-iAPI (MS Stack) and vice versa.

2. Fire-iAPI (ubCore)

Using the Fire-iAPI (ubCore) assumes that you are familiar with the following concepts: 1394 Globally Unique Identifiers (GUIDs) 1394 Bus Reset Procedures 1394 Digital Camera Video Formats 1394 Digital Camera Video Modes 1394 Digital Camera Frame Rates 1394 Digital Camera control command register 1394 Digital Camera Feature Definition and specification Win32 GDI Fire-iAPI (ubCore) Architecture The Fire-iAPI (ubCore) can be divided into three different parts: The Camera Initialization and Control Engine The Isochronous Receive Engine The Display Engine The three parts operate independently from each other. Isochronous Receive Engine uses a FIREi_CAMERA_STARTUP_INFO structure to perform isochronous receives. These structures are created and exported by the Camera Control Engine. The same goes for FIREi_CAMERA_FRAME structure that is created by the Isochronous Receive Engine and used by the Display Engine. The display engine uses DirectX 3.0 and later and gives the ability to the programmer to use hardware overlays if they are available by the graphics adapter of the system. The camera control and isoch engines use Unibrains ubCore driver stack and give the ability to the programmer to control all cameras found on the bus and receive frames from them. The scheme below describes the structure of the Fire-iAPI (ubCore).
The main functionality of the Fire-iAPI (ubCore) is exported through the Firei.dll. The Firei.dll sits above the ubCore 1394 driver stack. The structure of the ubCore 1394 driver stack is depicted by the following scheme. Additionally Fire-iAPI (ubCore) uses UB1394DH.dll that provides transparent control of 1394 nodes, using device handles instead of node Ids that might change after a bus reset.
Fire-iAPI (ubCore) Requirements Make sure that all ubCore 1394 drivers are installed and are working correctly. This includes Unibrain 1394 Class Driver, FireAPI Driver and PCILynx or OHCI Miniport. As long as the Unibrain Fire-i Software camera drivers are installed correctly all the Fire-iAPI samples and applications will work. Please refer to the documentation for detailed description of the required procedures to install the Fire-i Software drivers. Make sure that UB1394.dll and UB1394DH.dll is installed in a directory where it can be located by your executable. ubCore places UB1394.dll in the %SYSTEMROOT%\SYSTEM32 directory, so that every application can see it. Its suggested that you do the same with UB1394DH.dll. Alternatively you can copy it to a directory that is in your systems PATH. Each source file that uses Fire-iAPI functions must include the header file Firei.h. All other necessary header files are pulled in by this file

3. Fire-iAPI (MS Stack)

Using the Fire-iAPI (MS Stack) requires that you are familiar with the following concepts: 1394 Digital Camera Video Formats 1394 Digital Camera Video Modes 1394 Digital Camera Frame Rates 1394 Digital Camera control command register 1394 Digital Camera Feature Definition and specification Win32 Multimedia streaming architecture Microsoft component object model (COM) architecture Microsoft DirectX media SDK and DirectShow Fire-iAPI (MS Stack) Architecture The Fire-iAPI (MS Stack) is comprised by 5 different modules, one kernel mode component and 4 user mode components. fidcam.sys lower level kernel mode driver that handles all the camera initialisation through 1394 and all the streaming of the camera data from kernel mode to user mode. fiprop.ax user mode DirectShow filter driver that exposes interfaces to control a 1394 camera through 1394 and gives a set of camera property pages for even easier control of 1394 camera. fiyuv.ax user mode DirectShow Transform filter that converts the YUV camera data to an RGB format and passes them to an upstream filter (e.g. The DirectShow video renderer.). If the graphics adapter of the pc supports overlays this filter will not pass the YUV data to an upstream filter but it will instead handle the display it self in order to achieve better performance using the hardware.fiyuv.dll. This is an VFW style codec that performs Yuv to Rgb conversion and is provided for compatibility with older applications. fiyuv.dll user mode Video for windows codec that performs yuv to rgb conversion. This codec has similar functionality to the fiyuv.ax DirectShow filter and is present for compatibility with various 3rd party applications. fiext.dll user mode WIA compatible extension DLL. This DLL extends the Fire-i Drivers functionality in order to be fully compatible with the WIA capabilities of windows XP and Me Fire-iAPI (MS Stack) Requirements Make sure that all Microsoft 1394 drivers are installed and are working correctly. These drivers are build-in on Windows Me/2000/XP. As long as the Unibrain Fire-i Software camera drivers are installed correctly all the Fire-iAPI samples and applications will work. Please refer to the documentation for detailed description of the required procedures to install the Fire-i Software drivers. Each source file that uses Fire-iAPI functions must include the header file FiCamera.h. All other necessary header files are pulled in by this file. You must add the directory where the Fire-iAPI (MS Stack) header files reside to your projects include file. You must add the directory where the Microsoft DShow header files reside to your projects include file. You can find the Dshow headers in the DirectX media SDK autonomously or in the Microsoft platform SDK where the media sdk is now embedded.

The main functionality of the Fire-i is exported through six interfaces exposed by the fiprop.ax and FiYuv.ax DirectShow filters. Information about the video formats and modes of the camera is provided by the miniport driver fidcam.sys and is exposed to the user mode programmer by interfaces exported by the ksproxy.ax filter. ksproxy.ax is a Microsoft filter provided with all windows 2000 and windows 98 systems.
In the above scheme you can see that five interfaces are provided by the fiprop.ax and fiyuv.ax filter to let you control a 1394 digital camera.
In the above scheme you can see that five interfaces are provided by the fiprop.ax and fiyuv.ax filter that let you control a 1394 digital camera. These interfaces extend the functionality of the DirectShow API and give a better control of a 1394 digital camera. FiExpoControl Provides methods to query and control all the exposure feature controls of a 1394 digital camera. These controls can be gain, iris, auto exposure and shutter. FiColorControl Provides methods to query and control all the color feature controls of a 1394 digital camera. These features can be UB, VR, hue and saturation. FiBasicControl Provides methods to query and control all the basic feature controls of a 1394 digital camera. These features can be zoom, brightness, sharpness, focus and gamma. FiCameraInfo Provides methods that retrieve general vendor information of the camera like model name, guid e.t.c. It also provides methods that give the ability to the programmer to write and read arbitrary 1394 camera registers in the 1394 address space. FiVideoFormatConfig Provides methods to retrieve information about the camera supported stream formats as well as setup the camera in a specific format mode and frame rate. Iyuv2rgb Provides functionality to control the way the display is done by the fiyuv.ax decompressor filter. The user can control whether the frames are going to be displayed on screen by the fiyuv.ax filter via hardware overlays or whether the camera frames are going to be passed to a downstream filter for further processing or display. This interface provides also functionality to save incoming camera frames into the Hard Drive.
The user mode programmer will also be able to use a set of Microsoft DirectShow filters and interfaces in order to control the formats and modes the camera is displaying at. These interfaces are in brief the following: IAMStreamConfig. This interface will enable the user to query the output of the camera miniport (fidcam.sys) for supported Video formats. The programmer will also be able to set and get the current format of the camera through this interface. IgraphBuilder2. This interface allows automatic building of a filter graph in order to display the data captured from a 1394 digital camera. IAMVideoControl. This interface enables you to query supported frame rates , set the camera in trigger mode and perform various other tasks.

Above you can see the Fire-iAPI (MS Stack) modules rendered in a filter graph. The Unibrain Fire-i Software driver is the fidcam.sys module, the Fire-i YUV Decompressor is the fiyuv.ax filter that converts the camera frames from YUV to RGB format and passes them to the DirectShow video renderer. The Fiprop.ax filter is used in order to provide custom property sets and custom property pages for the Unibrain Fire-i Software driver. CFiCamera Class One of the key and most important features of the Fire-i API MS stack is the existence of c++ class that abstracts many of the details of DirectShow and COM programming as well as many of the details of the Fire-i API MS provided COM interfaces which are provided for compatibility with DirectShow. Using this class is extremely simple and grabbing images from a camera is a matter of a few lines of code. There is no need for the developer to delve into the complexities and pains of DirectShow and COM programming since most of them are abstracted by the CFiCamera Class. The CfiCamera class on the other hand provides full flexibility to do most of the most complicated tasks and ease of use on the other hand when doing most of the common tasks.
4. Fire-i API Pros and Cons
The following lists summarize the advantages and disadvantages of both camera control APIs provided by Unibrain. Fire-i API MS Stack Pros Compatible with DirectShow. Any DirectShow compliant application will automatically work with the API. Compatible with all applications present in the Microsoft Operating systems. Cons DirectShow and COM programming can sometimes be really complicated. This limitation can off course be overridden by the use of the CfiCamera Class. The interoperability with DirectShow , MS stack and other 3rd party modules has tremendous advantages but can sometimes cause problems that are hard to fix since so many different components are involved.
Uses the MS 1394 driver stack. Other 1394 devices can be used on the target pc that have 1394 drivers based on MS stack. Can easily use third party DirectShow compliant products like video compressors , video renderers e.t.c. Provides an extra abstraction layer over DirectX that can sometimes be very complicated. The CfiCamera class provided by Fire-I API is open source and makes camera image acquisition a matter of a few lines of code. TWAIN support in Me and XP. Fire-i API ubCore Pros Extremely simple to use c interface. All components are made by Unibrain making bug fixing and custom applications that suit the needs of the customer very easy. Provides full control over the 1394 bus and can be also used in conjunction with FireAPI so that the developer can get down into an even lower level of 1394 programing. The ubCore drivers and the Fire-I API ubCore are really stable and reliable since they are being used and debugged for years now. TWAIN driver that is also provided as a source sample that can be modified to suit user needs. Cons No inherent support for saving AVIs. The customer should do this by her self. Since the API is based on ubCore no other 3rd party drivers based on MS stack can be installed on the target machine for the 1394 adapter that has the ubCore drivers installed. No interoperability with DirectShow is provided.

5. Fire-iAPI (MS Stack) and Fire-iAPI (ubCore) are two distinct and completely different APIs
All of the Fire-iAPI (ubCore) functionality is exported through a single DLL that sits on top of Unibrains ubCore 1394 drivers. This dll provides a set of functions to control and identify 1394 cameras on the bus, receive the camera frames and display them on the screen. The display functions use Microsoft DirectX 3.0 and above and the camera control and frame receive functions use functionality exported by the Unibrain ubCore drivers. The Fire-iAPI (MS Stack) functionality is exported to user mode through a set of com interfaces that are provided by the direct show filters that come with the Fire-iAPI (MS Stack) camera drivers. These filters provide functionality to control 1394 cameras found on the bus and also with the help of the Microsoft DirectShow provided interfaces display the contents of the frame to a users pc. The main feature of the The Fire-iAPI (MS Stack) is the addition of c++ class that handles a lot of tedious and complicated camera tasks transparently from the user. Because of the inherent differences in the design of the two APIs they do not provide the same interface to the user mode programmer. The Fire-iAPI (MS Stack) uses com and C++ interfaces and the Fire-iAPI (ubCore) uses function of the Firei.dll written in c. Thus the two APIs provide a different set of functions and methods to the user mode programmer. Although it is possible to write a dll with wrapper functions to the Fire-iAPI (MS Stack) so that the functionality of the Fire-iAPI (ubCore) is exported this is not an ideal solution because the Fire-iAPI (MS Stack) has a totally different philosophy in its design and it will lose flexibility.