国家予算の概算要求が95兆380億円と過去最高になり、自民党政権時代を上回ったとマスコミは騒いでいる。
今のところ、マスコミの姿勢は「民主党は公約実現のため、赤字国債を出してでもやろうとしている。これはいかがなものか？」である。
これは早計であると私は考える。なぜならば概算要求は、政府の予算方針にしたがって省庁が出してきた「たたき台」であって、これから「予算」成立までに国会で審議されなければ決定ではないからである。
旧自民党政権では、概算要求でほぼ決まりだったので、いたしかたない部分もあるのだが。

とはいえ、私もよく成立過程についてよく知らないので調べてみると、下記の手続きで進められることがわかった。

【０】．予算編成方針を閣議で決定する。（9月29日）

財務省から出ている平成22年度予算の方針は下記のとおり

平成22 年度予算編成の方針について
平成21 年9 月29 日
閣議決定
１．平成22 年度予算については、年内に編成する。
２．平成22 年度の予算編成に当たっては、ムダづかいや不要不急な事業を根絶すること等により、マニフェストの工程表に掲げられた主要な事項を実現していくため、以下の方針で臨む。
(1) 現行の概算要求基準（「平成22年度予算の概算要求に当たっての基本的な方針について」（平成21 年7 月1 日閣議了解））は廃止する。
(2) マニフェスト（「三党連立政権合意書」を含む。以下同じ。）を踏まえた要求の提出は、10 月15 日までに行うこととする。
(3) マニフェストに従い、新規施策を実現するため、全ての予算を組み替え、新たな財源を生み出す。これにより、財政規律を守り、国債マーケットの信認を確保していく。
(4) 各大臣は、既存予算についてゼロベースで厳しく優先順位を見直し、できる限り要求段階から積極的な減額を行うこととする。

【１】.各省庁が予算編成方針に従いそれぞれの予算案を提出（概算要求）
ここが、95兆380億円である。
概算要求の概要は各省庁のHPで見ることができる。
この時点での評価すると、総額は「方針」とはかなりかけ離れたものとなっていて、感覚的には「マニフェスト実施費用＋前政権の宿題（ツケ）」となってしまっていることだ。方針(4)が徹底されていないような気がする。
また今回はシーリング（概算要求基準）が廃止され、予算枠がなくなってしまったので省庁とも歳出を抑えるということはないがごときの内容となってしまっている。
本当にそうなのかは、各省庁の概算要求を子細に見てみないとわからない。

【２】.財務省が取りまとめ、調整をおこない、財務省原案を作成
【２．５】復活折衝にて財務省原案の修正を行う。
【３】.財務省原案を閣議で議論し、決定すると予算案となる
【４】.予算案を衆院本会議に提出する。
【５】．衆院予算委員会にて議論。各省庁ごとに分科会を開き議論する。
【６】．衆院本会議で予算案を可決・否決する

【７】．参院本会議に予算案が提出される
【８】．参院予算委員会にて議論。各省庁ごとに分科会を開き議論する。
【９】．参院本会儀にて予算案を可決・否決する

いままでの政権では【３】−【９】までがほぼ形骸化していたわけであるが、現政権ではどうなるか見ものである。

なんとなくZ80についてググっていたら、すごいページを発見。
http://homepage3.nifty.com/z80/

HTMLに関してはかなり遠ざかっていたのだけれど、5.0になってマルチメディア関連のタグが増えている。
<audio>タグ オーディオストリーム
<video>タグ ビデオストリーム再生
<canvas>タグ 2D描画
これを使用すれば、下記のサイトのようなゲームつくりが可能である。
http://29a.ch/jswars/
すごい世の中になったものだ。。。
http://www.html5.jp/
ちょっと上記のサンプルを拝借してcanvasに描画してみたのが下の画面。
（おそらくMozillaやChromeでないと表示されません。）

V8のことを調べていたら、下記サイトを発見
Chromeってすごいね。
http://www.chromeexperiments.com/

今日は嫁に夕ご飯を作る宣言をしてしまったので、名古屋風の手羽先のから揚げを作ることにした。
手羽先とスペアリブをスーパーで買ってきて、てんぷら粉をまぶして油で15分程度揚げ、ダイショーの「手羽唐のたれ」と塩コショウをまぶして仕上げた。
結構うまくでき、子供も喜んで食べていたが、量が少なかった。。。
手羽先で満腹になるためには1Kgは必要かな。。。
まあ、僕は昼食が大久保二郎のつけ麺だったから、ちょうど良かったんだけれどね。

実装はあちこち回り道して遅々として進まない。
ようやくバッファサイズの列挙ができたところだ。

JUCEのデフォルトで持っているオーディオデバイスのセレクタクラス(AudioDeviceSelector)
の場合レイテンシはバッファサイズ指定がデフォルトで、WASAPIの場合レイテンシはREFERENCE_TIME型で100nsec単位の時間指定（僕のハードだと最小3ms、デフォルト10ms)となっているため、苦肉の策として3ms-10msまでを1ms単位で設定して実際に得られるバッファサイズを列挙している。
本当はSliderBarとかで時間指定したいので、カスタマイズできるかJUCEライブラリのAudioDeviceSelector関連コードを見ているところである。

気がついたらBoost.asioでWindowsの非同期ファイルI/Oがサポートされていた（最初から？）。

http://www.boost.org/doc/libs/1_40_0/doc/html/boost_asio/overview/windows/stream_handle.html

MMCSSに関して少し勉強した。
http://d.hatena.ne.jp/NyaRuRu/20060910
http://www.firefly-vj.net/imagery/?itemid=392
実行スレッド中でAvSetMmThreadCharacteristics をL"Audio"もしくはL"Pro Audio"を引数にして呼び出すと、timeBeginPeriod(1)と同様の効果がある。
つまりコンテキストスイッチの頻度が高くなり、精度が上がる（レイテンシが改善される、Sleep(1)が1msecで戻ってくる）。
ガイドラインとしては、10msec程度のレイテンシの場合L"Audio"、10msec以下の場合はL"Pro Audio"を指定する。
MMCSS、というかVistaのスレッドに関するMSの解説。
http://technet.microsoft.com/ja-jp/magazine/2007.02.vistakernel.aspx

久しくDirectX関連はウォッチしていなかったのだけれど、Windows 7からDirect2Dという2DグラフィックスAPIが搭載されるとのこと。
これはGDI,GDI+に取って代わるもので、D3Dの上で構築されている。
当初DirectXは2Dのゲーム用ビットマップグラフィックスAPIで、それから3D APIが搭載され、2D部分が（名目上）なくなって、ビジネスグラフィックスの置き換えのためにまた復活した。
GDI+と違い、ハードウェアアクセラレーションが効くとのことで普及するのではないかと見られている。
しかし、本当はビデオメモリに余計なオーバーヘッドなく読み書きができるようになれば後はソフトウェアでなんとかなりそうななんだが、そういう風には世の中は流れてはいかないようだ。

JUCEのWASAPIサポートはすでに始まっていて、ソースコードも見ることができる。
http://www.rawmaterialsoftware.com/juceforum/viewtopic.php?t=4404
ただ、いまのところ共有モードのみで、排他モードのサポートはないようだ。おそらくWindows 7が共有モードで低レイテンシ再生・録音が可能になっているためであろうと考える。
http://msdn.microsoft.com/en-us/library/dd756612(VS.85).aspx
とりあえず私は、上記ソースコードも参考にしながら、排他モードでのサポートを目指すことにする。

ptr_vectorの初期化にBoost.Assignemntを使ってみようとして午前中四苦八苦していた。
こうしたかったのだ。

boost::ptr_vector<WAVEFORMATEX> WASAPI::impl::wave_formats_ = 
		ptr_list_of<WAVEFORMATEX<
		( WAVE_FORMAT_PCM, 2, 192000,768000, 4, 16, 0 )    
		( WAVE_FORMAT_PCM, 2, 96000, 384000, 4, 16, 0 )    // 96-kHz, 16-bit stereo
		( WAVE_FORMAT_PCM, 2, 48000, 192000, 4, 16, 0 )    // 48-kHz, 16-bit stereo
		( WAVE_FORMAT_PCM, 2, 44100, 176400, 4, 16, 0 )    // 44.1-kHz, 16-bit stereo
		( WAVE_FORMAT_PCM, 2, 32000, 128000, 4, 16, 0 )    // 32-kHz, 16-bit stereo
		( WAVE_FORMAT_PCM, 2,  8000,  32000, 4, 16, 0 )    // 8-kHz, 16-bit stereo
		( WAVE_FORMAT_PCM, 2, 48000,  96000, 2,  8, 0 )    // 48-kHz, 8-bit stereo
		( WAVE_FORMAT_PCM, 2, 44100,  88200, 2,  8, 0 )    // 44.1-kHz, 8-bit stereo
		( WAVE_FORMAT_PCM, 2, 32000,  64000, 2,  8, 0 )    // 32-kHz, 8-bit stereo
		( WAVE_FORMAT_PCM, 2,  8000,  16000, 2,  8, 0 );//    // 8-kHz, 8-bit stereo

四苦八苦した結果、下記のとおりにすればできることがわかった。
（１）WAVEFORMATEXを継承した構造体、sf:WAVEFORMATEXを作成してコンストラクタを実装する。
（２）#define BOOST_ASSIGN_MAX_PARAMS 7をptr_list_of.hppをインクルードする前に入れる。

#define BOOST_ASSIGN_MAX_PARAMS 7
#include <boost/assign.hpp>
#include <oost/assign/ptr_list_of.hpp>
namespace sf {

struct WAVEFORMATEX : public ::WAVEFORMATEX {
	WAVEFORMATEX(
		WORD        FormatTag = 0,         /* format type */
		WORD        Channels = 0,          /* number of channels (i.e. mono, stereo...) */
		DWORD       SamplesPerSec = 0,     /* sample rate */
		DWORD       AvgBytesPerSec = 0,    /* for buffer estimation */
		WORD        BlockAlign = 0,        /* block size of data */
		WORD        BitsPerSample = 0,     /* number of bits per sample of mono data */
		WORD        Size = sizeof(::WAVEFORMATEX)            /* the count in bytes of the size of */
		)  
		{
			wFormatTag = FormatTag;
			nChannels = Channels;
			nSamplesPerSec = SamplesPerSec;
			nAvgBytesPerSec = AvgBytesPerSec;
			nBlockAlign = BlockAlign;
			wBitsPerSample = BitsPerSample;
			cbSize = Size;			
		};
};

boost::ptr_vector<sf::WAVEFORMATEX> WASAPI::impl::wave_formats_ = 
		ptr_list_of<sf::WAVEFORMATEX>
		( WAVE_FORMAT_PCM, 2, 192000,768000, 4, 16, 0 )    
		( WAVE_FORMAT_PCM, 2, 96000, 384000, 4, 16, 0 )    // 96-kHz, 16-bit stereo
		( WAVE_FORMAT_PCM, 2, 48000, 192000, 4, 16, 0 )    // 48-kHz, 16-bit stereo
		( WAVE_FORMAT_PCM, 2, 44100, 176400, 4, 16, 0 )    // 44.1-kHz, 16-bit stereo
		( WAVE_FORMAT_PCM, 2, 32000, 128000, 4, 16, 0 )    // 32-kHz, 16-bit stereo
		( WAVE_FORMAT_PCM, 2,  8000,  32000, 4, 16, 0 )    // 8-kHz, 16-bit stereo
		( WAVE_FORMAT_PCM, 2, 48000,  96000, 2,  8, 0 )    // 48-kHz, 8-bit stereo
		( WAVE_FORMAT_PCM, 2, 44100,  88200, 2,  8, 0 )    // 44.1-kHz, 8-bit stereo
		( WAVE_FORMAT_PCM, 2, 32000,  64000, 2,  8, 0 )    // 32-kHz, 8-bit stereo
		( WAVE_FORMAT_PCM, 2,  8000,  16000, 2,  8, 0 );//    // 8-kHz, 8-bit stereo

VC Express EditionにはATLがついてないので、CComPtr(COMスマートポインタ)がない。
boost::intrusive_ptrで代用していた(ちなみに代用方法はこちら参照)のだが、どうにも面倒臭いのでググってみたらやはりCComPtrクローンを作っている人がいた。
http://www.codeproject.com/KB/COM/ccomptr.aspx
http://www.firefly-vj.net/imagery/?itemid=354
上記2つを適当にマージして作ったのが下記コード。

#ifndef _COMPTR_H_
#define _COMPTR_H_

template<class INTERFACE, const IID* piid = NULL>
class CComPtr
{
public:
	CComPtr()
	{
		interface_ = NULL;
	}

	CComPtr(INTERFACE* lPtr)
	{
		interface_ = NULL;

		if (lPtr != NULL)
		{
			interface_ = lPtr;
			interface_->AddRef();
		}
	}

	CComPtr(const CComPtr<INTERFACE, piid>& RefComPtr)
	{
		interface_ = NULL;
		interface_ = (INTERFACE*)RefComPtr;

		if (interface_)
		{
			interface_->AddRef();
		}
	}
	CComPtr(IUnknown* pIUnknown, IID iid)
	{
		interface_ = NULL;

		if (pIUnknown != NULL)
		{
			pIUnknown->QueryInterface(iid, (void**)&interface_);
		}
	}
	~CComPtr()
	{
		if (interface_)
		{
			interface_->Release();
			interface_ = NULL;
		}
	}

public:
	operator INTERFACE*() const
    {
        return interface_;
    }

	INTERFACE& operator*() const
    {
		return *interface_;
    }

	INTERFACE** operator&()
    {
        return &interface_;
    }

	INTERFACE* operator->() const
	{
		return interface_;
	}

	INTERFACE* operator=(INTERFACE* lPtr)
	{

		if (IsEqualObject(lPtr))
		{
			return interface_;
		}

		interface_->Release();
		lPtr->AddRef();
		interface_ = lPtr;
		return interface_;
	}

	INTERFACE* operator=(IUnknown* pIUnknown)
    {
		assert(pIUnknown != NULL);
		assert(piid != NULL);
        pIUnknown->QueryInterface(*piid, (void**)&interface_);
		assert(interface_ != NULL);
		return interface_;
    }

	INTERFACE* operator=(const CComPtr<INTERFACE, piid>& RefComPtr)
	{
		assert(&RefComPtr != NULL);
		interface_ = (INTERFACE*)RefComPtr;

		if (interface_)
		{
			interface_->AddRef();
		}
		return interface_;
	}

	void Attach(INTERFACE* lPtr)
    {
        if (interface_)
		{
			interface_->Release();
		}
		interface_ = lPtr;
    }

    INTERFACE* Detach()
    {
        INTERFACE* lPtr = interface_;
        interface_ = NULL;
        return lPtr;
    }

	void Release()
	{
		if (interface_)
		{
			interface_->Release();
			interface_ = NULL;
		}
	}

	bool IsEqualObject(IUnknown* pOther)
	{
		assert(pOther != NULL);
		IUnknown* pUnknown = NULL;
		interface_->QueryInterface(IID_IUnknown, (void**)&pUnknown);
        bool Result = (pOther == pUnknown) ? true : false;
		pUnknown->Release();
		return Result;
	}

    HRESULT CreateInstance(const GUID &clsid, IID iid=GUID_NULL)
	{
		if(IsEqualObject(iid, GUID_NULL)) iid=__uuidof(T);
		HRESULT hr = ::CoCreateInstance(clsid, NULL
			,CLSCTX_INPROC_SERVER
			,iid
			,(void**)(&interface_));
		return hr;
    }

private:
	INTERFACE* interface_;
};

#endif // _COMPTR_H_

しかし、今頃になってCOM Interfaceラッパを作る羽目になるとは。。。

SyntaxHighlighterを2.0.320にアップした。
http://alexgorbatchev.com/wiki/SyntaxHighlighter

IMMDeviceのGetId( LPWSTR *ppstrId)で、デバイスIDの文字列が取得できるのだが、この文字列はOSでアロケートされたメモリに格納されるので、不要になったらCoTaskMemFree()しなくてはならない。
こういうのは忘れやすい僕にとっては危険な仕様なので、ラッパクラスを作って確実に解放するようにしたい。
すこしググってみたらやっぱり同じことを考えている人がいて、ポリシーベースの立派なものがすでに作られていたので、早速拝借することにする。

＜元ネタ＞https://forums.codegear.com/thread.jspa?messageID=97614&#97614

namespace sf
{
// policy class
struct HeapMemoryFreePolicy
{
template< typename T >
void operator()( const T* AMemory ) const
{
if( NULL != AMemory )
::HeapFree( ::GetProcessHeap(), 0, AMemory );
}
};
// policy class
struct LocalMemoryFreePolicy
{
template< typename T >
void operator()( const T* AMemory ) const
{
if( NULL != AMemory )
::LocalFree( AMemory );
}
};
// policy class
struct CoTaskMemoryFreePolicy
{
template< typename T >
void operator()( const T* AMemory ) const
{
if( NULL != AMemory )
::CoTaskMemFree( AMemory );
}
};
// base guard class
template< typename T,
class TFreePolicy
class BaseMemory
{
private:
T *FMemory;

public:
BaseMemory( T* AMemory = NULL )
: FMemory( AMemory ) {}

virtual ~BaseMemory( void )
{ Reset(); }

T* Release( void )
{
T *tmp = FMemory;
FMemory = NULL;
return tmp;
}

void Reset( T* AMemory = NULL )
{
if( AMemory != FMemory )
{
if( NULL != FMemory )
TFreePolicy( FMemory );

FMemory = AMemory;
}
}

T* Get( void )
{ return FMemory; }

T** operator&( void )
{ return &FMemory; }

};
template< typename T >
class HeapMemory : public BaseMemory< T, 
HeapMemoryFreePolicy >
{
public:
HeapMemory( T* AMemory = NULL )
: BaseMemory< T, HeapMemoryFreePolicy >( AMemory )
{ }
};
template< typename T >
class LocalMemory : public BaseMemory< T, 
LocalMemoryFreePolicy >
{
public:
LocalMemory( T* AMemory = NULL )
: BaseMemory< T, LocalMemoryFreePolicy >( AMemory )
{ }
};
template< typename T >
class CoTaskMemory : public BaseMemory< T, 
CoTaskMemoryFreePolicy >
{
public:
CoTaskMemory( T* AMemory = NULL )
: BaseMemory< T, CoTaskMemoryFreePolicy >( AMemory )
{ }
};

} // end namespace sf