WebSVN - shark - Blame - Rev 1070 - /shark/trunk/drivers/usb/shark_glue/shark

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	}

Subversion Repositories shark

(root)/shark/trunk/drivers/usb/shark_glue/shark_pwc.c - Rev 1070