Add alternative way to create command.c to svn history,

created by Rathann. Having this in the repository history
probably won't have much more than symbolic value but shouldn't
hurt either beyond bloating history size.


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

1 files changed, 2031 insertions, 0 deletions

diff --git a/command.c.tmp b/command.c.tmp
new file mode 100644
index 0000000000..f5c488dedc
--- /dev/null
+++ b/command.c.tmp
@@ -0,0 +1,2031 @@
+#include <inttypes.h>
+#include <stdlib.h>
+#include "config.h"
+
+#include <unistd.h>
+
+#include "help_mp.h"
+
+#include "m_option.h"
+#include "m_property.h"
+
+#include "libvo/video_out.h"
+
+#include "libvo/sub.h"
+
+#include "libao2/audio_out.h"
+
+#include "spudec.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))
+
+#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"
+
+#include "mp_core.h"
+
+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;
+        }
+    }
+    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
+ *
+ * Intended purpose is to allow convenient marking of bogus subtitles
+ * which need to be fixed while watching the movie.
+ */
+
+static void log_sub(void){
+    char *fname;
+    FILE *f;
+    int i;
+
+    if (subdata == NULL || vo_sub_last == NULL) return;
+    fname = get_path("subtitle_log");
+    f = fopen(fname, "a");
+    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);
+    } else {
+	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]);
+    }
+    fclose(f);
+}
+
+
+/// \defgroup Properties
+///@{
+
+/// \defgroup GeneralProperties General properties
+/// \ingroup Properties
+///@{
+
+/// 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);
+}
+
+/// Playback speed (RW)
+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;
+    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;
+    }
+    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);
+}
+
+/// 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++;
+    else
+        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);
+}
+
+/// 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;
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(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;
+    }
+    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;
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(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;
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(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;
+    switch (action) {
+    case M_PROPERTY_GET:
+        *(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) {
+    double len;
+    
+    if (!mpctx->demuxer ||
+        !(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;
+    }
+    return m_property_double_ro(prop,action,arg,len);
+}
+
+///@}
+
+/// \defgroup AudioProperties Audio properties
+/// \ingroup Properties
+///@{
+
+/// Volume (RW)
+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) {
+    case M_PROPERTY_GET:
+        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);
+    }        
+    case M_PROPERTY_STEP_UP:
+    case M_PROPERTY_STEP_DOWN:
+    case M_PROPERTY_SET:
+        break;
+    default:
+        return M_PROPERTY_NOT_IMPLEMENTED;
+    }
+
+    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;
+    case M_PROPERTY_STEP_UP:
+        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;
+    }
+    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) {
+    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;
+    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;
+    case M_PROPERTY_PRINT:
+        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);
+
+    }
+}
+
+/// 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) {
+    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;
+    default:
+        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;
+    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;
+    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;
+    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) {
+    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;
+    }
+    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) {
+    int current_id = -1, tmp;
+
+    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;
+    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);
+#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;
+                }
+            }
+#endif
+
+#ifdef USE_DVDNAV
+            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;
+
+    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;
+    default:
+        return M_PROPERTY_NOT_IMPLEMENTED;
+    }
+
+}
+
+/// Selected video id (RW)
+static int mp_property_video(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    int current_id = -1, tmp;
+
+    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;
+    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;
+
+    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;
+
+    default:
+        return M_PROPERTY_NOT_IMPLEMENTED;
+    }
+}
+
+static int mp_property_program(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    demux_program_t prog;
+
+    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;
+
+        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;
+    }
+}
+
+///@}
+
+/// \defgroup VideoProperties Video properties
+/// \ingroup Properties
+///@{
+
+/// Fullscreen state (RW)
+static int mp_property_fullscreen(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+
+    if (!mpctx->video_out) return M_PROPERTY_UNAVAILABLE;
+
+    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;
+    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
+#endif
+        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);
+    }
+}
+
+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;
+    vf = mpctx->sh_video->vfilter;
+    switch(action) {
+    case M_PROPERTY_GET:
+        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;
+    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;
+    }
+    return M_PROPERTY_NOT_IMPLEMENTED;
+}
+
+/// Panscan (RW)
+static int mp_property_panscan(m_option_t * prop, int action, void *arg, MPContext * mpctx)
+{
+
+    if (!mpctx->video_out || mpctx->video_out->control(VOCTRL_GET_PANSCAN, NULL) != VO_TRUE)
+        return M_PROPERTY_UNAVAILABLE;
+
+    switch(action) {
+    case M_PROPERTY_SET:
+        if(!arg) return M_PROPERTY_ERROR;
+        M_PROPERTY_CLAMP(prop,*(float*)arg);
+        vo_panscan = *(float*)arg;
+        mpctx->video_out->control(VOCTRL_SET_PANSCAN, NULL);
+        return M_PROPERTY_OK;
+    case M_PROPERTY_STEP_UP:
+    case M_PROPERTY_STEP_DOWN:
+        vo_panscan += (arg ? *(float*)arg : 0.1) *
+            (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
+        if(vo_panscan > 1) vo_panscan = 1;
+        else if(vo_panscan < 0) vo_panscan = 0;
+        mpctx->video_out->control(VOCTRL_SET_PANSCAN, NULL);
+        return M_PROPERTY_OK;
+    default:
+        return m_property_float_range(prop,action,arg,&vo_panscan);
+    }
+}
+
+/// Helper to set vo flags.
+/** \ingroup PropertyImplHelper
+ */
+static int mp_property_vo_flag(m_option_t* prop,int action,void* arg,
+                               int vo_ctrl, int *vo_var, MPContext * mpctx) {
+
+    if (!mpctx->video_out) return M_PROPERTY_UNAVAILABLE;
+
+    switch(action) {
+    case M_PROPERTY_SET:
+        if(!arg) return M_PROPERTY_ERROR;
+        M_PROPERTY_CLAMP(prop,*(int*)arg);
+        if(*vo_var == !!*(int*)arg) return M_PROPERTY_OK;
+    case M_PROPERTY_STEP_UP:
+    case M_PROPERTY_STEP_DOWN:
+        if (vo_config_count) mpctx->video_out->control(vo_ctrl, 0);
+        return M_PROPERTY_OK;
+    default:
+        return m_property_flag(prop,action,arg,vo_var);
+    }
+}
+
+/// Window always on top (RW)
+static int mp_property_ontop(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    return mp_property_vo_flag(prop, action, arg, VOCTRL_ONTOP, &vo_ontop, mpctx);
+}
+
+/// Display in the root window (RW)
+static int mp_property_rootwin(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    return mp_property_vo_flag(prop, action, arg, VOCTRL_ROOTWIN, &vo_rootwin, mpctx);
+}
+
+/// Show window borders (RW)
+static int mp_property_border(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    return mp_property_vo_flag(prop, action, arg, VOCTRL_BORDER, &vo_border, mpctx);
+}
+
+/// Framedropping state (RW)
+static int mp_property_framedropping(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+
+    if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
+    
+    switch(action) {
+    case M_PROPERTY_PRINT:
+        if(!arg) return M_PROPERTY_ERROR;
+        *(char**)arg = strdup(frame_dropping == 1 ? MSGTR_Enabled :
+                              (frame_dropping == 2 ? MSGTR_HardFrameDrop  : MSGTR_Disabled));
+        return M_PROPERTY_OK;
+    default:
+        return m_property_choice(prop,action,arg,&frame_dropping);
+    }
+}
+
+/// Color settings, try to use vf/vo then fall back on TV. (RW)
+static int mp_property_gamma(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    int* gamma = prop->priv, r;
+
+    if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
+
+    if(gamma[0] == 1000) {
+        gamma[0] = 0;
+        get_video_colors(mpctx->sh_video, prop->name, gamma);
+    }
+
+    switch(action) {
+    case M_PROPERTY_SET:
+        if(!arg) return M_PROPERTY_ERROR;
+        M_PROPERTY_CLAMP(prop,*(int*)arg);
+        *gamma = *(int*)arg;
+        r = set_video_colors(mpctx->sh_video, prop->name, *gamma);
+        if(r <= 0) break;
+        return r;
+    case M_PROPERTY_GET:
+        if(!arg) return M_PROPERTY_ERROR;
+        r = get_video_colors(mpctx->sh_video, prop->name, arg);
+        if(r <= 0) break;
+        return r;
+    case M_PROPERTY_STEP_UP:
+    case M_PROPERTY_STEP_DOWN:
+        *gamma += (arg ? *(int*)arg : 1) *
+            (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
+        M_PROPERTY_CLAMP(prop,*gamma);
+        r = set_video_colors(mpctx->sh_video, prop->name, *gamma);
+        if(r <= 0) break;
+        return r;
+    default:
+        return M_PROPERTY_NOT_IMPLEMENTED;
+    }
+    
+#ifdef USE_TV
+    if (mpctx->demuxer->type == DEMUXER_TYPE_TV) {
+        int l = strlen(prop->name);
+        char tv_prop[3+l+1];
+        sprintf(tv_prop,"tv_%s",prop->name);
+        return mp_property_do(tv_prop, action, arg, mpctx);
+    }
+#endif
+    
+    return M_PROPERTY_UNAVAILABLE;
+}
+
+/// VSync (RW)
+static int mp_property_vsync(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    return m_property_flag(prop,action,arg,&vo_vsync);
+}
+
+/// Video codec tag (RO)
+static int mp_property_video_format(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
+    return m_property_int_ro(prop, action, arg, mpctx->sh_video->format);
+}
+
+/// Video bitrate (RO)
+static int mp_property_video_bitrate(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
+    return m_property_int_ro(prop, action, arg, mpctx->sh_video->i_bps);
+}
+
+/// Video display width (RO)
+static int mp_property_width(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
+    return m_property_int_ro(prop, action, arg, mpctx->sh_video->disp_w);
+}
+
+/// Video display height (RO)
+static int mp_property_height(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
+    return m_property_int_ro(prop, action, arg, mpctx->sh_video->disp_h);
+}
+
+/// Video fps (RO)
+static int mp_property_fps(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
+    return m_property_float_ro(prop, action, arg, mpctx->sh_video->fps);
+}
+
+/// Video aspect (RO)
+static int mp_property_aspect(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
+    return m_property_float_ro(prop, action, arg, mpctx->sh_video->aspect);
+}
+
+///@}
+
+/// \defgroup SubProprties Subtitles properties
+/// \ingroup Properties
+///@{
+
+/// Text subtitle position (RW)
+static int mp_property_sub_pos(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
+
+    switch(action) {
+    case M_PROPERTY_SET:
+        if(!arg) return M_PROPERTY_ERROR;
+    case M_PROPERTY_STEP_UP:
+    case M_PROPERTY_STEP_DOWN:
+        vo_osd_changed(OSDTYPE_SUBTITLE);
+    default:
+        return m_property_int_range(prop,action,arg,&sub_pos);
+    }
+}
+
+/// Selected subtitles (RW)
+static int mp_property_sub(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    demux_stream_t *const d_sub = mpctx->d_sub;
+    const int global_sub_size = mpctx->global_sub_size;
+    int source = -1, reset_spu = 0;
+    char* sub_name;
+
+    if(global_sub_size <= 0) return M_PROPERTY_UNAVAILABLE;
+
+    switch(action) {
+    case M_PROPERTY_GET:
+        if(!arg) return M_PROPERTY_ERROR;
+        *(int *) arg = mpctx->global_sub_pos;
+        return M_PROPERTY_OK;
+    case M_PROPERTY_PRINT:
+        if(!arg) return M_PROPERTY_ERROR;
+        *(char**)arg = malloc(64);
+        (*(char**)arg)[63] = 0;
+        sub_name = 0;
+        if(subdata)
+            sub_name = subdata->filename;
+#ifdef USE_ASS
+        if (ass_track && ass_track->name)
+            sub_name = ass_track->name;
+#endif
+        if(sub_name) {
+            char *tmp,*tmp2;
+            tmp = sub_name;
+            if ((tmp2 = strrchr(tmp, '/')))
+                tmp = tmp2+1;
+
+            snprintf(*(char**)arg, 63, "(%d) %s%s",
+                     mpctx->set_of_sub_pos + 1,
+                     strlen(tmp) < 20 ? "" : "...",
+                     strlen(tmp) < 20 ? tmp : tmp+strlen(tmp)-19);
+            return M_PROPERTY_OK;
+        }
+#ifdef USE_DVDNAV
+        if (mpctx->stream->type == STREAMTYPE_DVDNAV) {
+            if(vo_spudec && dvdsub_id >= 0) {
+                unsigned char lang[3];
+                if (dvdnav_lang_from_sid(mpctx->stream, dvdsub_id, lang)) {
+                    snprintf(*(char**)arg, 63, "(%d) %s", dvdsub_id, lang);
+                    return M_PROPERTY_OK;
+                }
+            }
+        }
+#endif
+
+        if (mpctx->demuxer->type == DEMUXER_TYPE_MATROSKA && dvdsub_id >= 0) {
+            char lang[40] = MSGTR_Unknown;
+            demux_mkv_get_sub_lang(mpctx->demuxer, dvdsub_id, lang, 9);
+            snprintf(*(char**)arg, 63, "(%d) %s", dvdsub_id, lang);
+            return M_PROPERTY_OK;
+        }
+#ifdef HAVE_OGGVORBIS
+        if (mpctx->demuxer->type == DEMUXER_TYPE_OGG && d_sub && dvdsub_id >= 0) {
+            char *lang = demux_ogg_sub_lang(mpctx->demuxer, dvdsub_id);
+            if (!lang) lang = MSGTR_Unknown;
+            snprintf(*(char**)arg, 63, "(%d) %s",
+                     dvdsub_id, lang);
+            return M_PROPERTY_OK;
+        }
+#endif
+        if (vo_vobsub && vobsub_id >= 0) {
+            const char *language = MSGTR_Unknown;
+            language = vobsub_get_id(vo_vobsub, (unsigned int) vobsub_id);
+            snprintf(*(char**)arg, 63, "(%d) %s",
+                     vobsub_id, language ? language : MSGTR_Unknown);
+            return M_PROPERTY_OK;
+        }
+#ifdef USE_DVDREAD
+        if (vo_spudec && mpctx->stream->type == STREAMTYPE_DVD && dvdsub_id >= 0) {
+            char lang[3];
+            int code = dvd_lang_from_sid(mpctx->stream, dvdsub_id);
+                lang[0] = code >> 8;
+                lang[1] = code;
+                lang[2] = 0;
+            snprintf(*(char**)arg, 63, "(%d) %s",
+                     dvdsub_id, lang);
+            return M_PROPERTY_OK;
+        }
+#endif
+        if (dvdsub_id >= 0) {
+            snprintf(*(char**)arg, 63, "(%d) %s", dvdsub_id, MSGTR_Unknown);
+            return M_PROPERTY_OK;
+        }
+        snprintf(*(char**)arg, 63, MSGTR_Disabled);
+        return M_PROPERTY_OK;
+
+    case M_PROPERTY_SET:
+        if(!arg) return M_PROPERTY_ERROR;
+        if(*(int*)arg < -1) *(int*)arg = -1;
+        else if(*(int*)arg >= global_sub_size) *(int*)arg = global_sub_size-1;
+        mpctx->global_sub_pos = *(int *) arg;
+        break;
+    case M_PROPERTY_STEP_UP:
+        mpctx->global_sub_pos += 2;
+        mpctx->global_sub_pos = (mpctx->global_sub_pos % (global_sub_size + 1)) - 1;
+        break;
+    case M_PROPERTY_STEP_DOWN:
+        mpctx->global_sub_pos += global_sub_size + 1;
+        mpctx->global_sub_pos = (mpctx->global_sub_pos % (global_sub_size + 1)) - 1;
+        break;
+    default:
+        return M_PROPERTY_NOT_IMPLEMENTED;
+    }
+
+    if (mpctx->global_sub_pos >= 0)
+        source = sub_source(mpctx);
+
+    mp_msg(MSGT_CPLAYER, MSGL_DBG3,
+           "subtitles: %d subs, (v@%d s@%d d@%d), @%d, source @%d\n",
+           global_sub_size,
+           mpctx->global_sub_indices[SUB_SOURCE_VOBSUB],
+           mpctx->global_sub_indices[SUB_SOURCE_SUBS],
+           mpctx->global_sub_indices[SUB_SOURCE_DEMUX],
+           mpctx->global_sub_pos, source);
+
+    mpctx->set_of_sub_pos = -1;
+    subdata = NULL;
+    vo_sub_last = vo_sub = NULL;
+
+    vobsub_id = -1;
+    dvdsub_id = -1;
+    if (d_sub) {
+        if (d_sub->id > -2) reset_spu = 1;
+        d_sub->id = -2;
+    }
+#ifdef USE_ASS
+    ass_track = 0;
+#endif
+
+    if (source == SUB_SOURCE_VOBSUB) {
+        vobsub_id = mpctx->global_sub_pos - mpctx->global_sub_indices[SUB_SOURCE_VOBSUB];
+    } else if (source == SUB_SOURCE_SUBS) {
+        mpctx->set_of_sub_pos = mpctx->global_sub_pos - mpctx->global_sub_indices[SUB_SOURCE_SUBS];
+#ifdef USE_ASS
+        if (ass_enabled && mpctx->set_of_ass_tracks[mpctx->set_of_sub_pos])
+            ass_track = mpctx->set_of_ass_tracks[mpctx->set_of_sub_pos];
+        else 
+#endif
+        {
+            subdata = mpctx->set_of_subtitles[mpctx->set_of_sub_pos];
+            vo_osd_changed(OSDTYPE_SUBTITLE);
+        }
+    } else if (source == SUB_SOURCE_DEMUX) {
+        dvdsub_id = mpctx->global_sub_pos - mpctx->global_sub_indices[SUB_SOURCE_DEMUX];
+        if (d_sub) {
+#ifdef USE_DVDREAD
+            if (vo_spudec && mpctx->stream->type == STREAMTYPE_DVD) {
+                d_sub->id = dvdsub_id;
+            }
+#endif
+
+#ifdef USE_DVDNAV
+            if (vo_spudec && mpctx->stream->type == STREAMTYPE_DVDNAV) {
+                d_sub->id = dvdsub_id;
+            }
+#endif
+            if (mpctx->stream->type != STREAMTYPE_DVD && mpctx->stream->type != STREAMTYPE_DVDNAV) {
+              int i = 0;
+              for (d_sub->id = 0; d_sub->id < MAX_S_STREAMS; d_sub->id++) {
+                if (mpctx->demuxer->s_streams[d_sub->id]) {
+                  if (i == dvdsub_id) break;
+                  i++;
+                }
+              }
+              d_sub->sh = mpctx->demuxer->s_streams[d_sub->id];
+            }
+            if (mpctx->demuxer->type == DEMUXER_TYPE_MATROSKA) {
+                d_sub->id = demux_mkv_change_subs(mpctx->demuxer, dvdsub_id);
+            }
+            if (d_sub->sh && d_sub->id >= 0) {
+                sh_sub_t *sh = d_sub->sh;
+                if (sh->type == 'v')
+                    init_vo_spudec();
+#ifdef USE_ASS
+                else if (ass_enabled && sh->type == 'a')
+                    ass_track = sh->ass_track;
+#endif
+            }
+        }
+    }
+#ifdef USE_DVDREAD
+    if (vo_spudec && (mpctx->stream->type == STREAMTYPE_DVD || mpctx->stream->type == STREAMTYPE_DVDNAV) && dvdsub_id < 0 && reset_spu) {
+        dvdsub_id = -2;
+        d_sub->id = dvdsub_id;
+    }
+#endif
+    update_subtitles(mpctx->sh_video, d_sub, 1);
+
+    return M_PROPERTY_OK;
+}
+
+/// Subtitle delay (RW)
+static int mp_property_sub_delay(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    if (!mpctx->sh_video) return M_PROPERTY_UNAVAILABLE;
+    return m_property_delay(prop,action,arg,&sub_delay);
+}
+
+/// Alignment of text subtitles (RW) 
+static int mp_property_sub_alignment(m_option_t * prop, int action, void *arg, MPContext * mpctx) {
+    char* name[] = { MSGTR_Top, MSGTR_Center, MSGTR_Bottom };
+
+    if (!mpctx->sh_video || mpctx->global_sub_pos < 0 || sub_source(mpctx) != SUB_SOURCE_SUBS)
+        return M_PROPERTY_UNAVAILABLE;
+
+    switch(action) {
+    case M_PROPERTY_PRINT:
+        if(!arg) return M_PROPERTY_ERROR;
+        M_PROPERTY_CLAMP(prop,sub_alignment);
+        *(char**)arg = strdup(name[sub_alignment]);
+        return M_PROPERTY_OK;
+    case M_PROPERTY_SET:
+        if(!arg) return M_PROPERTY_ERROR;
+    case M_PROPERTY_STEP_UP:
+    case M_PROPERTY_STEP_DOWN:
+        vo_osd_changed(OSDTYPE_SUBTITLE);
+    default:
+        return m_property_choice