Change to match current command.c (same functionality).

The versions compile to the same code on my machine except for one test
instruction that has its operands swapped and conditional jump changed
accordingly.


git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@22497 b3059339-0415-0410-9bf9-f77b7e298cf2

1 files changed, 1732 insertions, 1373 deletions

diff --git a/command.c.tmp b/command.c.tmp
index f5c488dedc..7b1e910811 100644
--- a/command.c.tmp
+++ b/command.c.tmp
@@ -1,90 +1,103 @@
-#include <inttypes.h>
 #include <stdlib.h>
-#include "config.h"
-
+#include <inttypes.h>
 #include <unistd.h>
 
-#include "help_mp.h"
-
+#include "config.h"
+#include "input/input.h"
+#include "stream/stream.h"
+#include "libmpdemux/demuxer.h"
+#include "libmpdemux/stheader.h"
+#include "mplayer.h"
+#include "libvo/sub.h"
 #include "m_option.h"
 #include "m_property.h"
-
+#include "help_mp.h"
+#include "metadata.h"
+#include "libmpcodecs/mp_image.h"
+#include "libmpcodecs/vf.h"
+#include "libmpcodecs/vd.h"
 #include "libvo/video_out.h"
-
-#include "libvo/sub.h"
-
+#include "playtree.h"
 #include "libao2/audio_out.h"
-
-#include "spudec.h"
+#include "mpcommon.h"
+#include "mixer.h"
+#include "libmpdemux/matroska.h"
+#include "libmpcodecs/dec_video.h"
 #include "vobsub.h"
-
-#ifdef HAVE_NEW_GUI
-#include "Gui/interface.h"
-#endif
-
-#include "input/input.h"
-
-#define ROUND(x) ((int)((x)<0 ? (x)-0.5 : (x)+0.5))
-
+#include "spudec.h"
 #ifdef USE_TV
 #include "stream/tv.h"
 #endif
 #ifdef USE_RADIO
 #include "stream/stream_radio.h"
 #endif
-
 #ifdef HAS_DVBIN_SUPPORT
 #include "stream/dvbin.h"
 #endif
-#include "playtree.h"
-
-#include "stream/stream.h"
-#include "libmpdemux/demuxer.h"
-#include "libmpdemux/stheader.h"
-#include "libmpdemux/matroska.h"
-
 #ifdef USE_DVDREAD
 #include "stream/stream_dvd.h"
 #endif
-
 #ifdef USE_DVDNAV
 #include "stream/stream_dvdnav.h"
 #endif
-
-#include "libmpcodecs/dec_video.h"
-#include "libmpcodecs/mp_image.h"
-#include "libmpcodecs/vf.h"
-#include "libmpcodecs/vd.h"
 #ifdef USE_ASS
 #include "libass/ass.h"
 #include "libass/ass_mp.h"
 #endif
-#include "mpcommon.h"
-#include "metadata.h"
-#include "mixer.h"
-
-#include "mplayer.h"
+#ifdef HAVE_NEW_GUI
+#include "Gui/interface.h"
+#endif
 
 #include "mp_core.h"
 
+#define ROUND(x) ((int)((x)<0 ? (x)-0.5 : (x)+0.5))
+
+static void rescale_input_coordinates(int ix, int iy, double *dx, double *dy)
+{
+    //remove the borders, if any, and rescale to the range [0,1],[0,1]
+    if (vo_fs) {		//we are in full-screen mode
+	if (vo_screenwidth > vo_dwidth)	//there are borders along the x axis
+	    ix -= (vo_screenwidth - vo_dwidth) / 2;
+	if (vo_screenheight > vo_dheight)	//there are borders along the y axis (usual way)
+	    iy -= (vo_screenheight - vo_dheight) / 2;
+
+	if (ix < 0 || ix > vo_dwidth) {
+	    *dx = *dy = -1.0;
+	    return;
+	}			//we are on one of the borders
+	if (iy < 0 || iy > vo_dheight) {
+	    *dx = *dy = -1.0;
+	    return;
+	}			//we are on one of the borders
+    }
+
+    *dx = (double) ix / (double) vo_dwidth;
+    *dy = (double) iy / (double) vo_dheight;
+
+    mp_msg(MSGT_CPLAYER, MSGL_V,
+	   "\r\nrescaled coordinates: %.3lf, %.3lf, screen (%d x %d), vodisplay: (%d, %d), fullscreen: %d\r\n",
+	   *dx, *dy, vo_screenwidth, vo_screenheight, vo_dwidth,
+	   vo_dheight, vo_fs);
+}
+
 static int sub_source(MPContext * mpctx)
 {
     int source = -1;
     int top = -1;
     int i;
     for (i = 0; i < SUB_SOURCES; i++) {
-        int j = mpctx->global_sub_indices[i];
-        if ((j >= 0) && (j > top) && (mpctx->global_sub_pos >= j)) {
-            source = i;
-            top = j;
-        }
+	int j = mpctx->global_sub_indices[i];
+	if ((j >= 0) && (j > top) && (mpctx->global_sub_pos >= j)) {
+	    source = i;
+	    top = j;
+	}
     }
     return source;
 }
 
 /**
  * \brief Log the currently displayed subtitle to a file
- * 
+ *
  * Logs the current or last displayed subtitle together with filename
  * and time information to ~/.mplayer/subtitle_log
  *
@@ -92,24 +105,30 @@ static int sub_source(MPContext * mpctx)
  * which need to be fixed while watching the movie.
  */
 
-static void log_sub(void){
+static void log_sub(void)
+{
     char *fname;
     FILE *f;
     int i;
 
-    if (subdata == NULL || vo_sub_last == NULL) return;
+    if (subdata == NULL || vo_sub_last == NULL)
+	return;
     fname = get_path("subtitle_log");
     f = fopen(fname, "a");
-    if (!f) return;
+    if (!f)
+	return;
     fprintf(f, "----------------------------------------------------------\n");
     if (subdata->sub_uses_time) {
-	fprintf(f, "N: %s S: %02ld:%02ld:%02ld.%02ld E: %02ld:%02ld:%02ld.%02ld\n", filename, 
-		vo_sub_last->start/360000, (vo_sub_last->start/6000)%60,
-		(vo_sub_last->start/100)%60, vo_sub_last->start%100,
-		vo_sub_last->end/360000, (vo_sub_last->end/6000)%60,
-		(vo_sub_last->end/100)%60, vo_sub_last->end%100);
+	fprintf(f,
+		"N: %s S: %02ld:%02ld:%02ld.%02ld E: %02ld:%02ld:%02ld.%02ld\n",
+		filename, vo_sub_last->start / 360000,
+		(vo_sub_last->start / 6000) % 60,
+		(vo_sub_last->start / 100) % 60, vo_sub_last->start % 100,
+		vo_sub_last->end / 360000, (vo_sub_last->end / 6000) % 60,
+		(vo_sub_last->end / 100) % 60, vo_sub_last->end % 100);
     } else {
-	fprintf(f, "N: %s S: %ld E: %ld\n", filename, vo_sub_last->start, vo_sub_last->end);
+	fprintf(f, "N: %s S: %ld E: %ld\n", filename, vo_sub_last->start,
+		vo_sub_last->end);
     }
     for (i = 0; i < vo_sub_last->lines; i++) {
 	fprintf(f, "%s\n", vo_sub_last->text[i]);
@@ -126,127 +145,161 @@ static void log_sub(void){
 ///@{
 
 /// OSD level (RW)
-static int mp_property_osdlevel(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    return m_property_choice(prop,action,arg,&osd_level);
+static int mp_property_osdlevel(m_option_t * prop, int action, void *arg,
+				MPContext * mpctx)
+{
+    return m_property_choice(prop, action, arg, &osd_level);
 }
 
 /// Playback speed (RW)
-static int mp_property_playback_speed(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    switch(action) {
+static int mp_property_playback_speed(m_option_t * prop, int action,
+				      void *arg, MPContext * mpctx)
+{
+    switch (action) {
     case M_PROPERTY_SET:
-        if(!arg) return M_PROPERTY_ERROR;
-        M_PROPERTY_CLAMP(prop,*(float*)arg);
-        playback_speed = *(float*)arg;
-        build_afilter_chain(mpctx->sh_audio, &ao_data);
-        return M_PROPERTY_OK;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	M_PROPERTY_CLAMP(prop, *(float *) arg);
+	playback_speed = *(float *) arg;
+	build_afilter_chain(mpctx->sh_audio, &ao_data);
+	return M_PROPERTY_OK;
     case M_PROPERTY_STEP_UP:
     case M_PROPERTY_STEP_DOWN:
-        playback_speed += (arg ? *(float*)arg : 0.1) *
-            (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
-        M_PROPERTY_CLAMP(prop,playback_speed);
-        build_afilter_chain(mpctx->sh_audio, &ao_data);
-        return M_PROPERTY_OK;
+	playback_speed += (arg ? *(float *) arg : 0.1) *
+	    (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
+	M_PROPERTY_CLAMP(prop, playback_speed);
+	build_afilter_chain(mpctx->sh_audio, &ao_data);
+	return M_PROPERTY_OK;
     }
-    return m_property_float_range(prop,action,arg,&playback_speed);
+    return m_property_float_range(prop, action, arg, &playback_speed);
 }
 
 /// filename with path (RO)
-static int mp_property_path(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    return m_property_string_ro(prop,action,arg,filename);
+static int mp_property_path(m_option_t * prop, int action, void *arg,
+			    MPContext * mpctx)
+{
+    return m_property_string_ro(prop, action, arg, filename);
 }
 
 /// filename without path (RO)
-static int mp_property_filename(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    char* f;
-    if(!filename) return M_PROPERTY_UNAVAILABLE;
-    if(((f = strrchr(filename,'/')) || (f = strrchr(filename,'\\'))) && f[1])
-        f++;
+static int mp_property_filename(m_option_t * prop, int action, void *arg,
+				MPContext * mpctx)
+{
+    char *f;
+    if (!filename)
+	return M_PROPERTY_UNAVAILABLE;
+    if (((f = strrchr(filename, '/')) || (f = strrchr(filename, '\\'))) && f[1])
+	f++;
     else
-        f = filename;
-    return m_property_string_ro(prop,action,arg,f);
+	f = filename;
+    return m_property_string_ro(prop, action, arg, f);
 }
 
 /// Demuxer name (RO)
-static int mp_property_demuxer(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    if (!mpctx->demuxer) return M_PROPERTY_UNAVAILABLE;
-    return m_property_string_ro(prop, action, arg, (char *) mpctx->demuxer->desc->name);
+static int mp_property_demuxer(m_option_t * prop, int action, void *arg,
+			       MPContext * mpctx)
+{
+    if (!mpctx->demuxer)
+	return M_PROPERTY_UNAVAILABLE;
+    return m_property_string_ro(prop, action, arg,
+				(char *) mpctx->demuxer->desc->name);
 }
 
 /// Position in the stream (RW)
-static int mp_property_stream_pos(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    if (!mpctx->demuxer || !mpctx->demuxer->stream) return M_PROPERTY_UNAVAILABLE;
-    if (!arg) return M_PROPERTY_ERROR;
+static int mp_property_stream_pos(m_option_t * prop, int action, void *arg,
+				  MPContext * mpctx)
+{
+    if (!mpctx->demuxer || !mpctx->demuxer->stream)
+	return M_PROPERTY_UNAVAILABLE;
+    if (!arg)
+	return M_PROPERTY_ERROR;
     switch (action) {
     case M_PROPERTY_GET:
-        *(off_t *) arg = stream_tell(mpctx->demuxer->stream);
-        return M_PROPERTY_OK;
+	*(off_t *) arg = stream_tell(mpctx->demuxer->stream);
+	return M_PROPERTY_OK;
     case M_PROPERTY_SET:
-        M_PROPERTY_CLAMP(prop,*(off_t*)arg);
-        stream_seek(mpctx->demuxer->stream, *(off_t *) arg);
-        return M_PROPERTY_OK;
+	M_PROPERTY_CLAMP(prop, *(off_t *) arg);
+	stream_seek(mpctx->demuxer->stream, *(off_t *) arg);
+	return M_PROPERTY_OK;
     }
     return M_PROPERTY_NOT_IMPLEMENTED;
 }
 
 /// Stream start offset (RO)
-static int mp_property_stream_start(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    if (!mpctx->demuxer || !mpctx->demuxer->stream) return M_PROPERTY_UNAVAILABLE;
+static int mp_property_stream_start(m_option_t * prop, int action,
+				    void *arg, MPContext * mpctx)
+{
+    if (!mpctx->demuxer || !mpctx->demuxer->stream)
+	return M_PROPERTY_UNAVAILABLE;
     switch (action) {
     case M_PROPERTY_GET:
-        *(off_t *) arg = mpctx->demuxer->stream->start_pos;
-        return M_PROPERTY_OK;
+	*(off_t *) arg = mpctx->demuxer->stream->start_pos;
+	return M_PROPERTY_OK;
     }
     return M_PROPERTY_NOT_IMPLEMENTED;
 }
 
 /// Stream end offset (RO)
-static int mp_property_stream_end(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    if (!mpctx->demuxer || !mpctx->demuxer->stream) return M_PROPERTY_UNAVAILABLE;
+static int mp_property_stream_end(m_option_t * prop, int action, void *arg,
+				  MPContext * mpctx)
+{
+    if (!mpctx->demuxer || !mpctx->demuxer->stream)
+	return M_PROPERTY_UNAVAILABLE;
     switch (action) {
     case M_PROPERTY_GET:
-        *(off_t *) arg = mpctx->demuxer->stream->end_pos;
-        return M_PROPERTY_OK;
+	*(off_t *) arg = mpctx->demuxer->stream->end_pos;
+	return M_PROPERTY_OK;
     }
     return M_PROPERTY_NOT_IMPLEMENTED;
 }
 
 /// Stream length (RO)
-static int mp_property_stream_length(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    if (!mpctx->demuxer || !mpctx->demuxer->stream) return M_PROPERTY_UNAVAILABLE;
+static int mp_property_stream_length(m_option_t * prop, int action,
+				     void *arg, MPContext * mpctx)
+{
+    if (!mpctx->demuxer || !mpctx->demuxer->stream)
+	return M_PROPERTY_UNAVAILABLE;
     switch (action) {
     case M_PROPERTY_GET:
-        *(off_t *) arg = mpctx->demuxer->stream->end_pos - mpctx->demuxer->stream->start_pos;
-        return M_PROPERTY_OK;
+	*(off_t *) arg =
+	    mpctx->demuxer->stream->end_pos - mpctx->demuxer->stream->start_pos;
+	return M_PROPERTY_OK;
     }
     return M_PROPERTY_NOT_IMPLEMENTED;
 }
 
 /// Media length in seconds (RO)
-static int mp_property_length(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+static int mp_property_length(m_option_t * prop, int action, void *arg,
+			      MPContext * mpctx)
+{
     double len;
-    
+
     if (!mpctx->demuxer ||
-        !(int) (len = demuxer_get_time_length(mpctx->demuxer)))
-        return M_PROPERTY_UNAVAILABLE;
-    
-    switch(action) {
+	!(int) (len = demuxer_get_time_length(mpctx->demuxer)))
+	return M_PROPERTY_UNAVAILABLE;
+
+    switch (action) {
     case M_PROPERTY_PRINT:
-        if(!arg) return M_PROPERTY_ERROR;
-        else {
-            int h, m, s = len;
-            h = s/3600;
-            s -= h*3600;
-            m = s/60;
-            s -= m*60;
-            *(char**)arg = malloc(20);
-            if(h > 0) sprintf(*(char**)arg,"%d:%02d:%02d",h,m,s);
-            else if(m > 0) sprintf(*(char**)arg,"%d:%02d",m,s);
-            else sprintf(*(char**)arg,"%d",s);
-            return M_PROPERTY_OK;
-        }
-        break;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	else {
+	    int h, m, s = len;
+	    h = s / 3600;
+	    s -= h * 3600;
+	    m = s / 60;
+	    s -= m * 60;
+	    *(char **) arg = malloc(20);
+	    if (h > 0)
+		sprintf(*(char **) arg, "%d:%02d:%02d", h, m, s);
+	    else if (m > 0)
+		sprintf(*(char **) arg, "%d:%02d", m, s);
+	    else
+		sprintf(*(char **) arg, "%d", s);
+	    return M_PROPERTY_OK;
+	}
+	break;
     }
-    return m_property_double_ro(prop,action,arg,len);
+    return m_property_double_ro(prop, action, arg, len);
 }
 
 ///@}
@@ -256,276 +309,333 @@ static int mp_property_length(m_option_t * prop, int action, void *arg, MPContex
 ///@{
 
 /// Volume (RW)
-static int mp_property_volume(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+static int mp_property_volume(m_option_t * prop, int action, void *arg,
+			      MPContext * mpctx)
+{
 
-    if (!mpctx->sh_audio) return M_PROPERTY_UNAVAILABLE;
-    
-    switch(action) {
+    if (!mpctx->sh_audio)
+	return M_PROPERTY_UNAVAILABLE;
+
+    switch (action) {
     case M_PROPERTY_GET:
-        if(!arg) return M_PROPERTY_ERROR;
-        mixer_getbothvolume(&mpctx->mixer, arg);
-        return M_PROPERTY_OK;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	mixer_getbothvolume(&mpctx->mixer, arg);
+	return M_PROPERTY_OK;
     case M_PROPERTY_PRINT:{
-        float vol;
-        if(!arg) return M_PROPERTY_ERROR;
-        mixer_getbothvolume(&mpctx->mixer, &vol);
-        return m_property_float_range(prop,action,arg,&vol);
-    }        
+	    float vol;
+	    if (!arg)
+		return M_PROPERTY_ERROR;
+	    mixer_getbothvolume(&mpctx->mixer, &vol);
+	    return m_property_float_range(prop, action, arg, &vol);
+	}
     case M_PROPERTY_STEP_UP:
     case M_PROPERTY_STEP_DOWN:
     case M_PROPERTY_SET:
-        break;
+	break;
     default:
-        return M_PROPERTY_NOT_IMPLEMENTED;
+	return M_PROPERTY_NOT_IMPLEMENTED;
     }
 
-    if (mpctx->edl_muted) return M_PROPERTY_DISABLED;
+    if (mpctx->edl_muted)
+	return M_PROPERTY_DISABLED;
     mpctx->user_muted = 0;
 
-    switch(action) {
-   case M_PROPERTY_SET:
-        if(!arg) return M_PROPERTY_ERROR;
-        M_PROPERTY_CLAMP(prop,*(float*)arg);
-        mixer_setvolume(&mpctx->mixer, *(float *) arg, *(float *) arg);
-        return M_PROPERTY_OK;
+    switch (action) {
+    case M_PROPERTY_SET:
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	M_PROPERTY_CLAMP(prop, *(float *) arg);
+	mixer_setvolume(&mpctx->mixer, *(float *) arg, *(float *) arg);
+	return M_PROPERTY_OK;
     case M_PROPERTY_STEP_UP:
-        if(arg && *(float*)arg <= 0)
-            mixer_decvolume(&mpctx->mixer);
-        else
-            mixer_incvolume(&mpctx->mixer);
-        return M_PROPERTY_OK;
+	if (arg && *(float *) arg <= 0)
+	    mixer_decvolume(&mpctx->mixer);
+	else
+	    mixer_incvolume(&mpctx->mixer);
+	return M_PROPERTY_OK;
     case M_PROPERTY_STEP_DOWN:
-        if(arg && *(float*)arg <= 0)
-            mixer_incvolume(&mpctx->mixer);
-        else
-            mixer_decvolume(&mpctx->mixer);
-        return M_PROPERTY_OK;
+	if (arg && *(float *) arg <= 0)
+	    mixer_incvolume(&mpctx->mixer);
+	else
+	    mixer_decvolume(&mpctx->mixer);
+	return M_PROPERTY_OK;
     }
     return M_PROPERTY_NOT_IMPLEMENTED;
 }
 
 /// Mute (RW)
-static int mp_property_mute(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    
-    if (!mpctx->sh_audio) return M_PROPERTY_UNAVAILABLE;
-    
-    switch(action) {
+static int mp_property_mute(m_option_t * prop, int action, void *arg,
+			    MPContext * mpctx)
+{
+
+    if (!mpctx->sh_audio)
+	return M_PROPERTY_UNAVAILABLE;
+
+    switch (action) {
     case M_PROPERTY_SET:
-        if (mpctx->edl_muted) return M_PROPERTY_DISABLED;
-        if(!arg) return M_PROPERTY_ERROR;
-        if ((!!*(int *) arg) != mpctx->mixer.muted)
-            mixer_mute(&mpctx->mixer);
-        mpctx->user_muted = mpctx->mixer.muted;
-        return M_PROPERTY_OK;
+	if (mpctx->edl_muted)
+	    return M_PROPERTY_DISABLED;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	if ((!!*(int *) arg) != mpctx->mixer.muted)
+	    mixer_mute(&mpctx->mixer);
+	mpctx->user_muted = mpctx->mixer.muted;
+	return M_PROPERTY_OK;
     case M_PROPERTY_STEP_UP:
     case M_PROPERTY_STEP_DOWN:
-        if (mpctx->edl_muted) return M_PROPERTY_DISABLED;
-        mixer_mute(&mpctx->mixer);
-        mpctx->user_muted = mpctx->mixer.muted;
-        return M_PROPERTY_OK;
+	if (mpctx->edl_muted)
+	    return M_PROPERTY_DISABLED;
+	mixer_mute(&mpctx->mixer);
+	mpctx->user_muted = mpctx->mixer.muted;
+	return M_PROPERTY_OK;
     case M_PROPERTY_PRINT:
-        if(!arg) return M_PROPERTY_ERROR;
-        if (mpctx->edl_muted) {
-            *(char**)arg = strdup(MSGTR_EnabledEdl);
-            return M_PROPERTY_OK;
-        }
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	if (mpctx->edl_muted) {
+	    *(char **) arg = strdup(MSGTR_EnabledEdl);
+	    return M_PROPERTY_OK;
+	}
     default:
-        return m_property_flag(prop, action, arg, &mpctx->mixer.muted);
+	return m_property_flag(prop, action, arg, &mpctx->mixer.muted);
 
     }
 }
 
 /// Audio delay (RW)
-static int mp_property_audio_delay(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    if (!(mpctx->sh_audio && mpctx->sh_video)) return M_PROPERTY_UNAVAILABLE;
-    switch(action) {
+static int mp_property_audio_delay(m_option_t * prop, int action,
+				   void *arg, MPContext * mpctx)
+{
+    if (!(mpctx->sh_audio && mpctx->sh_video))
+	return M_PROPERTY_UNAVAILABLE;
+    switch (action) {
     case M_PROPERTY_SET:
     case M_PROPERTY_STEP_UP:
     case M_PROPERTY_STEP_DOWN:
-        if(!arg) return M_PROPERTY_ERROR;
-        else {
-            float delay = audio_delay;
-            m_property_delay(prop,action,arg,&audio_delay);
-            if (mpctx->sh_audio) mpctx->sh_audio->delay -= audio_delay - delay;
-        }
-        return M_PROPERTY_OK;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	else {
+	    float delay = audio_delay;
+	    m_property_delay(prop, action, arg, &audio_delay);
+	    if (mpctx->sh_audio)
+		mpctx->sh_audio->delay -= audio_delay - delay;
+	}
+	return M_PROPERTY_OK;
     default:
-        return m_property_delay(prop,action,arg,&audio_delay);
+	return m_property_delay(prop, action, arg, &audio_delay);
     }
 }
 
 /// Audio codec tag (RO)
-static int mp_property_audio_format(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    if (!mpctx->sh_audio) return M_PROPERTY_UNAVAILABLE;
+static int mp_property_audio_format(m_option_t * prop, int action,
+				    void *arg, MPContext * mpctx)
+{
+    if (!mpctx->sh_audio)
+	return M_PROPERTY_UNAVAILABLE;
     return m_property_int_ro(prop, action, arg, mpctx->sh_audio->format);
 }
 
 /// Audio bitrate (RO)
-static int mp_property_audio_bitrate(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    if (!mpctx->sh_audio) return M_PROPERTY_UNAVAILABLE;
+static int mp_property_audio_bitrate(m_option_t * prop, int action,
+				     void *arg, MPContext * mpctx)
+{
+    if (!mpctx->sh_audio)
+	return M_PROPERTY_UNAVAILABLE;
     return m_property_int_ro(prop, action, arg, mpctx->sh_audio->i_bps);
 }
 
 /// Samplerate (RO)
-static int mp_property_samplerate(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    if (!mpctx->sh_audio) return M_PROPERTY_UNAVAILABLE;
+static int mp_property_samplerate(m_option_t * prop, int action, void *arg,
+				  MPContext * mpctx)
+{
+    if (!mpctx->sh_audio)
+	return M_PROPERTY_UNAVAILABLE;
     return m_property_int_ro(prop, action, arg, mpctx->sh_audio->samplerate);
 }
 
 /// Number of channels (RO)
-static int mp_property_channels(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
-    if (!mpctx->sh_audio) return M_PROPERTY_UNAVAILABLE;
-    switch(action) {
+static int mp_property_channels(m_option_t * prop, int action, void *arg,
+				MPContext * mpctx)
+{
+    if (!mpctx->sh_audio)
+	return M_PROPERTY_UNAVAILABLE;
+    switch (action) {
     case M_PROPERTY_PRINT:
-        if(!arg) return M_PROPERTY_ERROR;
-        switch (mpctx->sh_audio->channels) {
-        case 1: *(char**)arg = strdup("mono"); break;
-        case 2: *(char**)arg = strdup("stereo"); break;
-        default:
-            *(char**)arg = malloc(32);
-            sprintf(*(char **) arg, "%d channels", mpctx->sh_audio->channels);
-        }
-        return M_PROPERTY_OK;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	switch (mpctx->sh_audio->channels) {
+	case 1:
+	    *(char **) arg = strdup("mono");
+	    break;
+	case 2:
+	    *(char **) arg = strdup("stereo");
+	    break;
+	default:
+	    *(char **) arg = malloc(32);
+	    sprintf(*(char **) arg, "%d channels", mpctx->sh_audio->channels);
+	}
+	return M_PROPERTY_OK;
     }
     return m_property_int_ro(prop, action, arg, mpctx->sh_audio->channels);
 }
 
 /// Selected audio id (RW)
-static int mp_property_audio(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+static int mp_property_audio(m_option_t * prop, int action, void *arg,
+			     MPContext * mpctx)
+{
     int current_id = -1, tmp;
 
-    switch(action) {
+    switch (action) {
     case M_PROPERTY_GET:
-        if (!mpctx->sh_audio) return M_PROPERTY_UNAVAILABLE;
-        if(!arg) return M_PROPERTY_ERROR;
-        *(int*)arg = audio_id;
-        return M_PROPERTY_OK;
+	if (!mpctx->sh_audio)
+	    return M_PROPERTY_UNAVAILABLE;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	*(int *) arg = audio_id;
+	return M_PROPERTY_OK;
     case M_PROPERTY_PRINT:
-        if (!mpctx->sh_audio) return M_PROPERTY_UNAVAILABLE;
-        if(!arg) return M_PROPERTY_ERROR;
-
-        if (audio_id < 0)
-            *(char**)arg = strdup(MSGTR_Disabled);
-        else {
-            char lang[40] = MSGTR_Unknown;
-            if (mpctx->demuxer->type == DEMUXER_TYPE_MATROSKA)
-                demux_mkv_get_audio_lang(mpctx->demuxer, audio_id, lang, 9);
+	if (!mpctx->sh_audio)
+	    return M_PROPERTY_UNAVAILABLE;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+
+	if (audio_id < 0)
+	    *(char **) arg = strdup(MSGTR_Disabled);
+	else {
+	    char lang[40] = MSGTR_Unknown;
+	    if (mpctx->demuxer->type == DEMUXER_TYPE_MATROSKA)
+		demux_mkv_get_audio_lang(mpctx->demuxer, audio_id, lang, 9);
 #ifdef USE_DVDREAD
-            else if (mpctx->stream->type == STREAMTYPE_DVD) {
-                int code = dvd_lang_from_aid(mpctx->stream, audio_id);
-                if (code) {
-                    lang[0] = code >> 8;
-                    lang[1] = code;
-                    lang[2] = 0;
-                }
-            }
+	    else if (mpctx->stream->type == STREAMTYPE_DVD) {
+		int code = dvd_lang_from_aid(mpctx->stream, audio_id);
+		if (code) {
+		    lang[0] = code >> 8;
+		    lang[1] = code;
+		    lang[2] = 0;
+		}
+	    }
 #endif
 
 #ifdef USE_DVDNAV
-            else if (mpctx->stream->type == STREAMTYPE_DVDNAV)
-                dvdnav_lang_from_aid(mpctx->stream, audio_id, lang);
+	    else if (mpctx->stream->type == STREAMTYPE_DVDNAV)
+		dvdnav_lang_from_aid(mpctx->stream, audio_id, lang);
 #endif
-            *(char**)arg = malloc(64);
-            snprintf(*(char**)arg, 64, "(%d) %s", audio_id, lang);
-        }
-        return M_PROPERTY_OK;
+	    *(char **) arg = malloc(64);
+	    snprintf(*(char **) arg, 64, "(%d) %s", audio_id, lang);
+	}
+	return M_PROPERTY_OK;
 
     case M_PROPERTY_STEP_UP:
     case M_PROPERTY_SET:
-        if(action==M_PROPERTY_SET && arg)
-            tmp = *((int*)arg);
-        else
-            tmp = -1;
-        current_id = mpctx->demuxer->audio->id;
-        audio_id = demuxer_switch_audio(mpctx->demuxer, tmp);
-        if (audio_id == -2 || (audio_id > -1 && mpctx->demuxer->audio->id != current_id && current_id != -2))
-          uninit_player(INITED_AO | INITED_ACODEC);
-        if (audio_id > -1 && mpctx->demuxer->audio->id != current_id) {
-          sh_audio_t *sh2;
-          sh2 = mpctx->demuxer->a_streams[mpctx->demuxer->audio->id];
-          if(sh2) {
-            sh2->ds = mpctx->demuxer->audio;
-            mpctx->sh_audio = sh2;
-            reinit_audio_chain();
-          }
-        }
-        mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AUDIO_TRACK=%d\n", audio_id);
-        return M_PROPERTY_OK;
+	if (action == M_PROPERTY_SET && arg)
+	    tmp = *((int *) arg);
+	else
+	    tmp = -1;
+	current_id = mpctx->demuxer->audio->id;
+	audio_id = demuxer_switch_audio(mpctx->demuxer, tmp);
+	if (audio_id == -2
+	    || (audio_id > -1
+		&& mpctx->demuxer->audio->id != current_id && current_id != -2))
+	    uninit_player(INITED_AO | INITED_ACODEC);
+	if (audio_id > -1 && mpctx->demuxer->audio->id != current_id) {
+	    sh_audio_t *sh2;
+	    sh2 = mpctx->demuxer->a_streams[mpctx->demuxer->audio->id];
+	    if (sh2) {
+		sh2->ds = mpctx->demuxer->audio;
+		mpctx->sh_audio = sh2;
+		reinit_audio_chain();
+	    }
+	}
+	mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AUDIO_TRACK=%d\n", audio_id);
+	return M_PROPERTY_OK;
     default:
-        return M_PROPERTY_NOT_IMPLEMENTED;
+	return M_PROPERTY_NOT_IMPLEMENTED;
     }
 
 }
 
 /// Selected video id (RW)
-static int mp_property_video(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+static int mp_property_video(m_option_t * prop, int action, void *arg,
+			     MPContext * mpctx)
+{
     int current_id = -1, tmp;
 
-    switch(action) {
+    switch (action) {
     case M_PROPERTY_GET:
-        if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
-        if(!arg) return M_PROPERTY_ERROR;
-        *(int*)arg = video_id;
-        return M_PROPERTY_OK;
+	if (!mpctx->sh_video)
+	    return M_PROPERTY_UNAVAILABLE;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	*(int *) arg = video_id;
+	return M_PROPERTY_OK;
     case M_PROPERTY_PRINT:
-        if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
-        if(!arg) return M_PROPERTY_ERROR;
-
-        if (video_id < 0)
-            *(char**)arg = strdup(MSGTR_Disabled);
-        else {
-            char lang[40] = MSGTR_Unknown;
-            *(char**)arg = malloc(64);
-            snprintf(*(char**)arg, 64, "(%d) %s", video_id, lang);
-        }
-        return M_PROPERTY_OK;
+	if (!mpctx->sh_video)
+	    return M_PROPERTY_UNAVAILABLE;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+
+	if (video_id < 0)
+	    *(char **) arg = strdup(MSGTR_Disabled);
+	else {
+	    char lang[40] = MSGTR_Unknown;
+	    *(char **) arg = malloc(64);
+	    snprintf(*(char **) arg, 64, "(%d) %s", video_id, lang);
+	}
+	return M_PROPERTY_OK;
 
     case M_PROPERTY_STEP_UP:
     case M_PROPERTY_SET:
-        current_id = mpctx->demuxer->video->id;
-        if(action==M_PROPERTY_SET && arg)
-            tmp = *((int*)arg);
-        else
-            tmp = -1;
-        video_id = demuxer_switch_video(mpctx->demuxer, tmp);
-        if (video_id == -2 || (video_id > -1 && mpctx->demuxer->video->id != current_id && current_id != -2))
-          uninit_player(INITED_VCODEC | (fixed_vo && video_id != -2 ? 0 : INITED_VO));
-        if (video_id > -1 && mpctx->demuxer->video->id != current_id) {
-          sh_video_t *sh2;
-          sh2 = mpctx->demuxer->v_streams[mpctx->demuxer->video->id];
-          if(sh2) {
-            sh2->ds = mpctx->demuxer->video;
-            mpctx->sh_video = sh2;
-            reinit_video_chain();
-          }
-        }
-        mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_TRACK=%d\n", video_id);
-        return M_PROPERTY_OK;
+	current_id = mpctx->demuxer->video->id;
+	if (action == M_PROPERTY_SET && arg)
+	    tmp = *((int *) arg);
+	else
+	    tmp = -1;
+	video_id = demuxer_switch_video(mpctx->demuxer, tmp);
+	if (video_id == -2
+	    || (video_id > -1 && mpctx->demuxer->video->id != current_id
+		&& current_id != -2))
+	    uninit_player(INITED_VCODEC |
+			  (fixed_vo && video_id != -2 ? 0 : INITED_VO));
+	if (video_id > -1 && mpctx->demuxer->video->id != current_id) {
+	    sh_video_t *sh2;
+	    sh2 = mpctx->demuxer->v_streams[mpctx->demuxer->video->id];
+	    if (sh2) {
+		sh2->ds = mpctx->demuxer->video;
+		mpctx->sh_video = sh2;
+		reinit_video_chain();
+	    }
+	}
+	mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_TRACK=%d\n", video_id);
+	return M_PROPERTY_OK;
 
     default:
-        return M_PROPERTY_NOT_IMPLEMENTED;
+	return M_PROPERTY_NOT_IMPLEMENTED;
     }
 }
 
-static int mp_property_program(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+static int mp_property_program(m_option_t * prop, int action, void *arg,
+			       MPContext * mpctx)
+{
     demux_program_t prog;
 
-    switch(action) {
+    switch (action) {
     case M_PROPERTY_STEP_UP:
     case M_PROPERTY_SET:
-        if(action==M_PROPERTY_SET && arg)
-            prog.progid = *((int*)arg);
-        else
-            prog.progid = -1;
-        if (demux_control(mpctx->demuxer, DEMUXER_CTRL_IDENTIFY_PROGRAM, &prog) == DEMUXER_CTRL_NOTIMPL)
-            return M_PROPERTY_ERROR;
+	if (action == M_PROPERTY_SET && arg)
+	    prog.progid = *((int *) arg);
+	else
+	    prog.progid = -1;
+	if (demux_control
+	    (mpctx->demuxer, DEMUXER_CTRL_IDENTIFY_PROGRAM,
+	     &prog) == DEMUXER_CTRL_NOTIMPL)
+	    return M_PROPERTY_ERROR;
 
-        mp_property_do("switch_audio", M_PROPERTY_SET, &prog.aid, mpctx);
-        mp_property_do("switch_video", M_PROPERTY_SET, &prog.vid, mpctx);
-        return M_PROPERTY_OK;
+	mp_property_do("switch_audio", M_PROPERTY_SET, &prog.aid, mpctx);
+	mp_property_do("switch_video", M_PROPERTY_SET, &prog.vid, mpctx);
+	return M_PROPERTY_OK;
 
     default:
-        return M_PROPERTY_NOT_IMPLEMENTED;
+	return M_PROPERTY_NOT_IMPLEMENTED;
     }
 }
 
@@ -536,219 +646,283 @@ static int mp_property_program(m_option_t * prop, int action, void *arg, MPConte
 ///@{
 
 /// Fullscreen state (RW)
-static int mp_property_fullscreen(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+static int mp_property_fullscreen(m_option_t * prop, int action, void *arg,
+				  MPContext * mpctx)
+{
 
-    if (!mpctx->video_out) return M_PROPERTY_UNAVAILABLE;
+    if (!mpctx->video_out)
+	return M_PROPERTY_UNAVAILABLE;
 
-    switch(action) {
+    switch (action) {
     case M_PROPERTY_SET:
-        if(!arg) return M_PROPERTY_ERROR;
-        M_PROPERTY_CLAMP(prop,*(int*)arg);
-        if(vo_fs == !!*(int*)arg) return M_PROPERTY_OK;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	M_PROPERTY_CLAMP(prop, *(int *) arg);
+	if (vo_fs == !!*(int *) arg)
+	    return M_PROPERTY_OK;
     case M_PROPERTY_STEP_UP:
     case M_PROPERTY_STEP_DOWN:
 #ifdef HAVE_NEW_GUI
-        if(use_gui) guiGetEvent(guiIEvent,(char*)MP_CMD_GUI_FULLSCREEN);
-        else
+	if (use_gui)
+	    guiGetEvent(guiIEvent, (char *) MP_CMD_GUI_FULLSCREEN);
+	else
 #endif
-        if (vo_config_count) mpctx->video_out->control(VOCTRL_FULLSCREEN, 0);
-        return M_PROPERTY_OK;
+	if (vo_config_count)
+	    mpctx->video_out->control(VOCTRL_FULLSCREEN, 0);
+	return M_PROPERTY_OK;
     default:
-        return m_property_flag(prop,action,arg,&vo_fs);
+	return m_property_flag(prop, action, arg, &vo_fs);
     }
 }
 
-static int mp_property_deinterlace(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+static int mp_property_deinterlace(m_option_t * prop, int action,
+				   void *arg, MPContext * mpctx)
+{
     int deinterlace;
     vf_instance_t *vf;
-    if (!mpctx->sh_video || !mpctx->sh_video->vfilter) return M_PROPERTY_UNAVAILABLE;
+    if (!mpctx->sh_video || !mpctx->sh_video->vfilter)
+	return M_PROPERTY_UNAVAILABLE;
     vf = mpctx->sh_video->vfilter;
-    switch(action) {
+    switch (action) {
     case M_PROPERTY_GET:
-        if(!arg) return M_PROPERTY_ERROR;
-        vf->control(vf, VFCTRL_GET_DEINTERLACE, arg);
-        return M_PROPERTY_OK;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	vf->control(vf, VFCTRL_GET_DEINTERLACE, arg);
+	return M_PROPERTY_OK;
     case M_PROPERTY_SET:
-        if(!arg) return M_PROPERTY_ERROR;
-        M_PROPERTY_CLAMP(prop,*(int*)arg);
-        vf->control(vf, VFCTRL_SET_DEINTERLACE, arg);
-        return M_PROPERTY_OK;
+	if (!arg)
+	    return M_PROPERTY_ERROR;
+	M_PROPERTY_CLAMP(prop, *(int *) arg);
+	vf->control(vf, VFCTRL_SET_DEINTERLACE, arg);
+	return M_PROPERTY_OK;
     case M_PROPERTY_STEP_UP:
     case M_PROPERTY_STEP_DOWN:
-        vf->control(vf, VFCTRL_GET_DEINTERLACE, &deinterlace);
-        deinterlace = !deinterlace;
-        vf->control(vf, VFCTRL_SET_DEINTERLACE, &deinterlace);
-        return M_PROPERTY_OK;
+	vf->control(vf, VFCTRL_GET_DEINTERLACE, &deinterlace);
+	deinterlace = !deinterlace;
+	vf->control(vf, VFCTRL_SET_DEINTERLACE, &deinterlace);
+	return M_PROPERTY_OK;
     }
     return M_PROPERTY