URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [video/] [videocodec.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/*
 * VIDEO MOTION CODECs internal API for video devices
 *
 * Interface for MJPEG (and maybe later MPEG/WAVELETS) codec's
 * bound to a master device.
 *
 * (c) 2002 Wolfgang Scherr <scherr@net4you.at>
 *
 * $Id: videocodec.c,v 1.1.2.8 2003/03/29 07:16:04 rbultje Exp $
 *
 * ------------------------------------------------------------------------
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * ------------------------------------------------------------------------
 */
 
#define VIDEOCODEC_VERSION "v0.2"
 
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/slab.h>
 
// kernel config is here (procfs flag)
 
#ifdef CONFIG_PROC_FS
#include <linux/proc_fs.h>
#include <asm/uaccess.h>
#endif
 
#include "videocodec.h"
 
static int debug = 0;
module_param(debug, int, 0);
MODULE_PARM_DESC(debug, "Debug level (0-4)");
 
#define dprintk(num, format, args...) \
        do { \
                if (debug >= num) \
                        printk(format, ##args); \
        } while (0)
 
struct attached_list {
        struct videocodec *codec;
        struct attached_list *next;
};
 
struct codec_list {
        const struct videocodec *codec;
        int attached;
        struct attached_list *list;
        struct codec_list *next;
};
 
static struct codec_list *codeclist_top = NULL;
 
/* ================================================= */
/* function prototypes of the master/slave interface */
/* ================================================= */
 
struct videocodec *
videocodec_attach (struct videocodec_master *master)
{
        struct codec_list *h = codeclist_top;
        struct attached_list *a, *ptr;
        struct videocodec *codec;
        int res;
 
        if (!master) {
                dprintk(1, KERN_ERR "videocodec_attach: no data\n");
                return NULL;
        }
 
        dprintk(2,
                "videocodec_attach: '%s', flags %lx, magic %lx\n",
                master->name, master->flags, master->magic);
 
        if (!h) {
                dprintk(1,
                        KERN_ERR
                        "videocodec_attach: no device available\n");
                return NULL;
        }
 
        while (h) {
                // attach only if the slave has at least the flags
                // expected by the master
                if ((master->flags & h->codec->flags) == master->flags) {
                        dprintk(4, "videocodec_attach: try '%s'\n",
                                h->codec->name);
 
                        if (!try_module_get(h->codec->owner))
                                return NULL;
 
                        codec =
                            kmalloc(sizeof(struct videocodec), GFP_KERNEL);
                        if (!codec) {
                                dprintk(1,
                                        KERN_ERR
                                        "videocodec_attach: no mem\n");
                                goto out_module_put;
                        }
                        memcpy(codec, h->codec, sizeof(struct videocodec));
 
                        snprintf(codec->name, sizeof(codec->name),
                                 "%s[%d]", codec->name, h->attached);
                        codec->master_data = master;
                        res = codec->setup(codec);
                        if (res == 0) {
                                dprintk(3, "videocodec_attach '%s'\n",
                                        codec->name);
                                ptr = kzalloc(sizeof(struct attached_list), GFP_KERNEL);
                                if (!ptr) {
                                        dprintk(1,
                                                KERN_ERR
                                                "videocodec_attach: no memory\n");
                                        goto out_kfree;
                                }
                                ptr->codec = codec;
 
                                a = h->list;
                                if (!a) {
                                        h->list = ptr;
                                        dprintk(4,
                                                "videocodec: first element\n");
                                } else {
                                        while (a->next)
                                                a = a->next;    // find end
                                        a->next = ptr;
                                        dprintk(4,
                                                "videocodec: in after '%s'\n",
                                                h->codec->name);
                                }
 
                                h->attached += 1;
                                return codec;
                        } else {
                                kfree(codec);
                        }
                }
                h = h->next;
        }
 
        dprintk(1, KERN_ERR "videocodec_attach: no codec found!\n");
        return NULL;
 
 out_module_put:
        module_put(h->codec->owner);
 out_kfree:
        kfree(codec);
        return NULL;
}
 
int
videocodec_detach (struct videocodec *codec)
{
        struct codec_list *h = codeclist_top;
        struct attached_list *a, *prev;
        int res;
 
        if (!codec) {
                dprintk(1, KERN_ERR "videocodec_detach: no data\n");
                return -EINVAL;
        }
 
        dprintk(2,
                "videocodec_detach: '%s', type: %x, flags %lx, magic %lx\n",
                codec->name, codec->type, codec->flags, codec->magic);
 
        if (!h) {
                dprintk(1,
                        KERN_ERR "videocodec_detach: no device left...\n");
                return -ENXIO;
        }
 
        while (h) {
                a = h->list;
                prev = NULL;
                while (a) {
                        if (codec == a->codec) {
                                res = a->codec->unset(a->codec);
                                if (res >= 0) {
                                        dprintk(3,
                                                "videocodec_detach: '%s'\n",
                                                a->codec->name);
                                        a->codec->master_data = NULL;
                                } else {
                                        dprintk(1,
                                                KERN_ERR
                                                "videocodec_detach: '%s'\n",
                                                a->codec->name);
                                        a->codec->master_data = NULL;
                                }
                                if (prev == NULL) {
                                        h->list = a->next;
                                        dprintk(4,
                                                "videocodec: delete first\n");
                                } else {
                                        prev->next = a->next;
                                        dprintk(4,
                                                "videocodec: delete middle\n");
                                }
                                module_put(a->codec->owner);
                                kfree(a->codec);
                                kfree(a);
                                h->attached -= 1;
                                return 0;
                        }
                        prev = a;
                        a = a->next;
                }
                h = h->next;
        }
 
        dprintk(1, KERN_ERR "videocodec_detach: given codec not found!\n");
        return -EINVAL;
}
 
int
videocodec_register (const struct videocodec *codec)
{
        struct codec_list *ptr, *h = codeclist_top;
 
        if (!codec) {
                dprintk(1, KERN_ERR "videocodec_register: no data!\n");
                return -EINVAL;
        }
 
        dprintk(2,
                "videocodec: register '%s', type: %x, flags %lx, magic %lx\n",
                codec->name, codec->type, codec->flags, codec->magic);
 
        ptr = kzalloc(sizeof(struct codec_list), GFP_KERNEL);
        if (!ptr) {
                dprintk(1, KERN_ERR "videocodec_register: no memory\n");
                return -ENOMEM;
        }
        ptr->codec = codec;
 
        if (!h) {
                codeclist_top = ptr;
                dprintk(4, "videocodec: hooked in as first element\n");
        } else {
                while (h->next)
                        h = h->next;    // find the end
                h->next = ptr;
                dprintk(4, "videocodec: hooked in after '%s'\n",
                        h->codec->name);
        }
 
        return 0;
}
 
int
videocodec_unregister (const struct videocodec *codec)
{
        struct codec_list *prev = NULL, *h = codeclist_top;
 
        if (!codec) {
                dprintk(1, KERN_ERR "videocodec_unregister: no data!\n");
                return -EINVAL;
        }
 
        dprintk(2,
                "videocodec: unregister '%s', type: %x, flags %lx, magic %lx\n",
                codec->name, codec->type, codec->flags, codec->magic);
 
        if (!h) {
                dprintk(1,
                        KERN_ERR
                        "videocodec_unregister: no device left...\n");
                return -ENXIO;
        }
 
        while (h) {
                if (codec == h->codec) {
                        if (h->attached) {
                                dprintk(1,
                                        KERN_ERR
                                        "videocodec: '%s' is used\n",
                                        h->codec->name);
                                return -EBUSY;
                        }
                        dprintk(3, "videocodec: unregister '%s' is ok.\n",
                                h->codec->name);
                        if (prev == NULL) {
                                codeclist_top = h->next;
                                dprintk(4,
                                        "videocodec: delete first element\n");
                        } else {
                                prev->next = h->next;
                                dprintk(4,
                                        "videocodec: delete middle element\n");
                        }
                        kfree(h);
                        return 0;
                }
                prev = h;
                h = h->next;
        }
 
        dprintk(1,
                KERN_ERR
                "videocodec_unregister: given codec not found!\n");
        return -EINVAL;
}
 
#ifdef CONFIG_PROC_FS
/* ============ */
/* procfs stuff */
/* ============ */
 
static char *videocodec_buf = NULL;
static int videocodec_bufsize = 0;
 
static int
videocodec_build_table (void)
{
        struct codec_list *h = codeclist_top;
        struct attached_list *a;
        int i = 0, size;
 
        // sum up amount of slaves plus their attached masters
        while (h) {
                i += h->attached + 1;
                h = h->next;
        }
#define LINESIZE 100
        size = LINESIZE * (i + 1);
 
        dprintk(3, "videocodec_build table: %d entries, %d bytes\n", i,
                size);
 
        kfree(videocodec_buf);
        videocodec_buf = kmalloc(size, GFP_KERNEL);
 
        if (!videocodec_buf)
                return 0;
 
        i = 0;
        i += scnprintf(videocodec_buf + i, size - 1,
                      "<S>lave or attached <M>aster name  type flags    magic    ");
        i += scnprintf(videocodec_buf + i, size -i - 1, "(connected as)\n");
 
        h = codeclist_top;
        while (h) {
                if (i > (size - LINESIZE))
                        break;  // security check
                i += scnprintf(videocodec_buf + i, size -i -1,
                              "S %32s %04x %08lx %08lx (TEMPLATE)\n",
                              h->codec->name, h->codec->type,
                              h->codec->flags, h->codec->magic);
                a = h->list;
                while (a) {
                        if (i > (size - LINESIZE))
                                break;  // security check
                        i += scnprintf(videocodec_buf + i, size -i -1,
                                      "M %32s %04x %08lx %08lx (%s)\n",
                                      a->codec->master_data->name,
                                      a->codec->master_data->type,
                                      a->codec->master_data->flags,
                                      a->codec->master_data->magic,
                                      a->codec->name);
                        a = a->next;
                }
                h = h->next;
        }
 
        return i;
}
 
//The definition:
//typedef int (read_proc_t)(char *page, char **start, off_t off,
//                          int count, int *eof, void *data);
 
static int
videocodec_info (char  *buffer,
                 char **buffer_location,
                 off_t  offset,
                 int    buffer_length,
                 int   *eof,
                 void  *data)
{
        int size;
 
        dprintk(3, "videocodec_info: offset: %ld, len %d / size %d\n",
                offset, buffer_length, videocodec_bufsize);
 
        if (offset == 0) {
                videocodec_bufsize = videocodec_build_table();
        }
        if ((offset < 0) || (offset >= videocodec_bufsize)) {
                dprintk(4,
                        "videocodec_info: call delivers no result, return 0\n");
                *eof = 1;
                return 0;
        }
 
        if (buffer_length < (videocodec_bufsize - offset)) {
                dprintk(4, "videocodec_info: %ld needed, %d got\n",
                        videocodec_bufsize - offset, buffer_length);
                size = buffer_length;
        } else {
                dprintk(4, "videocodec_info: last reading of %ld bytes\n",
                        videocodec_bufsize - offset);
                size = videocodec_bufsize - offset;
                *eof = 1;
        }
 
        memcpy(buffer, videocodec_buf + offset, size);
        /* doesn't work...                           */
        /* copy_to_user(buffer, videocodec_buf+offset, size); */
        /* *buffer_location = videocodec_buf+offset; */
 
        return size;
}
#endif
 
/* ===================== */
/* hook in driver module */
/* ===================== */
static int __init
videocodec_init (void)
{
#ifdef CONFIG_PROC_FS
        static struct proc_dir_entry *videocodec_proc_entry;
#endif
 
        printk(KERN_INFO "Linux video codec intermediate layer: %s\n",
               VIDEOCODEC_VERSION);
 
#ifdef CONFIG_PROC_FS
        videocodec_buf = NULL;
        videocodec_bufsize = 0;
 
        videocodec_proc_entry = create_proc_entry("videocodecs", 0, NULL);
        if (videocodec_proc_entry) {
                videocodec_proc_entry->read_proc = videocodec_info;
                videocodec_proc_entry->write_proc = NULL;
                videocodec_proc_entry->data = NULL;
                videocodec_proc_entry->owner = THIS_MODULE;
        } else {
                dprintk(1, KERN_ERR "videocodec: can't init procfs.\n");
        }
#endif
        return 0;
}
 
static void __exit
videocodec_exit (void)
{
#ifdef CONFIG_PROC_FS
        remove_proc_entry("videocodecs", NULL);
        kfree(videocodec_buf);
#endif
}
 
EXPORT_SYMBOL(videocodec_attach);
EXPORT_SYMBOL(videocodec_detach);
EXPORT_SYMBOL(videocodec_register);
EXPORT_SYMBOL(videocodec_unregister);
 
module_init(videocodec_init);
module_exit(videocodec_exit);
 
MODULE_AUTHOR("Wolfgang Scherr <scherr@net4you.at>");
MODULE_DESCRIPTION("Intermediate API module for video codecs "
                   VIDEOCODEC_VERSION);
MODULE_LICENSE("GPL");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [media/] [video/] [videocodec.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/*`
2			`* VIDEO MOTION CODECs internal API for video devices`
3			`*`
4			`* Interface for MJPEG (and maybe later MPEG/WAVELETS) codec's`
5			`* bound to a master device.`
6			`*`
7			`* (c) 2002 Wolfgang Scherr <scherr@net4you.at>`
8			`*`
9			`* $Id: videocodec.c,v 1.1.2.8 2003/03/29 07:16:04 rbultje Exp $`
10			`*`
11			`* ------------------------------------------------------------------------`
12			`*`
13			`* This program is free software; you can redistribute it and/or modify`
14			`* it under the terms of the GNU General Public License as published by`
15			`* the Free Software Foundation; either version 2 of the License, or`
16			`* (at your option) any later version.`
17			`*`
18			`* This program is distributed in the hope that it will be useful,`
19			`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
20			`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
21			`* GNU General Public License for more details.`
22			`*`
23			`* You should have received a copy of the GNU General Public License`
24			`* along with this program; if not, write to the Free Software`
25			`* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.`
26			`*`
27			`* ------------------------------------------------------------------------`
28			`*/`
29
30			`#define VIDEOCODEC_VERSION "v0.2"`
31
32			`#include <linux/kernel.h>`
33			`#include <linux/module.h>`
34			`#include <linux/init.h>`
35			`#include <linux/types.h>`
36			`#include <linux/slab.h>`
37
38			`// kernel config is here (procfs flag)`
39
40			`#ifdef CONFIG_PROC_FS`
41			`#include <linux/proc_fs.h>`
42			`#include <asm/uaccess.h>`
43			`#endif`
44
45			`#include "videocodec.h"`
46
47			`static int debug = 0;`
48			`module_param(debug, int, 0);`
49			`MODULE_PARM_DESC(debug, "Debug level (0-4)");`
50
51			`#define dprintk(num, format, args...) \`
52			`do { \`
53			`if (debug >= num) \`
54			`printk(format, ##args); \`
55			`} while (0)`
56
57			`struct attached_list {`
58			`struct videocodec *codec;`
59			`struct attached_list *next;`
60			`};`
61
62			`struct codec_list {`
63			`const struct videocodec *codec;`
64			`int attached;`
65			`struct attached_list *list;`
66			`struct codec_list *next;`
67			`};`
68
69			`static struct codec_list *codeclist_top = NULL;`
70
71			`/* ================================================= */`
72			`/* function prototypes of the master/slave interface */`
73			`/* ================================================= */`
74
75			`struct videocodec *`
76			`videocodec_attach (struct videocodec_master *master)`
77			`{`
78			`struct codec_list *h = codeclist_top;`
79			`struct attached_list a, ptr;`
80			`struct videocodec *codec;`
81			`int res;`
82
83			`if (!master) {`
84			`dprintk(1, KERN_ERR "videocodec_attach: no data\n");`
85			`return NULL;`
86			`}`
87
88			`dprintk(2,`
89			`"videocodec_attach: '%s', flags %lx, magic %lx\n",`
90			`master->name, master->flags, master->magic);`
91
92			`if (!h) {`
93			`dprintk(1,`
94			`KERN_ERR`
95			`"videocodec_attach: no device available\n");`
96			`return NULL;`
97			`}`
98
99			`while (h) {`
100			`// attach only if the slave has at least the flags`
101			`// expected by the master`
102			`if ((master->flags & h->codec->flags) == master->flags) {`
103			`dprintk(4, "videocodec_attach: try '%s'\n",`
104			`h->codec->name);`
105
106			`if (!try_module_get(h->codec->owner))`
107			`return NULL;`
108
109			`codec =`
110			`kmalloc(sizeof(struct videocodec), GFP_KERNEL);`
111			`if (!codec) {`
112			`dprintk(1,`
113			`KERN_ERR`
114			`"videocodec_attach: no mem\n");`
115			`goto out_module_put;`
116			`}`
117			`memcpy(codec, h->codec, sizeof(struct videocodec));`
118
119			`snprintf(codec->name, sizeof(codec->name),`
120			`"%s[%d]", codec->name, h->attached);`
121			`codec->master_data = master;`
122			`res = codec->setup(codec);`
123			`if (res == 0) {`
124			`dprintk(3, "videocodec_attach '%s'\n",`
125			`codec->name);`
126			`ptr = kzalloc(sizeof(struct attached_list), GFP_KERNEL);`
127			`if (!ptr) {`
128			`dprintk(1,`
129			`KERN_ERR`
130			`"videocodec_attach: no memory\n");`
131			`goto out_kfree;`
132			`}`
133			`ptr->codec = codec;`
134
135			`a = h->list;`
136			`if (!a) {`
137			`h->list = ptr;`
138			`dprintk(4,`
139			`"videocodec: first element\n");`
140			`} else {`
141			`while (a->next)`
142			`a = a->next; // find end`
143			`a->next = ptr;`
144			`dprintk(4,`
145			`"videocodec: in after '%s'\n",`
146			`h->codec->name);`
147			`}`
148
149			`h->attached += 1;`
150			`return codec;`
151			`} else {`
152			`kfree(codec);`
153			`}`
154			`}`
155			`h = h->next;`
156			`}`
157
158			`dprintk(1, KERN_ERR "videocodec_attach: no codec found!\n");`
159			`return NULL;`
160
161			`out_module_put:`
162			`module_put(h->codec->owner);`
163			`out_kfree:`
164			`kfree(codec);`
165			`return NULL;`
166			`}`
167
168			`int`
169			`videocodec_detach (struct videocodec *codec)`
170			`{`
171			`struct codec_list *h = codeclist_top;`
172			`struct attached_list a, prev;`
173			`int res;`
174
175			`if (!codec) {`
176			`dprintk(1, KERN_ERR "videocodec_detach: no data\n");`
177			`return -EINVAL;`
178			`}`
179
180			`dprintk(2,`
181			`"videocodec_detach: '%s', type: %x, flags %lx, magic %lx\n",`
182			`codec->name, codec->type, codec->flags, codec->magic);`
183
184			`if (!h) {`
185			`dprintk(1,`
186			`KERN_ERR "videocodec_detach: no device left...\n");`
187			`return -ENXIO;`
188			`}`
189
190			`while (h) {`
191			`a = h->list;`
192			`prev = NULL;`
193			`while (a) {`
194			`if (codec == a->codec) {`
195			`res = a->codec->unset(a->codec);`
196			`if (res >= 0) {`
197			`dprintk(3,`
198			`"videocodec_detach: '%s'\n",`
199			`a->codec->name);`
200			`a->codec->master_data = NULL;`
201			`} else {`
202			`dprintk(1,`
203			`KERN_ERR`
204			`"videocodec_detach: '%s'\n",`
205			`a->codec->name);`
206			`a->codec->master_data = NULL;`
207			`}`
208			`if (prev == NULL) {`
209			`h->list = a->next;`
210			`dprintk(4,`
211			`"videocodec: delete first\n");`
212			`} else {`
213			`prev->next = a->next;`
214			`dprintk(4,`
215			`"videocodec: delete middle\n");`
216			`}`
217			`module_put(a->codec->owner);`
218			`kfree(a->codec);`
219			`kfree(a);`
220			`h->attached -= 1;`
221			`return 0;`
222			`}`
223			`prev = a;`
224			`a = a->next;`
225			`}`
226			`h = h->next;`
227			`}`
228
229			`dprintk(1, KERN_ERR "videocodec_detach: given codec not found!\n");`
230			`return -EINVAL;`
231			`}`
232
233			`int`
234			`videocodec_register (const struct videocodec *codec)`
235			`{`
236			`struct codec_list ptr, h = codeclist_top;`
237
238			`if (!codec) {`
239			`dprintk(1, KERN_ERR "videocodec_register: no data!\n");`
240			`return -EINVAL;`
241			`}`
242
243			`dprintk(2,`
244			`"videocodec: register '%s', type: %x, flags %lx, magic %lx\n",`
245			`codec->name, codec->type, codec->flags, codec->magic);`
246
247			`ptr = kzalloc(sizeof(struct codec_list), GFP_KERNEL);`
248			`if (!ptr) {`
249			`dprintk(1, KERN_ERR "videocodec_register: no memory\n");`
250			`return -ENOMEM;`
251			`}`
252			`ptr->codec = codec;`
253
254			`if (!h) {`
255			`codeclist_top = ptr;`
256			`dprintk(4, "videocodec: hooked in as first element\n");`
257			`} else {`
258			`while (h->next)`
259			`h = h->next; // find the end`
260			`h->next = ptr;`
261			`dprintk(4, "videocodec: hooked in after '%s'\n",`
262			`h->codec->name);`
263			`}`
264
265			`return 0;`
266			`}`
267
268			`int`
269			`videocodec_unregister (const struct videocodec *codec)`
270			`{`
271			`struct codec_list prev = NULL, h = codeclist_top;`
272
273			`if (!codec) {`
274			`dprintk(1, KERN_ERR "videocodec_unregister: no data!\n");`
275			`return -EINVAL;`
276			`}`
277
278			`dprintk(2,`
279			`"videocodec: unregister '%s', type: %x, flags %lx, magic %lx\n",`
280			`codec->name, codec->type, codec->flags, codec->magic);`
281
282			`if (!h) {`
283			`dprintk(1,`
284			`KERN_ERR`
285			`"videocodec_unregister: no device left...\n");`
286			`return -ENXIO;`
287			`}`
288
289			`while (h) {`
290			`if (codec == h->codec) {`
291			`if (h->attached) {`
292			`dprintk(1,`
293			`KERN_ERR`
294			`"videocodec: '%s' is used\n",`
295			`h->codec->name);`
296			`return -EBUSY;`
297			`}`
298			`dprintk(3, "videocodec: unregister '%s' is ok.\n",`
299			`h->codec->name);`
300			`if (prev == NULL) {`
301			`codeclist_top = h->next;`
302			`dprintk(4,`
303			`"videocodec: delete first element\n");`
304			`} else {`
305			`prev->next = h->next;`
306			`dprintk(4,`
307			`"videocodec: delete middle element\n");`
308			`}`
309			`kfree(h);`
310			`return 0;`
311			`}`
312			`prev = h;`
313			`h = h->next;`
314			`}`
315
316			`dprintk(1,`
317			`KERN_ERR`
318			`"videocodec_unregister: given codec not found!\n");`
319			`return -EINVAL;`
320			`}`
321
322			`#ifdef CONFIG_PROC_FS`
323			`/* ============ */`
324			`/* procfs stuff */`
325			`/* ============ */`
326
327			`static char *videocodec_buf = NULL;`
328			`static int videocodec_bufsize = 0;`
329
330			`static int`
331			`videocodec_build_table (void)`
332			`{`
333			`struct codec_list *h = codeclist_top;`
334			`struct attached_list *a;`
335			`int i = 0, size;`
336
337			`// sum up amount of slaves plus their attached masters`
338			`while (h) {`
339			`i += h->attached + 1;`
340			`h = h->next;`
341			`}`
342			`#define LINESIZE 100`
343			`size = LINESIZE * (i + 1);`
344
345			`dprintk(3, "videocodec_build table: %d entries, %d bytes\n", i,`
346			`size);`
347
348			`kfree(videocodec_buf);`
349			`videocodec_buf = kmalloc(size, GFP_KERNEL);`
350
351			`if (!videocodec_buf)`
352			`return 0;`
353
354			`i = 0;`
355			`i += scnprintf(videocodec_buf + i, size - 1,`
356			`"<S>lave or attached <M>aster name type flags magic ");`
357			`i += scnprintf(videocodec_buf + i, size -i - 1, "(connected as)\n");`
358
359			`h = codeclist_top;`
360			`while (h) {`
361			`if (i > (size - LINESIZE))`
362			`break; // security check`
363			`i += scnprintf(videocodec_buf + i, size -i -1,`
364			`"S %32s %04x %08lx %08lx (TEMPLATE)\n",`
365			`h->codec->name, h->codec->type,`
366			`h->codec->flags, h->codec->magic);`
367			`a = h->list;`
368			`while (a) {`
369			`if (i > (size - LINESIZE))`
370			`break; // security check`
371			`i += scnprintf(videocodec_buf + i, size -i -1,`
372			`"M %32s %04x %08lx %08lx (%s)\n",`
373			`a->codec->master_data->name,`
374			`a->codec->master_data->type,`
375			`a->codec->master_data->flags,`
376			`a->codec->master_data->magic,`
377			`a->codec->name);`
378			`a = a->next;`
379			`}`
380			`h = h->next;`
381			`}`
382
383			`return i;`
384			`}`
385
386			`//The definition:`
387			`//typedef int (read_proc_t)(char page, char *start, off_t off,`
388			`// int count, int eof, void data);`
389
390			`static int`
391			`videocodec_info (char *buffer,`
392			`char **buffer_location,`
393			`off_t offset,`
394			`int buffer_length,`
395			`int *eof,`
396			`void *data)`
397			`{`
398			`int size;`
399
400			`dprintk(3, "videocodec_info: offset: %ld, len %d / size %d\n",`
401			`offset, buffer_length, videocodec_bufsize);`
402
403			`if (offset == 0) {`
404			`videocodec_bufsize = videocodec_build_table();`
405			`}`
406			`if ((offset < 0) \|\| (offset >= videocodec_bufsize)) {`
407			`dprintk(4,`
408			`"videocodec_info: call delivers no result, return 0\n");`
409			`*eof = 1;`
410			`return 0;`
411			`}`
412
413			`if (buffer_length < (videocodec_bufsize - offset)) {`
414			`dprintk(4, "videocodec_info: %ld needed, %d got\n",`
415			`videocodec_bufsize - offset, buffer_length);`
416			`size = buffer_length;`
417			`} else {`
418			`dprintk(4, "videocodec_info: last reading of %ld bytes\n",`
419			`videocodec_bufsize - offset);`
420			`size = videocodec_bufsize - offset;`
421			`*eof = 1;`
422			`}`
423
424			`memcpy(buffer, videocodec_buf + offset, size);`
425			`/* doesn't work... */`
426			`/* copy_to_user(buffer, videocodec_buf+offset, size); */`
427			`/* buffer_location = videocodec_buf+offset; /`
428
429			`return size;`
430			`}`
431			`#endif`
432
433			`/* ===================== */`
434			`/* hook in driver module */`
435			`/* ===================== */`
436			`static int __init`
437			`videocodec_init (void)`
438			`{`
439			`#ifdef CONFIG_PROC_FS`
440			`static struct proc_dir_entry *videocodec_proc_entry;`
441			`#endif`
442
443			`printk(KERN_INFO "Linux video codec intermediate layer: %s\n",`
444			`VIDEOCODEC_VERSION);`
445
446			`#ifdef CONFIG_PROC_FS`
447			`videocodec_buf = NULL;`
448			`videocodec_bufsize = 0;`
449
450			`videocodec_proc_entry = create_proc_entry("videocodecs", 0, NULL);`
451			`if (videocodec_proc_entry) {`
452			`videocodec_proc_entry->read_proc = videocodec_info;`
453			`videocodec_proc_entry->write_proc = NULL;`
454			`videocodec_proc_entry->data = NULL;`
455			`videocodec_proc_entry->owner = THIS_MODULE;`
456			`} else {`
457			`dprintk(1, KERN_ERR "videocodec: can't init procfs.\n");`
458			`}`
459			`#endif`
460			`return 0;`
461			`}`
462
463			`static void __exit`
464			`videocodec_exit (void)`
465			`{`
466			`#ifdef CONFIG_PROC_FS`
467			`remove_proc_entry("videocodecs", NULL);`
468			`kfree(videocodec_buf);`
469			`#endif`
470			`}`
471
472			`EXPORT_SYMBOL(videocodec_attach);`
473			`EXPORT_SYMBOL(videocodec_detach);`
474			`EXPORT_SYMBOL(videocodec_register);`
475			`EXPORT_SYMBOL(videocodec_unregister);`
476
477			`module_init(videocodec_init);`
478			`module_exit(videocodec_exit);`
479
480			`MODULE_AUTHOR("Wolfgang Scherr <scherr@net4you.at>");`
481			`MODULE_DESCRIPTION("Intermediate API module for video codecs "`
482			`VIDEOCODEC_VERSION);`
483			`MODULE_LICENSE("GPL");`