ValiantVision - Project Log

• Stopped the official AmithlonTV project.

• First creation of a catalog with driver specifications

• Again, reworked the driver stuff and designed a split up into hardware and picture processing.

  The chip drivers are no longer bond to a specific interface. The entire communication and controlling is handled by additional IO drivers. This allows to use the same chip driver with for example PCI and i2c connection without the need of specific adjustments.

• Created data structures and project drawers. This required a proper naming and I decided to use "TVInside". Alternative names are "SmartTV", "MultiTV" or "MMTV". Additional ideas are welcome.

• Official project start. Created first includes and headers with required chip definitions.

• This may sound boring and yes it is boring. Before something happens several different parts need to be finished and working.

  In the easiest case valiantvision.library, bt8x8.class and pci.class must be implemented. This will be the road map for the near future.

  In addition to that, there must be a simple viewer to get any video output. You can imagine that it's frustrating when writing stuff for a long time without beeing able to test anything for weeks or even month.

• Created new source so simplify the library and device creation. This would save days in development, because I don't need to waste time to think about the system specific stuff for each single class.

• Created a web site with all available information.

• wrote pci.class.

• Specified additional details for the driver classes.

• Started developing of ValiantCreator. This application will be a configuration tool box for tv card driver files. Until full implementation the ValiantCreator will be my testing platform for driver api testing.

• Additional changes to the includes. Also set up more definition standards to ensure clean and readable code.

• Specified additional details for the driver classes.

• Added more functions to the valiantvision.library. Now functions for reading and writing card configuration files are existing. I also added functions for internal structure creation, releasing and using.

• Renamed the libraries and classed during the new definition standards.

• Modified FAQ section and added some OS4 information.

• Added locale support to the new libdev header. So all libraries and classes using this header are using locale by default and save much time.

• The last modifications and renaming operations causes the sources of the two available libraries to look very different. I reworked and commented the code to make them look equal. Now they look quite nice and handy. This is important, because these file will be used a template for the upcoming classes. Some people may say it's wasting time, but the truth is these 20 Minute of intensive rework save hours in the future. A nice side effect is that you look over the entire code and find a glitch or a bug here, or a possible optimization there.

• Added first class control commands to ValiantCreator.

• Added markings to the official structures. Wrote a function for each structure to check it's integrity and report any problem. I also added calls to this functions to all functions using them. This allows to prevent system wide crashes caused by wrong pointers or wrong structure usage.

  Again this may sound crazy to add such resource eating code into a frequently called code. My experience is that such code prevents numerous reboots and detects faulty code even when the result isn't causing a crash within the next hour. Just call it runtime debugging. Combined with the resource tracking the stuff gets stable like a rock within a short time.

  Just think about that numerous drivers are interacting and if one driver makes a faulty action this may end in a disaster, so a proper working infra structure is strongly required.

• Just for information: I did not test anything yet!

• I spent 3 hours in writing boring internal routines, which will be used later.

  These new internal and external functions are required for data base handling, class control and to simplify external classes.

• Again two hours of improving routines and enhance the debug output.

• Added an information windows to the ValiantCreator, which provides information on the class, it's features and about the guy behind.

• First run of the ValiantCreator to enhance my motivation. Result: BOOM - system wide crash.

• Searched for the problem and found it within a few minutes. A little "!" within the ValiantCreator was missing and caused the disaster. Second try. ValiantCreator is popping up and speaks German. Now I select the only driver class to be added... It's working. The class and some information is added to the main class list and the info window shows information on the driver. Some small glitches like wrong gadget layout and one wrong driver info, but interaction between valiantvision.library and class driver is working.

• Motivation successfully raised!

• Again 3 hours of boring tag list and support function implementation. Also modified several functions to be more future compatible. I don't want to do that for all classes later, so it's done and history.

• Predefined more tags and cleaned the header files a little. More maintenance will be required in the near future, but for now it's fine. Better less now, than again later.

• Did some more funny Jobs: Added functions to the ValiantCreator.

  Now it's possible to select classes and configure their connection classes. Non working combinations are filtered automatically, so by knowing the chips on the card and selecting the classes you get a working interface. Even random guess would be possible. Future updates will provide a auto config mode, which tries all drivers until a proper configuration is found.

• Added an open GUI system, which allows to create gadget user interface in a very simple manner, without coping code from one class to another. Now it's all clean and handy.

• Added multi pci support to the pci class. Unfortunately this took a long time and was very boring.

• Added loader and search functions for those pci id files. This allows to show specific vendor and card information within the GUI and their lists.

• Finally added the configuration gui to the pci.class.

• Added class configuration and the required functions into the valiantvision.library.

• Tested some low level function by implementing them into the ValiantCreators and improved them if needed.

• Added new functions for hot plug capability. The sounds (again) if I implement stupid stuff not required yet, but it's very important. If an interface class looses contact with it's hardware, then it must be able to shut down the upstream classes bond to it until the problem is gone. This is strongly required within the pci class, because changing the pci system or the pci card itself is causing trouble. Upstream drivers still "think" the card is operational, but if for example the pci card was changed, anything known about that card is now invalid on the new one, even if the chip is the same. Of course this is only happening if the user changes the card within the configuration gui.

  Same is required when the user is unplugging and re plugging an usb tv card.

• Last weekend I spent very much time into the project, but I am still 3 days off schedule. I hope that the code quality and the ability to recycle huge parts of the code will spare time when implementing the other drivers.

• The pci class is now nearly done. Cards can be selected and it's possible to choose the pci api for interaction. There will be some minor corrections and enhancements needed in the future. Most of it are look and style issues, so for basic operation with open pci and power pci this is working fine.

• Reworked the global class files a little in preparation on the next step: The bt8x8 class. Yes, yes, yessssss!

• It seems the intensive implementation of security and check functions was worth it. No crash within two days of intensive testing all available components.

• Removed several known bugs and some enforcer hits.

• Fixed some bugs within the pci class.

• Started to create bt8x8 class. Took 1 minute to set up the basic class. :)

• Thanks to the second class I was able to enhance the ValiantCreator. The new interface selection is now limited to the available interfaces and the gadgets are disabled if needed. This passive intelligence should be enough to avoid the user is doing anything wrong.

• Class error reports are now displayed within the class list, so the user is able to find out where the problem is.

• Class communication seems to work. The bt8x8 class automatically found the BT878 chip, after choosing the pci card and specifying the interface link. Both classes signaled ready to go!

• Removed a very bad bug within the ValiantCreator, which caused the system to crash during loading a tv card profile. Now it's working without any additional problem and fortunately the problem wasn't located within the complicated card management system.

• Picture transport mechanism invented and implemented basic functions into the bt8x8 driver and the valiantvision.library.

• Added risc programming code into the bt8x8 class. Also added many support functions and a basic GUI setup into the driver.

• Fixed a bug that cause the entire system to crash when taking the gui tasks offline. It took hours to find and kill that beast.

• Changed project name

• Created more bt8x8 driver internal functions.

• After several hardware problems causing crashes without any reason, my developer system seems to be stable again.

• Krzysztof Kurzawski created a new Yahoo group for Valiant Vision and topics around Amiga and TV card hard and software. Subscriptions are moderated, so the appearance of spam should be limited.

• After searching a bug within the bt8x8 base code, I finally found it within an macro. Now the bt8x8 risc code is up and running.

• Added an internal picture class to the bt8x8 set-up page of the class GUI. Now it's possible to watch TV within the set up window. Looks cool! :)

  Well, actually it's there to control the card configuration just in time.

• Added some sliders for picture quality control into the set up window.

• Improved the bt8x8 code and cleaned the GUI stuff a little.

• Added more configuration stuff into the bt8x8 class gui. Now it's possible to setup the inputs and their corresponding types.

• Fixed miss calculation within the picture quality setup sliders. The sliders moved without any user adjustments straight and in very small steps to 100%. :)

• Implemented the i2c class and the required functions into the bt8x8 class. I also made several tests with the hardware and software driven i2c functions by reading the EEProm on the tv card.

• I made some strongly needed reworks on the includes and their names. This caused nearly all files to be effected, so manual adjustments all over the stuff were required, too. In the result the old "i only point to another file" files could be deleted and the stuff looks much cleaner now.

• Fixed some functions which weren't compiled correct when targeting MorphOS-PPC. Now all files get compiled again.

• Reached the magic 100! I spent over 100 hour's for creating this stuff so far!

• Updated the image of the bt8x8.class and added a picture of it's i2c page.

• Small minor cleanups. This was required to ensure a useful and readable source code.

• The ValiantCreator displays now the type of the class within the list. This makes the stuff more user friendly.

• Fixed a bug within the ValiantCreators class type selection. Some classes where rejected even if their type was correct.

• Started writing a tuner class. Driver gets found and communication over i2c class is working like a charm. Tuner got found from the first time. I think I need to reactivate my old A1200 for getting an antenna source, because I don't have any receiver with such old connector around.

• Did many outstanding changes to the header files. Renamed many methods and tags all over the code.

• The new tuner class now supports more than 40 tuners and thanks to the configuration gui it's possible to adjust and create a configuration for most of the tuners out there. By this new driver we have more drivers for ValiantVision than ever exists for AmithlonTV.

• I made a mistake during inventing the preferences handling. Now it's pay back time and I need to rewrite these routines. During the update process I already added the required methods. Adapting the valiantvision.library will be required soon, because without it's not possible to implement the switch class.

• Added flexible and easy to use timer stuff to valiantvision.library to make class creation a little more easy.

• Did more changes and cleanups to the code.

• Reworked the preferences handling within the valiantvision.library. Now the old mechanism is obsolete.

• Worked on the ToDo list, which growed silently and uncontrolled. :) Well, for now 50% is done.

• Adapted bt8x8 i2c class to use the new timer functions of the valiantvision.library.

• More work on the ToDo list. Only 7 points left.

• First MorphOS native test! The entire driver system seems to be working, but the stuff cause a long freeze before continuing. After a long search I found the reason. A missing TAG_DONE caused this trouble on MorphOS, while on 68K this didn't appear. Another good example how a seconds system can improve code and help debugging. Without having a MOS system this bug would required weeks of debugging.

  Now the native version seems to work perfect. Well, as far as I could test without a tv card.

• Fixed the resource tracking. The master output function wasn't implemented, so most of the errors and warnings didn't show up. After fixing nothing changed! Adding a single AllocVec() without FreeVec() gave the proper result warning, so it seems the entire driver system is working perfect without loosing resources.

• bt8x8.class: Cleaned driver startup.

• pci.class: Fixed bug within the open pci part that caused MorphOS to crash.

• pci.class: The card list now presents vendor and device values instead of a simple "unknown".

• class system: Changed the old "ClassHasGUI" tag. Now it's handled as Class GUI is available, which makes more sense, because the availability is changing during operation and a fixed "Has GUI" is quite useless. Since the ValiantCreator is the only tool dealing with the tag, it can simply be used to disable the configuration button.

• class system: Fixed a bug that caused crashes when trying to configure without having all interfaces online.

• pci.class: DMA Memory allocations are now done via valiantvision.library, when running on Amithlon. This allows me to track DMA usage without adding resource tracking into each class.

• Yes, I know! Again nothing new and no new functions. That's life! Creating a program now and make it work in the future is no option.

  For now the stuff is stable again and there are no "I know how to crash it" spots anymore and that was the goal in the first place.

• valiantvision.library: Fixed bug that caused stack overflow crash due recursive looping, which happened during closing a class. A class is using it's own interface, tried to close the interface first, which was the same class, so the interface was tried to be closed first.....

• bt8x8.class: Started implementing the pio class driver. It was required to replace the standard macros for preferences handling by little more complicated functions. This was required, because the class requires dynamic lists which results in dynamic sized preferences.

• ValiantCreator: Multiple interface support was implemented, but couldn't be set up. Since the bt8x8.class is now the first class supporting optional pio support, this problem suddenly occurred.

• Spent the last weekend with MUI classes and their creation. It was boring and of course keeped me from making ValiantVision stuff, but finally I got a smart bit array class which will be used within the PIO class.

• Many thanks to Manuel Habermann I now have a seconds bt8x8 card for Pegasos testing. :)

• There seem to be two problems with the driver system, I couldn't detect without a tv card. Opening the bt8x8.class gui is causing ValiantVision to freeze. Also adding the tuner.class is causing the stuff to freeze. After some search I found that the openpci.library was outdated. After replacing the stuff worked as expected. The tv picture isn't displayed, but this is because of the not yet 100% ready code inside, which uses static rgb values. A small check indicated, that tv card interrupts are coming through.

• bt8x8.class: Replaced the old picture to window transfer method - which was taken from AmithlonTV - by a newer version. The new transfer way works more efficient and and reduces the amount of data even with cybergraphics to minimum. This should prevent the Peagsos1 board from DMA freezing, like it did with AmithlonTV. Thanks to Frank Mariak for the tip.

• Removed additional bug causing hits under MorphOS.

• Again some cleanups. Many files reworked and combined.

• ValiantVision is now running perfect on MorphOS, as you can see on the screen shot above. Thanks again Manuel!

• bt8x8.class: Created PIO class gui and implemented basic list handling.

• Fixed several catalog strings and removed outdated debug output lines.

• bt8x8.class: Defined the PIO standard and implemented the missing stuff. After fixing the load and save settings functions it seems to work.

• Now the ValiantVision basic setup it nearly complete. Just the audio driver for the TDA chip on my card is missing, but it's quite simple. In addition to that the pio selection gadgets need to be connected and added to all other classes. I need to think on how to implement this best, because the stuff will repeat for all future classes and I don't want to rewrite or copy over the stuff. I guess another MUI custom class will be needed.

• Created a PopPIO MUI class, for easy PIO handling in class GUIs.

• Missing optional interfaces are now displayed in the ValiantCreator. This makes it easier to find our why some gadgets within the GUI are unavailable.

• Some minor corrections to the bt8x8 core and adapting the new PIO stuff. Now it's working like a charm and without any problem. The old AmithlonTV GPIanO tool is now integrated too and it's much more comfortable now.

• bt8x8.class: The tv card tuners are known to not send a proper signal on signal lost. This causes the bt8x8 to create a massive amount of interrupts, which in the result freezes the pegasos system after a few seconds. Seems I need to create some kind of workaround for pegasos1 boards around here, because channel search is impossible under such circumstance.

• bt8x8_pio.class: Class is ready for duty. There are still some routines and class methods missing, which are required for stuff like PIO remote controls. These will be implemented if needed. Doing this now would be a waste of time, because I may not develop the stuff into the needed direction. Thanks to the class type driver system extensions are quite easy and done within a few seconds.

• bt8x8.class: Modified pixel format and tv norm tables. Moved and renamed some routines.

• pci.class: Class is now detecting the audio part for the bt8x8 card. Somehow I broke that detection during cleanup.

• DOOOOOOOOOOHHHHHH! I pushed the Pegasos power button and beside a sound like a fly got caught in a blue light insect killer lamp nothing happened. After opening the case the power supply smelled badly. I replaced it by another one, without any change. The system stayed dead. Checking the PCI cards in my PCI indicated they survived. Same for the hard drive and the CDRom. Even with only the graphic board plugged in there is no response from the pegasos 1 main board. He's dead Jim!

  This is exactly the reason I mentioned above, when lending stuff for frequently usage. And of course the only hardware which isn't mine is dead! And of course the most expensive part of it seems to be killed.

  It was planned to return the peg, when getting the promised Freescale/Genesi ODW, because the ability of testing such a DMA based project on a Pegasos1 would become more and more impossible. Well, actually I reached those limited several times.

  So for now further MorphOS testing is impossible and support for MorphOS software has been halted.

  I am sorry, but it's really not my fault. First of all I need clear how this problem can be solved and if the board can be fixed.

• After being lazy during the last weekend, I spent a few hours to implement a major feature. It will to be a surprise for the Amiga Meeting 2005 in Bad Bramstedt (Germany) at the end of the week.

  I don't tell you what it is, but from sight of the Amiga Community it's kind of a world premiere.

  If you want to know details, then you'll have to wait until next weekend. The people at the Meeting will be the first to know.

  Well, I didn't expect the stuff to be ready that fast, especially after doing nothing the last few days. Having the head cleared by playing PS2 helped a lot. Also the preparations made in the past and the ability to copy over routines and especially the GUI, the ValiantVision project just made a very big jump forward.

  There is still a lot of fine tuning required, but I guess this will be done until the weekend.

• bt8x8.class: Reworked the class gui a little. Now the tuner is no longer part of the input set-up. This makes more sense and makes the whole stuff much easier to understand.

• Worked on the surprise. Most stuff is implemented and working. Just two or three bugs are still in there, but the main work is done and it's ready to be shown.

• ValiantCreator: Finally killed the annoying bug that activated subclasses created by a master class.

• Created some updated web pages which will be uploaded at the AmigaMeeting on Saturday after I made the presentation.

• We have a new class!

• saa713x.class: The mysterious driver I build during the last week, is for Philips saa713x base tv cards. The Philips chip has a better picture quality (compared to the bt8x8 chips) and is able to deliver two picture streams at the same time. This allows to show a scaled preview picture while recording a full sized picture.

  The base for digital television has been set up.

• Even if some people ment ValiantVision is dead, it isn't. There were other things to do, like replacing the Pegasos1 by a Pegasos2, getting real internet, ...

• Did some cleanup and reworked the entire memory resource tracking. This should fix the crashes when using several parts in debug mode at the same time.

• Recompiled the entire project with the latest SDKs and CLibs. Made several corrections and improvments to the makefiles.

• Set up ValientView.mcc, which will display the running tv picture in MUI applications. As test base I'll use the new tv application ValientView, which will be a MUI version of the good old TVWatch from AmithlonTV packet. Well, it will need some time until it gets that perfect.

• valiantvision.library: Added functions for direct pool support. These will replace the prior invented AllocVec() wrapper. Since the new resouretracking is able to check and handle pooled memory, this is the best solution.
• Modified all classes to use new alloc/free pool functions.

• Made several preparations for the upcoming implementation of the application API. Added and modified several header files.

• valiantvision.library: The first new application functions are implemented. Technically there not working, yet and are completley untested.
• Today the new tv card set arrived. Beside 2 analog card I got my first DVB-T card. I tested cards in my hardware test system and they identified themself without any problem. Seems the 12,50 Euro I spent for the cards were worth it.
• ValientView.mcc: Some of the new library functions are used by this class, so in the result it's currently not working anymore!

• Added more functions for frame handling. As always the entire stuff is untested, yet!

• Implemented basic frame processing.

• Implemented frame allocation and free functions.
• Added some graphic support functions into valiantvision.library. The functions are currently implemented in any video driver, so moving them into the main library made sense.

• Replaced the build in functions of the video class by the new version within the valiantvision.library.
• Fixed tons of FIXMES.

• Added frame allocation to bt8x8 class and it seems to work.

• Hmm, someone forgot to implement automatic card setup loading on library opening. So implementing this before continuing frame handling stuff.

• I have been asked for additional ValiantVision screen shots. Well, it's not possible. That is the problem between user and programmer. The programmer works month on a feature and nothing is visible at the surface. At last the is one single button and the user asks him self: "That's all?". Sometimes thinks are more complex on the inside. If you don't believe me, cut your thumb.

• valiantvision.library: Added some missing functions also required for card management.

• ValiantCreator: Added setup for card name, vendor, author.

• valiantvision.library: Added auto card file preset loading.

• valiantvision.library: Fixed a bug in card file loading that killed card naming.

• ValiantCreater: Added device selecting cycle gadget. There is still more stuff needed to make the entire setup work again.

• debug: New debug mode allows to slow down program code without adding Delay() function stuff. This allows to find crash positions without having a second system for logging connected.

• valiantvision.library: Fixed bug in class management. This little bastard caused be hours to find. Without the new debug it would have taken even longer.

• ValiantCreater: Additional changes. Now the removing and adding of classes should work as before, just in the new state of development and using the new functions. Both TV cards are listed and can be modified by using the GUI.

• valiantvision.library: Implemented more frame management stuff. (boring)

• bt8x8.class: Reworked interrupt and frame management. Made tons of optimizations.

• bt8x8.class: Reworked class internal picture routines. Now the internal GUI class is using the new frame mode stuff as well. I also consider to use the external mui class as preview. This would make the internal stuff much easier, but the class may fail due external problems. (memory, class missing, ...)

• bt8x8.class: Put the stuff together. Frame management and interrupt frame server seem to work quite nice. Frames go out as desired, but currently only visible in debug output. So, it's like watching the matrix.

• valiantview.mcc: Additional core changes. Adapted to latest application side API changes.

• Well, good news: The entire picture transfer management is implemented and working as desired. There are still a few things which need to be implemented and improved, but that can be don't when needed.

• The bad news is, that I found a gigant problem within the valiant core startup, that seems to be triggered by linking application hooks like the ValiantView.mcc class. In the result I still don't get any picture output here and must continue by using boring debug output. The startup code was next on my list to be changed, fixed and optimized. I'll try to make it later today, because the changes are good to find it during that process.

• Reworked and improved the library start up and shut down routines, but still sign of the stupid 0xdeadbeef bug.

• Finally found the stupid bug in the MUI class itself. Somehow I deceided to free hook memory right after linking it in. Stupid as stupid can be. I implemented the required stuff and now the picture gets displayed. Currently it's not scaled, but it looks impressive having 9 tv applications running at the same time. There seems to be a glitch in the bt8x8 driver, since it thinks to skip each second word in picture. In the result output looks miscolored and a little funky.

  So the MUI class basic functions are working. Next will be fixing a crashbug, when no calling avail flush before restarting the mess. Seems I introduced it during fixing process.

• Damn, internet is dead. No Ehrensenf, home page update and no IRC. Hopefully the technicians get it up and running till 4pm.

• Found and worked around the crash bug. Was located in a temporary fix within ValiantCreator and was for sure triggered by the changed valiantvision.library startup code. A real solution isn't possible yet, because the required functions aren't implemented or incomplete. Programmers solution: Wrote FIXME comment.

• Well, to ensure anyone is claiming me to be a hacker, I removed three FIXMEs from the bt8x8.class and replaced their workaround by the new and proper implemented functions and make it work without such hacking.

• Adapted saa713x.class to the latest changes. Currently not working perfect. Well, this class isn't as much tested as the bt8x8 version, but it will in the near future. I also found a few things which may need to be changed to stay flexible in the future. Currently there are only two different video drivers, so it's not a big deal.

• Fixed bug during class gui task startup. Well, not the one I searched for. Where are these bugs coming from? I hate bugs.

• The last versions of ValiantVision were instable. Crashing on exit because of many memory faults dumped by the resource tracking, I decided to rework class setup and shut down as well. To combine this process with something usefull I renamed class and library bases, since the original names were more AmithlonTV related or a little crytic.

  Starting with the .sfd files, continuing by deleting the old versions from SDK to prevent faulty includes are using them, I reworked the entire code base by using a CLI based "find and replace" tool to modify references and include lines. After around a hour the work was complete and after fixing a few missed references and removing several warnings, I compiled the entire code.

  I changed nearly anything, so if the stuff is now crashing, the easiest way to find the problem is to reinstall backup and try again in smaller steps. I closed eyes and gave it a run. No crash, no resource tracking alert and I wasn't even able to reproduce several known bugs. Cool!

• Reworked ValiantCreater startup/shutdown and fixed several bugs. Still needs more time to implement/support latest features and remove some known bugs.

• Seems the saa713x.class still contains a big bug. Using bt8x8.class works without any problem.

• Continued ValiantCreator reworking. During that task I fixed multi card support and some error located in class handling, which caused that closed classes from another card appeared in class list.

• Also fixed the crash bug within the saa713x class. Now the entire stuff is running amazing stable. Even button bashing isn't causing trouble.

• Additional changes to the external header files. Several files got renamed and splitted. Several structures got new names. In the result I needed to update the references all over the project. I think it was worth it. The entire code looks fresh and clean!

• Added external header for the ValiantView.mcc. I also added some parameter for later usage as full featured tv application.

• ValiantVision.mcc: The class is now opening the card handle before linking into the stream by using the latest card functions. So in the result the class can display the picture out of the box. No need to start ValiantCreator to work around that issue. Well display is still in wrong pixel format and unscaled.

• Additional code clean up.

• valiantvision.library: fixed the stupid pixel format problem. Now the picture is colorful and clear.

• pci.class: After removing openpcis broken Request() and Release() functions ValiantVision works on MorphOS again.

• Created a small tool to inject running TV picture into Ambient Panel.

• ValiantView.mcc: Implemented overlay support.

• ValiantCreator: Device cycle gadget now updates correct on card name changes.

• ValiantView.mcc: Improved several routines and fixed tag setup. Some new features improve ValiantTray.tray, the module which adds TV picture to Ambients panel. Implemented picture scaling.

• Searched the last days for a bug that isn't within my sources. Nice!

• saa713x.class: Class is up to date again and using all new frame functions. There are still a few bugs during init and when scaling preferences preview.

• Reworked my clib during the last two days. It takes around 120 Minutes to compile all OS and data model versions, so I am happy this long outstanding stuff is finally done.

  It was required to make a MorphOS native build of the ValiantVision project, which is currently 68K for most binaries.

• Reworked the entire main library code. Now the stuff is more logic and needs less object files.

• Fixed several library function entry points. Now the beast is finally running MorphOS native.

• Cleaned the makes files and made the stuff compatible to latest compiler updates.

• Changed simplecat catalog files to support the latest features. Latest SImpleCat found several glitches in translation, so I fixed that, too.

• ValiantCam: Started creating a web cam tool named ValiantCam, which allows to turns any photo camera or camcorder with video out into a webcam.

• ValiantCam: Added support for text rendering to ValiantCam and set up a proper GUI with preview. Main commodity is still missing.

• Found several bugs in VV which need to be fixed.

• ValiantCam: Cleaned and reworked some ValiantCam functions. Added jpg support.