• xvidcap
• recordmydesktop

I had some audio related problems with both programs - both recorded video with audio going out of sync, or nosie. I've found this: http://karussell.wordpress.com/2009/11/18/recordmydesktop/

And the options suggested in one of the comments are working fine for me:

 --v_bitrate 2000000 --s_quality 10 --delay 1 --fps 20 --overwrite -device plughw:0,0 --no-wm-check --buffer-size 65538 --freq 48000 --quick-subsampling --on-the-fly-encoding 

I've spend few more minutes to "import" this into the gtk-recordMyDesktop front-end to recordmydesktop. My .gtk-recordmydesktop file now looks like this:

 #Order and overall number of lines must be preserved #For this file to be read correctly #Framerate 12 #Cursor(0 xfixes,1 white,2 black,3 none) 0 #Sound,0 disabled 1 enabled 1 #Full shots,1 disabled 0 enabled 1 #Filename /home/dpc/test.ogv #Delay,seconds 0 #Number of channels 1 #Frequency 48000 #Sound-device plughw:0,0 #Video quality(0-63) 63 #Audio quality(0-10) 5 #Display $DISPLAY #Shared memory,1 disabled 0 enabled 0 #Reset capture area,1 disabled 0 enabled 0 #Recording area -1,-1,-1,-1 #Quick subsampling,1 disabled 0 enabled 0 #Working directory(temporary files) /tmp #On the fly encoding,1 disabled 0 enabled 0 #Zero compression,1 disabled 0 enabled 1 #overwrite existing files,0 disabled 1 enabled 0 #Include window decorations,1 disabled 0 enabled 1 #Use jack 0 #last used jack ports #Tooltips,1 disabled 0 enabled 0 #draw an on-screen frame, surrounding the capture area 0 #Extra options --v_bitrate 2000000 --no-wm-check --buffer-size 65538 --no-wm-check #Follow mouse,1 disabled 0 enabled 1 

I think that the following link may be useful soon - before publishing my videos:
http://wiki.showmedo.com/index.php/Video_editing_Ubuntu

So you'd like to start developing a microkernel? To do so you obviously need to have some experience with:

• C programming
• low level computer fundamentals

and have some UNIX (possibly Linux) installed.

If you don't know what L4 is, please read a wikipedia page about L4 microkernel family.

To start working with L4 you'll first have to understand how it works. The good starting point is L4 User Manual by Ihor Kuz from NICTA.

Due to its nature L4 perfectly matches the requirements of modern embedded systems. And now days almost all embedded systems are targeting the ARM architecture. The ARM reference manual contains all the information you could possibly need working with this architecture. However if this subject is completely new for you - you should probably search for more beginner-friendly documentation.

Implementation

There are several implementations of L4 out there, but the one that I've looked for to start playing with had to be:

• Open Sourced
• written in C & assembler
• easy to start playing with

After some time I've discovered Codezero Embedded Hypervizor and OS. As this project is quite new its codebase is not that overwhelming for a newcomer, however complete enough to give working and efficient starting point for my microkernel developing journey. Developers seem to put a lot of effort to maintain really well structured and clean code which seems very good for a project from which I'd like to learn.

Starting

While the Codezero Starting Guide is a good starting point and most of the time really useful it has some problems too: it's too lengthy and time consuming to follow and it contains some mistakes. That's why I've decided to automate all the work and set up my own Codezero git fork for newcomers. The init-build-env branch is where I accumulate all the changes that make life easier for a Codezero newcomer like me. With this changes you should be able to have L4 based project running in up to 30 minutes with most of the time spent on waiting for automated download and compilation process to complete.

Setting up tools and building codezero

To start just grab a copy of my Codezero's init-build-env repository with git:

 git clone git@github.com:dpc/codezero.git 

If you don't know what git is, how to run it or how it works - you should really spend some time getting familiar with it. Try Github's Introduction to Git.

So now, enter the project directory and run the tool script that will setup building environment for you:

 cd codezero ./tools/init-build-env.sh 

This script will do almost everything what is described in the Codezero's Getting Started page. It will download, build and install environment tools in [[~/opt/arm]] so that the only thing that you have to do (hopefully!) is to press enter once during installation, and add one directory to your PATH environment afterwards.

Just follow the process, install missing software if needed and rerun the script if required.

After successful execution you will have a build environment ready to build a codezero project.

First configure the project. The defaults are fine so just run:

 ./configure.py 

and press q to save the settings.

To build the project run:

 ./build.py 

If everything was prepared correctly the build process should create something like the following in the build directory:

 codezero$ ls build config.cml configdata config.h config.rules cont0 conts final.elf kernel.elf loader rules.compiled 

Runing codezero

To run and debug Codezero we will use a Qemu to emulate a fully working ARM-based system for us. So you should have qemu installed:

 codezero$ which qemu-system-arm /usr/bin/qemu-system-arm 

There are two options on how to debug the system:

• plain gdb
• insight frontend to gdb

As I don't like GUI applications in development process I'll describe using ./tools/run-qemu-gdb only. For Insight - you may use ./tools/run-qemu-insight - it does essentially the same thing.

So to make life easier link the script:

 ln -s tools/run-qemu-insight gdb 

and run it with:

 ./gdb 

so you should get:

 codezero$ ./gdb Qemu started. System serial console accessible via `telnet localhost 12445` GNU gdb (Sourcery G++ Lite 2009q3-67) 6.8.50.20090630-cvs Copyright (C) 2009 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "--host=i686-pc-linux-gnu --target=arm-none-linux-gnueabi". For bug reporting instructions, please see: <https://support.codesourcery.com/GNUToolchain/>. QEMU 0.11.0 monitor - type 'help' for more information (qemu) 0x00100000 in ?? () add symbol table from file "build/kernel.elf" at .text_addr = 0x8000 (gdb) 

What have just happened?

The script started Qemu to emulate an ARM system for us with a Codezero kernel image loaded. The virtual machine is stopped and waiting for commands. Two network sockets were created by the Qemu - one for gdb to control and debug the system and second emulating ARM system serial console - which embedded systems usually use as a basic I/O system.

Then - right after qemu - gdb is being started with symbols loaded and connected to qemu virtual machine so we can navigate through the source code as it's being executed and control the execution.

To connect to the system serial console, open new terminal and run:

 $ telnet localhost 12445 Trying ::1... Trying 127.0.0.1... Connected to localhost. Escape character is '^]'. 

Voila! You now have a L4 microkernel running in an ARM virtual machine and you're connected to it's serial port. Was not that hard, was it?

Initial debugging

As you may not know - the starting process for the Codezero is done in two steps. First - the loader is initializing the platform and then puts the kernel into the right place in the system's memory. Then it passes the execution to the kernel itself and gets out the way.

So, in the running gdb session try dissasemble command (or just dissas alias):

 (gdb) disas Dump of assembler code for function _start: 0x00100000 <_start+0>: ldr sp, [pc, #4] ; 0x10000c <_start+12> 0x00100004 <_start+4>: bl 0x102a8c <platform_init> 0x00100008 <_start+8>: bl 0x1003a0 <main> 0x0010000c <_start+12>: andseq lr, lr, r8, lsr #31 End of assembler dump. (gdb) 

It's here where everything starts. Corresponding code is in the loader/libs/c/crt/sys-userspace/arch-arm/crt0.S file and all the loader code is int the loader subdirectory. The starting point is written in the ARM assembler.

stepi will advance one CPU instruction forward. Run it two times, like this:

 (gdb) stepi 0x00100004 in _start () (gdb) stepi platform_init () at conts/libdev/uart/src/platform_init.c:56 56 { (gdb) 

As you may see the execution flow has reached the C code that is responsible for initializing the platform code. As we're now in the C code we can use list command to see the C code listing (or a l alias):

 (gdb) l 51 52 return 0; 53 } 54 55 void platform_init(void) 56 { 57 uart.base = PL011_BASE; 58 pl011_initialise(&uart); 59 } 60 (gdb) 

So we can see that platform_init function is doing only one thing here: initializing the UART.

As this is not a GDB tutorial I will not cover more about using gdb commands here. There are plenty of such tutorial on web - just look for it.

To advance to the point where the loaded gets out of the way do:

 (gdb) tbreak arch_start_kernel Temporary breakpoint 1 at 0x100374: file loader/main.c, line 103. (gdb) c Continuing. Breakpoint 1, arch_start_kernel (entry=0x102aa8) at loader/main.c:103 103 printf("elf-loader:\tStarting kernel\n\r"); (gdb) 

And then:

 (gdb) l 98 return 0; 99 } 100 101 void arch_start_kernel(void *entry) 102 { 103 printf("elf-loader:\tStarting kernel\n\r"); 104 void (*func)(unsigned long) = (void (*)(unsigned long)) (*(unsigned long*)entry); 105 func(0); 106 } 107 (gdb) n 103 printf("elf-loader:\tStarting kernel\n\r"); (gdb) n arch_start_kernel (entry=0x102aa8) at loader/main.c:104 104 void (*func)(unsigned long) = (void (*)(unsigned long)) (*(unsigned long*)entry); (gdb) n 105 func(0); (gdb) n 0x00008000 in _start_text () (gdb) 

You could be wondering at this point where are we. Well, we are at src/arch/arm/head.S on the line 27.

 (gdb) disassemble Dump of assembler code for function _start_text: 0x00008000 <_start_text+0>: msr CPSR_fc, #19 0x00008004 <_start_text+4>: mrc 15, 0, r0, cr1, cr0, {0} 0x00008008 <_start_text+8>: bic r0, r0, #1 0x0000800c <_start_text+12>: bic r0, r0, #4 0x00008010 <_start_text+16>: bic r0, r0, #4096 ; 0x1000 0x00008014 <_start_text+20>: bic r0, r0, #8 0x00008018 <_start_text+24>: mcr 15, 0, r0, cr1, cr0, {0} 0x0000801c <_start_text+28>: ldr sp, [pc, #40] ; 0x804c <_kernel_init_stack> 0x00008020 <_start_text+32>: msr CPSR_fc, #215 ; 0xd7 0x00008024 <_start_text+36>: ldr sp, [pc, #36] ; 0x8050 <_kernel_abt_stack> 0x00008028 <_start_text+40>: msr CPSR_fc, #210 ; 0xd2 0x0000802c <_start_text+44>: ldr sp, [pc, #32] ; 0x8054 <_kernel_irq_stack> 0x00008030 <_start_text+48>: msr CPSR_fc, #209 ; 0xd1 0x00008034 <_start_text+52>: ldr sp, [pc, #28] ; 0x8058 <_kernel_fiq_stack> 0x00008038 <_start_text+56>: msr CPSR_fc, #219 ; 0xdb 0x0000803c <_start_text+60>: ldr sp, [pc, #24] ; 0x805c <_kernel_und_stack> 0x00008040 <_start_text+64>: msr CPSR_fc, #211 ; 0xd3 0x00008044 <_start_text+68>: bl 0x1493c <start_kernel> 0x00008048 <_start_text+72>: b 0x8048 <_start_text+72> End of assembler dump. (gdb) 

To skip this code use step. This will get us to the next C code:

 (gdb) s Single stepping until exit from function _start_text, which has no line number information. start_kernel () at src/glue/arm/init.c:295 295 printascii("\n"__KERNELNAME__": start kernel...\n"); (gdb) l 290 scheduler_start(); 291 } 292 293 void start_kernel(void) 294 { 295 printascii("\n"__KERNELNAME__": start kernel...\n"); 296 297 /* 298 * Initialise section mappings 299 * for the kernel area (gdb) 

Last words

I think this is enough to start with. You should now concentrate on using debugger, reading a source code and available documentation to learn how do the things work in the Codezero L4 microkernel.

It may take you some time, but I hope you will have much more enthusiasm now - with a working codebase and debugger - to learn about L4 and Codezero. And eventually you may start to contribute to this wonderful project yourself.

If you had any problems or you find anything not clear enough, just leave me a note in a comment and I'll try to help and correct any mistakes that I've made.

 if [[ $- != *i* ]] ; then # Shell is non-interactive. Be done now! return fi if [[ "$IN_THE_SCREEN" != "TRUE" ]]; then export IN_THE_SCREEN="TRUE" exec screen -xRR -S main fi 

As I use bash as a default shell, I plug this code into .bashrc with just one line:

 [ -f "$HOME/.bashrc.screen" ] && source "$HOME/.bashrc.screen" 

This way I don't have to remember about running screen manually which obviously has many advantages. And I can connect/disconnect from multiple locations and work on one default session without disconnecting any ssh client already connected. It's like remote desktop session - only for shell account.

 $ uname -a Linux richiter 2.6.31-16-generic #52-Ubuntu SMP Thu Dec 3 22:07:16 UTC 2009 x86_64 GNU/Linux $ lspci -v | grep -i audio 00:1b.0 Audio device: Intel Corporation 82801H (ICH8 Family) HD Audio Controller (rev 03) 

Resources:
https://wiki.ubuntu.com/DebuggingSoundProblems/KarmicCaveats
http://blog.paulbetts.org/index.php/2007/05/27/make-wine-and-pulseaudio-get-along/

So I did:

• padsp winecfg, and changed driver to oss: hardware acceleration as emulation, 44100, 16 bit, no driver emulation;
• I've installed newer backport of alsa for Karmic Koala;
• I'm now running Spotify with env WINEPREFIX="/home/dpc/.wine" padsp wine "C:\Program Files\Spotify\spotify.exe" and sound is perfect;

Hope that will help somebody.—

Edit:
I have now installed wine1.2 package in Ubuntu and sound works even better without any winecfg tweaks.

I've decided to use Drupal 6. This is obvious choice as it's seems current and stable. Nothing to add here, I guess.

I must admit that installation was very straightforward and easy. Nothing really tricky. However I had some problems with hosting. On the current hosting provider that the organization is using: strefa.pl installation failed. After editing .htdocs file and removing "Option" sections I was able to get initial stage of installation, but it couldn't finish.

I've searched the web and found out that public opinion about this hosting is very bad and even on the most known polish hosting provider: home.pl things may need some trickery because they are not using apache.

After some research I've decided to try linuxpl.com hosting and so far I'm happy with the choice. It seems everything I need will be working even on the most basis hosting option, which is very cheap solution for me. However it's far to early to make any strong opinions about the overall quality of this hosting. But I must admit that the fact they have a linux in the name pleases me. They claim they give ssh access after fully activating the account (paying ;) ) which seems neat.

First impression

Right after installation Drupal functionality seemed painfully limited. Navigation is easy but I couldn't see where did the whole Drupal hype came from. I had no idea how to make anything more useful than basic WordPress installation …

However I've made a long journey to read about how to use Drupal and quickly discovered that it's very powerful after extending it with Drupal modules .

Understanding howto use Drupal

I think I've got it all figured out now, after few days with toying with it so I'll quickly describe what I think may help others to understand how to use Drupal.

Content on the page

Basically each page view in Drupal seems to be build from the following elements:

• menus
• blocks
• page content
• other minor elements

Menu configuration is very similar to the solutions from other CMSs - hierarchical system with few roots (primary links, secondary links, navigation). Of course you can do more advanced stuff with it, but the basic concept is simple.

Blocks for me are … widgets. Each site theme provides you with regions like: header, footer, left column, right column, etc. . In the block configuration menu you can put blocks (widgets) in the places (regions) you like with some more advanced options (what to display, when, and in what way). You can create your own blocks as well (more about this later).

Main content is displayed in the main content area (at least basically).

Modules

Drupal is all about it's modules. Take a look how many of them is there: Drupal modules. Got to the http://yoursite.com/admin/build/modules and get familiar with it. Installation of new modules is a matter of dropping extracted module to the modules subdirectory and enabling it on the module administration page.

Internationalization

If you're not going to use it you may consider installing it anyway. But if know you're going to use it at some point: install, configure it and play with it on the very beginning. It will save your time discovering how does it connect with other modules later. I18n is available almost everywhere and its configuration is on each and every place.

Content and CCK

Content Construction Kit (CCK) is the very basic module that you should install at the very beginning and which is crucial for the way Drupal works.

The basic idea is not to use page or article for everything on you site, but to create a content category for the things you want to be a content. If you're creating a site about music you may want to have a song, artist or album content type. Each content type may have a custom fields. Album will probably refer to it author as a artist reference, have it's cover (as image that you can upload). A song may refer to the album on which it's placed. This is all achievable through adding fields.

What does it give? It gives a structure to your content. Instead of thinking about the categories and pages - you create a content first. And then you can do some magic with other modules to make this objects display in many various ways. Create a widget to display "other songs for this artist", etc.

Views

Next main modules is the Views. It's damn hard to understand and learn, but it's incredibly powerful. Using structured data from the CCK you can create page content, blocks (widgets) with any functionality you imagine. You will have to seek for solutions on the web at first, but after a while you will have and menus, widgets and pages that you desire.

Big advice - read the provided documentation first. Learn how to create basic views and then implement some ideas described by other people on the web. You may have to code (or at least copy) some PHP to get more advanced views. And you may have a hard time figuring out what the heck is going on at first. But it's totally worth it.

And remember to look at the publication date of documents you read. Views 2 is the version you're using. There are many tutorials on the web that describe other older versions.

Taxonomy

Taxonomy module will allow you to attach abstract terms to the content. You can use many sets of terms for different purposes. This is used by Views and CCK. Read a documentation and understand how this works - it will be crucial for efficient use of Views and CCK.

Other modules

At the moment in my modules directory is about 60 entries.

Below are the one that I find most important:

admin_menu

Displays a handy administration menu to let you quickly work with your site. Very useful for site administator.

cck

Already described. A must-have.

extlink

Put these nice arrows next to outgoing links.

google_analytics

Obviously, you'll want to watch some stats about the result of your work.

imagecache

A must have if you're going to work with images in your content. Lets you configure profiles for the images to have them in desired sizes here and there.

imagefield

Lets you add fields of image type to your CCK content. As the above - a must-have.

masquerade

Want to take quick look how does the site looks like for particular user? This is it.

profile

Let's you configure a Profile content type where users put information about themselves.

realname

If you want users to be identified by the full names instead of logins - this will to the job.

taxonomy

Already described. A must-have.

views

Already described. A must-have indeed.

Summary

Drupal is powerful, but damn hard to understand at first. And things that make it powerful like CCK and Views are definitely not configurable for non tech-savy users. Each web site will have to get some kind of skilled admin that will get it up and running, understand relational databases (Views) and will be familiar with how do pieces (modules) work together. However it is possible to create an environment in which normal users (content editors, translators, users) will feel comfortable and able to work.

The project name for it is metaforward as more obvious metafilter is already used by metafilter weblog.

I'm pretty sure many people have already thought about this but I'm unable to find any existing project on the web.

Recently my disk crashed and I had to restore the data from backups. This have gave me an opportunity to make some maintenance with stuff I keep. I've already spent some time on online services, but now I've gone with my private data. It's good I've had some free time due to staying at home on a sick leave because it's so many of data to be segregated, compressed, backed up, etc.

Today I've finally was able to work on my wikidot page. I love wikidot, all it's features and endless possibilities it gives me. With help of firebug firefox extension I've quickly made my page look better and now I'm working on restructuring it a bit.

I was thinking about setting up a blog as nowadays I've got more and more interesting things on my mind that I'd like to share. As I think I'll be writing more now I hope to work more with my precious wiki.

So now you can find my wiki under dpc.ucore.info. I hope to have a comfort of possible domain delegation change when I'm moving my service providers. We shall see if it is going to work.

Lately I've made it public - hoping that someone will be willing to help me before I get a grade. (Kidding. :D) . I'm not even near finishing it, but the current state of UI is quite nice and I plan to add basic game logic soon.

I have migrated all my public repositories to github.

Changes:

• Remote control.
• Unicode status fixes.
• New home page and git public repository.

Today I've managed to find some time to get this wiki into shape that I can call "activation". I hope it will be useful (especially for me).