Version 0.3.0 released.

Fix generate of video output from StillPicture.
Add support for resolution dependend video parameterts (Deinterlace,
Scaling, Denoise, Sharpen, ...).

ChangeLog

@@ -1,5 +1,28 @@
 User johns
-Date:
+Date: Mon Jan  9 22:09:38 CET 2012
+
+    Release Version 0.3.0
+    Add support of resolution dependend video parameters (deint, scale, ...).
+    Add support for recording play back.
+    Add workaround for alsa crash in snd_pcm_prepare.
+    Fix bug: audio crash on exit.
+    Fix build with vdr without yaepg support.
+    Support yaepghd video picture output position change.
+
+Date: Sat Jan  7 13:20:07 CET 2012
+
+    Release Version 0.2.0
+    Add support for ac3 audio pass through.
+    Add workaround for alsa not playing hdmi sound.
+    Fix bug: broken device plugin stop and exit.
+    Show transparent cursor to hide cursor.
+    VDPAU: Add color standard support.
+    VDPAU: Add denoise and sharpness support.
+    VDPAU: Add skip chroma deinterlace support.
+    VDPAU: Show OSD only if something is to display, improves performance.
+    VDPAU: Add deinterlace with only 4 surfaces.
+
+Date: Thu Jan 4 17:00:00 CET 2012
 
     Release Version 0.1.5
     Adds OSS mixer support.

README.txt

@@ -92,19 +92,37 @@ Setup: /etc/vdr/setup.conf
 ------
 	Following is supported:
 
-	softhddevice.Deinterlace = 0
-	0 = bob, 1 = weave, 2 = temporal, 3 = temporal_spatial, 4 = software
-	(only 0, 1 supported with vaapi)
-
 	softhddevice.MakePrimary = 1
 	0 = no change, 1 make softhddevice primary at start
 
-	softhddevice.Scaling = 0
+	<res> of the next parameters is 567i, 720p, 1080i_fake or 1080i.
+	1080i_fake is 1280x1080 or 1440x1080
+	1080i is "real" 1920x1080
+
+	softhddevice.<res>.Scaling = 0
 	0 = normal, 1 = fast, 2 = HQ, 3 = anamorphic
 
+	softhddevice.<res>.Deinterlace = 0
+	0 = bob, 1 = weave, 2 = temporal, 3 = temporal_spatial, 4 = software
+	(only 0, 1 supported with vaapi)
+
+	softhddevice.<res>.SkipChromaDeinterlace = 0
+	0 = disabled, 1 = enabled (for slower cards, poor qualit<69>t)
+
+	softhddevice.<res>.Denoise = 0
+	0 .. 1000 noise reduction level (0 off, 1000 max)
+
+	softhddevice.<res>.Sharpness = 0
+	-1000 .. 1000 noise reduction level (0 off, -1000 max blur,
+	    1000 max sharp)
+
 	softhddevice.AudioDelay = 0
 	+n or -n ms
 
+	softhddevice.AudioPassthrough = 0
+	0 = none, 1 = AC-3
+
+
 Commandline:
 ------------
 

Todo

@@ -27,14 +27,21 @@ missing:
     atmolight
     zoom/fit-zoom 4:3
     multistream handling
-    HDMI/SPDIF Passthrough
     disable screensaver
     disable window cursor
+    ITU BT601, ITU BT709 (HD), RGB studio levels (16-235)?
 
 vdpau:
-    1080i with temporal spatial and level 1 scaling too slow with GT 520
-    1080i with temporal spatial too slow with GT 520 on some channels
+    1080i with temporal spatial and level 1 scaling too slow with my GT 520
+    1080i with temporal spatial too slow with my GT 520 on some channels
+    SkipChromaDeinterlace improves performance
+    Improve OSD handling, show only what is used. Big OSD costs performance
     VdpPreemptionCallback handling
+    hard channel switch
+
+libva:
+    hard channel switch
+    yaepghd (VaapiSetOutputPosition) support
 
 libva-intel-driver:
     intel still has hangups most with 1080i
@@ -71,8 +78,13 @@ audio/oss:
     alsa oss emulation mixer "pcm" not working
     ring buffer overflow with alsa oss emulation
 
+HDMI/SPDIF Passthrough:
+    only AC-3 written
+    Channels are wrong setup, if changing setting during operation.
+
 playback of recording
-    play back is too fast
+    pause is not reset, when replay exit
+    replay/pause need 100% cpu
 
 setup:
     Setup of decoder type.
@@ -81,3 +93,4 @@ setup:
     Setup 4:3 zoom type
     Setup parameters are not used until restart.
 	Can a notice be added to the setup menu?
+    576i, 720p, fake 1080i, 1080i

audio.c

@@ -43,6 +43,8 @@
 #endif
 //#define USE_ALSA			///< enable alsa support
 //#define USE_OSS			///< enable oss support
+#define noSEARCH_HDMI_BUG
+#define noSEARCH_HDMI_BUG2
 
 #include <stdio.h>
 #include <stdint.h>
@@ -88,6 +90,8 @@
 #endif
 #endif
 
+#include <alsa/iatomic.h>		// portable atomic_t
+
 #include "ringbuffer.h"
 #include "misc.h"
 #include "audio.h"
@@ -110,6 +114,95 @@ static int64_t AudioPTS;		///< audio pts clock
 static pthread_cond_t AudioStartCond;	///< condition variable
 #endif
 
+#ifdef SEARCH_HDMI_BUG2
+
+//----------------------------------------------------------------------------
+//	ring buffer
+//----------------------------------------------------------------------------
+
+// FIXME: use this code, to combine alsa&oss ring buffers
+
+#define AUDIO_RING_MAX 8		///< number of audio ring buffers
+
+/**
+**	Audio ring buffer.
+*/
+typedef struct _audio_ring_ring_
+{
+    char FlushBuffers;			///< flag: flush buffers
+    unsigned SampleRate;		///< sample rate in hz
+    unsigned Channels;			///< number of channels
+} AudioRingRing;
+
+    /// ring of audio ring buffers
+static AudioRingRing AudioRing[AUDIO_RING_MAX];
+static int AudioRingWrite;		///< audio ring write pointer
+static int AudioRingRead;		///< audio ring read pointer
+static atomic_t AudioRingFilled;	///< how many of the ring is used
+
+/**
+**	Add sample rate, number of channel change to ring.
+**
+**	@param freq	sample frequency
+**	@param channels	number of channels
+*/
+static int AudioRingAdd(int freq, int channels)
+{
+    int filled;
+
+    filled = atomic_read(&AudioRingFilled);
+    if (filled == AUDIO_RING_MAX) {	// no free slot
+	// FIXME: can wait for ring buffer empty
+	Error(_("audio: out of ring buffers\n"));
+	return -1;
+    }
+    AudioRing[AudioRingWrite].FlushBuffers = 1;
+    AudioRing[AudioRingWrite].SampleRate = freq;
+    AudioRing[AudioRingWrite].Channels = channels;
+
+    AudioRingWrite = (AudioRingWrite + 1) % AUDIO_RING_MAX;
+    atomic_inc(&AudioRingFilled);
+
+#ifdef USE_AUDIO_THREAD
+    // tell thread, that something todo
+    AudioRunning = 1;
+    pthread_cond_signal(&AudioStartCond);
+#endif
+
+    return 0;
+}
+
+/**
+**	Setup audio ring.
+*/
+static void AudioRingInit(void)
+{
+    int i;
+
+    for (i = 0; i < AUDIO_RING_MAX; ++i) {
+	// FIXME:
+	//AlsaRingBuffer = RingBufferNew(48000 * 8 * 2);	// ~1s 8ch 16bit
+    }
+    // one slot always reservered
+    AudioRingWrite = 1;
+    atomic_set(&AudioRingFilled, 1);
+}
+
+/**
+**	Cleanup audio ring.
+*/
+static void AudioRingExit(void)
+{
+    int i;
+
+    for (i = 0; i < AUDIO_RING_MAX; ++i) {
+	// FIXME:
+	//RingBufferDel(AlsaRingBuffer);
+    }
+}
+
+#endif
+
 #ifdef USE_ALSA
 
 //============================================================================
@@ -152,6 +245,7 @@ static int AlsaAddToRingbuffer(const void *samples, int count)
     if (n != count) {
 	Error(_("audio/alsa: can't place %d samples in ring buffer\n"), count);
 	// too many bytes are lost
+	// FIXME: should skip more, longer skip, but less often?
     }
     // Update audio clock
     AudioPTS +=
@@ -202,12 +296,25 @@ static int AlsaPlayRingbuffer(void)
 	    if (first) {
 		// happens with broken alsa drivers
 		Error(_("audio/alsa: broken driver %d\n"), avail);
+		usleep(5 * 1000);
 	    }
 	    Debug(4, "audio/alsa: break state %s\n",
 		snd_pcm_state_name(snd_pcm_state(AlsaPCMHandle)));
 	    break;
 	}
+#ifdef SEARCH_HDMI_BUG
+	{
+	    uint16_t buf[8192];
+	    unsigned u;
 
+	    for (u = 0; u < sizeof(buf) / 2; u++) {
+		buf[u] = random() & 0xffff;
+	    }
+
+	    n = sizeof(buf);
+	    p = buf;
+	}
+#else
 	n = RingBufferGetReadPointer(AlsaRingBuffer, &p);
 	if (!n) {			// ring buffer empty
 	    if (first) {		// only error on first loop
@@ -215,6 +322,7 @@ static int AlsaPlayRingbuffer(void)
 	    }
 	    return 0;
 	}
+#endif
 	if (n < avail) {		// not enough bytes in ring buffer
 	    avail = n;
 	}
@@ -229,12 +337,17 @@ static int AlsaPlayRingbuffer(void)
 	} else {
 	    err = snd_pcm_writei(AlsaPCMHandle, p, frames);
 	}
-	Debug(4, "audio/alsa: wrote %d/%d frames\n", err, frames);
+	//Debug(3, "audio/alsa: wrote %d/%d frames\n", err, frames);
 	if (err != frames) {
 	    if (err < 0) {
 		if (err == -EAGAIN) {
 		    goto again;
 		}
+		/*
+		   if (err == -EBADFD) {
+		   goto again;
+		   }
+		 */
 		Error(_("audio/alsa: underrun error?\n"));
 		err = snd_pcm_recover(AlsaPCMHandle, err, 0);
 		if (err >= 0) {
@@ -255,6 +368,29 @@ static int AlsaPlayRingbuffer(void)
     return 0;
 }
 
+/**
+**	Flush alsa buffers.
+*/
+static void AlsaFlushBuffers(void)
+{
+    int err;
+    snd_pcm_state_t state;
+
+    RingBufferReadAdvance(AlsaRingBuffer, RingBufferUsedBytes(AlsaRingBuffer));
+    state = snd_pcm_state(AlsaPCMHandle);
+    Debug(3, "audio/alsa: state %d - %s\n", state, snd_pcm_state_name(state));
+    if (state != SND_PCM_STATE_OPEN) {
+	if ((err = snd_pcm_drop(AlsaPCMHandle)) < 0) {
+	    Error(_("audio: snd_pcm_drop(): %s\n"), snd_strerror(err));
+	}
+	// ****ing alsa crash, when in open state here
+	if ((err = snd_pcm_prepare(AlsaPCMHandle)) < 0) {
+	    Error(_("audio: snd_pcm_prepare(): %s\n"), snd_strerror(err));
+	}
+    }
+    AudioPTS = INT64_C(0x8000000000000000);
+}
+
 #if 0
 
 //----------------------------------------------------------------------------
@@ -447,8 +583,20 @@ static void AlsaThread(void)
     for (;;) {
 	int err;
 
-	Debug(4, "audio: play loop\n");
 	pthread_testcancel();
+	if (AlsaFlushBuffer) {
+	    // we can flush too many, but wo cares
+	    Debug(3, "audio/alsa: flushing buffers\n");
+	    AlsaFlushBuffers();
+	    /*
+	       if ((err = snd_pcm_prepare(AlsaPCMHandle))) {
+	       Error(_("audio: snd_pcm_prepare(): %s\n"), snd_strerror(err));
+	       }
+	     */
+	    AlsaFlushBuffer = 0;
+	    break;
+	}
+	// wait for space in kernel buffers
 	if ((err = snd_pcm_wait(AlsaPCMHandle, 100)) < 0) {
 	    Error(_("audio/alsa: wait underrun error?\n"));
 	    err = snd_pcm_recover(AlsaPCMHandle, err, 0);
@@ -460,20 +608,7 @@ static void AlsaThread(void)
 	    continue;
 	}
 	if (AlsaFlushBuffer) {
-	    // we can flush too many, but wo cares
-	    Debug(3, "audio/alsa: flushing buffers\n");
-	    RingBufferReadAdvance(AlsaRingBuffer,
-		RingBufferUsedBytes(AlsaRingBuffer));
-#if 1
-	    if ((err = snd_pcm_drop(AlsaPCMHandle))) {
-		Error(_("audio: snd_pcm_drop(): %s\n"), snd_strerror(err));
-	    }
-	    if ((err = snd_pcm_prepare(AlsaPCMHandle))) {
-		Error(_("audio: snd_pcm_prepare(): %s\n"), snd_strerror(err));
-	    }
-#endif
-	    AlsaFlushBuffer = 0;
-	    break;
+	    continue;
 	}
 	if ((err = AlsaPlayRingbuffer())) {	// empty / error
 	    snd_pcm_state_t state;
@@ -486,7 +621,8 @@ static void AlsaThread(void)
 		Debug(3, "audio/alsa: stopping play\n");
 		break;
 	    }
-	    usleep(20 * 1000);
+	    pthread_yield();
+	    usleep(20 * 1000);		// let fill the buffers
 	}
     }
 }
@@ -499,8 +635,9 @@ static void AlsaThread(void)
 */
 static void AlsaEnqueue(const void *samples, int count)
 {
-    if (!AlsaRingBuffer || !AlsaPCMHandle) {
-	Debug(3, "audio/alsa: not ready\n");
+    if (!AlsaRingBuffer || !AlsaPCMHandle || !AudioSampleRate) {
+	printf("%p %p %d\n", AlsaRingBuffer, AlsaPCMHandle, AudioSampleRate);
+	Debug(3, "audio/alsa: enqueue not ready\n");
 	return;
     }
     if (AlsaAddToRingbuffer(samples, count)) {
@@ -518,35 +655,48 @@ static void AlsaEnqueue(const void *samples, int count)
 #endif
 
 /**
-**	Initialize alsa pcm device.
-**
-**	@see AudioPCMDevice
+**	Open alsa pcm device.
 */
-static void AlsaInitPCM(void)
+static snd_pcm_t *AlsaOpenPCM(void)
 {
     const char *device;
     snd_pcm_t *handle;
-    snd_pcm_hw_params_t *hw_params;
     int err;
-    snd_pcm_uframes_t buffer_size;
 
     if (!(device = AudioPCMDevice)) {
 	if (!(device = getenv("ALSA_DEVICE"))) {
 	    device = "default";
 	}
     }
-    // FIXME: must set alsa error output to /dev/null
     if ((err =
 	    snd_pcm_open(&handle, device, SND_PCM_STREAM_PLAYBACK,
 		SND_PCM_NONBLOCK)) < 0) {
-	Fatal(_("audio/alsa: playback open '%s' error: %s\n"), device,
+	Error(_("audio/alsa: playback open '%s' error: %s\n"), device,
 	    snd_strerror(err));
-	// FIXME: no fatal error for plugins!
+	return NULL;
     }
 
     if ((err = snd_pcm_nonblock(handle, 0)) < 0) {
 	Error(_("audio/alsa: can't set block mode: %s\n"), snd_strerror(err));
     }
+    return handle;
+}
+
+/**
+**	Initialize alsa pcm device.
+**
+**	@see AudioPCMDevice
+*/
+static void AlsaInitPCM(void)
+{
+    snd_pcm_t *handle;
+    snd_pcm_hw_params_t *hw_params;
+    int err;
+    snd_pcm_uframes_t buffer_size;
+
+    if (!(handle = AlsaOpenPCM())) {
+	return;
+    }
 
     snd_pcm_hw_params_alloca(&hw_params);
     // choose all parameters
@@ -556,8 +706,7 @@ static void AlsaInitPCM(void)
 	    snd_strerror(err));
     }
     AlsaCanPause = snd_pcm_hw_params_can_pause(hw_params);
-    Info(_("audio/alsa: hw '%s' supports pause: %s\n"), device,
-	AlsaCanPause ? "yes" : "no");
+    Info(_("audio/alsa: supports pause: %s\n"), AlsaCanPause ? "yes" : "no");
     snd_pcm_hw_params_get_buffer_size_max(hw_params, &buffer_size);
     Info(_("audio/alsa: max buffer size %lu\n"), buffer_size);
 
@@ -656,7 +805,7 @@ static uint64_t AlsaGetDelay(void)
     snd_pcm_sframes_t delay;
     uint64_t pts;
 
-    if (!AlsaPCMHandle) {
+    if (!AlsaPCMHandle || !AudioSampleRate) {
 	return 0UL;
     }
     // FIXME: thread safe? __assert_fail_base in snd_pcm_delay
@@ -702,12 +851,14 @@ static int AlsaSetup(int *freq, int *channels)
     snd_pcm_uframes_t period_size;
     int err;
     int ret;
+    snd_pcm_t *handle;
 
     if (!AlsaPCMHandle) {		// alsa not running yet
 	return -1;
     }
 #if 1
     // flush any buffered data
+#ifndef SEARCH_HDMI_BUG2
 #ifdef USE_AUDIO_THREAD
     if (AudioRunning) {
 	while (AudioRunning) {
@@ -718,11 +869,21 @@ static int AlsaSetup(int *freq, int *channels)
     } else
 #endif
     {
-	RingBufferReadAdvance(AlsaRingBuffer,
-	    RingBufferUsedBytes(AlsaRingBuffer));
+	AlsaFlushBuffers();
     }
+#endif
     AudioPTS = INT64_C(0x8000000000000000);
 
+    if (1) {				// close+open to fix hdmi no sound bugs
+	handle = AlsaPCMHandle;
+	AlsaPCMHandle = NULL;
+	snd_pcm_close(handle);
+	if (!(handle = AlsaOpenPCM())) {
+	    return -1;
+	}
+	AlsaPCMHandle = handle;
+    }
+
     ret = 0;
   try_again:
     AudioChannels = *channels;
@@ -844,6 +1005,41 @@ static int AlsaSetup(int *freq, int *channels)
     // FIXME: use hw_params for buffer_size period_size
 #endif
 
+#if 1
+    if (0) {				// no underruns allowed, play silence
+	snd_pcm_sw_params_t *sw_params;
+	snd_pcm_uframes_t boundary;
+
+	snd_pcm_sw_params_alloca(&sw_params);
+	err = snd_pcm_sw_params_current(AlsaPCMHandle, sw_params);
+	if (err < 0) {
+	    Error(_("audio: snd_pcm_sw_params_current failed: %s\n"),
+		snd_strerror(err));
+	}
+	if ((err = snd_pcm_sw_params_get_boundary(sw_params, &boundary)) < 0) {
+	    Error(_("audio: snd_pcm_sw_params_get_boundary failed: %s\n"),
+		snd_strerror(err));
+	}
+	Debug(4, "audio/alsa: boundary %lu frames\n", boundary);
+	if ((err =
+		snd_pcm_sw_params_set_stop_threshold(AlsaPCMHandle, sw_params,
+		    boundary)) < 0) {
+	    Error(_("audio: snd_pcm_sw_params_set_silence_size failed: %s\n"),
+		snd_strerror(err));
+	}
+	if ((err =
+		snd_pcm_sw_params_set_silence_size(AlsaPCMHandle, sw_params,
+		    boundary)) < 0) {
+	    Error(_("audio: snd_pcm_sw_params_set_silence_size failed: %s\n"),
+		snd_strerror(err));
+	}
+	if ((err = snd_pcm_sw_params(AlsaPCMHandle, sw_params)) < 0) {
+	    Error(_("audio: snd_pcm_sw_params failed: %s\n"),
+		snd_strerror(err));
+	}
+    }
+#endif
+
     // update buffer
 
     snd_pcm_get_params(AlsaPCMHandle, &buffer_size, &period_size);
@@ -954,6 +1150,7 @@ static int OssAddToRingbuffer(const void *samples, int count)
     if (n != count) {
 	Error(_("audio/oss: can't place %d samples in ring buffer\n"), count);
 	// too many bytes are lost
+	// FIXME: should skip more, longer skip, but less often?
     }
     // Update audio clock
     AudioPTS +=
@@ -1020,6 +1217,21 @@ static int OssPlayRingbuffer(void)
     return 0;
 }
 
+/**
+**	Flush oss buffers.
+*/
+static void OssFlushBuffers(void)
+{
+    RingBufferReadAdvance(OssRingBuffer, RingBufferUsedBytes(OssRingBuffer));
+    // flush kernel buffers
+    if (ioctl(OssPcmFildes, SNDCTL_DSP_HALT_OUTPUT, NULL) < 0) {
+	Error(_("audio/oss: ioctl(SNDCTL_DSP_HALT_OUTPUT): %s\n"),
+	    strerror(errno));
+	return;
+    }
+    AudioPTS = INT64_C(0x8000000000000000);
+}
+
 //----------------------------------------------------------------------------
 //	OSS pcm polled
 //----------------------------------------------------------------------------
@@ -1235,14 +1447,7 @@ static int OssSetup(int *freq, int *channels)
     // flush any buffered data
     {
 	AudioRunning = 0;
-	RingBufferReadAdvance(OssRingBuffer,
-	    RingBufferUsedBytes(OssRingBuffer));
-	// flush kernel buffers
-	if (ioctl(OssPcmFildes, SNDCTL_DSP_HALT_OUTPUT, NULL) == -1) {
-	    Error(_("audio/oss: ioctl(SNDCTL_DSP_HALT_OUTPUT): %s\n"),
-		strerror(errno));
-	    return -1;
-	}
+	OssFlushBuffers();
     }
     AudioPTS = INT64_C(0x8000000000000000);
 
@@ -1375,12 +1580,59 @@ static void *AudioPlayHandlerThread(void *dummy)
 	Debug(3, "audio: wait on start condition\n");
 	pthread_mutex_lock(&AudioMutex);
 	AudioRunning = 0;
+#ifndef SEARCH_HDMI_BUG
 	do {
 	    pthread_cond_wait(&AudioStartCond, &AudioMutex);
 	    // cond_wait can return, without signal!
 	} while (!AudioRunning);
+#else
+	usleep(1 * 1000);
+	AudioRunning = 1;
+#endif
 	pthread_mutex_unlock(&AudioMutex);
 
+#ifdef SEARCH_HDMI_BUG2
+	if (atomic_read(&AudioRingFilled) > 1) {
+	    int sample_rate;
+	    int channels;
+
+	    // skip all sample changes between
+	    while (atomic_read(&AudioRingFilled) > 1) {
+		Debug(3, "audio: skip ring buffer\n");
+		AudioRingRead = (AudioRingRead + 1) % AUDIO_RING_MAX;
+		atomic_dec(&AudioRingFilled);
+	    }
+
+#ifdef USE_ALSA
+	    // FIXME: flush only if there is something to flush
+	    AlsaFlushBuffers();
+
+	    sample_rate = AudioRing[AudioRingRead].SampleRate;
+	    channels = AudioRing[AudioRingRead].Channels;
+	    Debug(3, "audio: thread channels %d sample-rate %d hz\n", channels,
+		sample_rate);
+
+	    if (AlsaSetup(&sample_rate, &channels)) {
+		Error(_("audio: can't set channels %d sample-rate %d hz\n"),
+		    channels, sample_rate);
+	    }
+	    Debug(3, "audio: thread channels %d sample-rate %d hz\n",
+		AudioChannels, AudioSampleRate);
+	    if (1) {
+		int16_t buf[6144 / 2];
+
+		buf[0] = htole16(0xF872);	// iec 61937 sync word
+		buf[1] = htole16(0x4E1F);
+		buf[2] = htole16((7 << 5) << 8 | 0x00);
+		buf[3] = htole16(0x0000);
+		memset(buf + 4, 0, 6144 - 8);
+
+		AlsaEnqueue(buf, 6144);
+	    }
+#endif
+	}
+#endif
+
 	Debug(3, "audio: play start\n");
 #ifdef USE_ALSA
 	AlsaThread();
@@ -1406,6 +1658,8 @@ static void AudioInitThread(void)
 	pthread_yield();
     } while (!AlsaPCMHandle);
 #endif
+    pthread_yield();
+    usleep(5 * 1000);
 }
 
 /**
@@ -1415,14 +1669,16 @@ static void AudioExitThread(void)
 {
     void *retval;
 
-    if (pthread_cancel(AudioThread)) {
-	Error(_("audio: can't queue cancel play thread\n"));
+    if (AudioThread) {
+	if (pthread_cancel(AudioThread)) {
+	    Error(_("audio: can't queue cancel play thread\n"));
+	}
+	if (pthread_join(AudioThread, &retval) || retval != PTHREAD_CANCELED) {
+	    Error(_("audio: can't cancel play thread\n"));
+	}
+	pthread_cond_destroy(&AudioStartCond);
+	pthread_mutex_destroy(&AudioMutex);
     }
-    if (pthread_join(AudioThread, &retval) || retval != PTHREAD_CANCELED) {
-	Error(_("audio: can't cancel play thread\n"));
-    }
-    pthread_cond_destroy(&AudioStartCond);
-    pthread_mutex_destroy(&AudioMutex);
 }
 
 #endif
@@ -1448,6 +1704,30 @@ void AudioEnqueue(const void *samples, int count)
     (void)count;
 }
 
+/**
+**	Flush audio buffers.
+*/
+void AudioFlushBuffers(void)
+{
+#ifdef USE_ALSA
+#ifdef USE_AUDIO_THREAD
+    if (AudioRunning) {
+	while (AudioRunning) {
+	    AlsaFlushBuffer = 1;
+	    usleep(1 * 1000);
+	}
+	AlsaFlushBuffer = 0;
+    } else
+#endif
+    {
+	AlsaFlushBuffers();
+    }
+#endif
+#ifdef USE_OSS
+    OssFlushBuffers();
+#endif
+}
+
 /**
 **	Call back to play audio polled.
 */
@@ -1463,6 +1743,20 @@ void AudioPoller(void)
 #endif
 }
 
+/**
+**	Get free bytes in audio output.
+*/
+int AudioFreeBytes(void)
+{
+#ifdef USE_ALSA
+    return RingBufferFreeBytes(AlsaRingBuffer);
+#endif
+#ifdef USE_OSS
+    return RingBufferFreeBytes(OssRingBuffer);
+#endif
+    return -1;
+}
+
 /**
 **	Set audio clock base.
 **
@@ -1550,6 +1844,10 @@ int AudioSetup(int *freq, int *channels)
 	// FIXME: set flag invalid setup
 	return -1;
     }
+#if defined(SEARCH_HDMI_BUG) || defined(SEARCH_HDMI_BUG2)
+    // FIXME: need to store possible combination and report this
+    return AudioRingAdd(*freq, *channels);
+#endif
 #ifdef USE_ALSA
     return AlsaSetup(freq, channels);
 #endif
@@ -1577,6 +1875,9 @@ void AudioInit(void)
     int freq;
     int chan;
 
+#ifdef SEARCH_HDMI_BUG2
+    AudioRingInit();
+#endif
 #ifdef USE_ALSA
     AlsaInit();
 #endif
@@ -1609,6 +1910,9 @@ void AudioExit(void)
 #ifdef USE_OSS
     OssExit();
 #endif
+#ifdef SEARCH_HDMI_BUG2
+    AudioRingExit();
+#endif
 }
 
 #ifdef AUDIO_TEST

audio.h

@@ -1,7 +1,7 @@
 ///
 ///	@file audio.h		@brief Audio module headerfile
 ///
-///	Copyright (c) 2009 - 2011 by Johns.  All Rights Reserved.
+///	Copyright (c) 2009 - 2012 by Johns.  All Rights Reserved.
 ///
 ///	Contributor(s):
 ///
@@ -28,12 +28,14 @@
 //----------------------------------------------------------------------------
 
 extern void AudioEnqueue(const void *, int);	///< buffer audio samples
+extern void AudioFlushBuffers(void);	///< flush audio buffers
+extern void AudioPoller(void);		///< poll audio events/handling
+
+extern int AudioFreeBytes(void);	///< free bytes in audio output
 
-//extern int AudioFreeBytes(void);	///< free bytes in audio output
 //extern int AudioUsedBytes(void);	///< used bytes in audio output
 extern void AudioSetClock(int64_t);	///< set audio clock base
 extern int64_t AudioGetClock();		///< get current audio clock
-
 extern uint64_t AudioGetDelay(void);	///< get current audio delay
 
 extern int AudioSetup(int *, int *);	///< setup audio output

codec.c

@@ -35,8 +35,12 @@
     */
 #define USE_AVPARSER
 
+    /// compile with passthrough support (experimental)
+#define USE_PASSTHROUGH
+
 #include <stdio.h>
 #include <unistd.h>
+#include <endian.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -557,6 +561,16 @@ void CodecVideoDecode(VideoDecoder * decoder, const AVPacket * avpkt)
     }
 }
 
+/**
+**	Flush the video decoder.
+**
+**	@param decoder	video decoder data
+*/
+void CodecVideoFlushBuffers(VideoDecoder * decoder)
+{
+    avcodec_flush_buffers(decoder->VideoCtx);
+}
+
 //----------------------------------------------------------------------------
 //	Audio
 //----------------------------------------------------------------------------
@@ -585,8 +599,17 @@ struct _audio_decoder_
     int HwChannels;			///< hw channels
 
     ReSampleContext *ReSample;		///< audio resampling context
+
 };
 
+#ifdef USE_PASSTHROUGH
+//static char CodecPassthroughPCM;	///< pass pcm through (unsupported)
+static char CodecPassthroughAC3;	///< pass ac3 through
+
+//static char CodecPassthroughDTS;	///< pass dts through (unsupported)
+//static char CodecPassthroughMPA;	///< pass mpa through (unsupported)
+#endif
+
 /**
 **	Allocate a new audio decoder context.
 **
@@ -683,6 +706,18 @@ void CodecAudioClose(AudioDecoder * audio_decoder)
     }
 }
 
+/**
+**	Set audio pass-through.
+*/
+void CodecSetAudioPassthrough(int mask)
+{
+#ifdef USE_PASSTHROUGH
+    CodecPassthroughAC3 = mask & 1 ? 1 : 0;
+#endif
+    // FIXME: must update audio decoder (nr. of channels wrong)
+    (void)mask;
+}
+
 #ifdef USE_AVPARSER
 
 /**
@@ -713,9 +748,11 @@ void CodecAudioDecode(AudioDecoder * audio_decoder, const AVPacket * avpkt)
     spkt->pts = avpkt->pts;
     spkt->dts = avpkt->dts;
 #endif
+#ifdef DEBUG
     if (!audio_decoder->AudioParser) {
 	Fatal(_("codec: internal error parser freeded while running\n"));
     }
+#endif
 
     audio_ctx = audio_decoder->AudioCtx;
     index = 0;
@@ -730,6 +767,7 @@ void CodecAudioDecode(AudioDecoder * audio_decoder, const AVPacket * avpkt)
 	    !index ? (uint64_t) spkt->pts : AV_NOPTS_VALUE,
 	    !index ? (uint64_t) spkt->dts : AV_NOPTS_VALUE, -1);
 
+	// FIXME: make this a function for both #ifdef cases
 	if (dpkt->size) {
 	    int buf_sz;
 
@@ -765,7 +803,15 @@ void CodecAudioDecode(AudioDecoder * audio_decoder, const AVPacket * avpkt)
 		audio_decoder->SampleRate = audio_ctx->sample_rate;
 		audio_decoder->HwSampleRate = audio_ctx->sample_rate;
 		audio_decoder->Channels = audio_ctx->channels;
-		audio_decoder->HwChannels = audio_ctx->channels;
+#ifdef USE_PASSTHROUGH
+		// SPDIF/HDMI passthrough
+		if (CodecPassthroughAC3 && audio_ctx->codec_id == CODEC_ID_AC3) {
+		    audio_decoder->HwChannels = 2;
+		} else
+#endif
+		{
+		    audio_decoder->HwChannels = audio_ctx->channels;
+		}
 
 		// channels not support?
 		if ((err =
@@ -826,6 +872,81 @@ void CodecAudioDecode(AudioDecoder * audio_decoder, const AVPacket * avpkt)
 			AudioEnqueue(outbuf, outlen);
 		    }
 		} else {
+#ifdef USE_PASSTHROUGH
+		    // SPDIF/HDMI passthrough
+		    if (CodecPassthroughAC3
+			&& audio_ctx->codec_id == CODEC_ID_AC3) {
+			// build SPDIF header and append A52 audio to it
+			// dpkt is the original data
+			buf_sz = 6144;
+			if (buf_sz < dpkt->size + 8) {
+			    Error(_
+				("codec/audio: decoded data smaller than encoded\n"));
+			    break;
+			}
+			// copy original data for output
+			// FIXME: not 100% sure, if endian is correct
+			buf[0] = htole16(0xF872);	// iec 61937 sync word
+			buf[1] = htole16(0x4E1F);
+			buf[2] = htole16(0x01 | (dpkt->data[5] & 0x07) << 8);
+			buf[3] = htole16(dpkt->size * 8);
+			swab(dpkt->data, buf + 4, dpkt->size);
+			memset(buf + 4 + dpkt->size / 2, 0,
+			    buf_sz - 8 - dpkt->size);
+		    }
+#if 0
+		    //
+		    //	old experimental code
+		    //
+		    if (1) {
+			// FIXME: need to detect dts
+			// copy original data for output
+			// FIXME: buf is sint
+			buf[0] = 0x72;
+			buf[1] = 0xF8;
+			buf[2] = 0x1F;
+			buf[3] = 0x4E;
+			buf[4] = 0x00;
+			switch (dpkt->size) {
+			    case 512:
+				buf[5] = 0x0B;
+				break;
+			    case 1024:
+				buf[5] = 0x0C;
+				break;
+			    case 2048:
+				buf[5] = 0x0D;
+				break;
+			    default:
+				Debug(3,
+				    "codec/audio: dts sample burst not supported\n");
+				buf[5] = 0x00;
+				break;
+			}
+			buf[6] = (dpkt->size * 8);
+			buf[7] = (dpkt->size * 8) >> 8;
+			//buf[8] = 0x0B;
+			//buf[9] = 0x77;
+			//printf("%x %x\n", dpkt->data[0],dpkt->data[1]);
+			// swab?
+			memcpy(buf + 8, dpkt->data, dpkt->size);
+			memset(buf + 8 + dpkt->size, 0,
+			    buf_sz - 8 - dpkt->size);
+		    } else if (1) {
+			// FIXME: need to detect mp2
+			// FIXME: mp2 passthrough
+			// see softhddev.c version/layer
+			// 0x04 mpeg1 layer1
+			// 0x05 mpeg1 layer23
+			// 0x06 mpeg2 ext
+			// 0x07 mpeg2.5 layer 1
+			// 0x08 mpeg2.5 layer 2
+			// 0x09 mpeg2.5 layer 3
+		    }
+		    // DTS HD?
+		    // True HD?
+#endif
+#endif
 		    AudioEnqueue(buf, buf_sz);
 		}
 	    }
@@ -904,90 +1025,7 @@ void CodecAudioDecode(AudioDecoder * audio_decoder, const AVPacket * avpkt)
 	avcodec_decode_audio4(audio_ctx, frame, &got_frame, dpkt);
 #else
 #endif
-	if (buf_sz > 0) {		// something decoded
-	    // Update audio clock
-	    if ((uint64_t) spkt->pts != AV_NOPTS_VALUE) {
-		AudioSetClock(spkt->pts);
-		spkt->pts = AV_NOPTS_VALUE;
-	    }
-	    // FIXME: must first play remainings bytes, than change and play new.
-	    if (audio_decoder->SampleRate != audio_ctx->sample_rate
-		|| audio_decoder->Channels != audio_ctx->channels) {
-		int err;
-
-		if (audio_decoder->ReSample) {
-		    audio_resample_close(audio_decoder->ReSample);
-		    audio_decoder->ReSample = NULL;
-		}
-
-		audio_decoder->SampleRate = audio_ctx->sample_rate;
-		audio_decoder->HwSampleRate = audio_ctx->sample_rate;
-		audio_decoder->Channels = audio_ctx->channels;
-		audio_decoder->HwChannels = audio_ctx->channels;
-
-		// channels not support?
-		if ((err =
-			AudioSetup(&audio_decoder->HwSampleRate,
-			    &audio_decoder->HwChannels))) {
-		    Debug(3, "codec/audio: resample %dHz *%d -> %dHz *%d\n",
-			audio_ctx->sample_rate, audio_ctx->channels,
-			audio_decoder->HwSampleRate,
-			audio_decoder->HwChannels);
-
-		    if (err == 1) {
-			audio_decoder->ReSample =
-			    av_audio_resample_init(audio_decoder->HwChannels,
-			    audio_ctx->channels, audio_decoder->HwSampleRate,
-			    audio_ctx->sample_rate, audio_ctx->sample_fmt,
-			    audio_ctx->sample_fmt, 16, 10, 0, 0.8);
-			// libav-0.8_pre didn't support 6 -> 2 channels
-			if (!audio_decoder->ReSample) {
-			    Error(_("codec/audio: resample setup error\n"));
-			    audio_decoder->HwChannels = 0;
-			    audio_decoder->HwSampleRate = 0;
-			}
-		    } else {
-			// FIXME: handle errors
-			Debug(3, "codec/audio: audio setup error\n");
-			audio_decoder->HwChannels = 0;
-			audio_decoder->HwSampleRate = 0;
-			break;
-		    }
-		}
-	    }
-
-	    if (audio_decoder->HwSampleRate && audio_decoder->HwChannels) {
-		// need to resample audio
-		if (audio_decoder->ReSample) {
-		    int16_t outbuf[(AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 4 +
-			FF_INPUT_BUFFER_PADDING_SIZE]
-			__attribute__ ((aligned(16)));
-		    int outlen;
-
-		    // FIXME: libav-0.7.2 crash here
-		    outlen =
-			audio_resample(audio_decoder->ReSample, outbuf, buf,
-			buf_sz);
-#ifdef DEBUG
-		    if (outlen != buf_sz) {
-			Debug(3, "codec/audio: possible fixed ffmpeg\n");
-		    }
-#endif
-		    if (outlen) {
-			// outlen seems to be wrong in ffmpeg-0.9
-			outlen /= audio_ctx->channels *
-			    av_get_bytes_per_sample(audio_ctx->sample_fmt);
-			outlen *=
-			    audio_decoder->HwChannels *
-			    av_get_bytes_per_sample(audio_ctx->sample_fmt);
-			Debug(4, "codec/audio: %d -> %d\n", buf_sz, outlen);
-			AudioEnqueue(outbuf, outlen);
-		    }
-		} else {
-		    AudioEnqueue(buf, buf_sz);
-		}
-	    }
-	}
+	// FIXME: see above, old code removed
 
 	index += n;
     }
@@ -1000,6 +1038,17 @@ void CodecAudioDecode(AudioDecoder * audio_decoder, const AVPacket * avpkt)
 
 #endif
 
+/**
+**	Flush the audio decoder.
+**
+**	@param decoder	audio decoder data
+*/
+void CodecAudioFlushBuffers(AudioDecoder * decoder)
+{
+    // FIXME: reset audio parser
+    avcodec_flush_buffers(decoder->AudioCtx);
+}
+
 //----------------------------------------------------------------------------
 //	Codec
 //----------------------------------------------------------------------------

codec.h

@@ -1,7 +1,7 @@
 ///
 ///	@file codec.h	@brief Codec module headerfile
 ///
-///	Copyright (c) 2009 - 2011 by Johns.  All Rights Reserved.
+///	Copyright (c) 2009 - 2012 by Johns.  All Rights Reserved.
 ///
 ///	Contributor(s):
 ///
@@ -40,26 +40,32 @@ typedef struct _audio_decoder_ AudioDecoder;
     /// Allocate a new video decoder context.
 extern VideoDecoder *CodecVideoNewDecoder(VideoHwDecoder *);
 
-    /// Open video codec
+    /// Open video codec.
 extern void CodecVideoOpen(VideoDecoder *, const char *, int);
 
-    /// Close video codec
+    /// Close video codec.
 extern void CodecVideoClose(VideoDecoder *);
 
-    /// Decode a video packet
-extern void CodecVideoDecode(VideoDecoder *, const AVPacket * pkt);
+    /// Decode a video packet.
+extern void CodecVideoDecode(VideoDecoder *, const AVPacket *);
+
+    /// Flush video buffers.
+extern void CodecVideoFlushBuffers(VideoDecoder *);
 
     /// Allocate a new audio decoder context.
 extern AudioDecoder *CodecAudioNewDecoder(void);
 
-    /// Open audio codec
+    /// Open audio codec.
 extern void CodecAudioOpen(AudioDecoder *, const char *, int);
 
-    /// Close audio codec
+    /// Close audio codec.
 extern void CodecAudioClose(AudioDecoder *);
 
-    /// Decode an audio packet
-extern void CodecAudioDecode(AudioDecoder *, const AVPacket * pkt);
+    /// Decode an audio packet.
+extern void CodecAudioDecode(AudioDecoder *, const AVPacket *);
+
+    /// Flush audio buffers.
+extern void CodecAudioFlushBuffers(AudioDecoder *);
 
     /// Setup and initialize codec module.
 extern void CodecInit(void);

softhddev.c

@@ -42,7 +42,9 @@
 #include "video.h"
 #include "codec.h"
 
-static char BrokenThreadsAndPlugins;	///< broken vdr threads and plugins
+//////////////////////////////////////////////////////////////////////////////
+//	Variables
+//////////////////////////////////////////////////////////////////////////////
 
 #ifdef USE_VDPAU
 static char ConfigVdpauDecoder = 1;	///< use vdpau decoder, if possible
@@ -50,16 +52,17 @@ static char ConfigVdpauDecoder = 1;	///< use vdpau decoder, if possible
 #define ConfigVdpauDecoder 0		///< no vdpau decoder configured
 #endif
 
+static const char DeviceStopped = 1;	///< flag device stopped
+
 //////////////////////////////////////////////////////////////////////////////
 //	Audio
 //////////////////////////////////////////////////////////////////////////////
 
 static volatile char NewAudioStream;	///< new audio stream
+static volatile char SkipAudio;		///< skip audio stream
 static AudioDecoder *MyAudioDecoder;	///< audio decoder
 static enum CodecID AudioCodecID;	///< current codec id
 
-extern void AudioTest(void);		// FIXME:
-
 /**
 **	mpeg bitrate table.
 **
@@ -183,15 +186,13 @@ static int FindAudioSync(const AVPacket * avpkt)
 **	@param size	size of PES packet
 **	@param id	PES packet type
 */
-void PlayAudio(const uint8_t * data, int size,
+int PlayAudio(const uint8_t * data, int size,
     __attribute__ ((unused)) uint8_t id)
 {
     int n;
+    int osize;
     AVPacket avpkt[1];
 
-    if (BrokenThreadsAndPlugins) {
-	return;
-    }
     // channel switch: SetAudioChannelDevice: SetDigitalAudioDevice:
 
     if (NewAudioStream) {
@@ -200,12 +201,19 @@ void PlayAudio(const uint8_t * data, int size,
 	AudioCodecID = CODEC_ID_NONE;
 	NewAudioStream = 0;
     }
+    if (SkipAudio) {
+	return size;
+    }
     // PES header 0x00 0x00 0x01 ID
     // ID 0xBD 0xC0-0xCF
 
     if (size < 9) {
 	Error(_("[softhddev] invalid audio packet\n"));
-	return;
+	return size;
+    }
+    // Don't overrun audio buffers on replay
+    if (AudioFreeBytes() < 3072 * 8 * 8) {	// 8 channels 8 packets
+	return 0;
     }
 
     n = data[8];			// header size
@@ -226,11 +234,12 @@ void PlayAudio(const uint8_t * data, int size,
 	}
     }
 
+    osize = size;
     data += 9 + n;
     size -= 9 + n;			// skip pes header
     if (size <= 0) {
 	Error(_("[softhddev] invalid audio packet\n"));
-	return;
+	return osize;
     }
     // Detect audio code
     // MPEG-PS mp2 MPEG1, MPEG2, AC3
@@ -272,7 +281,7 @@ void PlayAudio(const uint8_t * data, int size,
 	    avpkt->size = size;
 	    n = FindAudioSync(avpkt);
 	    if (n < 0) {
-		return;
+		return osize;
 	    }
 	    if (!MyAudioDecoder) {
 		MyAudioDecoder = CodecAudioNewDecoder();
@@ -287,13 +296,15 @@ void PlayAudio(const uint8_t * data, int size,
 
     // no decoder or codec known
     if (!MyAudioDecoder || AudioCodecID == CODEC_ID_NONE) {
-	return;
+	return osize;
     }
 
     avpkt->data = (void *)data;
     avpkt->size = size;
     //memset(avpkt->data + avpkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
     CodecAudioDecode(MyAudioDecoder, avpkt);
+
+    return osize;
 }
 
 /**
@@ -301,9 +312,7 @@ void PlayAudio(const uint8_t * data, int size,
 */
 void Mute(void)
 {
-    if (BrokenThreadsAndPlugins) {
-	return;
-    }
+    SkipAudio = 1;
     AudioSetVolume(0);
 }
 
@@ -314,9 +323,6 @@ void Mute(void)
 */
 void SetVolumeDevice(int volume)
 {
-    if (BrokenThreadsAndPlugins) {
-	return;
-    }
     AudioSetVolume((volume * 100) / 255);
 }
 
@@ -356,8 +362,6 @@ static void VideoPacketInit(void)
 {
     int i;
 
-    Debug(4, "[softhddev]: %s\n", __FUNCTION__);
-
     for (i = 0; i < VIDEO_PACKET_MAX; ++i) {
 	AVPacket *avpkt;
 
@@ -379,16 +383,10 @@ static void VideoPacketExit(void)
 {
     int i;
 
-    Debug(4, "[softhddev]: %s\n", __FUNCTION__);
-
     atomic_set(&VideoPacketsFilled, 0);
 
     for (i = 0; i < VIDEO_PACKET_MAX; ++i) {
-	AVPacket *avpkt;
-
-	avpkt = &VideoPacketRb[i];
-	// build a clean ffmpeg av packet
-	av_free_packet(avpkt);
+	av_free_packet(&VideoPacketRb[i]);
     }
 }
 
@@ -439,6 +437,8 @@ static void VideoEnqueue(int64_t pts, const void *data, int size)
 
 /**
 **	Finish current packet advance to next.
+**
+**	@param codec_id	codec id of packet (MPEG/H264)
 */
 static void VideoNextPacket(int codec_id)
 {
@@ -469,13 +469,13 @@ static void VideoNextPacket(int codec_id)
     VideoPacketWrite = (VideoPacketWrite + 1) % VIDEO_PACKET_MAX;
     atomic_inc(&VideoPacketsFilled);
 
+    VideoDisplayWakeup();
+
     // intialize next package to use
     avpkt = &VideoPacketRb[VideoPacketWrite];
     avpkt->stream_index = 0;
     avpkt->pts = AV_NOPTS_VALUE;
     avpkt->dts = AV_NOPTS_VALUE;
-
-    VideoDisplayHandler();
 }
 
 /**
@@ -493,6 +493,10 @@ int VideoDecode(void)
     }
     if (VideoClearBuffers) {
 	atomic_set(&VideoPacketsFilled, 0);
+	VideoPacketRead = VideoPacketWrite;
+	if (MyVideoDecoder) {
+	    CodecVideoFlushBuffers(MyVideoDecoder);
+	}
 	VideoClearBuffers = 0;
 	return 1;
     }
@@ -637,9 +641,6 @@ int PlayVideo(const uint8_t * data, int size)
     int64_t pts;
     int n;
 
-    if (BrokenThreadsAndPlugins) {
-	return size;
-    }
     if (Usr1Signal) {			// x11 server ready
 	Usr1Signal = 0;
 	StartVideo();
@@ -760,9 +761,6 @@ int PlayVideo(const uint8_t * data, int size)
 */
 void SetPlayMode(void)
 {
-    if (BrokenThreadsAndPlugins) {
-	return;
-    }
     if (MyVideoDecoder) {
 	if (VideoCodecID != CODEC_ID_NONE) {
 	    NewVideoStream = 1;
@@ -770,8 +768,12 @@ void SetPlayMode(void)
 	}
     }
     if (MyAudioDecoder) {
-	NewAudioStream = 1;
+	if (AudioCodecID != CODEC_ID_NONE) {
+	    NewAudioStream = 1;
+	}
     }
+    VideoFreezed = 0;
+    SkipAudio = 0;
 }
 
 /**
@@ -779,9 +781,16 @@ void SetPlayMode(void)
 */
 void Clear(void)
 {
+    int i;
+
+    VideoNextPacket(VideoCodecID);	// terminate work
     VideoClearBuffers = 1;
     // FIXME: avcodec_flush_buffers
-    // FIXME: flush audio buffers
+    AudioFlushBuffers();
+
+    for (i = 0; VideoClearBuffers && i < 20; ++i) {
+	usleep(1 * 1000);
+    }
 }
 
 /**
@@ -790,6 +799,7 @@ void Clear(void)
 void Play(void)
 {
     VideoFreezed = 0;
+    SkipAudio = 0;
     // FIXME: restart audio
 }
 
@@ -800,16 +810,38 @@ void Freeze(void)
 {
     VideoFreezed = 1;
     // FIXME: freeze audio
+    AudioFlushBuffers();
+}
+
+/**
+**	Display the given I-frame as a still picture.
+*/
+void StillPicture(const uint8_t * data, int size)
+{
+    int i;
+
+    // must be a PES start code
+    if (size < 9 || !data || data[0] || data[1] || data[2] != 0x01) {
+	Error(_("[softhddev] invalid PES video packet\n"));
+	return;
+    }
+    Clear();				// flush video buffers
+    // +1 future for deinterlace
+    for (i = -1; i < (VideoCodecID == CODEC_ID_MPEG2VIDEO ? 3 : 17); ++i) {
+	PlayVideo(data, size);		// reference frames
+    }
+    VideoNextPacket(VideoCodecID);	// terminate last packet
 }
 
 /**
 **	Poll if device is ready.  Called by replay.
+**
+**	@param timeout	timeout to become ready in ms
 */
 int Poll(int timeout)
 {
     // buffers are too full
     if (atomic_read(&VideoPacketsFilled) >= VIDEO_PACKET_MAX / 2) {
-	Debug(3, "replay: poll %d\n", timeout);
 	if (timeout) {
 	    // let display thread work
 	    usleep(timeout * 1000);
@@ -819,6 +851,22 @@ int Poll(int timeout)
     return 0;
 }
 
+/**
+**	Flush the device output buffers.
+**
+**	@param timeout	timeout to flush in ms
+*/
+int Flush(int timeout)
+{
+    if (atomic_read(&VideoPacketsFilled)) {
+	if (timeout) {			// let display thread work
+	    usleep(timeout * 1000);
+	}
+	return !atomic_read(&VideoPacketsFilled);
+    }
+    return 1;
+}
+
 //////////////////////////////////////////////////////////////////////////////
 //	OSD
 //////////////////////////////////////////////////////////////////////////////
@@ -828,7 +876,9 @@ int Poll(int timeout)
 */
 void GetOsdSize(int *width, int *height, double *aspect)
 {
+#ifdef DEBUG
     static char done;
+#endif
 
     // FIXME: should be configured!
     *width = 1920;
@@ -838,11 +888,13 @@ void GetOsdSize(int *width, int *height, double *aspect)
 
     *aspect = 16.0 / 9.0 / (double)*width * (double)*height;
 
+#ifdef DEBUG
     if (!done) {
 	Debug(3, "[softhddev]%s: %dx%d %g\n", __FUNCTION__, *width, *height,
 	    *aspect);
 	done = 1;
     }
+#endif
 }
 
 /**
@@ -850,9 +902,6 @@ void GetOsdSize(int *width, int *height, double *aspect)
 */
 void OsdClose(void)
 {
-    if (BrokenThreadsAndPlugins) {
-	return;
-    }
     VideoOsdClear();
 }
 
@@ -861,9 +910,6 @@ void OsdClose(void)
 */
 void OsdDrawARGB(int x, int y, int height, int width, const uint8_t * argb)
 {
-    if (BrokenThreadsAndPlugins) {
-	return;
-    }
     VideoOsdDrawARGB(x, y, height, width, argb);
 }
 
@@ -876,10 +922,10 @@ static char StartX11Server;		///< flag start the x11 server
 */
 const char *CommandLineHelp(void)
 {
-    return "  -a device\talsa audio device (fe. hw:0,0)\n"
-	"  -d display\tdisplay of x11 server (f.e :0.0)\n"
+    return "  -a device\taudio device (fe. alsa: hw:0,0 oss: /dev/dsp)\n"
+	"  -d display\tdisplay of x11 server (fe. :0.0)\n"
 	"  -g geometry\tx11 window geometry wxh+x+y\n"
-	"  -x\tstart x11 server\n";
+	"  -x\t\tstart x11 server\n";
 }
 
 /**
@@ -1030,39 +1076,6 @@ static void StartXServer(void)
 */
 void SoftHdDeviceExit(void)
 {
-}
-
-/**
-**	Prepare plugin.
-*/
-void Start(void)
-{
-    if (StartX11Server) {
-	StartXServer();
-    }
-    CodecInit();
-    // FIXME: AudioInit for HDMI after X11 startup
-    AudioInit();
-    if (!StartX11Server) {
-	StartVideo();
-    }
-}
-
-/**
-**	Stop plugin.
-*/
-void Stop(void)
-{
-#ifdef DEBUG
-    Debug(3, "video: max used PES packet size: %d\n", VideoMaxPacketSize);
-#endif
-
-    // FIXME:
-    // don't let any thread enter our plugin, but can still crash, when
-    // a thread has called any function, while Stop is called.
-    BrokenThreadsAndPlugins = 1;
-    usleep(2 * 1000);
-
     // lets hope that vdr does a good thead cleanup
     // no it doesn't do a good thread cleanup
     if (MyVideoDecoder) {
@@ -1091,10 +1104,37 @@ void Stop(void)
     }
 }
 
+/**
+**	Prepare plugin.
+*/
+void Start(void)
+{
+    if (StartX11Server) {
+	StartXServer();
+    }
+    CodecInit();
+    // FIXME: AudioInit for HDMI after X11 startup
+    AudioInit();
+    if (!StartX11Server) {
+	StartVideo();
+    }
+}
+
+/**
+**	Stop plugin.
+**
+**	@note stop everything, but don't cleanup, module is still called.
+*/
+void Stop(void)
+{
+#ifdef DEBUG
+    Debug(3, "video: max used PES packet size: %d\n", VideoMaxPacketSize);
+#endif
+}
+
 /**
 **	Main thread hook, periodic called from main thread.
 */
 void MainThreadHook(void)
 {
-    VideoDisplayHandler();
 }

softhddev.h

@@ -1,7 +1,7 @@
 ///
 ///	@file softhddev.h	@brief software HD device plugin header file.
 ///
-///	Copyright (c) 2011 by Johns.  All Rights Reserved.
+///	Copyright (c) 2011 - 2012 by Johns.  All Rights Reserved.
 ///
 ///	Contributor(s):
 ///
@@ -36,7 +36,7 @@ extern "C"
     extern void OsdDrawARGB(int, int, int, int, const uint8_t *);
 
     /// C plugin play audio packet
-    extern void PlayAudio(const uint8_t *, int, uint8_t);
+    extern int PlayAudio(const uint8_t *, int, uint8_t);
     /// C plugin mute audio
     extern void Mute(void);
     /// C plugin set audio volume
@@ -55,8 +55,12 @@ extern "C"
     extern void Play(void);
     /// C plugin sets the device into "freeze frame" mode
     extern void Freeze(void);
+    /// C plugin display I-frame as a still picture.
+    extern void StillPicture(const uint8_t *, int);
     /// C plugin poll if ready
     extern int Poll(int);
+    /// C plugin flush output buffers
+    extern int Flush(int);
 
     /// C plugin command line help
     extern const char *CommandLineHelp(void);

softhddevice.cpp

@@ -33,14 +33,16 @@
 
 #include "softhddev.h"
 #include "softhddevice.h"
-extern "C" {
-    #include "video.h"
+extern "C"
+{
+#include "video.h"
     extern void AudioPoller(void);
+    extern void CodecSetAudioPassthrough(int);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-static const char *const VERSION = "0.1.5";
+static const char *const VERSION = "0.3.0";
 static const char *const DESCRIPTION =
 trNOOP("A software and GPU emulated HD device");
 
@@ -49,11 +51,33 @@ static class cSoftHdDevice *MyDevice;
 
 //////////////////////////////////////////////////////////////////////////////
 
-static char ConfigMakePrimary;			///< config primary wanted
-static char ConfigVideoDeinterlace;		///< config deinterlace
-static char ConfigVideoScaling;			///< config scaling
-static int ConfigVideoAudioDelay;		///< config audio delay
-static char DoMakePrimary;			///< flag switch primary
+#define RESOLUTIONS 4			///< number of resolutions
+
+static const char *const Resolution[RESOLUTIONS] = {
+    "576i", "720p", "1080i_fake", "1080i"
+};
+
+static char ConfigMakePrimary;		///< config primary wanted
+
+    /// config deinterlace
+static int ConfigVideoDeinterlace[RESOLUTIONS];
+
+    /// config skip chroma
+static int ConfigVideoSkipChromaDeinterlace[RESOLUTIONS];
+
+    /// config denoise
+static int ConfigVideoDenoise[RESOLUTIONS];
+
+    /// config sharpen
+static int ConfigVideoSharpen[RESOLUTIONS];
+
+    /// config scaling
+static int ConfigVideoScaling[RESOLUTIONS];
+
+static int ConfigVideoAudioDelay;	///< config audio delay
+static int ConfigAudioPassthrough;	///< config audio pass-through
+
+static volatile char DoMakePrimary;	///< flag switch primary
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -126,9 +150,14 @@ cSoftOsd::cSoftOsd(int left, int top, uint level)
 
 cSoftOsd::~cSoftOsd(void)
 {
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
     SetActive(false);
 
+#ifdef USE_YAEPG
+    if (vidWin.bpp) {
+	VideoSetOutputPosition(0, 0, 1920, 1080);
+    }
+#endif
     OsdClose();
 }
 
@@ -142,7 +171,18 @@ void cSoftOsd::Flush(void)
     if (!Active()) {
 	return;
     }
-    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    // support yaepghd, video window
+#ifdef USE_YAEPG
+    if (vidWin.bpp) {
+	dsyslog("[softhddev]%s: %dx%d+%d+%d\n", __FUNCTION__, vidWin.Width(),
+	    vidWin.Height(), vidWin.x1, vidWin.y2);
+
+	// FIXME: vidWin is OSD relative not video window.
+	VideoSetOutputPosition(Left() + vidWin.x1, Top() + vidWin.y1,
+	    vidWin.Width(), vidWin.Height());
+    }
+#endif
+
     if (!IsTrueColor()) {
 	static char warned;
 	cBitmap *bitmap;
@@ -203,8 +243,10 @@ void cSoftOsd::Flush(void)
 	w = pm->ViewPort().Width();
 	h = pm->ViewPort().Height();
 
-	dsyslog("[softhddev]%s: draw %dx%d+%d+%d %p\n", __FUNCTION__, w, h, x,
-	    y, pm->Data());
+	/*
+	   dsyslog("[softhddev]%s: draw %dx%d+%d+%d %p\n", __FUNCTION__, w, h, x,
+	   y, pm->Data());
+	 */
 
 	OsdDrawARGB(x, y, w, h, pm->Data());
 
@@ -226,14 +268,14 @@ class cSoftOsdProvider:public cOsdProvider
     cSoftOsdProvider(void);
 };
 
-cOsd *cSoftOsdProvider::Osd;			///< single osd
+cOsd *cSoftOsdProvider::Osd;		///< single osd
 
 /**
 **	Create a new OSD.
 */
 cOsd *cSoftOsdProvider::CreateOsd(int left, int top, uint level)
 {
-    dsyslog("[softhddev]%s: %d, %d, %d\n", __FUNCTION__, left, top, level);
+    //dsyslog("[softhddev]%s: %d, %d, %d\n", __FUNCTION__, left, top, level);
 
     Osd = new cSoftOsd(left, top, level);
     return Osd;
@@ -247,10 +289,13 @@ bool cSoftOsdProvider::ProvidesTrueColor(void)
     return true;
 }
 
+/**
+**	Create cOsdProvider class.
+*/
 cSoftOsdProvider::cSoftOsdProvider(void)
 :  cOsdProvider()
 {
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -261,36 +306,87 @@ class cMenuSetupSoft:public cMenuSetupPage
 {
   protected:
     int MakePrimary;
-    int Deinterlace;
-    int Scaling;
+    int Scaling[RESOLUTIONS];
+    int Deinterlace[RESOLUTIONS];
+    int SkipChromaDeinterlace[RESOLUTIONS];
+    int Denoise[RESOLUTIONS];
+    int Sharpen[RESOLUTIONS];
     int AudioDelay;
+    int AudioPassthrough;
   protected:
      virtual void Store(void);
   public:
      cMenuSetupSoft(void);
 };
 
+/**
+**	Create a seperator item.
+*/
+static inline cOsdItem *SeparatorItem(const char *label)
+{
+    cOsdItem *item;
+
+    item = new cOsdItem(cString::sprintf("* %s: ", label));
+    item->SetSelectable(false);
+
+    return item;
+}
+
 /**
 **	Constructor setup menu.
 */
 cMenuSetupSoft::cMenuSetupSoft(void)
 {
-    static const char * const deinterlace[] = {
-	"Bob", "Weave", "Temporal", "TemporalSpatial", "Software" };
-    static const char * const scaling[] = {
-	"Normal", "Fast", "HQ", "Anamorphic" };
+    static const char *const deinterlace[] = {
+	"Bob", "Weave", "Temporal", "TemporalSpatial", "Software"
+    };
+    static const char *const scaling[] = {
+	"Normal", "Fast", "HQ", "Anamorphic"
+    };
+    static const char *const passthrough[] = {
+	"None", "AC-3"
+    };
+    static const char *const resolution[RESOLUTIONS] = {
+	"576i", "720p", "fake 1080i", "1080i"
+    };
+    int i;
 
     // cMenuEditBoolItem cMenuEditBitItem cMenuEditNumItem
     // cMenuEditStrItem cMenuEditStraItem cMenuEditIntItem
     MakePrimary = ConfigMakePrimary;
     Add(new cMenuEditBoolItem(tr("Make primary device"), &MakePrimary,
 	    tr("no"), tr("yes")));
-    Deinterlace = ConfigVideoDeinterlace;
-    Add(new cMenuEditStraItem(tr("Deinterlace"), &Deinterlace, 5, deinterlace));
-    Scaling = ConfigVideoScaling;
-    Add(new cMenuEditStraItem(tr("Scaling"), &Scaling, 4, scaling));
+    //
+    //	video
+    //
+    Add(SeparatorItem(tr("Video")));
+    for (i = 0; i < RESOLUTIONS; ++i) {
+	Add(SeparatorItem(resolution[i]));
+	Scaling[i] = ConfigVideoScaling[i];
+	Add(new cMenuEditStraItem(tr("Scaling"), &Scaling[i], 4, scaling));
+	Deinterlace[i] = ConfigVideoDeinterlace[i];
+	Add(new cMenuEditStraItem(tr("Deinterlace"), &Deinterlace[i], 5,
+		deinterlace));
+	SkipChromaDeinterlace[i] = ConfigVideoSkipChromaDeinterlace[i];
+	Add(new cMenuEditBoolItem(tr("SkipChromaDeinterlace (vdpau)"),
+		&SkipChromaDeinterlace[i], tr("no"), tr("yes")));
+	Denoise[i] = ConfigVideoDenoise[i];
+	Add(new cMenuEditIntItem(tr("Denoise (0..1000) (vdpau)"), &Denoise[i],
+		0, 1000));
+	Sharpen[i] = ConfigVideoSharpen[i];
+	Add(new cMenuEditIntItem(tr("Sharpen (-1000..1000) (vdpau)"),
+		&Sharpen[i], -1000, 1000));
+    }
+    //
+    //	audio
+    //
+    Add(SeparatorItem(tr("Audio")));
     AudioDelay = ConfigVideoAudioDelay;
-    Add(new cMenuEditIntItem(tr("Audio delay (ms)"), &AudioDelay, -1000, 1000));
+    Add(new cMenuEditIntItem(tr("Audio delay (ms)"), &AudioDelay, -1000,
+	    1000));
+    AudioPassthrough = ConfigAudioPassthrough;
+    Add(new cMenuEditStraItem(tr("Audio pass-through"), &AudioPassthrough, 2,
+	    passthrough));
 }
 
 /**
@@ -298,13 +394,36 @@ cMenuSetupSoft::cMenuSetupSoft(void)
 */
 void cMenuSetupSoft::Store(void)
 {
+    int i;
+
     SetupStore("MakePrimary", ConfigMakePrimary = MakePrimary);
-    SetupStore("Deinterlace", ConfigVideoDeinterlace = Deinterlace);
-    VideoSetDeinterlace(ConfigVideoDeinterlace);
-    SetupStore("Scaling", ConfigVideoScaling = Scaling);
+
+    for (i = 0; i < RESOLUTIONS; ++i) {
+	char buf[128];
+
+	snprintf(buf, sizeof(buf), "%s.%s", Resolution[i], "Scaling");
+	SetupStore(buf, ConfigVideoScaling[i] = Scaling[i]);
+	snprintf(buf, sizeof(buf), "%s.%s", Resolution[i], "Deinterlace");
+	SetupStore(buf, ConfigVideoDeinterlace[i] = Deinterlace[i]);
+	snprintf(buf, sizeof(buf), "%s.%s", Resolution[i],
+	    "SkipChromaDeinterlace");
+	SetupStore(buf, ConfigVideoSkipChromaDeinterlace[i] =
+	    SkipChromaDeinterlace[i]);
+	snprintf(buf, sizeof(buf), "%s.%s", Resolution[i], "Denoise");
+	SetupStore(buf, ConfigVideoDenoise[i] = Denoise[i]);
+	snprintf(buf, sizeof(buf), "%s.%s", Resolution[i], "Sharpen");
+	SetupStore(buf, ConfigVideoSharpen[i] = Sharpen[i]);
+    }
     VideoSetScaling(ConfigVideoScaling);
+    VideoSetDeinterlace(ConfigVideoDeinterlace);
+    VideoSetSkipChromaDeinterlace(ConfigVideoSkipChromaDeinterlace);
+    VideoSetDenoise(ConfigVideoDenoise);
+    VideoSetSharpen(ConfigVideoSharpen);
+
     SetupStore("AudioDelay", ConfigVideoAudioDelay = AudioDelay);
     VideoSetAudioDelay(ConfigVideoAudioDelay);
+    SetupStore("AudioPassthrough", ConfigAudioPassthrough = AudioPassthrough);
+    CodecSetAudioPassthrough(ConfigAudioPassthrough);
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -333,7 +452,7 @@ class cSoftHdDevice:public cDevice
     virtual void GetOsdSize(int &, int &, double &);
     virtual int PlayVideo(const uchar *, int);
     //virtual int PlayTsVideo(const uchar *, int);
-#ifdef USE_OSS			// FIXME: testing only oss
+#ifdef USE_OSS				// FIXME: testing only oss
     virtual int PlayTsAudio(const uchar *, int);
 #endif
     virtual void SetAudioChannelDevice(int);
@@ -360,14 +479,14 @@ class cSoftHdDevice:public cDevice
 
 cSoftHdDevice::cSoftHdDevice(void)
 {
-    dsyslog("[softhddev]%s\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s\n", __FUNCTION__);
 
     spuDecoder = NULL;
 }
 
 cSoftHdDevice::~cSoftHdDevice(void)
 {
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
 }
 
 void cSoftHdDevice::MakePrimaryDevice(bool on)
@@ -383,7 +502,7 @@ void cSoftHdDevice::MakePrimaryDevice(bool on)
 int cSoftHdDevice::ProvidesCa(
     __attribute__ ((unused)) const cChannel * channel) const
 {
-    dsyslog("[softhddev]%s: %p\n", __FUNCTION__, channel);
+    //dsyslog("[softhddev]%s: %p\n", __FUNCTION__, channel);
 
     return 0;
 }
@@ -436,12 +555,17 @@ int64_t cSoftHdDevice::GetSTC(void)
 {
     // dsyslog("[softhddev]%s:\n", __FUNCTION__);
 
-    return ::VideoGetClock();
+    return::VideoGetClock();
 }
 
-void cSoftHdDevice::TrickSpeed(int Speed)
+/**
+**	Set trick play speed.
+**
+**	@param speed	trick speed
+*/
+void cSoftHdDevice::TrickSpeed(int speed)
 {
-    dsyslog("[softhddev]%s: %d\n", __FUNCTION__, Speed);
+    dsyslog("[softhddev]%s: %d\n", __FUNCTION__, speed);
 }
 
 void cSoftHdDevice::Clear(void)
@@ -473,7 +597,6 @@ void cSoftHdDevice::Mute(void)
     dsyslog("[softhddev]%s:\n", __FUNCTION__);
 
     cDevice::Mute();
-
     ::Mute();
 }
 
@@ -484,26 +607,46 @@ void cSoftHdDevice::SetVolumeDevice(int volume)
     ::SetVolumeDevice(volume);
 }
 
-void cSoftHdDevice::StillPicture(
-    __attribute__ ((unused)) const uchar * data, __attribute__ ((unused))
-    int length)
+/**
+**	Display the given I-frame as a still picture.
+*/
+void cSoftHdDevice::StillPicture(const uchar * data, int length)
 {
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    dsyslog("[softhddev]%s: %s\n", __FUNCTION__,
+	data[0] == 0x47 ? "ts" : "pes");
+
+    if (data[0] == 0x47) {		// ts sync
+	cDevice::StillPicture(data, length);
+	return;
+    }
+
+    ::StillPicture(data, length);
 }
 
+/**
+**	Check if the device is ready for further action.
+**
+**	@param poller		file handles (unused)
+**	@param timeout_ms	timeout in ms to become ready
+*/
 bool cSoftHdDevice::Poll(
     __attribute__ ((unused)) cPoller & poller, int timeout_ms)
 {
     // dsyslog("[softhddev]%s: %d\n", __FUNCTION__, timeout_ms);
 
-    return ::Poll(timeout_ms);
+    return::Poll(timeout_ms);
 }
 
+/**
+**	Flush the device output buffers.
+**
+**	@param timeout_ms	timeout in ms to become ready
+*/
 bool cSoftHdDevice::Flush(int timeout_ms)
 {
     dsyslog("[softhddev]%s: %d ms\n", __FUNCTION__, timeout_ms);
 
-    return true;
+    return::Flush(timeout_ms);
 }
 
 // ----------------------------------------------------------------------------
@@ -520,34 +663,36 @@ void cSoftHdDevice::GetOsdSize(int &width, int &height, double &pixel_aspect)
 
 // ----------------------------------------------------------------------------
 
+/**
+**	Play a audio packet.
+*/
 int cSoftHdDevice::PlayAudio(const uchar * data, int length, uchar id)
 {
     //dsyslog("[softhddev]%s: %p %p %d %d\n", __FUNCTION__, this, data, length, id);
 
-    ::PlayAudio(data, length, id);
-
-    return length;
+    return::PlayAudio(data, length, id);
 }
 
 void cSoftHdDevice::SetAudioTrackDevice(
     __attribute__ ((unused)) eTrackType type)
 {
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
 }
 
-void cSoftHdDevice::SetDigitalAudioDevice(bool on)
+void cSoftHdDevice::SetDigitalAudioDevice( __attribute__ ((unused)) bool on)
 {
-    dsyslog("[softhddev]%s: %s\n", __FUNCTION__, on ? "true" : "false");
+    //dsyslog("[softhddev]%s: %s\n", __FUNCTION__, on ? "true" : "false");
 }
 
-void cSoftHdDevice::SetAudioChannelDevice(int audio_channel)
+void cSoftHdDevice::SetAudioChannelDevice( __attribute__ ((unused))
+    int audio_channel)
 {
-    dsyslog("[softhddev]%s: %d\n", __FUNCTION__, audio_channel);
+    //dsyslog("[softhddev]%s: %d\n", __FUNCTION__, audio_channel);
 }
 
 int cSoftHdDevice::GetAudioChannelDevice(void)
 {
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
     return 0;
 }
 
@@ -560,7 +705,7 @@ int cSoftHdDevice::PlayVideo(const uchar * data, int length)
 {
     //dsyslog("[softhddev]%s: %p %d\n", __FUNCTION__, data, length);
 
-    return ::PlayVideo(data, length);
+    return::PlayVideo(data, length);
 }
 
 #if 0
@@ -573,7 +718,7 @@ int cSoftHdDevice::PlayTsVideo(const uchar * Data, int Length)
 }
 #endif
 
-#ifdef USE_OSS			// FIXME: testing only oss
+#ifdef USE_OSS				// FIXME: testing only oss
 ///
 ///	Play a TS audio packet.
 ///
@@ -583,7 +728,7 @@ int cSoftHdDevice::PlayTsAudio(const uchar * data, int length)
 {
     AudioPoller();
 
-    return cDevice::PlayTsAudio(data,length);
+    return cDevice::PlayTsAudio(data, length);
 }
 #endif
 
@@ -626,13 +771,13 @@ cPluginSoftHdDevice::cPluginSoftHdDevice(void)
     // Initialize any member variables here.
     // DON'T DO ANYTHING ELSE THAT MAY HAVE SIDE EFFECTS, REQUIRE GLOBAL
     // VDR OBJECTS TO EXIST OR PRODUCE ANY OUTPUT!
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
 }
 
 cPluginSoftHdDevice::~cPluginSoftHdDevice(void)
 {
     // Clean up after yourself!
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
 
     ::SoftHdDeviceExit();
 }
@@ -660,7 +805,7 @@ const char *cPluginSoftHdDevice::CommandLineHelp(void)
 */
 bool cPluginSoftHdDevice::ProcessArgs(int argc, char *argv[])
 {
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
 
     return::ProcessArgs(argc, argv);
 }
@@ -668,7 +813,7 @@ bool cPluginSoftHdDevice::ProcessArgs(int argc, char *argv[])
 bool cPluginSoftHdDevice::Initialize(void)
 {
     // Start any background activities the plugin shall perform.
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
 
     MyDevice = new cSoftHdDevice();
 
@@ -680,7 +825,7 @@ bool cPluginSoftHdDevice::Start(void)
     const cDevice *primary;
 
     // Start any background activities the plugin shall perform.
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
 
     primary = cDevice::PrimaryDevice();
     if (MyDevice != primary) {
@@ -703,7 +848,7 @@ bool cPluginSoftHdDevice::Start(void)
 
 void cPluginSoftHdDevice::Stop(void)
 {
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
 
     ::Stop();
 }
@@ -717,7 +862,7 @@ void cPluginSoftHdDevice::Housekeeping(void)
 
 const char *cPluginSoftHdDevice::MainMenuEntry(void)
 {
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
     return tr(MAINMENUENTRY);
     return NULL;
 }
@@ -730,7 +875,7 @@ const char *cPluginSoftHdDevice::MainMenuEntry(void)
 */
 void cPluginSoftHdDevice::MainThreadHook(void)
 {
-    // dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
 
     if (DoMakePrimary && MyDevice) {
 	dsyslog("[softhddev]%s: switching primary device\n", __FUNCTION__);
@@ -765,7 +910,7 @@ cOsdObject *cPluginSoftHdDevice::MainMenuAction(void)
 */
 cMenuSetupPage *cPluginSoftHdDevice::SetupMenu(void)
 {
-    dsyslog("[softhddev]%s:\n", __FUNCTION__);
+    //dsyslog("[softhddev]%s:\n", __FUNCTION__);
 
     return new cMenuSetupSoft;
 }
@@ -775,6 +920,9 @@ cMenuSetupPage *cPluginSoftHdDevice::SetupMenu(void)
 */
 bool cPluginSoftHdDevice::SetupParse(const char *name, const char *value)
 {
+    int i;
+    char buf[128];
+
     dsyslog("[softhddev]%s: '%s' = '%s'\n", __FUNCTION__, name, value);
 
     // FIXME: handle the values
@@ -782,18 +930,47 @@ bool cPluginSoftHdDevice::SetupParse(const char *name, const char *value)
 	ConfigMakePrimary = atoi(value);
 	return true;
     }
-    if (!strcmp(name, "Deinterlace")) {
-	VideoSetDeinterlace(ConfigVideoDeinterlace = atoi(value));
-	return true;
-    }
-    if (!strcmp(name, "Scaling")) {
-	VideoSetScaling(ConfigVideoScaling = atoi(value));
-	return true;
+    for (i = 0; i < RESOLUTIONS; ++i) {
+	snprintf(buf, sizeof(buf), "%s.%s", Resolution[i], "Scaling");
+	if (!strcmp(name, buf)) {
+	    ConfigVideoScaling[i] = atoi(value);
+	    VideoSetScaling(ConfigVideoScaling);
+	    return true;
+	}
+	snprintf(buf, sizeof(buf), "%s.%s", Resolution[i], "Deinterlace");
+	if (!strcmp(name, buf)) {
+	    ConfigVideoDeinterlace[i] = atoi(value);
+	    VideoSetDeinterlace(ConfigVideoDeinterlace);
+	    return true;
+	}
+	snprintf(buf, sizeof(buf), "%s.%s", Resolution[i],
+	    "SkipChromaDeinterlace");
+	if (!strcmp(name, buf)) {
+	    ConfigVideoSkipChromaDeinterlace[i] = atoi(value);
+	    VideoSetSkipChromaDeinterlace(ConfigVideoSkipChromaDeinterlace);
+	    return true;
+	}
+	snprintf(buf, sizeof(buf), "%s.%s", Resolution[i], "Denoise");
+	if (!strcmp(name, buf)) {
+	    ConfigVideoDenoise[i] = atoi(value);
+	    VideoSetDenoise(ConfigVideoDenoise);
+	    return true;
+	}
+	snprintf(buf, sizeof(buf), "%s.%s", Resolution[i], "Sharpen");
+	if (!strcmp(name, buf)) {
+	    ConfigVideoSharpen[i] = atoi(value);
+	    VideoSetSharpen(ConfigVideoSharpen);
+	    return true;
+	}
     }
     if (!strcmp(name, "AudioDelay")) {
 	VideoSetAudioDelay(ConfigVideoAudioDelay = atoi(value));
 	return true;
     }
+    if (!strcmp(name, "AudioPassthrough")) {
+	CodecSetAudioPassthrough(ConfigAudioPassthrough = atoi(value));
+	return true;
+    }
 
     return false;
 }

vdr-softhddevice-9999.ebuild

@@ -0,0 +1,71 @@
+# Copyright 1999-2012 Gentoo Foundation
+# Distributed under the terms of the GNU General Public License v2
+# $Header: $
+
+EAPI="3"
+
+inherit eutils vdr-plugin
+
+if [[ ${PV} == "9999" ]] ; then
+		inherit git-2
+		EGIT_REPO_URI="git://projects.vdr-developer.org/vdr-plugin-softhddevice.git"
+else
+		SRC_URI="http://projects.vdr-developer.org/attachments/download/838/${P}.tgz"
+fi
+
+
+DESCRIPTION="A software and GPU emulated HD output device plugin for VDR."
+HOMEPAGE="http://projects.vdr-developer.org/projects/show/plg-softhddevice"
+SRC_URI=""
+
+LICENSE="AGPL-3"
+SLOT="0"
+KEYWORDS="~x86 ~amd64"
+IUSE="vaapi vdpau alsa oss yaepg"
+
+DEPEND=">=x11-libs/libxcb-1.7
+		x11-libs/xcb-util
+		x11-libs/xcb-util-wm
+		x11-libs/xcb-util-wm
+		x11-libs/xcb-util-keysyms
+		x11-libs/xcb-util-renderutil
+		x11-libs/libX11
+		>=media-video/ffmpeg-0.7
+		sys-devel/gettext
+		sys-devel/make
+		dev-util/pkgconfig
+		yaepg? ( >=media-video/vdr-1.7[yaepg] )
+		!yaepg? ( >=media-video/vdr-1.7 )
+		vdpau? ( x11-libs/libvdpau )
+		vaapi? ( x11-libs/libva )
+		alsa? ( media-libs/alsa-lib )
+"
+
+src_prepare() {
+		vdr-plugin_src_prepare
+}
+
+src_compile() {
+		local myconf
+
+		myconf=""
+		use vdpau && myconf="${myconf} -DUSE_VDPAU"
+		use vaapi && myconf="${myconf} -DUSE_VAAPI"
+		use alsa && myconf="${myconf} -DUSE_ALSA"
+		use oss && myconf="${myconf} -DUSE_OSS"
+
+		emake all CC="$(tc-getCC)" CFLAGS="${CFLAGS}" \
+			LDFLAGS="${LDFLAGS}" CONFIG="${myconf}" LIBDIR="." || die
+}
+
+src_install() {
+		vdr-plugin_src_install
+
+		dodir /etc/vdr/plugins || die
+
+		insinto /etc/vdr/plugins
+		fowners -R vdr:vdr /etc/vdr || die
+
+		#insinto /etc/conf.d
+		#doins vdr.softhddevice
+}

video.h

@@ -1,7 +1,7 @@
 ///
 ///	@file video.h	@brief Video module header file
 ///
-///	Copyright (c) 2009 - 2011 by Johns.  All Rights Reserved.
+///	Copyright (c) 2009 - 2012 by Johns.  All Rights Reserved.
 ///
 ///	Contributor(s):
 ///
@@ -30,13 +30,6 @@
     /// Video hardware decoder typedef
 typedef struct _video_hw_decoder_ VideoHwDecoder;
 
-//----------------------------------------------------------------------------
-//	Variables
-//----------------------------------------------------------------------------
-
-//extern unsigned VideoWindowWidth;	///< current video output width
-//extern unsigned VideoWindowHeight;	///< current video output height
-
 //----------------------------------------------------------------------------
 //	Prototypes
 //----------------------------------------------------------------------------
@@ -47,14 +40,14 @@ extern VideoHwDecoder *VideoNewHwDecoder(void);
     /// Get and allocate a video hardware surface.
 extern unsigned VideoGetSurface(VideoHwDecoder *);
 
-    /// Release a video hardware surface.
+    /// Release a video hardware surface
 extern void VideoReleaseSurface(VideoHwDecoder *, unsigned);
 
 #ifdef LIBAVCODEC_VERSION
-    /// Render a ffmpeg frame
+    /// Render a ffmpeg frame.
 extern void VideoRenderFrame(VideoHwDecoder *, AVCodecContext *, AVFrame *);
 
-    /// Get ffmpeg vaapi context
+    /// Get ffmpeg vaapi context.
 extern struct vaapi_context *VideoGetVaapiContext(VideoHwDecoder *);
 
     /// Callback to negotiate the PixelFormat.
@@ -62,48 +55,60 @@ extern enum PixelFormat Video_get_format(VideoHwDecoder *, AVCodecContext *,
     const enum PixelFormat *);
 
 #ifdef AVCODEC_VDPAU_H
-    /// Draw vdpau render state
+    /// Draw vdpau render state.
 extern void VideoDrawRenderState(VideoHwDecoder *,
     struct vdpau_render_state *);
 #endif
 #endif
 
-    /// Display video TEST
-extern void VideoDisplayHandler(void);
-
-    /// Poll video events
+    /// Poll video events.
 extern void VideoPollEvent(void);
 
-    /// set video mode
+    /// Wakeup display handler.
+extern void VideoDisplayWakeup(void);
+
+    /// Set video mode.
 //extern void VideoSetVideoMode(int, int, int, int);
 
-    /// set video geometry
+    /// Set video geometry.
 extern int VideoSetGeometry(const char *);
 
-    /// set deinterlace
-extern void VideoSetDeinterlace(int);
+    /// Set video output position.
+extern void VideoSetOutputPosition(int, int, int, int);
 
-    /// set scaling
-extern void VideoSetScaling(int);
+    /// Set deinterlace.
+extern void VideoSetDeinterlace(int[]);
 
-    /// set audio delay
+    /// Set skip chroma deinterlace.
+extern void VideoSetSkipChromaDeinterlace(int[]);
+
+    /// Set scaling.
+extern void VideoSetScaling(int[]);
+
+    /// Set denoise.
+extern void VideoSetDenoise(int[]);
+
+    /// Set sharpen.
+extern void VideoSetSharpen(int[]);
+
+    /// Set audio delay.
 extern void VideoSetAudioDelay(int);
 
-    /// Clear OSD
+    /// Clear OSD.
 extern void VideoOsdClear(void);
 
-    /// Draw an OSD ARGB image
+    /// Draw an OSD ARGB image.
 extern void VideoOsdDrawARGB(int, int, int, int, const uint8_t *);
 
-extern int64_t VideoGetClock(void);	///< get video clock
+extern int64_t VideoGetClock(void);	///< Get video clock.
 
-extern void VideoOsdInit(void);		///< setup osd
-extern void VideoOsdExit(void);		///< cleanup osd
+extern void VideoOsdInit(void);		///< Setup osd.
+extern void VideoOsdExit(void);		///< Cleanup osd.
 
-extern void VideoInit(const char *);	///< setup video module
-extern void VideoExit(void);		///< cleanup and exit video module
+extern void VideoInit(const char *);	///< Setup video module.
+extern void VideoExit(void);		///< Cleanup and exit video module.
 
-extern void VideoFlushInput(void);	///< flush codec input buffers
-extern int VideoDecode(void);		///< decode
+extern void VideoFlushInput(void);	///< Flush video input buffers.
+extern int VideoDecode(void);		///< Decode video input buffers.
 
 /// @}