Subversion Repositories shark

Rev

Rev 1063 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1063 tullio 1
 
2
/*
3
 * This program is free software; you can redistribute it and/or modify
4
 * it under the terms of the GNU General Public License as published by
5
 * the Free Software Foundation; either version 2 of the License, or
6
 * (at your option) any later version.
7
 *
8
 * This program is distributed in the hope that it will be useful,
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 * GNU General Public License for more details.
12
 *
13
 * You should have received a copy of the GNU General Public License
14
 * along with this program; if not, write to the Free Software
15
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
16
 *
17
 */
18
 
1049 mauro 19
#include <linuxcomp.h>
20
 
21
#include <linux/config.h>
22
#include <linux/types.h>
23
#include <linux/major.h>
24
#include <linux/errno.h>
25
#include <linux/signal.h>
26
 
27
#include "media/pwc-ioctl.h"
28
#include <linux/videodev.h>
29
#include <drivers/shark_pwc26.h>
30
 
31
/*
32
* shark lowlevel wrapper
33
*/
34
 
35
struct PWC_data {
36
        struct file* file;
37
        struct pwc_imagesize RealSize;
38
        struct pwc_coord m_ViewSize, m_RealSize;
39
        struct pwc_coord m_Offset;
40
        struct video_capability Capability;
41
        struct pwc_probe Probe;
42
        struct video_picture Picture;
43
        struct video_window Window;
44
        struct pwc_video_command VideoCmd;
45
        void *m_pPWCXBuffer, *m_pInputBuffer, *m_pImageBuffer;
46
        int m_Frames, len, m_UseRaw, m_ImageSize, m_ImageLen;
47
        int m_Type, m_Bandlength, m_Bayer;
48
        int m_InputLen;
49
};
50
 
51
 
52
extern int usb_pwc_init();
53
extern void* malloc(size_t size);
54
 
55
extern int pwc_video_do_ioctl(struct inode *inode, struct file *file, unsigned int cmd, void *arg);
56
extern int pwc_video_open(struct inode *inode, struct file *file);
57
extern int pwc_video_close(struct inode *inode, struct file *file);
58
extern ssize_t pwc_video_read(struct file *file, char *buf, size_t count, loff_t *ppos);
59
extern int pwc_video_ioctl(struct inode *inode, struct file *file, unsigned int ioctlnr, unsigned long arg);
60
 
61
void shark_PWC_init()
62
{
63
        usb_pwc_init();
64
}
65
 
66
int shark_PWC_open(struct PWC26_DEVICE *pwc26, int width, int height, int fps, int quality, int webcamnr)
67
{
68
        int err;
69
        struct PWC_data *pwc_data;
70
        struct file *file;
71
        struct inode *inode;
72
 
73
        pwc_data = malloc(sizeof(struct PWC_data));
74
        pwc26->private_data = (void*)pwc_data;
75
 
76
        if (!pwc_data)
77
                return -ENOMEM;
78
 
79
        memset(pwc_data, 0, sizeof(struct PWC_data));
80
        file =  malloc(sizeof(struct file));
81
        if (!file)
82
                return -ENOMEM;
83
 
84
        file->f_dentry= malloc(sizeof(struct dentry));
85
        if (!file->f_dentry)
86
                return -ENOMEM;
87
 
88
        file->f_dentry->d_inode = malloc(sizeof(struct inode));
89
        if (!file->f_dentry->d_inode)
90
                return -ENOMEM;
91
 
92
        file->f_dentry->d_inode->i_rdev = webcamnr;
93
        inode = file->f_dentry->d_inode;
94
 
95
        pwc_data->file = file;
96
        pwc_data->m_ViewSize.x = width;
97
        pwc_data->m_ViewSize.y = height;
98
        pwc_data->m_Frames = fps;
99
 
100
        pwc_data->m_RealSize = pwc_data->m_ViewSize;
101
 
102
        pwc_data->m_Offset.x = 0;
103
        pwc_data->m_Offset.y = 0;
104
        pwc_data->m_UseRaw = TRUE;
105
        pwc_data->m_Bayer = FALSE;
106
        pwc_data->m_pInputBuffer = NULL;
107
        pwc_data->m_InputLen = 0;
108
        pwc_data->m_pImageBuffer = NULL;
109
        pwc_data->m_ImageLen = NULL;
110
        pwc_data->m_Type = NULL;
111
 
112
        pwc_data->m_pPWCXBuffer = malloc(60000); // large enoug for all cams
113
        if (!pwc_data->m_pPWCXBuffer)
114
                return -ENOMEM;
115
 
116
        err=pwc_video_open(inode, file);
117
        if (err <0)
118
                return err;
119
 
120
        pwc_video_do_ioctl(inode, file, VIDIOCGCAP, &pwc_data->Capability);
121
 
122
        printk(KERN_INFO "Capability->type= %d\n", pwc_data->Capability.type);
123
        printk(KERN_INFO "Capability->channels =%d\n",pwc_data->Capability.channels);
124
        printk(KERN_INFO "Capability->audios=%d\n",pwc_data->Capability.audios);
125
        printk(KERN_INFO "Capability->minwidth=%d\n",pwc_data->Capability.minwidth);
126
        printk(KERN_INFO "Capability->minheight=%d\n",pwc_data->Capability.minheight);
127
        printk(KERN_INFO "Capability->maxwidth=%d\n",pwc_data->Capability.maxwidth);
128
        printk(KERN_INFO "Capability->maxheight=%d\n",pwc_data->Capability.maxheight);
129
 
130
        memset(&pwc_data->Probe, 0, sizeof(pwc_data->Probe));
131
        pwc_video_do_ioctl(inode, file, VIDIOCPWCPROBE, &pwc_data->Probe);
132
        pwc_video_do_ioctl(inode, file, VIDIOCGPICT, &pwc_data->Picture);
133
 
134
        if (pwc_data->m_UseRaw)
135
                pwc_data->Picture.palette = VIDEO_PALETTE_RAW;
136
        else
137
                pwc_data->Picture.palette = VIDEO_PALETTE_YUV420P;
138
 
139
        pwc_video_do_ioctl(inode, file, VIDIOCSPICT, &pwc_data->Picture);
140
        pwc_video_do_ioctl(inode, file, VIDIOCGWIN, &pwc_data->Window);
141
 
142
        /* unavailable in pwc 10.x */
143
        if (pwc_data->m_Bayer)
144
        {
145
                // special raw Bayer mode
146
                pwc_data->m_ViewSize.x = 640;
147
                pwc_data->m_ViewSize.y = 480;
148
                pwc_data->m_Frames = 5;
149
                pwc_data->m_RealSize = pwc_data->m_ViewSize;
150
        }
151
 
152
        pwc_data->Window.width = pwc_data->m_ViewSize.x;
153
        pwc_data->Window.height = pwc_data->m_ViewSize.y;
154
        pwc_data->Window.flags = (pwc_data->m_Frames << PWC_FPS_SHIFT);
155
 
156
        if (pwc_data->m_Bayer)
157
                pwc_data->Window.flags |= PWC_FPS_SNAPSHOT;
158
 
159
        pwc_video_do_ioctl(inode, file, VIDIOCSWIN, &pwc_data->Window);
160
 
161
        if (pwc_data->m_UseRaw)
162
        {
163
                pwc_video_do_ioctl(inode, file, VIDIOCPWCGVIDCMD, &pwc_data->VideoCmd);
164
 
165
                pwc_data->m_Type = pwc_data->VideoCmd.type;
166
                pwc_data->m_InputLen = pwc_data->VideoCmd.frame_size;
167
                pwc_data->m_Bandlength = pwc_data->VideoCmd.bandlength;
168
 
169
                if (pwc_data->m_Bandlength > 0)
170
                {
171
                        switch(pwc_data->m_Type)
172
                        {
173
                                case 645:
174
                                case 646:
175
                                        pwcx_init_decompress_Nala(pwc_data->m_Type, pwc_data->VideoCmd.release, &pwc_data->VideoCmd.command_buf, pwc_data->m_pPWCXBuffer);
176
                                break;
177
 
178
                                case 675:
179
                                case 680:
180
                                case 690:
181
                                        pwcx_init_decompress_Timon(pwc_data->m_Type, pwc_data->VideoCmd.release, &pwc_data->VideoCmd.command_buf, pwc_data->m_pPWCXBuffer);
182
                                        break;
183
 
184
                                case 720:
185
                                case 730:
186
                                case 740:
187
                                case 750:
188
                                        pwcx_init_decompress_Kiara(pwc_data->m_Type, pwc_data->VideoCmd.release, &pwc_data->VideoCmd.command_buf, pwc_data->m_pPWCXBuffer);
189
                                        break;
190
 
191
                                default:
192
                                        //                              qDebug("Unknown type of camera (%d)!", VideoCmd.type);
193
                                        break;
194
                        } // ..switch
195
                } // ..m_Bandlength > 0
196
 
197
                if (pwc_video_do_ioctl(inode, file, VIDIOCPWCGREALSIZE, &pwc_data->RealSize) == 0)
198
                {
199
                        pwc_data->m_Offset.x = (pwc_data->m_ViewSize.x - pwc_data->RealSize.width) / 2;
200
                        pwc_data->m_Offset.y = (pwc_data->m_ViewSize.y - pwc_data->RealSize.height) / 2;
201
                }
202
        }
203
 
204
        pwc_data->m_ImageLen = pwc_data->m_ViewSize.x * pwc_data->m_ViewSize.y * 3;
205
        pwc_data->m_pImageBuffer = malloc (pwc_data->m_ImageLen);
206
 
207
        if (pwc_data->m_UseRaw)
208
        {
209
                pwc_data->m_pInputBuffer = malloc(pwc_data->m_InputLen);
210
        }
211
        else
212
        {
213
                if (pwc_data->m_pImageBuffer != 0)
214
                {
215
                        pwc_data->m_pInputBuffer = pwc_data->m_pImageBuffer;
216
                        pwc_data->m_InputLen = pwc_data->m_ImageLen;
217
                }
218
        }
219
 
220
        pwc26->width=pwc_data->m_ViewSize.x ;
221
        pwc26->height=pwc_data->m_ViewSize.y ;
222
        pwc26->imgptr=(BYTE*)pwc_data->m_pImageBuffer;
223
 
224
        return 0;
225
}
226
 
227
int shark_PWC_read(struct PWC26_DEVICE *pwc26)
228
{
229
        int len;
230
        struct PWC_data *pwc_data = (struct PWC_data*)pwc26->private_data;
231
 
232
        if (pwc_data->m_pInputBuffer == 0 || pwc_data->m_pImageBuffer == 0)
233
                return -666;
234
 
235
        len = pwc_video_read(pwc_data->file, pwc_data->m_pInputBuffer, pwc_data->m_InputLen, 0);
236
 
237
        if (len > 0 && pwc_data->m_Bandlength > 0)
238
        {
239
                switch(pwc_data->m_Type)
240
                {
241
                        case 645:
242
                        case 646:
243
                                pwcx_decompress_Nala(&pwc_data->m_RealSize, &pwc_data->m_ViewSize, &pwc_data->m_Offset, \
244
                                pwc_data->m_pInputBuffer, pwc_data->m_pImageBuffer, \
245
                                PWCX_FLAG_PLANAR, \
246
                                pwc_data->m_pPWCXBuffer, pwc_data->m_Bandlength);
247
                                break;
248
 
249
                        case 675:
250
                        case 680:
251
                        case 690:
252
                                pwcx_decompress_Timon(&pwc_data->m_RealSize, &pwc_data->m_ViewSize, &pwc_data->m_Offset, \
253
                                pwc_data->m_pInputBuffer, pwc_data->m_pImageBuffer, \
254
                                PWCX_FLAG_PLANAR, \
255
                                pwc_data->m_pPWCXBuffer, pwc_data->m_Bandlength);
256
                                break;
257
 
258
                        case 720:
259
                        case 730:
260
                        case 740:
261
                        case 750:
262
                                pwcx_decompress_Kiara(&pwc_data->m_RealSize, &pwc_data->m_ViewSize, &pwc_data->m_Offset, \
263
                                pwc_data->m_pInputBuffer, pwc_data->m_pImageBuffer, \
264
                                PWCX_FLAG_PLANAR | (pwc_data->m_Bayer ? PWCX_FLAG_BAYER : 0), \
265
                                pwc_data->m_pPWCXBuffer, pwc_data->m_Bandlength);
266
                                break;
267
                }
268
        }
269
        return len;
270
}
271
 
272
void shark_PWC_close(struct PWC26_DEVICE *pwc26)
273
{
274
        struct file *file;
275
        struct inode *inode;
276
        struct PWC_data *pwc_data = (struct PWC_data*)pwc26->private_data;
277
 
278
        if (!pwc_data)
279
                return;
280
 
281
        free(pwc_data->m_pPWCXBuffer);
282
 
283
        file = pwc_data->file;
284
        inode = file->f_dentry->d_inode;
285
        //  pwc_video_close(inode, file);
286
 
287
        free(inode);
288
        free(file->f_dentry);
289
        free(file);
290
        free(pwc_data);
291
}