]> git.sesse.net Git - vlc/blob - modules/access/imem.c
Added an input from memory access.
[vlc] / modules / access / imem.c
1 /*****************************************************************************
2  * imem.c : Memory input for VLC
3  *****************************************************************************
4  * Copyright (C) 2009 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
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 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 General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, 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_demux.h>
37 #include <vlc_charset.h>
38
39 /*****************************************************************************
40  * Module descriptior
41  *****************************************************************************/
42 static int  Open (vlc_object_t *);
43 static void Close(vlc_object_t *);
44
45 #define CACHING_TEXT N_("Caching value in ms")
46 #define CACHING_LONGTEXT N_(\
47     "Caching value for imem streams. This " \
48     "value should be set in milliseconds.")
49
50 #define ID_TEXT N_("ID")
51 #define ID_LONGTEXT N_(\
52     "Set the ID of the elementary stream")
53
54 #define GROUP_TEXT N_("Group")
55 #define GROUP_LONGTEXT N_(\
56     "Set the group of the elementary stream")
57
58 #define CAT_TEXT N_("Category")
59 #define CAT_LONGTEXT N_(\
60     "Set the category of the elementary stream")
61 static const int cat_values[] = {
62     0, 1, 2, 3
63 };
64 static const char *cat_texts[] = {
65     N_("Unknown"), N_("Audio"), N_("Video"), N_("Subtitle")
66 };
67
68 #define CODEC_TEXT N_("Codec")
69 #define CODEC_LONGTEXT N_(\
70     "Set the codec of the elementary stream")
71
72 #define LANGUAGE_TEXT N_("Language")
73 #define LANGUAGE_LONGTEXT N_(\
74     "Language of the elementary stream as described by ISO639")
75
76 #define SAMPLERATE_TEXT N_("Sample rate")
77 #define SAMPLERATE_LONGTEXT N_(\
78     "Sample rate of an audio elementary stream")
79
80 #define CHANNELS_TEXT N_("Channels count")
81 #define CHANNELS_LONGTEXT N_(\
82     "Channels count of an audio elementary stream")
83
84 #define WIDTH_TEXT N_("Width")
85 #define WIDTH_LONGTEXT N_("Width of video or subtitle elementary streams")
86
87 #define HEIGHT_TEXT N_("Height")
88 #define HEIGHT_LONGTEXT N_("Height of video or subtitle elementary streams")
89
90 #define DAR_TEXT N_("Display aspect ratio")
91 #define DAR_LONGTEXT N_(\
92     "Display aspect ratio of a video elementary stream")
93
94 #define FPS_TEXT N_("Frame rate")
95 #define FPS_LONGTEXT N_(\
96     "Frame rate of a video elementary stream")
97
98 #define DATA_TEXT N_("Callback data")
99 #define DATA_LONGTEXT N_(\
100     "Data for the get and release functions")
101
102 #define GET_TEXT N_("Get function")
103 #define GET_LONGTEXT N_(\
104     "Address of the get callback function")
105
106 #define RELEASE_TEXT N_("Release function")
107 #define RELEASE_LONGTEXT N_(\
108     "Address of the release callback function")
109
110 vlc_module_begin()
111     set_shortname(N_("Memory input"))
112     set_description(N_("Memory input"))
113     set_category(CAT_INPUT)
114     set_subcategory(SUBCAT_INPUT_ACCESS)
115
116     add_integer("imem-caching", DEFAULT_PTS_DELAY / 1000, NULL, CACHING_TEXT, CACHING_LONGTEXT, true)
117     add_string ("imem-get", "0", NULL, GET_TEXT, GET_LONGTEXT, true)
118     add_string ("imem-release", "0", NULL, RELEASE_TEXT, RELEASE_LONGTEXT, true)
119     add_string ("imem-data", "0", NULL, DATA_TEXT, DATA_LONGTEXT, true)
120
121     add_integer("imem-id", -1, NULL, ID_TEXT, ID_LONGTEXT, true)
122     add_integer("imem-group", 0, NULL, GROUP_TEXT, GROUP_LONGTEXT, true)
123     add_integer("imem-cat", 0, NULL, CAT_TEXT, CAT_LONGTEXT, true)
124         change_integer_list(cat_values, cat_texts, NULL)
125     add_string ("imem-codec", NULL, NULL, CODEC_TEXT, CODEC_LONGTEXT, true)
126     add_string( "imem-language", NULL, NULL, LANGUAGE_TEXT, LANGUAGE_LONGTEXT, false);
127
128     add_integer("imem-samplerate", 0, NULL, SAMPLERATE_TEXT, SAMPLERATE_LONGTEXT, true)
129     add_integer("imem-channels", 0, NULL, CHANNELS_TEXT, CHANNELS_LONGTEXT, true)
130
131     add_integer("imem-width", 0, NULL, WIDTH_TEXT, WIDTH_LONGTEXT, true)
132     add_integer("imem-height", 0, NULL, HEIGHT_TEXT, HEIGHT_LONGTEXT, true)
133     add_string ("imem-dar", NULL, NULL, DAR_TEXT, DAR_LONGTEXT, true)
134     add_string ("imem-fps", NULL, NULL, FPS_TEXT, FPS_LONGTEXT, true)
135
136     add_shortcut("imem")
137     set_capability("access_demux", 0)
138     set_callbacks(Open, Close)
139 vlc_module_end()
140
141 /*****************************************************************************
142  * Exported API
143  *****************************************************************************/
144
145 /* The clock origin for the DTS and PTS is assumed to be 0.
146  * A negative value means unknown.
147  *
148  * TODO define flags
149  */
150 typedef int  (*imem_get_t)(void *data,
151                            int64_t *dts, int64_t *pts, unsigned *flags,
152                            size_t *, void **);
153 typedef void (*imem_release_t)(void *data, size_t, void *);
154
155 /*****************************************************************************
156  * Local prototypes
157  *****************************************************************************/
158
159 /* */
160 static int Demux(demux_t *);
161 static int Control(demux_t *, int, va_list);
162
163 /* */
164 struct demux_sys_t {
165     struct {
166         imem_get_t      get;
167         imem_release_t  release;
168         void            *data;
169     } source;
170
171     es_out_id_t  *es;
172
173     mtime_t      pts_delay;
174
175     mtime_t      dts;
176
177     mtime_t      deadline;
178 };
179
180 static void ParseMRL(demux_t *);
181 static int var_CreateGetRational(demux_t *,
182                                  unsigned *num, unsigned *den,
183                                  const char *var);
184
185 /**
186  * It opens an imem access_demux
187  */
188 static int Open(vlc_object_t *object)
189 {
190     demux_t     *demux = (demux_t*)object;
191     char *tmp;
192
193         /* */
194     demux_sys_t *sys = calloc(1, sizeof(*sys));
195         if (!sys)
196                 return VLC_ENOMEM;
197
198     /* Read the user functions */
199     tmp = var_CreateGetString(demux, "imem-get");
200     if (tmp)
201         sys->source.get = (imem_get_t)(intptr_t)strtoll(tmp, NULL, 0);
202     free(tmp);
203
204     tmp = var_CreateGetString(demux, "imem-release");
205     if (tmp)
206         sys->source.release = (imem_release_t)(intptr_t)strtoll(tmp, NULL, 0);
207     free(tmp);
208
209     if (!sys->source.get || !sys->source.release) {
210         msg_Err(demux, "Invalid get/release function pointers");
211         free(sys);
212         return VLC_EGENERIC;
213     }
214
215     /* Now we can parse the MRL (get/release must not be parsed to avoid
216      * security risks) */
217     if (*demux->psz_path)
218         ParseMRL(demux);
219
220     tmp = var_CreateGetString(demux, "imem-data");
221     if (tmp)
222         sys->source.data = (void*)(intptr_t)strtoll(tmp, NULL, 0);
223     free(tmp);
224
225     msg_Dbg(demux, "Using get(%p) release(%p) and data(%p)",
226             sys->source.get, sys->source.release, sys->source.data);
227
228         /* ES format */
229     es_format_t fmt;
230         es_format_Init(&fmt, UNKNOWN_ES, 0);
231
232     fmt.i_id = var_CreateGetInteger(demux, "imem-id");
233     fmt.i_group = var_CreateGetInteger(demux, "imem-group");
234
235     tmp = var_CreateGetString(demux, "imem-codec");
236     if (tmp)
237         fmt.i_codec = vlc_fourcc_GetCodecFromString(UNKNOWN_ES, tmp);
238     free(tmp);
239
240     switch (var_CreateGetInteger(demux, "imem-cat")) {
241     case 1: {
242         fmt.i_cat = AUDIO_ES;
243         fmt.audio.i_channels = var_CreateGetInteger(demux, "imem-channels");
244         fmt.audio.i_rate = var_CreateGetInteger(demux, "imem-samplerate");
245
246         msg_Dbg(demux, "Audio %4.4s %d channels %d Hz",
247                 (const char *)&fmt.i_codec,
248                 fmt.audio.i_channels, fmt.audio.i_rate);
249         break;
250     }
251     case 2: {
252         fmt.i_cat = VIDEO_ES;
253         fmt.video.i_width  = var_CreateGetInteger(demux, "imem-width");
254         fmt.video.i_height = var_CreateGetInteger(demux, "imem-height");
255         unsigned num, den;
256         if (!var_CreateGetRational(demux, &num, &den, "imem-dar") && num > 0 && den > 0) {
257             fmt.video.i_aspect = VOUT_ASPECT_FACTOR * num / den;
258             if (fmt.video.i_width > 0 && fmt.video.i_height > 0) {
259                 fmt.video.i_sar_num = num * fmt.video.i_height;
260                 fmt.video.i_sar_den = den * fmt.video.i_width;
261             }
262         }
263         if (!var_CreateGetRational(demux, &num, &den, "imem-fps") && num > 0 && den > 0) {
264             fmt.video.i_frame_rate      = num;
265             fmt.video.i_frame_rate_base = den;
266         }
267
268         msg_Dbg(demux, "Video %4.4s %dx%d  SAR %d:%d frame rate %u/%u",
269                 (const char *)&fmt.i_codec,
270                 fmt.video.i_width, fmt.video.i_height,
271                 fmt.video.i_sar_num, fmt.video.i_sar_den,
272                 fmt.video.i_frame_rate, fmt.video.i_frame_rate_base);
273         break;
274     }
275     case 3: {
276         fmt.i_cat = SPU_ES;
277         fmt.subs.spu.i_original_frame_width =
278             var_CreateGetInteger(demux, "imem-width");
279         fmt.subs.spu.i_original_frame_height =
280             var_CreateGetInteger(demux, "imem-height");
281
282         msg_Dbg(demux, "Subtitle %4.4s",
283                 (const char *)&fmt.i_codec);
284         break;
285     }
286     default:
287         msg_Err(demux, "Invalid ES category");
288         es_format_Clean(&fmt);
289         free(sys);
290         return VLC_EGENERIC;
291     }
292
293     fmt.psz_language = var_CreateGetString(demux, "imem-language");
294
295     /* */
296         sys->es = es_out_Add(demux->out, &fmt);
297     es_format_Clean(&fmt);
298
299     if (!sys->es) {
300         free(sys);
301         return VLC_EGENERIC;
302     }
303
304     /* */
305     sys->pts_delay = var_CreateGetInteger(demux, "imem-caching") * INT64_C(1000);
306     sys->dts       = 0;
307     sys->deadline  = VLC_TS_INVALID;
308
309     /* Set up demux */
310     demux->pf_control = Control;
311     demux->pf_demux   = Demux;
312     demux->p_sys      = sys;
313
314     demux->info.i_update = 0;
315     demux->info.i_title = 0;
316     demux->info.i_seekpoint = 0;
317     return VLC_SUCCESS;
318 }
319
320 /**
321  * It closes an imem access_demux
322  */
323 static void Close(vlc_object_t *object)
324 {
325     demux_t     *demux = (demux_t *)object;
326
327     free(demux->p_sys);
328 }
329
330 /**
331  * It controls imem
332  */
333 static int Control(demux_t *demux, int i_query, va_list args)
334 {
335     demux_sys_t *sys = demux->p_sys;
336
337     switch (i_query)
338     {
339     case DEMUX_CAN_PAUSE:
340     case DEMUX_CAN_CONTROL_PACE: {
341         bool *b = va_arg(args, bool *);
342         *b = true;
343         return VLC_SUCCESS;
344     }
345     case DEMUX_SET_PAUSE_STATE:
346         return VLC_SUCCESS;
347
348     case DEMUX_GET_PTS_DELAY: {
349         int64_t *delay = va_arg(args, int64_t *);
350         *delay = sys->pts_delay;
351         return VLC_SUCCESS;
352     }
353     case DEMUX_GET_POSITION: {
354         double *position = va_arg(args, double *);
355         *position = 0.0;
356         return VLC_SUCCESS;
357     }
358     case DEMUX_GET_TIME: {
359         int64_t *t = va_arg(args, int64_t *);
360         *t = sys->dts;
361         return VLC_SUCCESS;
362     }
363     case DEMUX_GET_LENGTH: {
364         int64_t *l = va_arg(args, int64_t *);
365         *l = 0;
366         return VLC_SUCCESS;
367     }
368     case DEMUX_SET_NEXT_DEMUX_TIME:
369         sys->deadline = va_arg(args, int64_t);
370         return VLC_SUCCESS;
371
372     /* */
373     case DEMUX_CAN_SEEK:
374     case DEMUX_SET_POSITION:
375     case DEMUX_SET_TIME:
376     default:
377         return VLC_EGENERIC;
378     }
379
380     return VLC_EGENERIC;
381 }
382
383 /**
384  * It retreives data using the get() callback, sends them to es_out
385  * and the release it using the release() callback.
386  */
387 static int Demux(demux_t *demux)
388 {
389     demux_sys_t *sys = demux->p_sys;
390
391     if (sys->deadline == VLC_TS_INVALID)
392         sys->deadline = sys->dts + 1;
393
394     for (;;) {
395         if (sys->deadline <= sys->dts)
396             break;
397
398         /* */
399         int64_t dts, pts;
400         unsigned flags;
401         size_t buffer_size;
402         void   *buffer;
403
404         if (sys->source.get(sys->source.data, &dts, &pts, &flags, &buffer_size, &buffer))
405             return 0;
406
407         if (dts < 0)
408             dts = pts;
409
410         if (buffer_size > 0) {
411             block_t *block = block_New(demux, buffer_size);
412             if (block) {
413                 block->i_dts = dts >= 0 ? (1 + dts) : VLC_TS_INVALID;
414                 block->i_pts = pts >= 0 ? (1 + pts) : VLC_TS_INVALID;
415                 memcpy(block->p_buffer, buffer, buffer_size);
416
417                 es_out_Control(demux->out, ES_OUT_SET_PCR, block->i_dts);
418                 es_out_Send(demux->out, sys->es, block);
419             }
420         }
421
422         sys->dts = dts;
423
424         sys->source.release(sys->source.data, buffer_size, buffer);
425     }
426     sys->deadline = VLC_TS_INVALID;
427     return 1;
428 }
429
430 /**
431  * It parses a rational number (it also accepts basic float number).
432  *
433  * It returns an error if the rational number cannot be parsed (0/0 is valid).
434  */
435 static int var_CreateGetRational(demux_t *demux,
436                                  unsigned *num, unsigned *den,
437                                  const char *var)
438 {
439     /* */
440     *num = 0;
441     *den = 0;
442
443     /* */
444     char *tmp = var_CreateGetString(demux, var);
445     if (!tmp)
446         goto error;
447
448     char *next;
449     unsigned n = strtol(tmp,  &next, 0);
450     unsigned d = strtol(*next ? &next[1] : "0", NULL, 0);
451
452     if (*next == '.') {
453         /* Interpret as a float number */
454         double r = us_atof(tmp);
455         double c = ceil(r);
456         if (c >= UINT_MAX)
457             goto error;
458         unsigned m = c;
459         if (m > 0) {
460             d = UINT_MAX / m;
461             n = r * d;
462         } else {
463             n = 0;
464             d = 0;
465         }
466     }
467
468     if (n > 0 && d > 0)
469         vlc_ureduce(num, den, n, d, 0);
470
471     free(tmp);
472     return VLC_SUCCESS;
473
474 error:
475     free(tmp);
476     return VLC_EGENERIC;
477 }
478
479 /**
480  * Parse the MRL and extract configuration from it.
481  *
482  * Syntax: option1=value1[:option2=value2[...]]
483  *
484  * XXX get and release are not supported on purpose.
485  */
486 static void ParseMRL(demux_t *demux)
487 {
488     static const struct {
489         const char *name;
490         int        type;
491     } options[] = {
492         { "caching",    VLC_VAR_INTEGER },
493         { "id",         VLC_VAR_INTEGER },
494         { "group",      VLC_VAR_INTEGER },
495         { "cat",        VLC_VAR_INTEGER },
496         { "samplerate", VLC_VAR_INTEGER },
497         { "channels",   VLC_VAR_INTEGER },
498         { "width",      VLC_VAR_INTEGER },
499         { "height",     VLC_VAR_INTEGER },
500         { "data",       VLC_VAR_STRING },
501         { "codec",      VLC_VAR_STRING },
502         { "language",   VLC_VAR_STRING },
503         { "dar",        VLC_VAR_STRING },
504         { "fps",        VLC_VAR_STRING },
505         { NULL, -1 }
506     };
507
508     char *dup = strdup(demux->psz_path);
509     if (!dup)
510         return;
511     char *current = dup;
512
513     while (current) {
514         char *next = strchr(current, ':');
515         if (next)
516             *next++ = '\0';
517
518         char *option = current;
519         char *value = strchr(current, '=');
520         if (value) {
521             *value++ = '\0';
522             msg_Dbg(demux, "option '%s' value '%s'", option, value);
523         } else {
524             msg_Dbg(demux, "option '%s' without value (unsupported)", option);
525         }
526
527         char *name;
528         if (asprintf(&name, "imem-%s", option) < 0)
529             name = NULL;
530         for (unsigned i = 0; name && options[i].name; i++) {
531             if (strcmp(options[i].name, option))
532                 continue;
533             /* */
534             var_Create(demux, name, options[i].type | VLC_VAR_DOINHERIT);
535             if (options[i].type == VLC_VAR_INTEGER && value) {
536                 var_SetInteger(demux, name, strtol(value, NULL, 0));
537             } else if (options[i].type == VLC_VAR_STRING && value) {
538                 var_SetString(demux, name, value);
539             }
540             break;
541         }
542         free(name);
543
544         /* */
545         current = next;
546     }
547     free(dup);
548 }