vlc_list: prevent name conflict
[vlc.git] / modules / access / imem.c
1 /*****************************************************************************
2  * imem.c : Memory input for VLC
3  *****************************************************************************
4  * Copyright (C) 2009-2010 Laurent Aimar
5  * $Id$
6  *
7  * Author: Laurent Aimar <fenrir _AT_ videolan _DOT org>
8  *
9  * This program is free software; you can redistribute it and/or modify it
10  * under the terms of the GNU Lesser General Public License as published by
11  * the Free Software Foundation; either version 2.1 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27
28 #ifdef HAVE_CONFIG_H
29 # include "config.h"
30 #endif
31 #include <limits.h>
32 #include <math.h>
33
34 #include <vlc_common.h>
35 #include <vlc_plugin.h>
36 #include <vlc_access.h>
37 #include <vlc_demux.h>
38 #include <vlc_charset.h>
39
40 /*****************************************************************************
41  * Module descriptior
42  *****************************************************************************/
43 static int  OpenAccess (vlc_object_t *);
44 static void CloseAccess(vlc_object_t *);
45
46 static int  OpenDemux (vlc_object_t *);
47 static void CloseDemux(vlc_object_t *);
48
49 #define ID_TEXT N_("ID")
50 #define ID_LONGTEXT N_(\
51     "Set the ID of the elementary stream")
52
53 #define GROUP_TEXT N_("Group")
54 #define GROUP_LONGTEXT N_(\
55     "Set the group of the elementary stream")
56
57 #define CAT_TEXT N_("Category")
58 #define CAT_LONGTEXT N_(\
59     "Set the category of the elementary stream")
60 static const int cat_values[] = {
61     0, 1, 2, 3, 4,
62 };
63 static const char *cat_texts[] = {
64     N_("Unknown"), N_("Audio"), N_("Video"), N_("Subtitle"), N_("Data")
65 };
66
67 #define CODEC_TEXT N_("Codec")
68 #define CODEC_LONGTEXT N_(\
69     "Set the codec of the elementary stream")
70
71 #define LANGUAGE_TEXT N_("Language")
72 #define LANGUAGE_LONGTEXT N_(\
73     "Language of the elementary stream as described by ISO639")
74
75 #define SAMPLERATE_TEXT N_("Sample rate")
76 #define SAMPLERATE_LONGTEXT N_(\
77     "Sample rate of an audio elementary stream")
78
79 #define CHANNELS_TEXT N_("Channels count")
80 #define CHANNELS_LONGTEXT N_(\
81     "Channels count of an audio elementary stream")
82
83 #define WIDTH_TEXT N_("Width")
84 #define WIDTH_LONGTEXT N_("Width of video or subtitle elementary streams")
85
86 #define HEIGHT_TEXT N_("Height")
87 #define HEIGHT_LONGTEXT N_("Height of video or subtitle elementary streams")
88
89 #define DAR_TEXT N_("Display aspect ratio")
90 #define DAR_LONGTEXT N_(\
91     "Display aspect ratio of a video elementary stream")
92
93 #define FPS_TEXT N_("Frame rate")
94 #define FPS_LONGTEXT N_(\
95     "Frame rate of a video elementary stream")
96
97 #define COOKIE_TEXT N_("Callback cookie string")
98 #define COOKIE_LONGTEXT N_(\
99     "Text identifier for the callback functions")
100
101 #define DATA_TEXT N_("Callback data")
102 #define DATA_LONGTEXT N_(\
103     "Data for the get and release functions")
104
105 #define GET_TEXT N_("Get function")
106 #define GET_LONGTEXT N_(\
107     "Address of the get callback function")
108
109 #define RELEASE_TEXT N_("Release function")
110 #define RELEASE_LONGTEXT N_(\
111     "Address of the release callback function")
112
113 #define SIZE_TEXT N_("Size")
114 #define SIZE_LONGTEXT N_(\
115     "Size of stream in bytes")
116
117 vlc_module_begin()
118     set_shortname(N_("Memory input"))
119     set_description(N_("Memory input"))
120     set_category(CAT_INPUT)
121     set_subcategory(SUBCAT_INPUT_ACCESS)
122
123     add_string ("imem-get", "0", GET_TEXT, GET_LONGTEXT, true)
124         change_volatile()
125     add_string ("imem-release", "0", RELEASE_TEXT, RELEASE_LONGTEXT, true)
126         change_volatile()
127     add_string ("imem-cookie", NULL, COOKIE_TEXT, COOKIE_LONGTEXT, true)
128         change_volatile()
129         change_safe()
130     add_string ("imem-data", "0", DATA_TEXT, DATA_LONGTEXT, true)
131         change_volatile()
132
133     add_integer("imem-id", -1, ID_TEXT, ID_LONGTEXT, true)
134         change_private()
135         change_safe()
136     add_integer("imem-group", 0, GROUP_TEXT, GROUP_LONGTEXT, true)
137         change_private()
138         change_safe()
139     add_integer("imem-cat", 0, CAT_TEXT, CAT_LONGTEXT, true)
140         change_integer_list(cat_values, cat_texts)
141         change_private()
142         change_safe()
143     add_string ("imem-codec", NULL, CODEC_TEXT, CODEC_LONGTEXT, true)
144         change_private()
145         change_safe()
146     add_string( "imem-language", NULL, LANGUAGE_TEXT, LANGUAGE_LONGTEXT, false)
147         change_private()
148         change_safe()
149
150     add_integer("imem-samplerate", 0, SAMPLERATE_TEXT, SAMPLERATE_LONGTEXT, true)
151         change_private()
152         change_safe()
153     add_integer("imem-channels", 0, CHANNELS_TEXT, CHANNELS_LONGTEXT, true)
154         change_private()
155         change_safe()
156
157     add_integer("imem-width", 0, WIDTH_TEXT, WIDTH_LONGTEXT, true)
158         change_private()
159         change_safe()
160     add_integer("imem-height", 0, HEIGHT_TEXT, HEIGHT_LONGTEXT, true)
161         change_private()
162         change_safe()
163     add_string ("imem-dar", NULL, DAR_TEXT, DAR_LONGTEXT, true)
164         change_private()
165         change_safe()
166     add_string ("imem-fps", NULL, FPS_TEXT, FPS_LONGTEXT, true)
167         change_private()
168         change_safe()
169
170     add_integer ("imem-size", 0, SIZE_TEXT, SIZE_LONGTEXT, true)
171         change_private()
172         change_safe()
173
174     add_shortcut("imem")
175     set_capability("access", 1)
176     set_callbacks(OpenDemux, CloseDemux)
177
178     add_submodule()
179         add_shortcut("imem")
180         set_capability("access", 0)
181         set_callbacks(OpenAccess, CloseAccess)
182 vlc_module_end()
183
184 /*****************************************************************************
185  * Exported API
186  *****************************************************************************/
187
188 /* The clock origin for the DTS and PTS is assumed to be 0.
189  * A negative value means unknown.
190  *
191  * TODO define flags
192  */
193 typedef int  (*imem_get_t)(void *data, const char *cookie,
194                            int64_t *dts, int64_t *pts, unsigned *flags,
195                            size_t *, void **);
196 typedef void (*imem_release_t)(void *data, const char *cookie, size_t, void *);
197
198 /*****************************************************************************
199  * Local prototypes
200  *****************************************************************************/
201
202 /* */
203 static block_t *Block(stream_t *, bool *);
204 static int ControlAccess(stream_t *, int, va_list);
205
206 static int Demux(demux_t *);
207 static int ControlDemux(demux_t *, int, va_list);
208
209 /* */
210 typedef struct {
211     struct {
212         imem_get_t      get;
213         imem_release_t  release;
214         void           *data;
215         char           *cookie;
216     } source;
217
218     es_out_id_t  *es;
219
220     vlc_tick_t   dts;
221
222     vlc_tick_t   deadline;
223 } imem_sys_t;
224
225 static void ParseMRL(vlc_object_t *, const char *);
226
227 /**
228  * It closes the common part of the access and access_demux
229  */
230 static void CloseCommon(imem_sys_t *sys)
231 {
232     free(sys->source.cookie);
233 }
234
235 /**
236  * It initializes the common part for imem access/access_demux.
237  */
238 static int OpenCommon(vlc_object_t *object, imem_sys_t **sys_ptr, const char *psz_path)
239 {
240     char *tmp;
241
242     /* */
243     imem_sys_t *sys = vlc_obj_calloc(object, 1, sizeof(*sys));
244     if (!sys)
245         return VLC_ENOMEM;
246
247     /* Read the user functions */
248     tmp = var_InheritString(object, "imem-get");
249     if (tmp)
250         sys->source.get = (imem_get_t)(intptr_t)strtoll(tmp, NULL, 0);
251     free(tmp);
252
253     tmp = var_InheritString(object, "imem-release");
254     if (tmp)
255         sys->source.release = (imem_release_t)(intptr_t)strtoll(tmp, NULL, 0);
256     free(tmp);
257
258     if (!sys->source.get || !sys->source.release) {
259         msg_Err(object, "Invalid get/release function pointers");
260         return VLC_EGENERIC;
261     }
262
263     tmp = var_InheritString(object, "imem-data");
264     if (tmp)
265         sys->source.data = (void *)(uintptr_t)strtoull(tmp, NULL, 0);
266     free(tmp);
267
268     /* Now we can parse the MRL (get/release must not be parsed to avoid
269      * security risks) */
270     if (*psz_path)
271         ParseMRL(object, psz_path);
272
273     sys->source.cookie = var_InheritString(object, "imem-cookie");
274
275     msg_Dbg(object, "Using get(%p), release(%p), data(%p), cookie(%s)",
276             (void *)sys->source.get, (void *)sys->source.release,
277             sys->source.data,
278             sys->source.cookie ? sys->source.cookie : "(null)");
279
280     /* */
281     sys->dts       = 0;
282     sys->deadline  = VLC_TS_INVALID;
283
284     *sys_ptr = sys;
285     return VLC_SUCCESS;
286 }
287
288 /**
289  * It opens an imem access.
290  */
291 static int OpenAccess(vlc_object_t *object)
292 {
293     stream_t   *access = (stream_t *)object;
294     imem_sys_t *sys;
295
296     if (OpenCommon(object, &sys, access->psz_location))
297         return VLC_EGENERIC;
298
299     if (var_InheritInteger(object, "imem-cat") != 4) {
300         CloseCommon(sys);
301         return VLC_EGENERIC;
302     }
303
304     /* */
305     access->pf_control = ControlAccess;
306     access->pf_read    = NULL;
307     access->pf_block   = Block;
308     access->pf_seek    = NULL;
309     access->p_sys      = sys;
310
311     return VLC_SUCCESS;
312 }
313
314 /**
315  * It closes an imem access
316  */
317 static void CloseAccess(vlc_object_t *object)
318 {
319     stream_t *access = (stream_t *)object;
320
321     CloseCommon((imem_sys_t*)access->p_sys);
322 }
323
324 /**
325  * It controls an imem access
326  */
327 static int ControlAccess(stream_t *access, int i_query, va_list args)
328 {
329     (void) access;
330     switch (i_query)
331     {
332     case STREAM_CAN_SEEK:
333     case STREAM_CAN_FASTSEEK: {
334         bool *b = va_arg( args, bool* );
335         *b = false;
336         return VLC_SUCCESS;
337     }
338     case STREAM_CAN_PAUSE:
339     case STREAM_CAN_CONTROL_PACE: {
340         bool *b = va_arg( args, bool* );
341         *b = true;
342         return VLC_SUCCESS;
343     }
344     case STREAM_GET_SIZE: {
345         uint64_t *s = va_arg(args, uint64_t *);
346         *s = var_InheritInteger(access, "imem-size");
347         return *s ? VLC_SUCCESS : VLC_EGENERIC;
348     }
349     case STREAM_GET_PTS_DELAY: {
350         int64_t *delay = va_arg(args, int64_t *);
351         *delay = DEFAULT_PTS_DELAY; /* FIXME? */
352         return VLC_SUCCESS;
353     }
354     case STREAM_SET_PAUSE_STATE:
355         return VLC_SUCCESS;
356
357     default:
358         return VLC_EGENERIC;
359     }
360 }
361
362 /**
363  * It retreives data using the get() callback, copies them,
364  * and then release them using the release() callback.
365  */
366 static block_t *Block(stream_t *access, bool *restrict eof)
367 {
368     imem_sys_t *sys = (imem_sys_t*)access->p_sys;
369
370     unsigned flags;
371     size_t buffer_size;
372     void   *buffer;
373
374     if (sys->source.get(sys->source.data, sys->source.cookie,
375                         NULL, NULL, &flags, &buffer_size, &buffer)) {
376         *eof = true;
377         return NULL;
378     }
379
380     block_t *block = NULL;
381     if (buffer_size > 0) {
382         block = block_Alloc(buffer_size);
383         if (block)
384             memcpy(block->p_buffer, buffer, buffer_size);
385     }
386
387     sys->source.release(sys->source.data, sys->source.cookie,
388                         buffer_size, buffer);
389     return block;
390 }
391
392 static inline int GetCategory(vlc_object_t *object)
393 {
394     const int cat = var_InheritInteger(object, "imem-cat");
395     switch (cat)
396     {
397     case 1:
398         return AUDIO_ES;
399     case 2:
400         return VIDEO_ES;
401     case 3:
402         return SPU_ES;
403     default:
404         msg_Err(object, "Invalid ES category");
405         /* fall through */
406     case 4:
407         return UNKNOWN_ES;
408     }
409 }
410
411 /**
412  * It opens an imem access_demux.
413  */
414 static int OpenDemux(vlc_object_t *object)
415 {
416     demux_t    *demux = (demux_t *)object;
417     imem_sys_t *sys;
418
419     if (demux->out == NULL)
420         return VLC_EGENERIC;
421
422     if (OpenCommon(object, &sys, demux->psz_location))
423         return VLC_EGENERIC;
424
425     /* ES format */
426     es_format_t fmt;
427     es_format_Init(&fmt, GetCategory(object), 0);
428
429     fmt.i_id = var_InheritInteger(object, "imem-id");
430     fmt.i_group = var_InheritInteger(object, "imem-group");
431
432     char *tmp = var_InheritString(object, "imem-codec");
433     if (tmp)
434         fmt.i_codec = vlc_fourcc_GetCodecFromString(fmt.i_cat, tmp);
435     free(tmp);
436
437     switch (fmt.i_cat) {
438     case AUDIO_ES: {
439         fmt.audio.i_channels = var_InheritInteger(object, "imem-channels");
440         fmt.audio.i_rate = var_InheritInteger(object, "imem-samplerate");
441
442         msg_Dbg(object, "Audio %4.4s %d channels %d Hz",
443                 (const char *)&fmt.i_codec,
444                 fmt.audio.i_channels, fmt.audio.i_rate);
445         break;
446     }
447     case VIDEO_ES: {
448         fmt.video.i_width  = var_InheritInteger(object, "imem-width");
449         fmt.video.i_height = var_InheritInteger(object, "imem-height");
450         unsigned num, den;
451         if (!var_InheritURational(object, &num, &den, "imem-dar") && num > 0 && den > 0) {
452             if (fmt.video.i_width != 0 && fmt.video.i_height != 0) {
453                 fmt.video.i_sar_num = num * fmt.video.i_height;
454                 fmt.video.i_sar_den = den * fmt.video.i_width;
455             }
456         }
457         if (!var_InheritURational(object, &num, &den, "imem-fps") && num > 0 && den > 0) {
458             fmt.video.i_frame_rate      = num;
459             fmt.video.i_frame_rate_base = den;
460         }
461
462         msg_Dbg(object, "Video %4.4s %dx%d  SAR %d:%d frame rate %u/%u",
463                 (const char *)&fmt.i_codec,
464                 fmt.video.i_width, fmt.video.i_height,
465                 fmt.video.i_sar_num, fmt.video.i_sar_den,
466                 fmt.video.i_frame_rate, fmt.video.i_frame_rate_base);
467         break;
468     }
469     case SPU_ES: {
470         fmt.subs.spu.i_original_frame_width =
471             var_InheritInteger(object, "imem-width");
472         fmt.subs.spu.i_original_frame_height =
473             var_InheritInteger(object, "imem-height");
474
475         msg_Dbg(object, "Subtitle %4.4s",
476                 (const char *)&fmt.i_codec);
477         break;
478     }
479     default:
480         es_format_Clean(&fmt);
481         CloseCommon(sys);
482         return VLC_EGENERIC;
483     }
484
485     fmt.psz_language = var_InheritString(object, "imem-language");
486
487     sys->es = es_out_Add(demux->out, &fmt);
488     es_format_Clean(&fmt);
489
490     if (!sys->es) {
491         CloseCommon(sys);
492         return VLC_EGENERIC;
493     }
494
495     /* */
496     demux->pf_control = ControlDemux;
497     demux->pf_demux   = Demux;
498     demux->p_sys      = sys;
499
500     return VLC_SUCCESS;
501 }
502
503 /**
504  * It closes an imem access_demux
505  */
506 static void CloseDemux(vlc_object_t *object)
507 {
508     demux_t *demux = (demux_t *)object;
509
510     CloseCommon((imem_sys_t*)demux->p_sys);
511 }
512
513 /**
514  * It controls an imem access_demux
515  */
516 static int ControlDemux(demux_t *demux, int i_query, va_list args)
517 {
518     imem_sys_t *sys = (imem_sys_t*)demux->p_sys;
519
520     switch (i_query)
521     {
522     case DEMUX_CAN_PAUSE:
523     case DEMUX_CAN_CONTROL_PACE: {
524         bool *b = va_arg(args, bool *);
525         *b = true;
526         return VLC_SUCCESS;
527     }
528     case DEMUX_SET_PAUSE_STATE:
529         return VLC_SUCCESS;
530
531     case DEMUX_GET_PTS_DELAY: {
532         int64_t *delay = va_arg(args, int64_t *);
533         *delay = DEFAULT_PTS_DELAY; /* FIXME? */
534         return VLC_SUCCESS;
535     }
536     case DEMUX_GET_POSITION: {
537         double *position = va_arg(args, double *);
538         *position = 0.0;
539         return VLC_SUCCESS;
540     }
541     case DEMUX_GET_TIME: {
542         int64_t *t = va_arg(args, int64_t *);
543         *t = sys->dts;
544         return VLC_SUCCESS;
545     }
546     case DEMUX_GET_LENGTH: {
547         int64_t *l = va_arg(args, int64_t *);
548         *l = 0;
549         return VLC_SUCCESS;
550     }
551     case DEMUX_SET_NEXT_DEMUX_TIME:
552         sys->deadline = va_arg(args, vlc_tick_t);
553         return VLC_SUCCESS;
554
555     /* */
556     case DEMUX_CAN_SEEK:
557     case DEMUX_SET_POSITION:
558     case DEMUX_SET_TIME:
559     default:
560         return VLC_EGENERIC;
561     }
562
563     return VLC_EGENERIC;
564 }
565
566 /**
567  * It retreives data using the get() callback, sends them to es_out
568  * and the release it using the release() callback.
569  */
570 static int Demux(demux_t *demux)
571 {
572     imem_sys_t *sys = (imem_sys_t*)demux->p_sys;
573
574     if (sys->deadline == VLC_TS_INVALID)
575         sys->deadline = sys->dts + 1;
576
577     for (;;) {
578         if (sys->deadline <= sys->dts)
579             break;
580
581         /* */
582         int64_t dts, pts;
583         unsigned flags;
584         size_t buffer_size;
585         void   *buffer;
586
587         if (sys->source.get(sys->source.data, sys->source.cookie,
588                             &dts, &pts, &flags, &buffer_size, &buffer))
589             return 0;
590
591         if (dts < 0)
592             dts = pts;
593
594         if (buffer_size > 0) {
595             block_t *block = block_Alloc(buffer_size);
596             if (block) {
597                 block->i_dts = dts >= 0 ? (1 + dts) : VLC_TS_INVALID;
598                 block->i_pts = pts >= 0 ? (1 + pts) : VLC_TS_INVALID;
599                 memcpy(block->p_buffer, buffer, buffer_size);
600
601                 es_out_SetPCR(demux->out, block->i_dts);
602                 es_out_Send(demux->out, sys->es, block);
603             }
604         }
605
606         sys->dts = dts;
607
608         sys->source.release(sys->source.data, sys->source.cookie,
609                             buffer_size, buffer);
610     }
611     sys->deadline = VLC_TS_INVALID;
612     return 1;
613 }
614
615 /**
616  * Parse the MRL and extract configuration from it.
617  *
618  * Syntax: option1=value1[:option2=value2[...]]
619  *
620  * XXX get and release are not supported on purpose.
621  */
622 static void ParseMRL(vlc_object_t *object, const char *psz_path)
623 {
624     static const struct {
625         const char *name;
626         int        type;
627     } options[] = {
628         { "id",         VLC_VAR_INTEGER },
629         { "group",      VLC_VAR_INTEGER },
630         { "cat",        VLC_VAR_INTEGER },
631         { "samplerate", VLC_VAR_INTEGER },
632         { "channels",   VLC_VAR_INTEGER },
633         { "width",      VLC_VAR_INTEGER },
634         { "height",     VLC_VAR_INTEGER },
635         { "cookie",     VLC_VAR_STRING },
636         { "codec",      VLC_VAR_STRING },
637         { "language",   VLC_VAR_STRING },
638         { "dar",        VLC_VAR_STRING },
639         { "fps",        VLC_VAR_STRING },
640         { NULL, -1 }
641     };
642
643     char *dup = strdup(psz_path);
644     if (!dup)
645         return;
646     char *current = dup;
647
648     while (current) {
649         char *next = strchr(current, ':');
650         if (next)
651             *next++ = '\0';
652
653         char *option = current;
654         char *value = strchr(current, '=');
655         if (value) {
656             *value++ = '\0';
657             msg_Dbg(object, "option '%s' value '%s'", option, value);
658         } else {
659             msg_Dbg(object, "option '%s' without value (unsupported)", option);
660         }
661
662         char *name;
663         if (asprintf(&name, "imem-%s", option) < 0)
664             name = NULL;
665         for (unsigned i = 0; name && options[i].name; i++) {
666             if (strcmp(options[i].name, option))
667                 continue;
668             /* */
669             var_Create(object, name, options[i].type | VLC_VAR_DOINHERIT);
670             if (options[i].type == VLC_VAR_INTEGER && value) {
671                 var_SetInteger(object, name, strtol(value, NULL, 0));
672             } else if (options[i].type == VLC_VAR_STRING && value) {
673                 var_SetString(object, name, value);
674             }
675             break;
676         }
677         free(name);
678
679         /* */
680         current = next;
681     }
682     free(dup);
683 }