Update to MPlayer SVN rev 29473 and FFmpeg SVN rev 19572.
[vaapi:athaifas-mplayer.git] / command.c
1 #include <stdlib.h>
2 #include <inttypes.h>
3 #include <unistd.h>
4 #include <string.h>
5
6 #include "config.h"
7 #include "command.h"
8 #include "input/input.h"
9 #include "stream/stream.h"
10 #include "libmpdemux/demuxer.h"
11 #include "libmpdemux/stheader.h"
12 #include "codec-cfg.h"
13 #include "mplayer.h"
14 #include "libvo/sub.h"
15 #include "m_option.h"
16 #include "m_property.h"
17 #include "help_mp.h"
18 #include "metadata.h"
19 #include "libmpcodecs/vf.h"
20 #include "libmpcodecs/vd.h"
21 #include "libvo/video_out.h"
22 #include "libvo/font_load.h"
23 #include "playtree.h"
24 #include "libao2/audio_out.h"
25 #include "mpcommon.h"
26 #include "mixer.h"
27 #include "libmpcodecs/dec_video.h"
28 #include "vobsub.h"
29 #include "spudec.h"
30 #include "get_path.h"
31 #include "stream/tv.h"
32 #include "stream/stream_radio.h"
33 #include "stream/pvr.h"
34 #ifdef CONFIG_DVBIN
35 #include "stream/dvbin.h"
36 #endif
37 #include "stream/stream_dvd.h"
38 #include "stream/stream_dvdnav.h"
39 #include "libass/ass.h"
40 #include "libass/ass_mp.h"
41 #include "m_struct.h"
42 #include "libmenu/menu.h"
43 #include "gui/interface.h"
44
45 #include "mp_core.h"
46 #include "mp_fifo.h"
47 #include "libavutil/avstring.h"
48
49 #define ROUND(x) ((int)((x)<0 ? (x)-0.5 : (x)+0.5))
50
51 extern int use_menu;
52
53 static void rescale_input_coordinates(int ix, int iy, double *dx, double *dy)
54 {
55     //remove the borders, if any, and rescale to the range [0,1],[0,1]
56     if (vo_fs) {                //we are in full-screen mode
57         if (vo_screenwidth > vo_dwidth) //there are borders along the x axis
58             ix -= (vo_screenwidth - vo_dwidth) / 2;
59         if (vo_screenheight > vo_dheight)       //there are borders along the y axis (usual way)
60             iy -= (vo_screenheight - vo_dheight) / 2;
61
62         if (ix < 0 || ix > vo_dwidth) {
63             *dx = *dy = -1.0;
64             return;
65         }                       //we are on one of the borders
66         if (iy < 0 || iy > vo_dheight) {
67             *dx = *dy = -1.0;
68             return;
69         }                       //we are on one of the borders
70     }
71
72     *dx = (double) ix / (double) vo_dwidth;
73     *dy = (double) iy / (double) vo_dheight;
74
75     mp_msg(MSGT_CPLAYER, MSGL_V,
76            "\r\nrescaled coordinates: %.3lf, %.3lf, screen (%d x %d), vodisplay: (%d, %d), fullscreen: %d\r\n",
77            *dx, *dy, vo_screenwidth, vo_screenheight, vo_dwidth,
78            vo_dheight, vo_fs);
79 }
80
81 static int sub_source_by_pos(MPContext * mpctx, int pos)
82 {
83     int source = -1;
84     int top = -1;
85     int i;
86     for (i = 0; i < SUB_SOURCES; i++) {
87         int j = mpctx->global_sub_indices[i];
88         if ((j >= 0) && (j > top) && (pos >= j)) {
89             source = i;
90             top = j;
91         }
92     }
93     return source;
94 }
95
96 static int sub_source(MPContext * mpctx)
97 {
98     return sub_source_by_pos(mpctx, mpctx->global_sub_pos);
99 }
100
101 /**
102  * \brief Log the currently displayed subtitle to a file
103  *
104  * Logs the current or last displayed subtitle together with filename
105  * and time information to ~/.mplayer/subtitle_log
106  *
107  * Intended purpose is to allow convenient marking of bogus subtitles
108  * which need to be fixed while watching the movie.
109  */
110
111 static void log_sub(void)
112 {
113     char *fname;
114     FILE *f;
115     int i;
116
117     if (subdata == NULL || vo_sub_last == NULL)
118         return;
119     fname = get_path("subtitle_log");
120     f = fopen(fname, "a");
121     if (!f)
122         return;
123     fprintf(f, "----------------------------------------------------------\n");
124     if (subdata->sub_uses_time) {
125         fprintf(f,
126                 "N: %s S: %02ld:%02ld:%02ld.%02ld E: %02ld:%02ld:%02ld.%02ld\n",
127                 filename, vo_sub_last->start / 360000,
128                 (vo_sub_last->start / 6000) % 60,
129                 (vo_sub_last->start / 100) % 60, vo_sub_last->start % 100,
130                 vo_sub_last->end / 360000, (vo_sub_last->end / 6000) % 60,
131                 (vo_sub_last->end / 100) % 60, vo_sub_last->end % 100);
132     } else {
133         fprintf(f, "N: %s S: %ld E: %ld\n", filename, vo_sub_last->start,
134                 vo_sub_last->end);
135     }
136     for (i = 0; i < vo_sub_last->lines; i++) {
137         fprintf(f, "%s\n", vo_sub_last->text[i]);
138     }
139     fclose(f);
140 }
141
142
143 /// \defgroup Properties
144 ///@{
145
146 /// \defgroup GeneralProperties General properties
147 /// \ingroup Properties
148 ///@{
149
150 /// OSD level (RW)
151 static int mp_property_osdlevel(m_option_t * prop, int action, void *arg,
152                                 MPContext * mpctx)
153 {
154     return m_property_choice(prop, action, arg, &osd_level);
155 }
156
157 /// Loop (RW)
158 static int mp_property_loop(m_option_t * prop, int action, void *arg,
159                             MPContext * mpctx)
160 {
161     switch (action) {
162     case M_PROPERTY_PRINT:
163         if (!arg) return M_PROPERTY_ERROR;
164         if (mpctx->loop_times < 0)
165             *(char**)arg = strdup("off");
166         else if (mpctx->loop_times == 0)
167             *(char**)arg = strdup("inf");
168         else
169             break;
170         return M_PROPERTY_OK;
171     }
172     return m_property_int_range(prop, action, arg, &mpctx->loop_times);
173 }
174
175 /// Playback speed (RW)
176 static int mp_property_playback_speed(m_option_t * prop, int action,
177                                       void *arg, MPContext * mpctx)
178 {
179     switch (action) {
180     case M_PROPERTY_SET:
181         if (!arg)
182             return M_PROPERTY_ERROR;
183         M_PROPERTY_CLAMP(prop, *(float *) arg);
184         playback_speed = *(float *) arg;
185         build_afilter_chain(mpctx->sh_audio, &ao_data);
186         return M_PROPERTY_OK;
187     case M_PROPERTY_STEP_UP:
188     case M_PROPERTY_STEP_DOWN:
189         playback_speed += (arg ? *(float *) arg : 0.1) *
190             (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
191         M_PROPERTY_CLAMP(prop, playback_speed);
192         build_afilter_chain(mpctx->sh_audio, &ao_data);
193         return M_PROPERTY_OK;
194     }
195     return m_property_float_range(prop, action, arg, &playback_speed);
196 }
197
198 /// filename with path (RO)
199 static int mp_property_path(m_option_t * prop, int action, void *arg,
200                             MPContext * mpctx)
201 {
202     return m_property_string_ro(prop, action, arg, filename);
203 }
204
205 /// filename without path (RO)
206 static int mp_property_filename(m_option_t * prop, int action, void *arg,
207                                 MPContext * mpctx)
208 {
209     char *f;
210     if (!filename)
211         return M_PROPERTY_UNAVAILABLE;
212     if (((f = strrchr(filename, '/')) || (f = strrchr(filename, '\\'))) && f[1])
213         f++;
214     else
215         f = filename;
216     return m_property_string_ro(prop, action, arg, f);
217 }
218
219 /// Demuxer name (RO)
220 static int mp_property_demuxer(m_option_t * prop, int action, void *arg,
221                                MPContext * mpctx)
222 {
223     if (!mpctx->demuxer)
224         return M_PROPERTY_UNAVAILABLE;
225     return m_property_string_ro(prop, action, arg,
226                                 (char *) mpctx->demuxer->desc->name);
227 }
228
229 /// Position in the stream (RW)
230 static int mp_property_stream_pos(m_option_t * prop, int action, void *arg,
231                                   MPContext * mpctx)
232 {
233     if (!mpctx->demuxer || !mpctx->demuxer->stream)
234         return M_PROPERTY_UNAVAILABLE;
235     if (!arg)
236         return M_PROPERTY_ERROR;
237     switch (action) {
238     case M_PROPERTY_GET:
239         *(off_t *) arg = stream_tell(mpctx->demuxer->stream);
240         return M_PROPERTY_OK;
241     case M_PROPERTY_SET:
242         M_PROPERTY_CLAMP(prop, *(off_t *) arg);
243         stream_seek(mpctx->demuxer->stream, *(off_t *) arg);
244         return M_PROPERTY_OK;
245     }
246     return M_PROPERTY_NOT_IMPLEMENTED;
247 }
248
249 /// Stream start offset (RO)
250 static int mp_property_stream_start(m_option_t * prop, int action,
251                                     void *arg, MPContext * mpctx)
252 {
253     if (!mpctx->demuxer || !mpctx->demuxer->stream)
254         return M_PROPERTY_UNAVAILABLE;
255     switch (action) {
256     case M_PROPERTY_GET:
257         *(off_t *) arg = mpctx->demuxer->stream->start_pos;
258         return M_PROPERTY_OK;
259     }
260     return M_PROPERTY_NOT_IMPLEMENTED;
261 }
262
263 /// Stream end offset (RO)
264 static int mp_property_stream_end(m_option_t * prop, int action, void *arg,
265                                   MPContext * mpctx)
266 {
267     if (!mpctx->demuxer || !mpctx->demuxer->stream)
268         return M_PROPERTY_UNAVAILABLE;
269     switch (action) {
270     case M_PROPERTY_GET:
271         *(off_t *) arg = mpctx->demuxer->stream->end_pos;
272         return M_PROPERTY_OK;
273     }
274     return M_PROPERTY_NOT_IMPLEMENTED;
275 }
276
277 /// Stream length (RO)
278 static int mp_property_stream_length(m_option_t * prop, int action,
279                                      void *arg, MPContext * mpctx)
280 {
281     if (!mpctx->demuxer || !mpctx->demuxer->stream)
282         return M_PROPERTY_UNAVAILABLE;
283     switch (action) {
284     case M_PROPERTY_GET:
285         *(off_t *) arg =
286             mpctx->demuxer->stream->end_pos - mpctx->demuxer->stream->start_pos;
287         return M_PROPERTY_OK;
288     }
289     return M_PROPERTY_NOT_IMPLEMENTED;
290 }
291
292 /// Media length in seconds (RO)
293 static int mp_property_length(m_option_t * prop, int action, void *arg,
294                               MPContext * mpctx)
295 {
296     double len;
297
298     if (!mpctx->demuxer ||
299         !(int) (len = demuxer_get_time_length(mpctx->demuxer)))
300         return M_PROPERTY_UNAVAILABLE;
301
302     return m_property_time_ro(prop, action, arg, len);
303 }
304
305 /// Current position in percent (RW)
306 static int mp_property_percent_pos(m_option_t * prop, int action,
307                                    void *arg, MPContext * mpctx) {
308     int pos;
309
310     if (!mpctx->demuxer)
311         return M_PROPERTY_UNAVAILABLE;
312
313     switch(action) {
314     case M_PROPERTY_SET:
315         if(!arg) return M_PROPERTY_ERROR;
316         M_PROPERTY_CLAMP(prop, *(int*)arg);
317         pos = *(int*)arg;
318         break;
319     case M_PROPERTY_STEP_UP:
320     case M_PROPERTY_STEP_DOWN:
321         pos = demuxer_get_percent_pos(mpctx->demuxer);
322         pos += (arg ? *(int*)arg : 10) *
323             (action == M_PROPERTY_STEP_UP ? 1 : -1);
324         M_PROPERTY_CLAMP(prop, pos);
325         break;
326     default:
327         return m_property_int_ro(prop, action, arg,
328                                  demuxer_get_percent_pos(mpctx->demuxer));
329     }
330
331     abs_seek_pos = SEEK_ABSOLUTE | SEEK_FACTOR;
332     rel_seek_secs = pos / 100.0;
333     return M_PROPERTY_OK;
334 }
335
336 /// Current position in seconds (RW)
337 static int mp_property_time_pos(m_option_t * prop, int action,
338                                 void *arg, MPContext * mpctx) {
339     if (!(mpctx->sh_video || (mpctx->sh_audio && mpctx->audio_out)))
340         return M_PROPERTY_UNAVAILABLE;
341
342     switch(action) {
343     case M_PROPERTY_SET:
344         if(!arg) return M_PROPERTY_ERROR;
345         M_PROPERTY_CLAMP(prop, *(double*)arg);
346         abs_seek_pos = SEEK_ABSOLUTE;
347         rel_seek_secs = *(double*)arg;
348         return M_PROPERTY_OK;
349     case M_PROPERTY_STEP_UP:
350     case M_PROPERTY_STEP_DOWN:
351         rel_seek_secs += (arg ? *(double*)arg : 10.0) *
352             (action == M_PROPERTY_STEP_UP ? 1.0 : -1.0);
353         return M_PROPERTY_OK;
354     }
355     return m_property_time_ro(prop, action, arg,
356                               mpctx->sh_video ? mpctx->sh_video->pts :
357                               playing_audio_pts(mpctx->sh_audio,
358                                                 mpctx->d_audio,
359                                                 mpctx->audio_out));
360 }
361
362 /// Current chapter (RW)
363 static int mp_property_chapter(m_option_t *prop, int action, void *arg,
364                                MPContext *mpctx)
365 {
366     int chapter = -1;
367     float next_pts = 0;
368     int chapter_num;
369     int step_all;
370     char *chapter_name = NULL;
371
372     if (mpctx->demuxer)
373         chapter = demuxer_get_current_chapter(mpctx->demuxer);
374     if (chapter < 0)
375         return M_PROPERTY_UNAVAILABLE;
376
377     switch (action) {
378     case M_PROPERTY_GET:
379         if (!arg)
380             return M_PROPERTY_ERROR;
381         *(int *) arg = chapter;
382         return M_PROPERTY_OK;
383     case M_PROPERTY_PRINT: {
384         if (!arg)
385             return M_PROPERTY_ERROR;
386         chapter_name = demuxer_chapter_display_name(mpctx->demuxer, chapter);
387         if (!chapter_name)
388             return M_PROPERTY_UNAVAILABLE;
389         *(char **) arg = chapter_name;
390         return M_PROPERTY_OK;
391     }
392     case M_PROPERTY_SET:
393         if (!arg)
394             return M_PROPERTY_ERROR;
395         M_PROPERTY_CLAMP(prop, *(int*)arg);
396         step_all = *(int *)arg - chapter;
397         chapter += step_all;
398         break;
399     case M_PROPERTY_STEP_UP:
400     case M_PROPERTY_STEP_DOWN: {
401         step_all = (arg && *(int*)arg != 0 ? *(int*)arg : 1)
402                    * (action == M_PROPERTY_STEP_UP ? 1 : -1);
403         chapter += step_all;
404         if (chapter < 0)
405             chapter = 0;
406         break;
407     }
408     default:
409         return M_PROPERTY_NOT_IMPLEMENTED;
410     }
411     rel_seek_secs = 0;
412     abs_seek_pos = 0;
413     chapter = demuxer_seek_chapter(mpctx->demuxer, chapter, 1,
414                                    &next_pts, &chapter_num, &chapter_name);
415     if (chapter >= 0) {
416         if (next_pts > -1.0) {
417             abs_seek_pos = SEEK_ABSOLUTE;
418             rel_seek_secs = next_pts;
419         }
420         if (chapter_name)
421             set_osd_msg(OSD_MSG_TEXT, 1, osd_duration,
422                         MSGTR_OSDChapter, chapter + 1, chapter_name);
423     }
424     else if (step_all > 0)
425         rel_seek_secs = 1000000000.;
426     else
427         set_osd_msg(OSD_MSG_TEXT, 1, osd_duration,
428                     MSGTR_OSDChapter, 0, MSGTR_Unknown);
429     if (chapter_name)
430         free(chapter_name);
431     return M_PROPERTY_OK;
432 }
433
434 /// Number of chapters in file
435 static int mp_property_chapters(m_option_t *prop, int action, void *arg,
436                                MPContext *mpctx)
437 {
438     if (!mpctx->demuxer)
439         return M_PROPERTY_UNAVAILABLE;
440     if (mpctx->demuxer->num_chapters == 0)
441         stream_control(mpctx->demuxer->stream, STREAM_CTRL_GET_NUM_CHAPTERS, &mpctx->demuxer->num_chapters);
442     return m_property_int_ro(prop, action, arg, mpctx->demuxer->num_chapters);
443 }
444
445 /// Current dvd angle (RW)
446 static int mp_property_angle(m_option_t *prop, int action, void *arg,
447                                MPContext *mpctx)
448 {
449     int angle = -1;
450     int angles;
451     char *angle_name = NULL;
452
453     if (mpctx->demuxer)
454         angle = demuxer_get_current_angle(mpctx->demuxer);
455     if (angle < 0)
456         return M_PROPERTY_UNAVAILABLE;
457     angles = demuxer_angles_count(mpctx->demuxer);
458     if (angles <= 1)
459         return M_PROPERTY_UNAVAILABLE;
460
461     switch (action) {
462     case M_PROPERTY_GET:
463         if (!arg)
464             return M_PROPERTY_ERROR;
465         *(int *) arg = angle;
466         return M_PROPERTY_OK;
467     case M_PROPERTY_PRINT: {
468         if (!arg)
469             return M_PROPERTY_ERROR;
470         angle_name = calloc(1, 64);
471         if (!angle_name)
472             return M_PROPERTY_UNAVAILABLE;
473         snprintf(angle_name, 64, "%d/%d", angle, angles);
474         *(char **) arg = angle_name;
475         return M_PROPERTY_OK;
476     }
477     case M_PROPERTY_SET:
478         if (!arg)
479             return M_PROPERTY_ERROR;
480         angle = *(int *)arg;
481         M_PROPERTY_CLAMP(prop, angle);
482         break;
483     case M_PROPERTY_STEP_UP:
484     case M_PROPERTY_STEP_DOWN: {
485         int step = 0;
486         if(arg)
487             step = *(int*)arg;
488         if(!step)
489             step = 1;
490         step *= (action == M_PROPERTY_STEP_UP ? 1 : -1);
491         angle += step;
492         if (angle < 1) //cycle
493             angle = angles;
494         break;
495     }
496     default:
497         return M_PROPERTY_NOT_IMPLEMENTED;
498     }
499     angle = demuxer_set_angle(mpctx->demuxer, angle);
500     set_osd_msg(OSD_MSG_TEXT, 1, osd_duration,
501                         MSGTR_OSDAngle, angle, angles);
502     if (angle_name)
503         free(angle_name);
504     return M_PROPERTY_OK;
505 }
506
507 /// Demuxer meta data
508 static int mp_property_metadata(m_option_t * prop, int action, void *arg,
509                                 MPContext * mpctx) {
510     m_property_action_t* ka;
511     char* meta;
512     static m_option_t key_type =
513         { "metadata", NULL, CONF_TYPE_STRING, 0, 0, 0, NULL };
514     if (!mpctx->demuxer)
515         return M_PROPERTY_UNAVAILABLE;
516
517     switch(action) {
518     case M_PROPERTY_GET:
519         if(!arg) return M_PROPERTY_ERROR;
520         *(char***)arg = mpctx->demuxer->info;
521         return M_PROPERTY_OK;
522     case M_PROPERTY_KEY_ACTION:
523         if(!arg) return M_PROPERTY_ERROR;
524         ka = arg;
525         if(!(meta = demux_info_get(mpctx->demuxer,ka->key)))
526             return M_PROPERTY_UNKNOWN;
527         switch(ka->action) {
528         case M_PROPERTY_GET:
529             if(!ka->arg) return M_PROPERTY_ERROR;
530             *(char**)ka->arg = meta;
531             return M_PROPERTY_OK;
532         case M_PROPERTY_GET_TYPE:
533             if(!ka->arg) return M_PROPERTY_ERROR;
534             *(m_option_t**)ka->arg = &key_type;
535             return M_PROPERTY_OK;
536         }
537     }
538     return M_PROPERTY_NOT_IMPLEMENTED;
539 }
540
541 static int mp_property_pause(m_option_t * prop, int action, void *arg,
542                              MPContext * mpctx)
543 {
544     return m_property_flag_ro(prop, action, arg, mpctx->osd_function == OSD_PAUSE);
545 }
546
547
548 ///@}
549
550 /// \defgroup AudioProperties Audio properties
551 /// \ingroup Properties
552 ///@{
553
554 /// Volume (RW)
555 static int mp_property_volume(m_option_t * prop, int action, void *arg,
556                               MPContext * mpctx)
557 {
558
559     if (!mpctx->sh_audio)
560         return M_PROPERTY_UNAVAILABLE;
561
562     switch (action) {
563     case M_PROPERTY_GET:
564         if (!arg)
565             return M_PROPERTY_ERROR;
566         mixer_getbothvolume(&mpctx->mixer, arg);
567         return M_PROPERTY_OK;
568     case M_PROPERTY_PRINT:{
569             float vol;
570             if (!arg)
571                 return M_PROPERTY_ERROR;
572             mixer_getbothvolume(&mpctx->mixer, &vol);
573             return m_property_float_range(prop, action, arg, &vol);
574         }
575     case M_PROPERTY_STEP_UP:
576     case M_PROPERTY_STEP_DOWN:
577     case M_PROPERTY_SET:
578         break;
579     default:
580         return M_PROPERTY_NOT_IMPLEMENTED;
581     }
582
583     if (mpctx->edl_muted)
584         return M_PROPERTY_DISABLED;
585     mpctx->user_muted = 0;
586
587     switch (action) {
588     case M_PROPERTY_SET:
589         if (!arg)
590             return M_PROPERTY_ERROR;
591         M_PROPERTY_CLAMP(prop, *(float *) arg);
592         mixer_setvolume(&mpctx->mixer, *(float *) arg, *(float *) arg);
593         return M_PROPERTY_OK;
594     case M_PROPERTY_STEP_UP:
595         if (arg && *(float *) arg <= 0)
596             mixer_decvolume(&mpctx->mixer);
597         else
598             mixer_incvolume(&mpctx->mixer);
599         return M_PROPERTY_OK;
600     case M_PROPERTY_STEP_DOWN:
601         if (arg && *(float *) arg <= 0)
602             mixer_incvolume(&mpctx->mixer);
603         else
604             mixer_decvolume(&mpctx->mixer);
605         return M_PROPERTY_OK;
606     }
607     return M_PROPERTY_NOT_IMPLEMENTED;
608 }
609
610 /// Mute (RW)
611 static int mp_property_mute(m_option_t * prop, int action, void *arg,
612                             MPContext * mpctx)
613 {
614
615     if (!mpctx->sh_audio)
616         return M_PROPERTY_UNAVAILABLE;
617
618     switch (action) {
619     case M_PROPERTY_SET:
620         if (mpctx->edl_muted)
621             return M_PROPERTY_DISABLED;
622         if (!arg)
623             return M_PROPERTY_ERROR;
624         if ((!!*(int *) arg) != mpctx->mixer.muted)
625             mixer_mute(&mpctx->mixer);
626         mpctx->user_muted = mpctx->mixer.muted;
627         return M_PROPERTY_OK;
628     case M_PROPERTY_STEP_UP:
629     case M_PROPERTY_STEP_DOWN:
630         if (mpctx->edl_muted)
631             return M_PROPERTY_DISABLED;
632         mixer_mute(&mpctx->mixer);
633         mpctx->user_muted = mpctx->mixer.muted;
634         return M_PROPERTY_OK;
635     case M_PROPERTY_PRINT:
636         if (!arg)
637             return M_PROPERTY_ERROR;
638         if (mpctx->edl_muted) {
639             *(char **) arg = strdup(MSGTR_EnabledEdl);
640             return M_PROPERTY_OK;
641         }
642     default:
643         return m_property_flag(prop, action, arg, &mpctx->mixer.muted);
644
645     }
646 }
647
648 /// Audio delay (RW)
649 static int mp_property_audio_delay(m_option_t * prop, int action,
650                                    void *arg, MPContext * mpctx)
651 {
652     if (!(mpctx->sh_audio && mpctx->sh_video))
653         return M_PROPERTY_UNAVAILABLE;
654     switch (action) {
655     case M_PROPERTY_SET:
656     case M_PROPERTY_STEP_UP:
657     case M_PROPERTY_STEP_DOWN: {
658             int ret;
659             float delay = audio_delay;
660             ret = m_property_delay(prop, action, arg, &audio_delay);
661             if (ret != M_PROPERTY_OK)
662                 return ret;
663             if (mpctx->sh_audio)
664                 mpctx->delay -= audio_delay - delay;
665         }
666         return M_PROPERTY_OK;
667     default:
668         return m_property_delay(prop, action, arg, &audio_delay);
669     }
670 }
671
672 /// Audio codec tag (RO)
673 static int mp_property_audio_format(m_option_t * prop, int action,
674                                     void *arg, MPContext * mpctx)
675 {
676     if (!mpctx->sh_audio)
677         return M_PROPERTY_UNAVAILABLE;
678     return m_property_int_ro(prop, action, arg, mpctx->sh_audio->format);
679 }
680
681 /// Audio codec name (RO)
682 static int mp_property_audio_codec(m_option_t * prop, int action,
683                                    void *arg, MPContext * mpctx)
684 {
685     if (!mpctx->sh_audio || !mpctx->sh_audio->codec)
686         return M_PROPERTY_UNAVAILABLE;
687     return m_property_string_ro(prop, action, arg, mpctx->sh_audio->codec->name);
688 }
689
690 /// Audio bitrate (RO)
691 static int mp_property_audio_bitrate(m_option_t * prop, int action,
692                                      void *arg, MPContext * mpctx)
693 {
694     if (!mpctx->sh_audio)
695         return M_PROPERTY_UNAVAILABLE;
696     return m_property_bitrate(prop, action, arg, mpctx->sh_audio->i_bps);
697 }
698
699 /// Samplerate (RO)
700 static int mp_property_samplerate(m_option_t * prop, int action, void *arg,
701                                   MPContext * mpctx)
702 {
703     if (!mpctx->sh_audio)
704         return M_PROPERTY_UNAVAILABLE;
705     switch(action) {
706     case M_PROPERTY_PRINT:
707         if(!arg) return M_PROPERTY_ERROR;
708         *(char**)arg = malloc(16);
709         sprintf(*(char**)arg,"%d kHz",mpctx->sh_audio->samplerate/1000);
710         return M_PROPERTY_OK;
711     }
712     return m_property_int_ro(prop, action, arg, mpctx->sh_audio->samplerate);
713 }
714
715 /// Number of channels (RO)
716 static int mp_property_channels(m_option_t * prop, int action, void *arg,
717                                 MPContext * mpctx)
718 {
719     if (!mpctx->sh_audio)
720         return M_PROPERTY_UNAVAILABLE;
721     switch (action) {
722     case M_PROPERTY_PRINT:
723         if (!arg)
724             return M_PROPERTY_ERROR;
725         switch (mpctx->sh_audio->channels) {
726         case 1:
727             *(char **) arg = strdup("mono");
728             break;
729         case 2:
730             *(char **) arg = strdup("stereo");
731             break;
732         default:
733             *(char **) arg = malloc(32);
734             sprintf(*(char **) arg, "%d channels", mpctx->sh_audio->channels);
735         }
736         return M_PROPERTY_OK;
737     }
738     return m_property_int_ro(prop, action, arg, mpctx->sh_audio->channels);
739 }
740
741 /// Balance (RW)
742 static int mp_property_balance(m_option_t * prop, int action, void *arg,
743                               MPContext * mpctx)
744 {
745     float bal;
746
747     if (!mpctx->sh_audio || mpctx->sh_audio->channels < 2)
748         return M_PROPERTY_UNAVAILABLE;
749
750     switch (action) {
751     case M_PROPERTY_GET:
752         if (!arg)
753             return M_PROPERTY_ERROR;
754         mixer_getbalance(&mpctx->mixer, arg);
755         return M_PROPERTY_OK;
756     case M_PROPERTY_PRINT: {
757             char** str = arg;
758             if (!arg)
759                 return M_PROPERTY_ERROR;
760             mixer_getbalance(&mpctx->mixer, &bal);
761             if (bal == 0.f)
762                 *str = strdup("center");
763             else if (bal == -1.f)
764                 *str = strdup("left only");
765             else if (bal == 1.f)
766                 *str = strdup("right only");
767             else {
768                 unsigned right = (bal + 1.f) / 2.f * 100.f;
769                 *str = malloc(sizeof("left xxx%, right xxx%"));
770                 sprintf(*str, "left %d%%, right %d%%", 100 - right, right);
771             }
772             return M_PROPERTY_OK;
773         }
774     case M_PROPERTY_STEP_UP:
775     case M_PROPERTY_STEP_DOWN:
776         mixer_getbalance(&mpctx->mixer, &bal);
777         bal += (arg ? *(float*)arg : .1f) *
778             (action == M_PROPERTY_STEP_UP ? 1.f : -1.f);
779         M_PROPERTY_CLAMP(prop, bal);
780         mixer_setbalance(&mpctx->mixer, bal);
781         return M_PROPERTY_OK;
782     case M_PROPERTY_SET:
783         if (!arg)
784             return M_PROPERTY_ERROR;
785         M_PROPERTY_CLAMP(prop, *(float*)arg);
786         mixer_setbalance(&mpctx->mixer, *(float*)arg);
787         return M_PROPERTY_OK;
788     }
789     return M_PROPERTY_NOT_IMPLEMENTED;
790 }
791
792 /// Selected audio id (RW)
793 static int mp_property_audio(m_option_t * prop, int action, void *arg,
794                              MPContext * mpctx)
795 {
796     int current_id = -1, tmp;
797
798     switch (action) {
799     case M_PROPERTY_GET:
800         if (!mpctx->sh_audio)
801             return M_PROPERTY_UNAVAILABLE;
802         if (!arg)
803             return M_PROPERTY_ERROR;
804         *(int *) arg = audio_id;
805         return M_PROPERTY_OK;
806     case M_PROPERTY_PRINT:
807         if (!mpctx->sh_audio)
808             return M_PROPERTY_UNAVAILABLE;
809         if (!arg)
810             return M_PROPERTY_ERROR;
811
812         if (audio_id < 0)
813             *(char **) arg = strdup(MSGTR_Disabled);
814         else {
815             char lang[40] = MSGTR_Unknown;
816             sh_audio_t* sh = mpctx->sh_audio;
817             if (sh && sh->lang)
818                 av_strlcpy(lang, sh->lang, 40);
819 #ifdef CONFIG_DVDREAD
820             else if (mpctx->stream->type == STREAMTYPE_DVD) {
821                 int code = dvd_lang_from_aid(mpctx->stream, audio_id);
822                 if (code) {
823                     lang[0] = code >> 8;
824                     lang[1] = code;
825                     lang[2] = 0;
826                 }
827             }
828 #endif
829
830 #ifdef CONFIG_DVDNAV
831             else if (mpctx->stream->type == STREAMTYPE_DVDNAV)
832                 mp_dvdnav_lang_from_aid(mpctx->stream, audio_id, lang);
833 #endif
834             *(char **) arg = malloc(64);
835             snprintf(*(char **) arg, 64, "(%d) %s", audio_id, lang);
836         }
837         return M_PROPERTY_OK;
838
839     case M_PROPERTY_STEP_UP:
840     case M_PROPERTY_SET:
841         if (!mpctx->demuxer)
842             return M_PROPERTY_UNAVAILABLE;
843         if (action == M_PROPERTY_SET && arg)
844             tmp = *((int *) arg);
845         else
846             tmp = -1;
847         current_id = mpctx->demuxer->audio->id;
848         audio_id = demuxer_switch_audio(mpctx->demuxer, tmp);
849         if (audio_id == -2
850             || (audio_id > -1
851                 && mpctx->demuxer->audio->id != current_id && current_id != -2))
852             uninit_player(INITIALIZED_AO | INITIALIZED_ACODEC);
853         if (audio_id > -1 && mpctx->demuxer->audio->id != current_id) {
854             sh_audio_t *sh2;
855             sh2 = mpctx->demuxer->a_streams[mpctx->demuxer->audio->id];
856             if (sh2) {
857                 sh2->ds = mpctx->demuxer->audio;
858                 mpctx->sh_audio = sh2;
859                 reinit_audio_chain();
860             }
861         }
862         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_AUDIO_TRACK=%d\n", audio_id);
863         return M_PROPERTY_OK;
864     default:
865         return M_PROPERTY_NOT_IMPLEMENTED;
866     }
867
868 }
869
870 /// Selected video id (RW)
871 static int mp_property_video(m_option_t * prop, int action, void *arg,
872                              MPContext * mpctx)
873 {
874     int current_id = -1, tmp;
875
876     switch (action) {
877     case M_PROPERTY_GET:
878         if (!mpctx->sh_video)
879             return M_PROPERTY_UNAVAILABLE;
880         if (!arg)
881             return M_PROPERTY_ERROR;
882         *(int *) arg = video_id;
883         return M_PROPERTY_OK;
884     case M_PROPERTY_PRINT:
885         if (!mpctx->sh_video)
886             return M_PROPERTY_UNAVAILABLE;
887         if (!arg)
888             return M_PROPERTY_ERROR;
889
890         if (video_id < 0)
891             *(char **) arg = strdup(MSGTR_Disabled);
892         else {
893             char lang[40] = MSGTR_Unknown;
894             *(char **) arg = malloc(64);
895             snprintf(*(char **) arg, 64, "(%d) %s", video_id, lang);
896         }
897         return M_PROPERTY_OK;
898
899     case M_PROPERTY_STEP_UP:
900     case M_PROPERTY_SET:
901         current_id = mpctx->demuxer->video->id;
902         if (action == M_PROPERTY_SET && arg)
903             tmp = *((int *) arg);
904         else
905             tmp = -1;
906         video_id = demuxer_switch_video(mpctx->demuxer, tmp);
907         if (video_id == -2
908             || (video_id > -1 && mpctx->demuxer->video->id != current_id
909                 && current_id != -2))
910             uninit_player(INITIALIZED_VCODEC |
911                           (fixed_vo && video_id != -2 ? 0 : INITIALIZED_VO));
912         if (video_id > -1 && mpctx->demuxer->video->id != current_id) {
913             sh_video_t *sh2;
914             sh2 = mpctx->demuxer->v_streams[mpctx->demuxer->video->id];
915             if (sh2) {
916                 sh2->ds = mpctx->demuxer->video;
917                 mpctx->sh_video = sh2;
918                 reinit_video_chain();
919             }
920         }
921         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VIDEO_TRACK=%d\n", video_id);
922         return M_PROPERTY_OK;
923
924     default:
925         return M_PROPERTY_NOT_IMPLEMENTED;
926     }
927 }
928
929 static int mp_property_program(m_option_t * prop, int action, void *arg,
930                                MPContext * mpctx)
931 {
932     demux_program_t prog;
933
934     switch (action) {
935     case M_PROPERTY_STEP_UP:
936     case M_PROPERTY_SET:
937         if (action == M_PROPERTY_SET && arg)
938             prog.progid = *((int *) arg);
939         else
940             prog.progid = -1;
941         if (demux_control
942             (mpctx->demuxer, DEMUXER_CTRL_IDENTIFY_PROGRAM,
943              &prog) == DEMUXER_CTRL_NOTIMPL)
944             return M_PROPERTY_ERROR;
945
946         mp_property_do("switch_audio", M_PROPERTY_SET, &prog.aid, mpctx);
947         mp_property_do("switch_video", M_PROPERTY_SET, &prog.vid, mpctx);
948         return M_PROPERTY_OK;
949
950     default:
951         return M_PROPERTY_NOT_IMPLEMENTED;
952     }
953 }
954
955 ///@}
956
957 /// \defgroup VideoProperties Video properties
958 /// \ingroup Properties
959 ///@{
960
961 /// Fullscreen state (RW)
962 static int mp_property_fullscreen(m_option_t * prop, int action, void *arg,
963                                   MPContext * mpctx)
964 {
965
966     if (!mpctx->video_out)
967         return M_PROPERTY_UNAVAILABLE;
968
969     switch (action) {
970     case M_PROPERTY_SET:
971         if (!arg)
972             return M_PROPERTY_ERROR;
973         M_PROPERTY_CLAMP(prop, *(int *) arg);
974         if (vo_fs == !!*(int *) arg)
975             return M_PROPERTY_OK;
976     case M_PROPERTY_STEP_UP:
977     case M_PROPERTY_STEP_DOWN:
978 #ifdef CONFIG_GUI
979         if (use_gui)
980             guiGetEvent(guiIEvent, (char *) MP_CMD_GUI_FULLSCREEN);
981         else
982 #endif
983         if (vo_config_count)
984             mpctx->video_out->control(VOCTRL_FULLSCREEN, 0);
985         return M_PROPERTY_OK;
986     default:
987         return m_property_flag(prop, action, arg, &vo_fs);
988     }
989 }
990
991 static int mp_property_deinterlace(m_option_t * prop, int action,
992                                    void *arg, MPContext * mpctx)
993 {
994     int deinterlace;
995     vf_instance_t *vf;
996     if (!mpctx->sh_video || !mpctx->sh_video->vfilter)
997         return M_PROPERTY_UNAVAILABLE;
998     vf = mpctx->sh_video->vfilter;
999     switch (action) {
1000     case M_PROPERTY_GET:
1001         if (!arg)
1002             return M_PROPERTY_ERROR;
1003         vf->control(vf, VFCTRL_GET_DEINTERLACE, arg);
1004         return M_PROPERTY_OK;
1005     case M_PROPERTY_SET:
1006         if (!arg)
1007             return M_PROPERTY_ERROR;
1008         M_PROPERTY_CLAMP(prop, *(int *) arg);
1009         vf->control(vf, VFCTRL_SET_DEINTERLACE, arg);
1010         return M_PROPERTY_OK;
1011     case M_PROPERTY_STEP_UP:
1012     case M_PROPERTY_STEP_DOWN:
1013         vf->control(vf, VFCTRL_GET_DEINTERLACE, &deinterlace);
1014         deinterlace = !deinterlace;
1015         vf->control(vf, VFCTRL_SET_DEINTERLACE, &deinterlace);
1016         return M_PROPERTY_OK;
1017     }
1018     return M_PROPERTY_NOT_IMPLEMENTED;
1019 }
1020
1021 /// Panscan (RW)
1022 static int mp_property_panscan(m_option_t * prop, int action, void *arg,
1023                                MPContext * mpctx)
1024 {
1025
1026     if (!mpctx->video_out
1027         || mpctx->video_out->control(VOCTRL_GET_PANSCAN, NULL) != VO_TRUE)
1028         return M_PROPERTY_UNAVAILABLE;
1029
1030     switch (action) {
1031     case M_PROPERTY_SET:
1032         if (!arg)
1033             return M_PROPERTY_ERROR;
1034         M_PROPERTY_CLAMP(prop, *(float *) arg);
1035         vo_panscan = *(float *) arg;
1036         mpctx->video_out->control(VOCTRL_SET_PANSCAN, NULL);
1037         return M_PROPERTY_OK;
1038     case M_PROPERTY_STEP_UP:
1039     case M_PROPERTY_STEP_DOWN:
1040         vo_panscan += (arg ? *(float *) arg : 0.1) *
1041             (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
1042         if (vo_panscan > 1)
1043             vo_panscan = 1;
1044         else if (vo_panscan < 0)
1045             vo_panscan = 0;
1046         mpctx->video_out->control(VOCTRL_SET_PANSCAN, NULL);
1047         return M_PROPERTY_OK;
1048     default:
1049         return m_property_float_range(prop, action, arg, &vo_panscan);
1050     }
1051 }
1052
1053 /// Helper to set vo flags.
1054 /** \ingroup PropertyImplHelper
1055  */
1056 static int mp_property_vo_flag(m_option_t * prop, int action, void *arg,
1057                                int vo_ctrl, int *vo_var, MPContext * mpctx)
1058 {
1059
1060     if (!mpctx->video_out)
1061         return M_PROPERTY_UNAVAILABLE;
1062
1063     switch (action) {
1064     case M_PROPERTY_SET:
1065         if (!arg)
1066             return M_PROPERTY_ERROR;
1067         M_PROPERTY_CLAMP(prop, *(int *) arg);
1068         if (*vo_var == !!*(int *) arg)
1069             return M_PROPERTY_OK;
1070     case M_PROPERTY_STEP_UP:
1071     case M_PROPERTY_STEP_DOWN:
1072         if (vo_config_count)
1073             mpctx->video_out->control(vo_ctrl, 0);
1074         return M_PROPERTY_OK;
1075     default:
1076         return m_property_flag(prop, action, arg, vo_var);
1077     }
1078 }
1079
1080 /// Window always on top (RW)
1081 static int mp_property_ontop(m_option_t * prop, int action, void *arg,
1082                              MPContext * mpctx)
1083 {
1084     return mp_property_vo_flag(prop, action, arg, VOCTRL_ONTOP, &vo_ontop,
1085                                mpctx);
1086 }
1087
1088 /// Display in the root window (RW)
1089 static int mp_property_rootwin(m_option_t * prop, int action, void *arg,
1090                                MPContext * mpctx)
1091 {
1092     return mp_property_vo_flag(prop, action, arg, VOCTRL_ROOTWIN,
1093                                &vo_rootwin, mpctx);
1094 }
1095
1096 /// Show window borders (RW)
1097 static int mp_property_border(m_option_t * prop, int action, void *arg,
1098                               MPContext * mpctx)
1099 {
1100     return mp_property_vo_flag(prop, action, arg, VOCTRL_BORDER,
1101                                &vo_border, mpctx);
1102 }
1103
1104 /// Framedropping state (RW)
1105 static int mp_property_framedropping(m_option_t * prop, int action,
1106                                      void *arg, MPContext * mpctx)
1107 {
1108
1109     if (!mpctx->sh_video)
1110         return M_PROPERTY_UNAVAILABLE;
1111
1112     switch (action) {
1113     case M_PROPERTY_PRINT:
1114         if (!arg)
1115             return M_PROPERTY_ERROR;
1116         *(char **) arg = strdup(frame_dropping == 1 ? MSGTR_Enabled :
1117                                 (frame_dropping == 2 ? MSGTR_HardFrameDrop :
1118                                  MSGTR_Disabled));
1119         return M_PROPERTY_OK;
1120     default:
1121         return m_property_choice(prop, action, arg, &frame_dropping);
1122     }
1123 }
1124
1125 /// Color settings, try to use vf/vo then fall back on TV. (RW)
1126 static int mp_property_gamma(m_option_t * prop, int action, void *arg,
1127                              MPContext * mpctx)
1128 {
1129     int *gamma = prop->priv, r, val;
1130
1131     if (!mpctx->sh_video)
1132         return M_PROPERTY_UNAVAILABLE;
1133
1134     if (gamma[0] == 1000) {
1135         gamma[0] = 0;
1136         get_video_colors(mpctx->sh_video, prop->name, gamma);
1137     }
1138
1139     switch (action) {
1140     case M_PROPERTY_SET:
1141         if (!arg)
1142             return M_PROPERTY_ERROR;
1143         M_PROPERTY_CLAMP(prop, *(int *) arg);
1144         *gamma = *(int *) arg;
1145         r = set_video_colors(mpctx->sh_video, prop->name, *gamma);
1146         if (r <= 0)
1147             break;
1148         return r;
1149     case M_PROPERTY_GET:
1150         if (get_video_colors(mpctx->sh_video, prop->name, &val) > 0) {
1151             if (!arg)
1152                 return M_PROPERTY_ERROR;
1153             *(int *)arg = val;
1154             return M_PROPERTY_OK;
1155         }
1156         break;
1157     case M_PROPERTY_STEP_UP:
1158     case M_PROPERTY_STEP_DOWN:
1159         *gamma += (arg ? *(int *) arg : 1) *
1160             (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
1161         M_PROPERTY_CLAMP(prop, *gamma);
1162         r = set_video_colors(mpctx->sh_video, prop->name, *gamma);
1163         if (r <= 0)
1164             break;
1165         return r;
1166     default:
1167         return M_PROPERTY_NOT_IMPLEMENTED;
1168     }
1169
1170 #ifdef CONFIG_TV
1171     if (mpctx->demuxer->type == DEMUXER_TYPE_TV) {
1172         int l = strlen(prop->name);
1173         char tv_prop[3 + l + 1];
1174         sprintf(tv_prop, "tv_%s", prop->name);
1175         return mp_property_do(tv_prop, action, arg, mpctx);
1176     }
1177 #endif
1178
1179     return M_PROPERTY_UNAVAILABLE;
1180 }
1181
1182 /// VSync (RW)
1183 static int mp_property_vsync(m_option_t * prop, int action, void *arg,
1184                              MPContext * mpctx)
1185 {
1186     return m_property_flag(prop, action, arg, &vo_vsync);
1187 }
1188
1189 /// Video codec tag (RO)
1190 static int mp_property_video_format(m_option_t * prop, int action,
1191                                     void *arg, MPContext * mpctx)
1192 {
1193     char* meta;
1194     if (!mpctx->sh_video)
1195         return M_PROPERTY_UNAVAILABLE;
1196     switch(action) {
1197     case M_PROPERTY_PRINT:
1198         if (!arg)
1199             return M_PROPERTY_ERROR;
1200         switch(mpctx->sh_video->format) {
1201         case 0x10000001:
1202             meta = strdup ("mpeg1"); break;
1203         case 0x10000002:
1204             meta = strdup ("mpeg2"); break;
1205         case 0x10000004:
1206             meta = strdup ("mpeg4"); break;
1207         case 0x10000005:
1208             meta = strdup ("h264"); break;
1209         default:
1210             if(mpctx->sh_video->format >= 0x20202020) {
1211                 meta = malloc(5);
1212                 sprintf (meta, "%.4s", (char *) &mpctx->sh_video->format);
1213             } else   {
1214                 meta = malloc(20);
1215                 sprintf (meta, "0x%08X", mpctx->sh_video->format);
1216             }
1217         }
1218         *(char**)arg = meta;
1219         return M_PROPERTY_OK;
1220     }
1221     return m_property_int_ro(prop, action, arg, mpctx->sh_video->format);
1222 }
1223
1224 /// Video codec name (RO)
1225 static int mp_property_video_codec(m_option_t * prop, int action,
1226                                    void *arg, MPContext * mpctx)
1227 {
1228     if (!mpctx->sh_video || !mpctx->sh_video->codec)
1229         return M_PROPERTY_UNAVAILABLE;
1230     return m_property_string_ro(prop, action, arg, mpctx->sh_video->codec->name);
1231 }
1232
1233
1234 /// Video bitrate (RO)
1235 static int mp_property_video_bitrate(m_option_t * prop, int action,
1236                                      void *arg, MPContext * mpctx)
1237 {
1238     if (!mpctx->sh_video)
1239         return M_PROPERTY_UNAVAILABLE;
1240     return m_property_bitrate(prop, action, arg, mpctx->sh_video->i_bps);
1241 }
1242
1243 /// Video display width (RO)
1244 static int mp_property_width(m_option_t * prop, int action, void *arg,
1245                              MPContext * mpctx)
1246 {
1247     if (!mpctx->sh_video)
1248         return M_PROPERTY_UNAVAILABLE;
1249     return m_property_int_ro(prop, action, arg, mpctx->sh_video->disp_w);
1250 }
1251
1252 /// Video display height (RO)
1253 static int mp_property_height(m_option_t * prop, int action, void *arg,
1254                               MPContext * mpctx)
1255 {
1256     if (!mpctx->sh_video)
1257         return M_PROPERTY_UNAVAILABLE;
1258     return m_property_int_ro(prop, action, arg, mpctx->sh_video->disp_h);
1259 }
1260
1261 /// Video fps (RO)
1262 static int mp_property_fps(m_option_t * prop, int action, void *arg,
1263                            MPContext * mpctx)
1264 {
1265     if (!mpctx->sh_video)
1266         return M_PROPERTY_UNAVAILABLE;
1267     return m_property_float_ro(prop, action, arg, mpctx->sh_video->fps);
1268 }
1269
1270 /// Video aspect (RO)
1271 static int mp_property_aspect(m_option_t * prop, int action, void *arg,
1272                               MPContext * mpctx)
1273 {
1274     if (!mpctx->sh_video)
1275         return M_PROPERTY_UNAVAILABLE;
1276     return m_property_float_ro(prop, action, arg, mpctx->sh_video->aspect);
1277 }
1278
1279 ///@}
1280
1281 /// \defgroup SubProprties Subtitles properties
1282 /// \ingroup Properties
1283 ///@{
1284
1285 /// Text subtitle position (RW)
1286 static int mp_property_sub_pos(m_option_t * prop, int action, void *arg,
1287                                MPContext * mpctx)
1288 {
1289     if (!mpctx->sh_video)
1290         return M_PROPERTY_UNAVAILABLE;
1291
1292     switch (action) {
1293     case M_PROPERTY_SET:
1294         if (!arg)
1295             return M_PROPERTY_ERROR;
1296     case M_PROPERTY_STEP_UP:
1297     case M_PROPERTY_STEP_DOWN:
1298         vo_osd_changed(OSDTYPE_SUBTITLE);
1299     default:
1300         return m_property_int_range(prop, action, arg, &sub_pos);
1301     }
1302 }
1303
1304 /// Selected subtitles (RW)
1305 static int mp_property_sub(m_option_t * prop, int action, void *arg,
1306                            MPContext * mpctx)
1307 {
1308     demux_stream_t *const d_sub = mpctx->d_sub;
1309     const int global_sub_size = mpctx->global_sub_size;
1310     int source = -1, reset_spu = 0;
1311     char *sub_name;
1312
1313     if (global_sub_size <= 0)
1314         return M_PROPERTY_UNAVAILABLE;
1315
1316     switch (action) {
1317     case M_PROPERTY_GET:
1318         if (!arg)
1319             return M_PROPERTY_ERROR;
1320         *(int *) arg = mpctx->global_sub_pos;
1321         return M_PROPERTY_OK;
1322     case M_PROPERTY_PRINT:
1323         if (!arg)
1324             return M_PROPERTY_ERROR;
1325         *(char **) arg = malloc(64);
1326         (*(char **) arg)[63] = 0;
1327         sub_name = 0;
1328         if (subdata)
1329             sub_name = subdata->filename;
1330 #ifdef CONFIG_ASS
1331         if (ass_track && ass_track->name)
1332             sub_name = ass_track->name;
1333 #endif
1334         if (sub_name) {
1335             char *tmp, *tmp2;
1336             tmp = sub_name;
1337             if ((tmp2 = strrchr(tmp, '/')))
1338                 tmp = tmp2 + 1;
1339
1340             snprintf(*(char **) arg, 63, "(%d) %s%s",
1341                      mpctx->set_of_sub_pos + 1,
1342                      strlen(tmp) < 20 ? "" : "...",
1343                      strlen(tmp) < 20 ? tmp : tmp + strlen(tmp) - 19);
1344             return M_PROPERTY_OK;
1345         }
1346 #ifdef CONFIG_DVDNAV
1347         if (mpctx->stream->type == STREAMTYPE_DVDNAV) {
1348             if (vo_spudec && dvdsub_id >= 0) {
1349                 unsigned char lang[3];
1350                 if (mp_dvdnav_lang_from_sid(mpctx->stream, dvdsub_id, lang)) {
1351                     snprintf(*(char **) arg, 63, "(%d) %s", dvdsub_id, lang);
1352                     return M_PROPERTY_OK;
1353                 }
1354             }
1355         }
1356 #endif
1357
1358         if ((mpctx->demuxer->type == DEMUXER_TYPE_MATROSKA
1359              || mpctx->demuxer->type == DEMUXER_TYPE_LAVF
1360              || mpctx->demuxer->type == DEMUXER_TYPE_LAVF_PREFERRED
1361              || mpctx->demuxer->type == DEMUXER_TYPE_OGG)
1362              && d_sub && d_sub->sh && dvdsub_id >= 0) {
1363             const char* lang = ((sh_sub_t*)d_sub->sh)->lang;
1364             if (!lang) lang = MSGTR_Unknown;
1365             snprintf(*(char **) arg, 63, "(%d) %s", dvdsub_id, lang);
1366             return M_PROPERTY_OK;
1367         }
1368
1369         if (vo_vobsub && vobsub_id >= 0) {
1370             const char *language = MSGTR_Unknown;
1371             language = vobsub_get_id(vo_vobsub, (unsigned int) vobsub_id);
1372             snprintf(*(char **) arg, 63, "(%d) %s",
1373                      vobsub_id, language ? language : MSGTR_Unknown);
1374             return M_PROPERTY_OK;
1375         }
1376 #ifdef CONFIG_DVDREAD
1377         if (vo_spudec && mpctx->stream->type == STREAMTYPE_DVD
1378             && dvdsub_id >= 0) {
1379             char lang[3];
1380             int code = dvd_lang_from_sid(mpctx->stream, dvdsub_id);
1381             lang[0] = code >> 8;
1382             lang[1] = code;
1383             lang[2] = 0;
1384             snprintf(*(char **) arg, 63, "(%d) %s", dvdsub_id, lang);
1385             return M_PROPERTY_OK;
1386         }
1387 #endif
1388         if (dvdsub_id >= 0) {
1389             snprintf(*(char **) arg, 63, "(%d) %s", dvdsub_id, MSGTR_Unknown);
1390             return M_PROPERTY_OK;
1391         }
1392         snprintf(*(char **) arg, 63, MSGTR_Disabled);
1393         return M_PROPERTY_OK;
1394
1395     case M_PROPERTY_SET:
1396         if (!arg)
1397             return M_PROPERTY_ERROR;
1398         if (*(int *) arg < -1)
1399             *(int *) arg = -1;
1400         else if (*(int *) arg >= global_sub_size)
1401             *(int *) arg = global_sub_size - 1;
1402         mpctx->global_sub_pos = *(int *) arg;
1403         break;
1404     case M_PROPERTY_STEP_UP:
1405         mpctx->global_sub_pos += 2;
1406         mpctx->global_sub_pos =
1407             (mpctx->global_sub_pos % (global_sub_size + 1)) - 1;
1408         break;
1409     case M_PROPERTY_STEP_DOWN:
1410         mpctx->global_sub_pos += global_sub_size + 1;
1411         mpctx->global_sub_pos =
1412             (mpctx->global_sub_pos % (global_sub_size + 1)) - 1;
1413         break;
1414     default:
1415         return M_PROPERTY_NOT_IMPLEMENTED;
1416     }
1417
1418     if (mpctx->global_sub_pos >= 0)
1419         source = sub_source(mpctx);
1420
1421     mp_msg(MSGT_CPLAYER, MSGL_DBG3,
1422            "subtitles: %d subs, (v@%d s@%d d@%d), @%d, source @%d\n",
1423            global_sub_size,
1424            mpctx->global_sub_indices[SUB_SOURCE_VOBSUB],
1425            mpctx->global_sub_indices[SUB_SOURCE_SUBS],
1426            mpctx->global_sub_indices[SUB_SOURCE_DEMUX],
1427            mpctx->global_sub_pos, source);
1428
1429     mpctx->set_of_sub_pos = -1;
1430     subdata = NULL;
1431
1432     vobsub_id = -1;
1433     dvdsub_id = -1;
1434     if (d_sub) {
1435         if (d_sub->id > -2)
1436             reset_spu = 1;
1437         d_sub->id = -2;
1438     }
1439 #ifdef CONFIG_ASS
1440     ass_track = 0;
1441 #endif
1442
1443     if (source == SUB_SOURCE_VOBSUB) {
1444         vobsub_id = vobsub_get_id_by_index(vo_vobsub, mpctx->global_sub_pos - mpctx->global_sub_indices[SUB_SOURCE_VOBSUB]);
1445     } else if (source == SUB_SOURCE_SUBS) {
1446         mpctx->set_of_sub_pos =
1447             mpctx->global_sub_pos - mpctx->global_sub_indices[SUB_SOURCE_SUBS];
1448 #ifdef CONFIG_ASS
1449         if (ass_enabled && mpctx->set_of_ass_tracks[mpctx->set_of_sub_pos])
1450             ass_track = mpctx->set_of_ass_tracks[mpctx->set_of_sub_pos];
1451         else
1452 #endif
1453         {
1454             subdata = mpctx->set_of_subtitles[mpctx->set_of_sub_pos];
1455             vo_osd_changed(OSDTYPE_SUBTITLE);
1456         }
1457     } else if (source == SUB_SOURCE_DEMUX) {
1458         dvdsub_id =
1459             mpctx->global_sub_pos - mpctx->global_sub_indices[SUB_SOURCE_DEMUX];
1460         if (d_sub && dvdsub_id < MAX_S_STREAMS) {
1461             int i = 0;
1462             // default: assume 1:1 mapping of sid and stream id
1463             d_sub->id = dvdsub_id;
1464             d_sub->sh = mpctx->demuxer->s_streams[d_sub->id];
1465             ds_free_packs(d_sub);
1466             for (i = 0; i < MAX_S_STREAMS; i++) {
1467                 sh_sub_t *sh = mpctx->demuxer->s_streams[i];
1468                 if (sh && sh->sid == dvdsub_id) {
1469                     d_sub->id = i;
1470                     d_sub->sh = sh;
1471                     break;
1472                 }
1473             }
1474             if (d_sub->sh && d_sub->id >= 0) {
1475                 sh_sub_t *sh = d_sub->sh;
1476                 if (sh->type == 'v')
1477                     init_vo_spudec();
1478 #ifdef CONFIG_ASS
1479                 else if (ass_enabled)
1480                     ass_track = sh->ass_track;
1481 #endif
1482             } else {
1483               d_sub->id = -2;
1484               d_sub->sh = NULL;
1485             }
1486         }
1487     }
1488 #ifdef CONFIG_DVDREAD
1489     if (vo_spudec
1490         && (mpctx->stream->type == STREAMTYPE_DVD
1491             || mpctx->stream->type == STREAMTYPE_DVDNAV)
1492         && dvdsub_id < 0 && reset_spu) {
1493         dvdsub_id = -2;
1494         d_sub->id = dvdsub_id;
1495     }
1496 #endif
1497     update_subtitles(mpctx->sh_video, d_sub, 1);
1498
1499     return M_PROPERTY_OK;
1500 }
1501
1502 /// Selected sub source (RW)
1503 static int mp_property_sub_source(m_option_t * prop, int action, void *arg,
1504                                   MPContext * mpctx)
1505 {
1506     int source;
1507     if (!mpctx->sh_video || mpctx->global_sub_size <= 0)
1508         return M_PROPERTY_UNAVAILABLE;
1509
1510     switch (action) {
1511     case M_PROPERTY_GET:
1512         if (!arg)
1513             return M_PROPERTY_ERROR;
1514         *(int *) arg = sub_source(mpctx);
1515         return M_PROPERTY_OK;
1516     case M_PROPERTY_PRINT:
1517         if (!arg)
1518             return M_PROPERTY_ERROR;
1519         *(char **) arg = malloc(64);
1520         (*(char **) arg)[63] = 0;
1521         switch (sub_source(mpctx))
1522         {
1523         case SUB_SOURCE_SUBS:
1524             snprintf(*(char **) arg, 63, MSGTR_SubSourceFile);
1525             break;
1526         case SUB_SOURCE_VOBSUB:
1527             snprintf(*(char **) arg, 63, MSGTR_SubSourceVobsub);
1528             break;
1529         case SUB_SOURCE_DEMUX:
1530             snprintf(*(char **) arg, 63, MSGTR_SubSourceDemux);
1531             break;
1532         default:
1533             snprintf(*(char **) arg, 63, MSGTR_Disabled);
1534         }
1535         return M_PROPERTY_OK;
1536     case M_PROPERTY_SET:
1537         if (!arg)
1538             return M_PROPERTY_ERROR;
1539         M_PROPERTY_CLAMP(prop, *(int*)arg);
1540         if (*(int *) arg < 0)
1541             mpctx->global_sub_pos = -1;
1542         else if (*(int *) arg != sub_source(mpctx)) {
1543             if (*(int *) arg != sub_source_by_pos(mpctx, mpctx->global_sub_indices[*(int *) arg]))
1544                 return M_PROPERTY_UNAVAILABLE;
1545             mpctx->global_sub_pos = mpctx->global_sub_indices[*(int *) arg];
1546         }
1547         break;
1548     case M_PROPERTY_STEP_UP:
1549     case M_PROPERTY_STEP_DOWN: {
1550         int step_all = (arg && *(int*)arg != 0 ? *(int*)arg : 1)
1551                        * (action == M_PROPERTY_STEP_UP ? 1 : -1);
1552         int step = (step_all > 0) ? 1 : -1;
1553         int cur_source = sub_source(mpctx);
1554         source = cur_source;
1555         while (step_all) {
1556             source += step;
1557             if (source >= SUB_SOURCES)
1558                 source = -1;
1559             else if (source < -1)
1560                 source = SUB_SOURCES - 1;
1561             if (source == cur_source || source == -1 ||
1562                     source == sub_source_by_pos(mpctx, mpctx->global_sub_indices[source]))
1563                 step_all -= step;
1564         }
1565         if (source == cur_source)
1566             return M_PROPERTY_OK;
1567         if (source == -1)
1568             mpctx->global_sub_pos = -1;
1569         else
1570             mpctx->global_sub_pos = mpctx->global_sub_indices[source];
1571         break;
1572     }
1573     default:
1574         return M_PROPERTY_NOT_IMPLEMENTED;
1575     }
1576     --mpctx->global_sub_pos;
1577     return mp_property_sub(prop, M_PROPERTY_STEP_UP, NULL, mpctx);
1578 }
1579
1580 /// Selected subtitles from specific source (RW)
1581 static int mp_property_sub_by_type(m_option_t * prop, int action, void *arg,
1582                                    MPContext * mpctx)
1583 {
1584     int source, is_cur_source, offset;
1585     if (!mpctx->sh_video || mpctx->global_sub_size <= 0)
1586         return M_PROPERTY_UNAVAILABLE;
1587
1588     if (!strcmp(prop->name, "sub_file"))
1589         source = SUB_SOURCE_SUBS;
1590     else if (!strcmp(prop->name, "sub_vob"))
1591         source = SUB_SOURCE_VOBSUB;
1592     else if (!strcmp(prop->name, "sub_demux"))
1593         source = SUB_SOURCE_DEMUX;
1594     else
1595         return M_PROPERTY_ERROR;
1596
1597     offset = mpctx->global_sub_indices[source];
1598     if (offset < 0 || source != sub_source_by_pos(mpctx, offset))
1599         return M_PROPERTY_UNAVAILABLE;
1600
1601     is_cur_source = sub_source(mpctx) == source;
1602     switch (action) {
1603     case M_PROPERTY_GET:
1604         if (!arg)
1605             return M_PROPERTY_ERROR;
1606         if (is_cur_source) {
1607             *(int *) arg = mpctx->global_sub_pos - offset;
1608             if (source == SUB_SOURCE_VOBSUB)
1609                 *(int *) arg = vobsub_get_id_by_index(vo_vobsub, *(int *) arg);
1610         }
1611         else
1612             *(int *) arg = -1;
1613         return M_PROPERTY_OK;
1614     case M_PROPERTY_PRINT:
1615         if (!arg)
1616             return M_PROPERTY_ERROR;
1617         if (is_cur_source)
1618             return mp_property_sub(prop, M_PROPERTY_PRINT, arg, mpctx);
1619         *(char **) arg = malloc(64);
1620         (*(char **) arg)[63] = 0;
1621         snprintf(*(char **) arg, 63, MSGTR_Disabled);
1622         return M_PROPERTY_OK;
1623     case M_PROPERTY_SET:
1624         if (!arg)
1625             return M_PROPERTY_ERROR;
1626         if (*(int *) arg >= 0) {
1627             int index = *(int *)arg;
1628             if (source == SUB_SOURCE_VOBSUB)
1629                 index = vobsub_get_index_by_id(vo_vobsub, index);
1630             mpctx->global_sub_pos = offset + index;
1631             if (index < 0 || mpctx->global_sub_pos >= mpctx->global_sub_size
1632                     || sub_source(mpctx) != source) {
1633                 mpctx->global_sub_pos = -1;
1634                 *(int *) arg = -1;
1635             }
1636         }
1637         else
1638             mpctx->global_sub_pos = -1;
1639         break;
1640     case M_PROPERTY_STEP_UP:
1641     case M_PROPERTY_STEP_DOWN: {
1642         int step_all = (arg && *(int*)arg != 0 ? *(int*)arg : 1)
1643                        * (action == M_PROPERTY_STEP_UP ? 1 : -1);
1644         int step = (step_all > 0) ? 1 : -1;
1645         int max_sub_pos_for_source = -1;
1646         if (!is_cur_source)
1647             mpctx->global_sub_pos = -1;
1648         while (step_all) {
1649             if (mpctx->global_sub_pos == -1) {
1650                 if (step > 0)
1651                     mpctx->global_sub_pos = offset;
1652                 else if (max_sub_pos_for_source == -1) {
1653                     // Find max pos for specific source
1654                     mpctx->global_sub_pos = mpctx->global_sub_size - 1;
1655                     while (mpctx->global_sub_pos >= 0
1656                             && sub_source(mpctx) != source)
1657                         --mpctx->global_sub_pos;
1658                 }
1659                 else
1660                     mpctx->global_sub_pos = max_sub_pos_for_source;
1661             }
1662             else {
1663                 mpctx->global_sub_pos += step;
1664                 if (mpctx->global_sub_pos < offset ||
1665                         mpctx->global_sub_pos >= mpctx->global_sub_size ||
1666                         sub_source(mpctx) != source)
1667                     mpctx->global_sub_pos = -1;
1668             }
1669             step_all -= step;
1670         }
1671         break;
1672     }
1673     default:
1674         return M_PROPERTY_NOT_IMPLEMENTED;
1675     }
1676     --mpctx->global_sub_pos;
1677     return mp_property_sub(prop, M_PROPERTY_STEP_UP, NULL, mpctx);
1678 }
1679
1680 /// Subtitle delay (RW)
1681 static int mp_property_sub_delay(m_option_t * prop, int action, void *arg,
1682                                  MPContext * mpctx)
1683 {
1684     if (!mpctx->sh_video)
1685         return M_PROPERTY_UNAVAILABLE;
1686     return m_property_delay(prop, action, arg, &sub_delay);
1687 }
1688
1689 /// Alignment of text subtitles (RW)
1690 static int mp_property_sub_alignment(m_option_t * prop, int action,
1691                                      void *arg, MPContext * mpctx)
1692 {
1693     char *name[] = { MSGTR_Top, MSGTR_Center, MSGTR_Bottom };
1694
1695     if (!mpctx->sh_video || mpctx->global_sub_pos < 0
1696         || sub_source(mpctx) != SUB_SOURCE_SUBS)
1697         return M_PROPERTY_UNAVAILABLE;
1698
1699     switch (action) {
1700     case M_PROPERTY_PRINT:
1701         if (!arg)
1702             return M_PROPERTY_ERROR;
1703         M_PROPERTY_CLAMP(prop, sub_alignment);
1704         *(char **) arg = strdup(name[sub_alignment]);
1705         return M_PROPERTY_OK;
1706     case M_PROPERTY_SET:
1707         if (!arg)
1708             return M_PROPERTY_ERROR;
1709     case M_PROPERTY_STEP_UP:
1710     case M_PROPERTY_STEP_DOWN:
1711         vo_osd_changed(OSDTYPE_SUBTITLE);
1712     default:
1713         return m_property_choice(prop, action, arg, &sub_alignment);
1714     }
1715 }
1716
1717 /// Subtitle visibility (RW)
1718 static int mp_property_sub_visibility(m_option_t * prop, int action,
1719                                       void *arg, MPContext * mpctx)
1720 {
1721     if (!mpctx->sh_video)
1722         return M_PROPERTY_UNAVAILABLE;
1723
1724     switch (action) {
1725     case M_PROPERTY_SET:
1726         if (!arg)
1727             return M_PROPERTY_ERROR;
1728     case M_PROPERTY_STEP_UP:
1729     case M_PROPERTY_STEP_DOWN:
1730         vo_osd_changed(OSDTYPE_SUBTITLE);
1731         if (vo_spudec)
1732             vo_osd_changed(OSDTYPE_SPU);
1733     default:
1734         return m_property_flag(prop, action, arg, &sub_visibility);
1735     }
1736 }
1737
1738 #ifdef CONFIG_ASS
1739 /// Use margins for libass subtitles (RW)
1740 static int mp_property_ass_use_margins(m_option_t * prop, int action,
1741                                       void *arg, MPContext * mpctx)
1742 {
1743     if (!mpctx->sh_video)
1744         return M_PROPERTY_UNAVAILABLE;
1745
1746     switch (action) {
1747     case M_PROPERTY_SET:
1748         if (!arg)
1749             return M_PROPERTY_ERROR;
1750     case M_PROPERTY_STEP_UP:
1751     case M_PROPERTY_STEP_DOWN:
1752         ass_force_reload = 1;
1753     default:
1754         return m_property_flag(prop, action, arg, &ass_use_margins);
1755     }
1756 }
1757 #endif
1758
1759 /// Show only forced subtitles (RW)
1760 static int mp_property_sub_forced_only(m_option_t * prop, int action,
1761                                        void *arg, MPContext * mpctx)
1762 {
1763     if (!vo_spudec)
1764         return M_PROPERTY_UNAVAILABLE;
1765
1766     switch (action) {
1767     case M_PROPERTY_SET:
1768         if (!arg)
1769             return M_PROPERTY_ERROR;
1770     case M_PROPERTY_STEP_UP:
1771     case M_PROPERTY_STEP_DOWN:
1772         m_property_flag(prop, action, arg, &forced_subs_only);
1773         spudec_set_forced_subs_only(vo_spudec, forced_subs_only);
1774         return M_PROPERTY_OK;
1775     default:
1776         return m_property_flag(prop, action, arg, &forced_subs_only);
1777     }
1778
1779 }
1780
1781 #ifdef CONFIG_FREETYPE
1782 /// Subtitle scale (RW)
1783 static int mp_property_sub_scale(m_option_t * prop, int action, void *arg,
1784                               MPContext * mpctx)
1785 {
1786
1787     switch (action) {
1788         case M_PROPERTY_SET:
1789             if (!arg)
1790                 return M_PROPERTY_ERROR;
1791             M_PROPERTY_CLAMP(prop, *(float *) arg);
1792 #ifdef CONFIG_ASS
1793             if (ass_enabled) {
1794                 ass_font_scale = *(float *) arg;
1795                 ass_force_reload = 1;
1796             }
1797 #endif
1798             text_font_scale_factor = *(float *) arg;
1799             force_load_font = 1;
1800             return M_PROPERTY_OK;
1801         case M_PROPERTY_STEP_UP:
1802         case M_PROPERTY_STEP_DOWN:
1803 #ifdef CONFIG_ASS
1804             if (ass_enabled) {
1805                 ass_font_scale += (arg ? *(float *) arg : 0.1)*
1806                   (action == M_PROPERTY_STEP_UP ? 1.0 : -1.0);
1807                 M_PROPERTY_CLAMP(prop, ass_font_scale);
1808                 ass_force_reload = 1;
1809             }
1810 #endif
1811             text_font_scale_factor += (arg ? *(float *) arg : 0.1)*
1812               (action == M_PROPERTY_STEP_UP ? 1.0 : -1.0);
1813             M_PROPERTY_CLAMP(prop, text_font_scale_factor);
1814             force_load_font = 1;
1815             return M_PROPERTY_OK;
1816         default:
1817 #ifdef CONFIG_ASS
1818             if (ass_enabled)
1819                 return m_property_float_ro(prop, action, arg, ass_font_scale);
1820             else
1821 #endif
1822                 return m_property_float_ro(prop, action, arg, text_font_scale_factor);
1823     }
1824 }
1825 #endif
1826
1827 ///@}
1828
1829 /// \defgroup TVProperties TV properties
1830 /// \ingroup Properties
1831 ///@{
1832
1833 #ifdef CONFIG_TV
1834
1835 /// TV color settings (RW)
1836 static int mp_property_tv_color(m_option_t * prop, int action, void *arg,
1837                                 MPContext * mpctx)
1838 {
1839     int r, val;
1840     tvi_handle_t *tvh = mpctx->demuxer->priv;
1841     if (mpctx->demuxer->type != DEMUXER_TYPE_TV || !tvh)
1842         return M_PROPERTY_UNAVAILABLE;
1843
1844     switch (action) {
1845     case M_PROPERTY_SET:
1846         if (!arg)
1847             return M_PROPERTY_ERROR;
1848         M_PROPERTY_CLAMP(prop, *(int *) arg);
1849         return tv_set_color_options(tvh, (int) prop->priv, *(int *) arg);
1850     case M_PROPERTY_GET:
1851         return tv_get_color_options(tvh, (int) prop->priv, arg);
1852     case M_PROPERTY_STEP_UP:
1853     case M_PROPERTY_STEP_DOWN:
1854         if ((r = tv_get_color_options(tvh, (int) prop->priv, &val)) >= 0) {
1855             if (!r)
1856                 return M_PROPERTY_ERROR;
1857             val += (arg ? *(int *) arg : 1) *
1858                 (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
1859             M_PROPERTY_CLAMP(prop, val);
1860             return tv_set_color_options(tvh, (int) prop->priv, val);
1861         }
1862         return M_PROPERTY_ERROR;
1863     }
1864     return M_PROPERTY_NOT_IMPLEMENTED;
1865 }
1866
1867 #endif
1868
1869 #ifdef CONFIG_TV_TELETEXT
1870 static int mp_property_teletext_common(m_option_t * prop, int action, void *arg,
1871                   MPContext * mpctx)
1872 {
1873     int val,result;
1874     int base_ioctl=(int)prop->priv;
1875     /*
1876       for teletext's GET,SET,STEP ioctls this is not 0
1877       SET is GET+1
1878       STEP is GET+2
1879     */
1880     tvi_handle_t *tvh = mpctx->demuxer->priv;
1881     if (mpctx->demuxer->type != DEMUXER_TYPE_TV || !tvh)
1882         return M_PROPERTY_UNAVAILABLE;
1883     if(!base_ioctl)
1884         return M_PROPERTY_ERROR;
1885
1886     switch (action) {
1887     case M_PROPERTY_GET:
1888         if (!arg)
1889             return M_PROPERTY_ERROR;
1890         result=tvh->functions->control(tvh->priv, base_ioctl, arg);
1891         break;
1892     case M_PROPERTY_SET:
1893         if (!arg)
1894             return M_PROPERTY_ERROR;
1895         M_PROPERTY_CLAMP(prop, *(int *) arg);
1896         result=tvh->functions->control(tvh->priv, base_ioctl+1, arg);
1897         break;
1898     case M_PROPERTY_STEP_UP:
1899     case M_PROPERTY_STEP_DOWN:
1900         result=tvh->functions->control(tvh->priv, base_ioctl, &val);
1901         val += (arg ? *(int *) arg : 1) * (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
1902         result=tvh->functions->control(tvh->priv, base_ioctl+1, &val);
1903         break;
1904     default:
1905         return M_PROPERTY_NOT_IMPLEMENTED;
1906     }
1907
1908     return result == TVI_CONTROL_TRUE ? M_PROPERTY_OK : M_PROPERTY_ERROR;
1909 }
1910
1911 static int mp_property_teletext_mode(m_option_t * prop, int action, void *arg,
1912                   MPContext * mpctx)
1913 {
1914     tvi_handle_t *tvh = mpctx->demuxer->priv;
1915     int result;
1916     int val;
1917
1918     //with tvh==NULL will fail too
1919     result=mp_property_teletext_common(prop,action,arg,mpctx);
1920     if(result!=M_PROPERTY_OK)
1921         return result;
1922
1923     if(tvh->functions->control(tvh->priv, prop->priv, &val)==TVI_CONTROL_TRUE && val)
1924         mp_input_set_section("teletext");
1925     else
1926         mp_input_set_section("tv");
1927     return M_PROPERTY_OK;
1928 }
1929
1930 static int mp_property_teletext_page(m_option_t * prop, int action, void *arg,
1931                   MPContext * mpctx)
1932 {
1933     tvi_handle_t *tvh = mpctx->demuxer->priv;
1934     int result;
1935     int val;
1936     if (mpctx->demuxer->type != DEMUXER_TYPE_TV || !tvh)
1937         return M_PROPERTY_UNAVAILABLE;
1938     switch(action){
1939     case M_PROPERTY_STEP_UP:
1940     case M_PROPERTY_STEP_DOWN:
1941         //This should be handled separately
1942         val = (arg ? *(int *) arg : 1) * (action == M_PROPERTY_STEP_DOWN ? -1 : 1);
1943         result=tvh->functions->control(tvh->priv, TV_VBI_CONTROL_STEP_PAGE, &val);
1944         break;
1945     default:
1946         result=mp_property_teletext_common(prop,action,arg,mpctx);
1947     }
1948     return result;
1949 }
1950
1951
1952 #endif /* CONFIG_TV_TELETEXT */
1953
1954 ///@}
1955
1956 /// All properties available in MPlayer.
1957 /** \ingroup Properties
1958  */
1959 static const m_option_t mp_properties[] = {
1960     // General
1961     { "osdlevel", mp_property_osdlevel, CONF_TYPE_INT,
1962      M_OPT_RANGE, 0, 3, NULL },
1963     { "loop", mp_property_loop, CONF_TYPE_INT,
1964      M_OPT_MIN, -1, 0, NULL },
1965     { "speed", mp_property_playback_speed, CONF_TYPE_FLOAT,
1966      M_OPT_RANGE, 0.01, 100.0, NULL },
1967     { "filename", mp_property_filename, CONF_TYPE_STRING,
1968      0, 0, 0, NULL },
1969     { "path", mp_property_path, CONF_TYPE_STRING,
1970      0, 0, 0, NULL },
1971     { "demuxer", mp_property_demuxer, CONF_TYPE_STRING,
1972      0, 0, 0, NULL },
1973     { "stream_pos", mp_property_stream_pos, CONF_TYPE_POSITION,
1974      M_OPT_MIN, 0, 0, NULL },
1975     { "stream_start", mp_property_stream_start, CONF_TYPE_POSITION,
1976      M_OPT_MIN, 0, 0, NULL },
1977     { "stream_end", mp_property_stream_end, CONF_TYPE_POSITION,
1978      M_OPT_MIN, 0, 0, NULL },
1979     { "stream_length", mp_property_stream_length, CONF_TYPE_POSITION,
1980      M_OPT_MIN, 0, 0, NULL },
1981     { "length", mp_property_length, CONF_TYPE_TIME,
1982      M_OPT_MIN, 0, 0, NULL },
1983     { "percent_pos", mp_property_percent_pos, CONF_TYPE_INT,
1984      M_OPT_RANGE, 0, 100, NULL },
1985     { "time_pos", mp_property_time_pos, CONF_TYPE_TIME,
1986      M_OPT_MIN, 0, 0, NULL },
1987     { "chapter", mp_property_chapter, CONF_TYPE_INT,
1988      M_OPT_MIN, 0, 0, NULL },
1989     { "chapters", mp_property_chapters, CONF_TYPE_INT,
1990      0, 0, 0, NULL },
1991     { "angle", mp_property_angle, CONF_TYPE_INT,
1992      CONF_RANGE, -2, 10, NULL },
1993     { "metadata", mp_property_metadata, CONF_TYPE_STRING_LIST,
1994      0, 0, 0, NULL },
1995     { "pause", mp_property_pause, CONF_TYPE_FLAG,
1996      M_OPT_RANGE, 0, 1, NULL },
1997
1998     // Audio
1999     { "volume", mp_property_volume, CONF_TYPE_FLOAT,
2000      M_OPT_RANGE, 0, 100, NULL },
2001     { "mute", mp_property_mute, CONF_TYPE_FLAG,
2002      M_OPT_RANGE, 0, 1, NULL },
2003     { "audio_delay", mp_property_audio_delay, CONF_TYPE_FLOAT,
2004      M_OPT_RANGE, -100, 100, NULL },
2005     { "audio_format", mp_property_audio_format, CONF_TYPE_INT,
2006      0, 0, 0, NULL },
2007     { "audio_codec", mp_property_audio_codec, CONF_TYPE_STRING,
2008      0, 0, 0, NULL },
2009     { "audio_bitrate", mp_property_audio_bitrate, CONF_TYPE_INT,
2010      0, 0, 0, NULL },
2011     { "samplerate", mp_property_samplerate, CONF_TYPE_INT,
2012      0, 0, 0, NULL },
2013     { "channels", mp_property_channels, CONF_TYPE_INT,
2014      0, 0, 0, NULL },
2015     { "switch_audio", mp_property_audio, CONF_TYPE_INT,
2016      CONF_RANGE, -2, 65535, NULL },
2017     { "balance", mp_property_balance, CONF_TYPE_FLOAT,
2018      M_OPT_RANGE, -1, 1, NULL },
2019
2020     // Video
2021     { "fullscreen", mp_property_fullscreen, CONF_TYPE_FLAG,
2022      M_OPT_RANGE, 0, 1, NULL },
2023     { "deinterlace", mp_property_deinterlace, CONF_TYPE_FLAG,
2024      M_OPT_RANGE, 0, 1, NULL },
2025     { "ontop", mp_property_ontop, CONF_TYPE_FLAG,
2026      M_OPT_RANGE, 0, 1, NULL },
2027     { "rootwin", mp_property_rootwin, CONF_TYPE_FLAG,
2028      M_OPT_RANGE, 0, 1, NULL },
2029     { "border", mp_property_border, CONF_TYPE_FLAG,
2030      M_OPT_RANGE, 0, 1, NULL },
2031     { "framedropping", mp_property_framedropping, CONF_TYPE_INT,
2032      M_OPT_RANGE, 0, 2, NULL },
2033     { "gamma", mp_property_gamma, CONF_TYPE_INT,
2034      M_OPT_RANGE, -100, 100, &vo_gamma_gamma },
2035     { "brightness", mp_property_gamma, CONF_TYPE_INT,
2036      M_OPT_RANGE, -100, 100, &vo_gamma_brightness },
2037     { "contrast", mp_property_gamma, CONF_TYPE_INT,
2038      M_OPT_RANGE, -100, 100, &vo_gamma_contrast },
2039     { "saturation", mp_property_gamma, CONF_TYPE_INT,
2040      M_OPT_RANGE, -100, 100, &vo_gamma_saturation },
2041     { "hue", mp_property_gamma, CONF_TYPE_INT,
2042      M_OPT_RANGE, -100, 100, &vo_gamma_hue },
2043     { "panscan", mp_property_panscan, CONF_TYPE_FLOAT,
2044      M_OPT_RANGE, 0, 1, NULL },
2045     { "vsync", mp_property_vsync, CONF_TYPE_FLAG,
2046      M_OPT_RANGE, 0, 1, NULL },
2047     { "video_format", mp_property_video_format, CONF_TYPE_INT,
2048      0, 0, 0, NULL },
2049     { "video_codec", mp_property_video_codec, CONF_TYPE_STRING,
2050      0, 0, 0, NULL },
2051     { "video_bitrate", mp_property_video_bitrate, CONF_TYPE_INT,
2052      0, 0, 0, NULL },
2053     { "width", mp_property_width, CONF_TYPE_INT,
2054      0, 0, 0, NULL },
2055     { "height", mp_property_height, CONF_TYPE_INT,
2056      0, 0, 0, NULL },
2057     { "fps", mp_property_fps, CONF_TYPE_FLOAT,
2058      0, 0, 0, NULL },
2059     { "aspect", mp_property_aspect, CONF_TYPE_FLOAT,
2060      0, 0, 0, NULL },
2061     { "switch_video", mp_property_video, CONF_TYPE_INT,
2062      CONF_RANGE, -2, 65535, NULL },
2063     { "switch_program", mp_property_program, CONF_TYPE_INT,
2064      CONF_RANGE, -1, 65535, NULL },
2065
2066     // Subs
2067     { "sub", mp_property_sub, CONF_TYPE_INT,
2068      M_OPT_MIN, -1, 0, NULL },
2069     { "sub_source", mp_property_sub_source, CONF_TYPE_INT,
2070      M_OPT_RANGE, -1, SUB_SOURCES - 1, NULL },
2071     { "sub_vob", mp_property_sub_by_type, CONF_TYPE_INT,
2072      M_OPT_MIN, -1, 0, NULL },
2073     { "sub_demux", mp_property_sub_by_type, CONF_TYPE_INT,
2074      M_OPT_MIN, -1, 0, NULL },
2075     { "sub_file", mp_property_sub_by_type, CONF_TYPE_INT,
2076      M_OPT_MIN, -1, 0, NULL },
2077     { "sub_delay", mp_property_sub_delay, CONF_TYPE_FLOAT,
2078      0, 0, 0, NULL },
2079     { "sub_pos", mp_property_sub_pos, CONF_TYPE_INT,
2080      M_OPT_RANGE, 0, 100, NULL },
2081     { "sub_alignment", mp_property_sub_alignment, CONF_TYPE_INT,
2082      M_OPT_RANGE, 0, 2, NULL },
2083     { "sub_visibility", mp_property_sub_visibility, CONF_TYPE_FLAG,
2084      M_OPT_RANGE, 0, 1, NULL },
2085     { "sub_forced_only", mp_property_sub_forced_only, CONF_TYPE_FLAG,
2086      M_OPT_RANGE, 0, 1, NULL },
2087 #ifdef CONFIG_FREETYPE
2088     { "sub_scale", mp_property_sub_scale, CONF_TYPE_FLOAT,
2089      M_OPT_RANGE, 0, 100, NULL },
2090 #endif
2091 #ifdef CONFIG_ASS
2092     { "ass_use_margins", mp_property_ass_use_margins, CONF_TYPE_FLAG,
2093      M_OPT_RANGE, 0, 1, NULL },
2094 #endif
2095
2096 #ifdef CONFIG_TV
2097     { "tv_brightness", mp_property_tv_color, CONF_TYPE_INT,
2098      M_OPT_RANGE, -100, 100, (void *) TV_COLOR_BRIGHTNESS },
2099     { "tv_contrast", mp_property_tv_color, CONF_TYPE_INT,
2100      M_OPT_RANGE, -100, 100, (void *) TV_COLOR_CONTRAST },
2101     { "tv_saturation", mp_property_tv_color, CONF_TYPE_INT,
2102      M_OPT_RANGE, -100, 100, (void *) TV_COLOR_SATURATION },
2103     { "tv_hue", mp_property_tv_color, CONF_TYPE_INT,
2104      M_OPT_RANGE, -100, 100, (void *) TV_COLOR_HUE },
2105 #endif
2106
2107 #ifdef CONFIG_TV_TELETEXT
2108     { "teletext_page", mp_property_teletext_page, CONF_TYPE_INT,
2109      M_OPT_RANGE, 100, 899,  (void*)TV_VBI_CONTROL_GET_PAGE },
2110     { "teletext_subpage", mp_property_teletext_common, CONF_TYPE_INT,
2111      M_OPT_RANGE, 0, 64, (void*)TV_VBI_CONTROL_GET_SUBPAGE },
2112     { "teletext_mode", mp_property_teletext_mode, CONF_TYPE_FLAG,
2113      M_OPT_RANGE, 0, 1, (void*)TV_VBI_CONTROL_GET_MODE },
2114     { "teletext_format", mp_property_teletext_common, CONF_TYPE_INT,
2115      M_OPT_RANGE, 0, 3, (void*)TV_VBI_CONTROL_GET_FORMAT },
2116     { "teletext_half_page", mp_property_teletext_common, CONF_TYPE_INT,
2117      M_OPT_RANGE, 0, 2, (void*)TV_VBI_CONTROL_GET_HALF_PAGE },
2118 #endif
2119
2120     { NULL, NULL, NULL, 0, 0, 0, NULL }
2121 };
2122
2123
2124 int mp_property_do(const char *name, int action, void *val, void *ctx)
2125 {
2126     return m_property_do(mp_properties, name, action, val, ctx);
2127 }
2128
2129 char* mp_property_print(const char *name, void* ctx)
2130 {
2131     char* ret = NULL;
2132     if(mp_property_do(name,M_PROPERTY_PRINT,&ret,ctx) <= 0)
2133         return NULL;
2134     return ret;
2135 }
2136
2137 char *property_expand_string(MPContext * mpctx, char *str)
2138 {
2139     return m_properties_expand_string(mp_properties, str, mpctx);
2140 }
2141
2142 void property_print_help(void)
2143 {
2144     m_properties_print_help_list(mp_properties);
2145 }
2146
2147
2148 ///@}
2149 // Properties group
2150
2151
2152 /**
2153  * \defgroup Command2Property Command to property bridge
2154  *
2155  * It is used to handle most commands that just set a property
2156  * and optionally display something on the OSD.
2157  * Two kinds of commands are handled: adjust or toggle.
2158  *
2159  * Adjust commands take 1 or 2 parameters: <value> <abs>
2160  * If <abs> is non-zero the property is set to the given value
2161  * otherwise it is adjusted.
2162  *
2163  * Toggle commands take 0 or 1 parameters. With no parameter
2164  * or a value less than the property minimum it just steps the
2165  * property to its next value. Otherwise it sets it to the given
2166  * value.
2167  *
2168  *@{
2169  */
2170
2171 /// List of the commands that can be handled by setting a property.
2172 static struct {
2173     /// property name
2174     const char *name;
2175     /// cmd id
2176     int cmd;
2177     /// set/adjust or toggle command
2178     int toggle;
2179     /// progressbar type
2180     int osd_progbar;
2181     /// osd msg id if it must be shared
2182     int osd_id;
2183     /// osd msg template
2184     const char *osd_msg;
2185 } set_prop_cmd[] = {
2186     // general
2187     { "loop", MP_CMD_LOOP, 0, 0, -1, MSGTR_LoopStatus },
2188     { "chapter", MP_CMD_SEEK_CHAPTER, 0, 0, -1, NULL },
2189     { "angle", MP_CMD_SWITCH_ANGLE, 0, 0, -1, NULL },
2190     // audio
2191     { "volume", MP_CMD_VOLUME, 0, OSD_VOLUME, -1, MSGTR_Volume },
2192     { "mute", MP_CMD_MUTE, 1, 0, -1, MSGTR_MuteStatus },
2193     { "audio_delay", MP_CMD_AUDIO_DELAY, 0, 0, -1, MSGTR_AVDelayStatus },
2194     { "switch_audio", MP_CMD_SWITCH_AUDIO, 1, 0, -1, MSGTR_OSDAudio },
2195     { "balance", MP_CMD_BALANCE, 0, OSD_BALANCE, -1, MSGTR_Balance },
2196     // video
2197     { "fullscreen", MP_CMD_VO_FULLSCREEN, 1, 0, -1, NULL },
2198     { "panscan", MP_CMD_PANSCAN, 0, OSD_PANSCAN, -1, MSGTR_Panscan },
2199     { "ontop", MP_CMD_VO_ONTOP, 1, 0, -1, MSGTR_OnTopStatus },
2200     { "rootwin", MP_CMD_VO_ROOTWIN, 1, 0, -1, MSGTR_RootwinStatus },
2201     { "border", MP_CMD_VO_BORDER, 1, 0, -1, MSGTR_BorderStatus },
2202     { "framedropping", MP_CMD_FRAMEDROPPING, 1, 0, -1, MSGTR_FramedroppingStatus },
2203     { "gamma", MP_CMD_GAMMA, 0, OSD_BRIGHTNESS, -1, MSGTR_Gamma },
2204     { "brightness", MP_CMD_BRIGHTNESS, 0, OSD_BRIGHTNESS, -1, MSGTR_Brightness },
2205     { "contrast", MP_CMD_CONTRAST, 0, OSD_CONTRAST, -1, MSGTR_Contrast },
2206     { "saturation", MP_CMD_SATURATION, 0, OSD_SATURATION, -1, MSGTR_Saturation },
2207     { "hue", MP_CMD_HUE, 0, OSD_HUE, -1, MSGTR_Hue },
2208     { "vsync", MP_CMD_SWITCH_VSYNC, 1, 0, -1, MSGTR_VSyncStatus },
2209         // subs
2210     { "sub", MP_CMD_SUB_SELECT, 1, 0, -1, MSGTR_SubSelectStatus },
2211     { "sub_source", MP_CMD_SUB_SOURCE, 1, 0, -1, MSGTR_SubSourceStatus },
2212     { "sub_vob", MP_CMD_SUB_VOB, 1, 0, -1, MSGTR_SubSelectStatus },
2213     { "sub_demux", MP_CMD_SUB_DEMUX, 1, 0, -1, MSGTR_SubSelectStatus },
2214     { "sub_file", MP_CMD_SUB_FILE, 1, 0, -1, MSGTR_SubSelectStatus },
2215     { "sub_pos", MP_CMD_SUB_POS, 0, 0, -1, MSGTR_SubPosStatus },
2216     { "sub_alignment", MP_CMD_SUB_ALIGNMENT, 1, 0, -1, MSGTR_SubAlignStatus },
2217     { "sub_delay", MP_CMD_SUB_DELAY, 0, 0, OSD_MSG_SUB_DELAY, MSGTR_SubDelayStatus },
2218     { "sub_visibility", MP_CMD_SUB_VISIBILITY, 1, 0, -1, MSGTR_SubVisibleStatus },
2219     { "sub_forced_only", MP_CMD_SUB_FORCED_ONLY, 1, 0, -1, MSGTR_SubForcedOnlyStatus },
2220 #ifdef CONFIG_FREETYPE
2221     { "sub_scale", MP_CMD_SUB_SCALE, 0, 0, -1, MSGTR_SubScale},
2222 #endif
2223 #ifdef CONFIG_ASS
2224     { "ass_use_margins", MP_CMD_ASS_USE_MARGINS, 1, 0, -1, NULL },
2225 #endif
2226 #ifdef CONFIG_TV
2227     { "tv_brightness", MP_CMD_TV_SET_BRIGHTNESS, 0, OSD_BRIGHTNESS, -1, MSGTR_Brightness },
2228     { "tv_hue", MP_CMD_TV_SET_HUE, 0, OSD_HUE, -1, MSGTR_Hue },
2229     { "tv_saturation", MP_CMD_TV_SET_SATURATION, 0, OSD_SATURATION, -1, MSGTR_Saturation },
2230     { "tv_contrast", MP_CMD_TV_SET_CONTRAST, 0, OSD_CONTRAST, -1, MSGTR_Contrast },
2231 #endif
2232     { NULL, 0, 0, 0, -1, NULL }
2233 };
2234
2235
2236 /// Handle commands that set a property.
2237 static int set_property_command(MPContext * mpctx, mp_cmd_t * cmd)
2238 {
2239     int i, r;
2240     m_option_t* prop;
2241     const char *pname;
2242
2243     // look for the command
2244     for (i = 0; set_prop_cmd[i].name; i++)
2245         if (set_prop_cmd[i].cmd == cmd->id)
2246             break;
2247     if (!(pname = set_prop_cmd[i].name))
2248         return 0;
2249
2250     if (mp_property_do(pname,M_PROPERTY_GET_TYPE,&prop,mpctx) <= 0 || !prop)
2251         return 0;
2252
2253     // toggle command
2254     if (set_prop_cmd[i].toggle) {
2255         // set to value
2256         if (cmd->nargs > 0 && cmd->args[0].v.i >= prop->min)
2257             r = mp_property_do(pname, M_PROPERTY_SET, &cmd->args[0].v.i, mpctx);
2258         else
2259             r = mp_property_do(pname, M_PROPERTY_STEP_UP, NULL, mpctx);
2260     } else if (cmd->args[1].v.i)        //set
2261         r = mp_property_do(pname, M_PROPERTY_SET, &cmd->args[0].v, mpctx);
2262     else                        // adjust
2263         r = mp_property_do(pname, M_PROPERTY_STEP_UP, &cmd->args[0].v, mpctx);
2264
2265     if (r <= 0)
2266         return 1;
2267
2268     if (set_prop_cmd[i].osd_progbar) {
2269         if (prop->type == CONF_TYPE_INT) {
2270             if (mp_property_do(pname, M_PROPERTY_GET, &r, mpctx) > 0)
2271                 set_osd_bar(set_prop_cmd[i].osd_progbar,
2272                             set_prop_cmd[i].osd_msg, prop->min, prop->max, r);
2273         } else if (prop->type == CONF_TYPE_FLOAT) {
2274             float f;
2275             if (mp_property_do(pname, M_PROPERTY_GET, &f, mpctx) > 0)
2276                 set_osd_bar(set_prop_cmd[i].osd_progbar,
2277                             set_prop_cmd[i].osd_msg, prop->min, prop->max, f);
2278         } else
2279             mp_msg(MSGT_CPLAYER, MSGL_ERR,
2280                    "Property use an unsupported type.\n");
2281         return 1;
2282     }
2283
2284     if (set_prop_cmd[i].osd_msg) {
2285         char *val = mp_property_print(pname, mpctx);
2286         if (val) {
2287             set_osd_msg(set_prop_cmd[i].osd_id >=
2288                         0 ? set_prop_cmd[i].osd_id : OSD_MSG_PROPERTY + i,
2289                         1, osd_duration, set_prop_cmd[i].osd_msg, val);
2290             free(val);
2291         }
2292     }
2293     return 1;
2294 }
2295
2296 #ifdef CONFIG_DVDNAV
2297 static const struct {
2298   const char *name;
2299   const mp_command_type cmd;
2300 } mp_dvdnav_bindings[] = {
2301   { "up",       MP_CMD_DVDNAV_UP              },
2302   { "down",     MP_CMD_DVDNAV_DOWN            },
2303   { "left",     MP_CMD_DVDNAV_LEFT            },
2304   { "right",    MP_CMD_DVDNAV_RIGHT           },
2305   { "menu",     MP_CMD_DVDNAV_MENU            },
2306   { "select",   MP_CMD_DVDNAV_SELECT          },
2307   { "prev",     MP_CMD_DVDNAV_PREVMENU        },
2308   { "mouse",    MP_CMD_DVDNAV_MOUSECLICK      },
2309
2310   /*
2311    * keep old dvdnav sub-command options for a while in order not to
2312    *  break slave-mode API too suddenly.
2313    */
2314   { "1",        MP_CMD_DVDNAV_UP              },
2315   { "2",        MP_CMD_DVDNAV_DOWN            },
2316   { "3",        MP_CMD_DVDNAV_LEFT            },
2317   { "4",        MP_CMD_DVDNAV_RIGHT           },
2318   { "5",        MP_CMD_DVDNAV_MENU            },
2319   { "6",        MP_CMD_DVDNAV_SELECT          },
2320   { "7",        MP_CMD_DVDNAV_PREVMENU        },
2321   { "8",        MP_CMD_DVDNAV_MOUSECLICK      },
2322   { NULL,       0                             }
2323 };
2324 #endif
2325
2326 int run_command(MPContext * mpctx, mp_cmd_t * cmd)
2327 {
2328     sh_audio_t * const sh_audio = mpctx->sh_audio;
2329     sh_video_t * const sh_video = mpctx->sh_video;
2330     int brk_cmd = 0;
2331     if (!set_property_command(mpctx, cmd))
2332         switch (cmd->id) {
2333         case MP_CMD_SEEK:{
2334                 float v;
2335                 int abs;
2336                 if (sh_video)
2337                     mpctx->osd_show_percentage = sh_video->fps;
2338                 v = cmd->args[0].v.f;
2339                 abs = (cmd->nargs > 1) ? cmd->args[1].v.i : 0;
2340                 if (abs == 2) { /* Absolute seek to a specific timestamp in seconds */
2341                     abs_seek_pos = SEEK_ABSOLUTE;
2342                     if (sh_video)
2343                         mpctx->osd_function =
2344                             (v > sh_video->pts) ? OSD_FFW : OSD_REW;
2345                     rel_seek_secs = v;
2346                 } else if (abs) {       /* Absolute seek by percentage */
2347                     abs_seek_pos = SEEK_ABSOLUTE | SEEK_FACTOR;
2348                     if (sh_video)
2349                         mpctx->osd_function = OSD_FFW;  // Direction isn't set correctly
2350                     rel_seek_secs = v / 100.0;
2351                 } else {
2352                     rel_seek_secs += v;
2353                     mpctx->osd_function = (v > 0) ? OSD_FFW : OSD_REW;
2354                 }
2355                 brk_cmd = 1;
2356             }
2357             break;
2358
2359         case MP_CMD_SET_PROPERTY:{
2360                 int r = mp_property_do(cmd->args[0].v.s, M_PROPERTY_PARSE,
2361                                        cmd->args[1].v.s, mpctx);
2362                 if (r == M_PROPERTY_UNKNOWN)
2363                     mp_msg(MSGT_CPLAYER, MSGL_WARN,
2364                            "Unknown property: '%s'\n", cmd->args[0].v.s);
2365                 else if (r <= 0)
2366                     mp_msg(MSGT_CPLAYER, MSGL_WARN,
2367                            "Failed to set property '%s' to '%s'.\n",
2368                            cmd->args[0].v.s, cmd->args[1].v.s);
2369             }
2370             break;
2371
2372         case MP_CMD_STEP_PROPERTY:{
2373                 void* arg = NULL;
2374                 int r,i;
2375                 double d;
2376                 off_t o;
2377                 if (cmd->args[1].v.f) {
2378                     m_option_t* prop;
2379                     if((r = mp_property_do(cmd->args[0].v.s,
2380                                            M_PROPERTY_GET_TYPE,
2381                                            &prop, mpctx)) <= 0)
2382                         goto step_prop_err;
2383                     if(prop->type == CONF_TYPE_INT ||
2384                        prop->type == CONF_TYPE_FLAG)
2385                         i = cmd->args[1].v.f, arg = &i;
2386                     else if(prop->type == CONF_TYPE_FLOAT)
2387                         arg = &cmd->args[1].v.f;
2388                     else if(prop->type == CONF_TYPE_DOUBLE ||
2389                             prop->type == CONF_TYPE_TIME)
2390                         d = cmd->args[1].v.f, arg = &d;
2391                     else if(prop->type == CONF_TYPE_POSITION)
2392                         o = cmd->args[1].v.f, arg = &o;
2393                     else
2394                         mp_msg(MSGT_CPLAYER, MSGL_WARN,
2395                                "Ignoring step size stepping property '%s'.\n",
2396                                cmd->args[0].v.s);
2397                 }
2398                 r = mp_property_do(cmd->args[0].v.s,
2399                                    cmd->args[2].v.i < 0 ?
2400                                    M_PROPERTY_STEP_DOWN : M_PROPERTY_STEP_UP,
2401                                    arg, mpctx);
2402             step_prop_err:
2403                 if (r == M_PROPERTY_UNKNOWN)
2404                     mp_msg(MSGT_CPLAYER, MSGL_WARN,
2405                            "Unknown property: '%s'\n", cmd->args[0].v.s);
2406                 else if (r <= 0)
2407                     mp_msg(MSGT_CPLAYER, MSGL_WARN,
2408                            "Failed to increment property '%s' by %f.\n",
2409                            cmd->args[0].v.s, cmd->args[1].v.f);
2410             }
2411             break;
2412
2413         case MP_CMD_GET_PROPERTY:{
2414                 char *tmp;
2415                 if (mp_property_do(cmd->args[0].v.s, M_PROPERTY_TO_STRING,
2416                                    &tmp, mpctx) <= 0) {
2417                     mp_msg(MSGT_CPLAYER, MSGL_WARN,
2418                            "Failed to get value of property '%s'.\n",
2419                            cmd->args[0].v.s);
2420                     break;
2421                 }
2422                 mp_msg(MSGT_GLOBAL, MSGL_INFO, "ANS_%s=%s\n",
2423                        cmd->args[0].v.s, tmp);
2424                 free(tmp);
2425             }
2426             break;
2427
2428         case MP_CMD_EDL_MARK:
2429             if (edl_fd) {
2430                 float v = sh_video ? sh_video->pts :
2431                     playing_audio_pts(sh_audio, mpctx->d_audio,
2432                                       mpctx->audio_out);
2433
2434                 if (mpctx->begin_skip == MP_NOPTS_VALUE) {
2435                     mpctx->begin_skip = v;
2436                     mp_msg(MSGT_CPLAYER, MSGL_INFO, MSGTR_EdloutStartSkip);
2437                 } else {
2438                     if (mpctx->begin_skip > v)
2439                         mp_msg(MSGT_CPLAYER, MSGL_WARN, MSGTR_EdloutBadStop);
2440                     else {
2441                         fprintf(edl_fd, "%f %f %d\n", mpctx->begin_skip, v, 0);
2442                         mp_msg(MSGT_CPLAYER, MSGL_INFO, MSGTR_EdloutEndSkip);
2443                     }
2444                     mpctx->begin_skip = MP_NOPTS_VALUE;
2445                 }
2446             }
2447             break;
2448
2449         case MP_CMD_SWITCH_RATIO:
2450             if (!sh_video)
2451                 break;
2452             if (cmd->nargs == 0 || cmd->args[0].v.f == -1)
2453                 movie_aspect = (float) sh_video->disp_w / sh_video->disp_h;
2454             else
2455                 movie_aspect = cmd->args[0].v.f;
2456             mpcodecs_config_vo(sh_video, sh_video->disp_w, sh_video->disp_h, 0);
2457             break;
2458
2459         case MP_CMD_SPEED_INCR:{
2460                 float v = cmd->args[0].v.f;
2461                 playback_speed += v;
2462                 build_afilter_chain(sh_audio, &ao_data);
2463                 set_osd_msg(OSD_MSG_SPEED, 1, osd_duration, MSGTR_OSDSpeed,
2464                             playback_speed);
2465             } break;
2466
2467         case MP_CMD_SPEED_MULT:{
2468                 float v = cmd->args[0].v.f;
2469                 playback_speed *= v;
2470                 build_afilter_chain(sh_audio, &ao_data);
2471                 set_osd_msg(OSD_MSG_SPEED, 1, osd_duration, MSGTR_OSDSpeed,
2472                             playback_speed);
2473             } break;
2474
2475         case MP_CMD_SPEED_SET:{
2476                 float v = cmd->args[0].v.f;
2477                 playback_speed = v;
2478                 build_afilter_chain(sh_audio, &ao_data);
2479                 set_osd_msg(OSD_MSG_SPEED, 1, osd_duration, MSGTR_OSDSpeed,
2480                             playback_speed);
2481             } break;
2482
2483         case MP_CMD_FRAME_STEP:
2484         case MP_CMD_PAUSE:
2485             cmd->pausing = 1;
2486             brk_cmd = 1;
2487             break;
2488
2489         case MP_CMD_FILE_FILTER:
2490             file_filter = cmd->args[0].v.i;
2491             break;
2492
2493         case MP_CMD_QUIT:
2494             exit_player_with_rc(EXIT_QUIT,
2495                                 (cmd->nargs > 0) ? cmd->args[0].v.i : 0);
2496
2497         case MP_CMD_PLAY_TREE_STEP:{
2498                 int n = cmd->args[0].v.i == 0 ? 1 : cmd->args[0].v.i;
2499                 int force = cmd->args[1].v.i;
2500
2501 #ifdef CONFIG_GUI
2502                 if (use_gui) {
2503                     int i = 0;
2504                     if (n > 0)
2505                         for (i = 0; i < n; i++)
2506                             mplNext();
2507                     else
2508                         for (i = 0; i < -1 * n; i++)
2509                             mplPrev();
2510                 } else
2511 #endif
2512                 {
2513                     if (!force && mpctx->playtree_iter) {
2514                         play_tree_iter_t *i =
2515                             play_tree_iter_new_copy(mpctx->playtree_iter);
2516                         if (play_tree_iter_step(i, n, 0) ==
2517                             PLAY_TREE_ITER_ENTRY)
2518                             mpctx->eof =
2519                                 (n > 0) ? PT_NEXT_ENTRY : PT_PREV_ENTRY;
2520                         play_tree_iter_free(i);
2521                     } else
2522                         mpctx->eof = (n > 0) ? PT_NEXT_ENTRY : PT_PREV_ENTRY;
2523                     if (mpctx->eof)
2524                         mpctx->play_tree_step = n;
2525                     brk_cmd = 1;
2526                 }
2527             }
2528             break;
2529
2530         case MP_CMD_PLAY_TREE_UP_STEP:{
2531                 int n = cmd->args[0].v.i > 0 ? 1 : -1;
2532                 int force = cmd->args[1].v.i;
2533
2534                 if (!force && mpctx->playtree_iter) {
2535                     play_tree_iter_t *i =
2536                         play_tree_iter_new_copy(mpctx->playtree_iter);
2537                     if (play_tree_iter_up_step(i, n, 0) == PLAY_TREE_ITER_ENTRY)
2538                         mpctx->eof = (n > 0) ? PT_UP_NEXT : PT_UP_PREV;
2539                     play_tree_iter_free(i);
2540                 } else
2541                     mpctx->eof = (n > 0) ? PT_UP_NEXT : PT_UP_PREV;
2542                 brk_cmd = 1;
2543             }
2544             break;
2545
2546         case MP_CMD_PLAY_ALT_SRC_STEP:
2547             if (mpctx->playtree_iter && mpctx->playtree_iter->num_files > 1) {
2548                 int v = cmd->args[0].v.i;
2549                 if (v > 0
2550                     && mpctx->playtree_iter->file <
2551                     mpctx->playtree_iter->num_files)
2552                     mpctx->eof = PT_NEXT_SRC;
2553                 else if (v < 0 && mpctx->playtree_iter->file > 1)
2554                     mpctx->eof = PT_PREV_SRC;
2555             }
2556             brk_cmd = 1;
2557             break;
2558
2559         case MP_CMD_SUB_STEP:
2560             if (sh_video) {
2561                 int movement = cmd->args[0].v.i;
2562                 step_sub(subdata, sh_video->pts, movement);
2563 #ifdef CONFIG_ASS
2564                 if (ass_track)
2565                     sub_delay +=
2566                         ass_step_sub(ass_track,
2567                                      (sh_video->pts +
2568                                       sub_delay) * 1000 + .5, movement) / 1000.;
2569 #endif
2570                 set_osd_msg(OSD_MSG_SUB_DELAY, 1, osd_duration,
2571                             MSGTR_OSDSubDelay, ROUND(sub_delay * 1000));
2572             }
2573             break;
2574
2575         case MP_CMD_SUB_LOG:
2576             log_sub();
2577             break;
2578
2579         case MP_CMD_OSD:{
2580                 int v = cmd->args[0].v.i;
2581                 int max = (term_osd
2582                            && !sh_video) ? MAX_TERM_OSD_LEVEL : MAX_OSD_LEVEL;
2583                 if (osd_level > max)
2584                     osd_level = max;
2585                 if (v < 0)
2586                     osd_level = (osd_level + 1) % (max + 1);
2587                 else
2588                     osd_level = v > max ? max : v;
2589                 /* Show OSD state when disabled, but not when an explicit
2590                    argument is given to the OSD command, i.e. in slave mode. */
2591                 if (v == -1 && osd_level <= 1)
2592                     set_osd_msg(OSD_MSG_OSD_STATUS, 0, osd_duration,
2593                                 MSGTR_OSDosd,
2594                                 osd_level ? MSGTR_OSDenabled :
2595                                 MSGTR_OSDdisabled);
2596                 else
2597                     rm_osd_msg(OSD_MSG_OSD_STATUS);
2598             }
2599             break;
2600
2601         case MP_CMD_OSD_SHOW_TEXT:
2602             set_osd_msg(OSD_MSG_TEXT, cmd->args[2].v.i,
2603                         (cmd->args[1].v.i <
2604                          0 ? osd_duration : cmd->args[1].v.i),
2605                         "%-.63s", cmd->args[0].v.s);
2606             break;
2607
2608         case MP_CMD_OSD_SHOW_PROPERTY_TEXT:{
2609                 char *txt = m_properties_expand_string(mp_properties,
2610                                                        cmd->args[0].v.s,
2611                                                        mpctx);
2612                 /* if no argument supplied take default osd_duration, else <arg> ms. */
2613                 if (txt) {
2614                     set_osd_msg(OSD_MSG_TEXT, cmd->args[2].v.i,
2615                                 (cmd->args[1].v.i <
2616                                  0 ? osd_duration : cmd->args[1].v.i),
2617                                 "%-.63s", txt);
2618                     free(txt);
2619                 }
2620             }
2621             break;
2622
2623         case MP_CMD_LOADFILE:{
2624                 play_tree_t *e = play_tree_new();
2625                 play_tree_add_file(e, cmd->args[0].v.s);
2626
2627                 if (cmd->args[1].v.i)   // append
2628                     play_tree_append_entry(mpctx->playtree->child, e);
2629                 else {
2630                     // Go back to the starting point.
2631                     while (play_tree_iter_up_step
2632                            (mpctx->playtree_iter, 0, 1) != PLAY_TREE_ITER_END)
2633                         /* NOP */ ;
2634                     play_tree_free_list(mpctx->playtree->child, 1);
2635                     play_tree_set_child(mpctx->playtree, e);
2636                     pt_iter_goto_head(mpctx->playtree_iter);
2637                     mpctx->eof = PT_NEXT_SRC;
2638                 }
2639                 brk_cmd = 1;
2640             }
2641             break;
2642
2643         case MP_CMD_LOADLIST:{
2644                 play_tree_t *e = parse_playlist_file(cmd->args[0].v.s);
2645                 if (!e)
2646                     mp_msg(MSGT_CPLAYER, MSGL_ERR,
2647                            MSGTR_PlaylistLoadUnable, cmd->args[0].v.s);
2648                 else {
2649                     if (cmd->args[1].v.i)       // append
2650                         play_tree_append_entry(mpctx->playtree->child, e);
2651                     else {
2652                         // Go back to the starting point.
2653                         while (play_tree_iter_up_step
2654                                (mpctx->playtree_iter, 0, 1)
2655                                != PLAY_TREE_ITER_END)
2656                             /* NOP */ ;
2657                         play_tree_free_list(mpctx->playtree->child, 1);
2658                         play_tree_set_child(mpctx->playtree, e);
2659                         pt_iter_goto_head(mpctx->playtree_iter);
2660                         mpctx->eof = PT_NEXT_SRC;
2661                     }
2662                 }
2663                 brk_cmd = 1;
2664             }
2665             break;
2666
2667         case MP_CMD_STOP:
2668             // Go back to the starting point.
2669             while (play_tree_iter_up_step
2670                    (mpctx->playtree_iter, 0, 1) != PLAY_TREE_ITER_END)
2671                 /* NOP */ ;
2672             mpctx->eof = PT_STOP;
2673             brk_cmd = 1;
2674             break;
2675
2676 #ifdef CONFIG_RADIO
2677         case MP_CMD_RADIO_STEP_CHANNEL:
2678             if (mpctx->demuxer->stream->type == STREAMTYPE_RADIO) {
2679                 int v = cmd->args[0].v.i;
2680                 if (v > 0)
2681                     radio_step_channel(mpctx->demuxer->stream,
2682                                        RADIO_CHANNEL_HIGHER);
2683                 else
2684                     radio_step_channel(mpctx->demuxer->stream,
2685                                        RADIO_CHANNEL_LOWER);
2686                 if (radio_get_channel_name(mpctx->demuxer->stream)) {
2687                     set_osd_msg(OSD_MSG_RADIO_CHANNEL, 1, osd_duration,
2688                                 MSGTR_OSDChannel,
2689                                 radio_get_channel_name(mpctx->demuxer->stream));
2690                 }
2691             }
2692             break;
2693
2694         case MP_CMD_RADIO_SET_CHANNEL:
2695             if (mpctx->demuxer->stream->type == STREAMTYPE_RADIO) {
2696                 radio_set_channel(mpctx->demuxer->stream, cmd->args[0].v.s);
2697                 if (radio_get_channel_name(mpctx->demuxer->stream)) {
2698                     set_osd_msg(OSD_MSG_RADIO_CHANNEL, 1, osd_duration,
2699                                 MSGTR_OSDChannel,
2700                                 radio_get_channel_name(mpctx->demuxer->stream));
2701                 }
2702             }
2703             break;
2704
2705         case MP_CMD_RADIO_SET_FREQ:
2706             if (mpctx->demuxer->stream->type == STREAMTYPE_RADIO)
2707                 radio_set_freq(mpctx->demuxer->stream, cmd->args[0].v.f);
2708             break;
2709
2710         case MP_CMD_RADIO_STEP_FREQ:
2711             if (mpctx->demuxer->stream->type == STREAMTYPE_RADIO)
2712                 radio_step_freq(mpctx->demuxer->stream, cmd->args[0].v.f);
2713             break;
2714 #endif
2715
2716 #ifdef CONFIG_TV
2717         case MP_CMD_TV_START_SCAN:
2718             if (mpctx->file_format == DEMUXER_TYPE_TV)
2719                 tv_start_scan((tvi_handle_t *) (mpctx->demuxer->priv),1);
2720             break;
2721         case MP_CMD_TV_SET_FREQ:
2722             if (mpctx->file_format == DEMUXER_TYPE_TV)
2723                 tv_set_freq((tvi_handle_t *) (mpctx->demuxer->priv),
2724                             cmd->args[0].v.f * 16.0);
2725 #ifdef CONFIG_PVR
2726             else if (mpctx->stream && mpctx->stream->type == STREAMTYPE_PVR) {
2727               pvr_set_freq (mpctx->stream, ROUND (cmd->args[0].v.f));
2728               set_osd_msg (OSD_MSG_TV_CHANNEL, 1, osd_duration, "%s: %s",
2729                            pvr_get_current_channelname (mpctx->stream),
2730                            pvr_get_current_stationname (mpctx->stream));
2731             }
2732 #endif /* CONFIG_PVR */
2733             break;
2734
2735         case MP_CMD_TV_STEP_FREQ:
2736             if (mpctx->file_format == DEMUXER_TYPE_TV)
2737                 tv_step_freq((tvi_handle_t *) (mpctx->demuxer->priv),
2738                             cmd->args[0].v.f * 16.0);
2739 #ifdef CONFIG_PVR
2740             else if (mpctx->stream && mpctx->stream->type == STREAMTYPE_PVR) {
2741               pvr_force_freq_step (mpctx->stream, ROUND (cmd->args[0].v.f));
2742               set_osd_msg (OSD_MSG_TV_CHANNEL, 1, osd_duration, "%s: f %d",
2743                            pvr_get_current_channelname (mpctx->stream),
2744                            pvr_get_current_frequency (mpctx->stream));
2745             }
2746 #endif /* CONFIG_PVR */
2747             break;
2748
2749         case MP_CMD_TV_SET_NORM:
2750             if (mpctx->file_format == DEMUXER_TYPE_TV)
2751                 tv_set_norm((tvi_handle_t *) (mpctx->demuxer->priv),
2752                             cmd->args[0].v.s);
2753             break;
2754
2755         case MP_CMD_TV_STEP_CHANNEL:{
2756                 if (mpctx->file_format == DEMUXER_TYPE_TV) {
2757                     int v = cmd->args[0].v.i;
2758                     if (v > 0) {
2759                         tv_step_channel((tvi_handle_t *) (mpctx->
2760                                                           demuxer->priv),
2761                                         TV_CHANNEL_HIGHER);
2762                     } else {
2763                         tv_step_channel((tvi_handle_t *) (mpctx->
2764                                                           demuxer->priv),
2765                                         TV_CHANNEL_LOWER);
2766                     }
2767                     if (tv_channel_list) {
2768                         set_osd_msg(OSD_MSG_TV_CHANNEL, 1, osd_duration,
2769                                     MSGTR_OSDChannel, tv_channel_current->name);
2770                         //vo_osd_changed(OSDTYPE_SUBTITLE);
2771                     }
2772                 }
2773 #ifdef CONFIG_PVR
2774                 else if (mpctx->stream &&
2775                          mpctx->stream->type == STREAMTYPE_PVR) {
2776                   pvr_set_channel_step (mpctx->stream, cmd->args[0].v.i);
2777                   set_osd_msg (OSD_MSG_TV_CHANNEL, 1, osd_duration, "%s: %s",
2778                                pvr_get_current_channelname (mpctx->stream),
2779                                pvr_get_current_stationname (mpctx->stream));
2780                 }
2781 #endif /* CONFIG_PVR */
2782             }
2783 #ifdef CONFIG_DVBIN
2784             if (mpctx->stream->type == STREAMTYPE_DVB) {
2785                     int dir;
2786                     int v = cmd->args[0].v.i;
2787
2788                     mpctx->last_dvb_step = v;
2789                     if (v > 0)
2790                         dir = DVB_CHANNEL_HIGHER;
2791                     else
2792                         dir = DVB_CHANNEL_LOWER;
2793
2794
2795                     if (dvb_step_channel(mpctx->stream, dir))
2796                         mpctx->eof = mpctx->dvbin_reopen = 1;
2797             }
2798 #endif /* CONFIG_DVBIN */
2799             break;
2800
2801         case MP_CMD_TV_SET_CHANNEL:
2802             if (mpctx->file_format == DEMUXER_TYPE_TV) {
2803                 tv_set_channel((tvi_handle_t *) (mpctx->demuxer->priv),
2804                                cmd->args[0].v.s);
2805                 if (tv_channel_list) {
2806                     set_osd_msg(OSD_MSG_TV_CHANNEL, 1, osd_duration,
2807                                 MSGTR_OSDChannel, tv_channel_current->name);
2808                     //vo_osd_changed(OSDTYPE_SUBTITLE);
2809                 }
2810             }
2811 #ifdef CONFIG_PVR
2812             else if (mpctx->stream && mpctx->stream->type == STREAMTYPE_PVR) {
2813               pvr_set_channel (mpctx->stream, cmd->args[0].v.s);
2814               set_osd_msg (OSD_MSG_TV_CHANNEL, 1, osd_duration, "%s: %s",
2815                            pvr_get_current_channelname (mpctx->stream),
2816                            pvr_get_current_stationname (mpctx->stream));
2817      &nb