cvdv.c

linux dvb的文件

		       ": Video Decoder Prepare failed\n");
		return -ENODEV;
	}
}	


static long margi_write_audio(struct cvdv_cards *card, const char *data,
                      unsigned long count, int nonblock)
{
	struct StreamSetup *setup = &card->setup;

	int res;
	long int out=0;
	int free;

	free = ring_write_rest(&(card->rbufB));

	if (card != NULL) {
		card->nonblock = nonblock;
	
		if (count > 0) {	// Do we have data?
			if ((res = Prepare(card)))
				return res;
			if ((setup->streamtype == stream_ES)
			    || (setup->streamtype == stream_PES)){
				if (!card->use_ringB)
					MargiSetBuffers(card, NBBUF*
                                                         CHANNELBUFFERSIZE,1);
				if (!nonblock && 
				    !wait_event_interruptible(
					    card->wqB, 
					    ring_write_rest(&(card->rbufB))
					    > count)){
					out = MargiPushB(card, count,
							 data);
				} else {
					out = MargiPushB(card, count, data);
				}
			}
		}
		return out;
	} else {
		MDEBUG(0,
		       ": Video Decoder Prepare failed\n");
		return -ENODEV;
	}
}	

void pes_write(uint8_t *buf, int count, void *priv)
{
	struct cvdv_cards *card = (struct cvdv_cards *) priv;
	
	margi_write(card, buf, count, 0);
}

static int
OSD_DrawCommand(struct cvdv_cards *card,osd_cmd_t *dc)
{

	switch (dc->cmd) {
	case OSD_Close:
		MDEBUG(1,": OSD Close\n");
		return OSDClose(card);
	case OSD_Open:	// Open(x0,y0,x1,y1,BitPerPixel(2/4/8),mix(0..15))
		return OSDOpen(card, dc->x0,
			       dc->y0, dc->x1,
			       dc->y1,
			       dc->color & 0x0F,
			       (dc->color >> 4) &
			       0x0F);
	case OSD_Show:
		return OSDShow(card);
	case OSD_Hide:
		return OSDHide(card);
	case OSD_Clear:
		return OSDClear(card);
	case OSD_Fill:	// Fill(color)
		return OSDFill(card, dc->color);
	case OSD_SetColor:    // SetColor(color,R(x0),G(y0),B(x1),opacity(y1))
		return (OSDSetColor
			(card, dc->color, dc->x0,
			 dc->y0, dc->x1, 0,
			 (dc->y1 != 255),
			 (dc->y1 == 0)) >= 0);
	case OSD_SetPalette:// SetPalette(firstcolor{color},lastcolor{x0},data)
		return OSDSetPalette(card,
				     dc->color,
				     dc->x0, (uint8_t *)
				     dc->data);
	case OSD_SetTrans:	// SetTrans(transparency{color})
		return OSDSetTrans(card,
				   (dc->color >> 4)
				   & 0x0F);
	case OSD_SetPixel:	// SetPixel(x0,y0,color)
		return OSDSetPixel(card, dc->x0,
				   dc->y0,
				   dc->color);
	case OSD_GetPixel:	// GetPixel(x0,y0);
		return OSDGetPixel(card, dc->x0,
				   dc->y0);
	case OSD_SetRow:	// SetRow(x0,y0,x1,(uint8_t*)data)
		return OSDSetRow(card, dc->x0,
				 dc->y0, dc->x1,
				 (uint8_t *) dc->data);
	case OSD_SetBlock:	// SetBlock(x0,y0,x1,y1,(uint8_t*)data)
		return OSDSetBlock(card, dc->x0,
				   dc->y0, dc->x1,
				   dc->y1,
				   dc->color,
				   (uint8_t *)
				   dc->data);
	case OSD_FillRow:	// FillRow(x0,y0,x1,color)
		return OSDFillRow(card, dc->x0,
				  dc->y0, dc->x1,
				  dc->color);
	case OSD_FillBlock:	// FillRow(x0,y0,x1,y1,color)
		return OSDFillBlock(card, dc->x0,
				    dc->y0, dc->x1,
				    dc->y1,
				    dc->color);
	case OSD_Line:	// Line(x0,y0,x1,y1,color);
		return OSDLine(card, dc->x0,
			       dc->y0, dc->x1,
			       dc->y1, dc->color);
	case OSD_Query:	// Query(x0,y0,x1,y1,aspect(color:11)
		return OSDQuery(card, &dc->x0,
				&dc->y0, &dc->x1,
				&dc->y1,
				&dc->color);
	case OSD_Test:
		return OSDTest(card);
	default:
		return -EINVAL;
	}
}


static int margi_open(struct cvdv_cards *card, int flags)
{
	int closed;
	if (card != NULL) {
		MDEBUG(1, ": -- open \n");
		CloseCard(card);
		OSDClose(card);
		card->timer.function = Timerfunction;
		card->timer.data=(unsigned long) card;
		card->timer.expires=jiffies+1;
		add_timer(&card->timer);
		if (card->open)
			MDEBUG(0,": margi_open - already open\n");
		closed = 1;
		if (card->open)
			closed = 0;
		if (closed) {	// first open() for this card?
			MargiFreeBuffers(card);
			VideoSetBackground(card, 1, 0, 0, 0);	// black
		}
		card->open++;
		MOD_INC_USE_COUNT;
		return 0;
	} else {
		MDEBUG(0,
		       ": Video Decoder Prepare failed\n");
		return -ENODEV;
	}

}


static int dvb_video_open(struct inode *inode, struct file *file)
{
        dvb_device_t *dvbdev=*(dvb_device_t **) file->private_data;
        struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
        int err;

        if ((err=dvb_generic_open(inode, file))<0)
                return err;

	card->video_blank=true;
	card->audiostate.AV_sync_state=true;
	card->videostate.stream_source=VIDEO_SOURCE_DEMUX;
	margi_open(card, file->f_flags);
	
	return 0;
}

static int dvb_audio_open(struct inode *inode, struct file *file)
{
        dvb_device_t *dvbdev=*(dvb_device_t **) file->private_data;
        struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
        int err;

        if ((err=dvb_generic_open(inode, file))<0)
                return err;

	card->audiostate.AV_sync_state=true;
	card->audiostate.stream_source=AUDIO_SOURCE_DEMUX;
        return 0;
}


static int dvb_video_release(struct inode *inode, struct file *file)
{
        dvb_device_t *dvbdev=*(dvb_device_t **) file->private_data;
        struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;

	DecoderPause(card);                   
	card->videostate.play_state = VIDEO_STOPPED;
	if (card->videostate.video_blank)
		VideoSetBackground(card, 1, 0, 0, 0);  
		
        return dvb_generic_release(inode, file);
}

static int dvb_audio_release(struct inode *inode, struct file *file)
{
        dvb_device_t *dvbdev=*(dvb_device_t **) file->private_data;
        struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;

	AudioStopDecode(card);
	card->audiostate.play_state=AUDIO_STOPPED;

        return dvb_generic_release(inode, file);
}


static ssize_t 
dvb_video_write(struct file *file, const char *buf, 
                size_t count, loff_t *ppos)
{
        dvb_device_t *dvbdev=*(dvb_device_t **) file->private_data;
        struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;

	if (card->videostate.stream_source!=VIDEO_SOURCE_MEMORY)
		return -EPERM;
	return margi_write(card, buf, count, 
			   file->f_flags&O_NONBLOCK);
}


static ssize_t 
dvb_audio_write(struct file *file, const char *buf, 
                size_t count, loff_t *ppos)
{
        dvb_device_t *dvbdev=*(dvb_device_t **) file->private_data;
        struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;

	if (card->audiostate.stream_source!=AUDIO_SOURCE_MEMORY)
		return -EPERM;
	if ( card->setup.streamtype !=  stream_PES )
		return -EPERM;
	
	return margi_write_audio(card, buf, count, 
				 file->f_flags&O_NONBLOCK);
}


static int 
dvb_video_ioctl(struct inode *inode, struct file *file,
            unsigned int cmd, void *parg)
{
	dvb_device_t *dvbdev=*(dvb_device_t **) file->private_data;
        unsigned long arg=(unsigned long) parg;
	struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;

	if (((file->f_flags&O_ACCMODE)==O_RDONLY) &&
	    (cmd!=VIDEO_GET_STATUS))
		return -EPERM;

	switch (cmd) {
		
	case VIDEO_STOP:
		DecoderPause(card);                   
		card->videostate.play_state = VIDEO_STOPPED;
		if (card->videostate.video_blank)
			VideoSetBackground(card, 1, 0, 0, 0);  
		
		
		return 0; 
		
	case VIDEO_PLAY:
		
		if (card->videostate.stream_source==
		    VIDEO_SOURCE_MEMORY) {
			if (card->videostate.play_state==VIDEO_FREEZED){
				DecoderUnPause(card);	
			} else {
				DecoderUnPause(card);	
			} 
		}
		break;

	case VIDEO_FREEZE:
		DecoderPause(card);                   
		break;
		
	case VIDEO_CONTINUE:
		if (card->videostate.play_state==VIDEO_FREEZED) {
			DecoderUnPause(card);                   
		} 
		break;
		
	case VIDEO_SELECT_SOURCE:
		card->videostate.stream_source=(video_stream_source_t) arg;
		break;
		
	case VIDEO_SET_BLANK:
		card->videostate.video_blank=(boolean) arg;
		break;
		
	case VIDEO_GET_STATUS:
		if(copy_to_user(parg, &card->videostate, 
				sizeof(struct video_status)))
			return -EFAULT;
		break;
		
	case VIDEO_GET_EVENT:
		return -EOPNOTSUPP;
		
	case VIDEO_SET_DISPLAY_FORMAT:
	{
		video_displayformat_t format=(video_displayformat_t) arg;
		uint16_t val=0;
		
		switch(format) {
		case VIDEO_PAN_SCAN:
			val=VID_PAN_SCAN_PREF;
			break;
			
		case VIDEO_LETTER_BOX:
			val=VID_VC_AND_PS_PREF;
			break;
			
		case VIDEO_CENTER_CUT_OUT:
			val=VID_CENTRE_CUT_PREF;
			break;
			
		default:
			return -EINVAL;
		}
		
		card->videostate.video_format=format;
		return 0;
	}
	
	case VIDEO_STILLPICTURE:
	{ 
		struct video_still_picture pic;
		
		if(copy_from_user(&pic, parg, 
				  sizeof(struct video_still_picture)))
			return -EFAULT;
		
		break;
	}
	
	case VIDEO_FAST_FORWARD:
		if (card->videostate.stream_source !=
		    VIDEO_SOURCE_MEMORY)
			return -EPERM;
		card->videoffwd = 3;
		break;
		
	case VIDEO_SLOWMOTION:
		if (card->videostate.stream_source!=VIDEO_SOURCE_MEMORY)
			return -EPERM;
		card->videoslow = arg;
		
		break;
		
	case VIDEO_GET_CAPABILITIES:
	{
		int cap=VIDEO_CAP_MPEG1|
			VIDEO_CAP_MPEG2|
			VIDEO_CAP_SYS|
			VIDEO_CAP_PROG|
			VIDEO_CAP_SPU|
			VIDEO_CAP_NAVI|
			VIDEO_CAP_CSS;
		
                        
		if (copy_to_user(parg, &cap, 
				 sizeof(cap)))
			return -EFAULT;
		break;
	}

	case VIDEO_SET_STREAMTYPE:
	{
		int f = -1;
		switch(arg){
		case VIDEO_CAP_MPEG1:
		case VIDEO_CAP_MPEG2:
			f = stream_PES;
			break;
			
		case VIDEO_CAP_SYS:
		case VIDEO_CAP_PROG:
			f = stream_PS;
			break;
			
		case VIDEO_CAP_SPU:
		case VIDEO_CAP_NAVI:
		case VIDEO_CAP_CSS:
			f = stream_DVD;
		}   
		card->setup.streamtype =  f;
		
	}			
	break;
	
	case VIDEO_SET_ID:
		card->setup.videoID = arg;
		DecoderPrepareVideo(card);
		break;
		
	case VIDEO_SET_SYSTEM:
		card->videomode = (videosystem) arg;
		SetVideoSystem(card);
		break;
		
	case VIDEO_SET_HIGHLIGHT:
	{
		uint8_t data1[4];
		uint8_t data2[6];
		video_highlight_t vh;
		
		if(copy_from_user(&vh, parg, sizeof(video_highlight_t)))
			return -EFAULT;
		
		data1[0] = vh.contrast1;
		data1[1] = vh.contrast2;
		data1[2] = vh.color1;
		data1[3] = vh.color2;
		data2[0] = vh.ypos & 0xFF;
		data2[1] = (uint8_t) ((vh.ypos >> 1) & 0xFF);
		data2[2] = (uint8_t) ((vh.ypos >> 2) & 0xFF);
		data2[3] = vh.xpos & 0xFF;
		data2[4] = (uint8_t) ((vh.xpos >> 1) & 0xFF);
		data2[5] = (uint8_t) ((vh.xpos >> 2) & 0xFF);
		return DecoderHighlight(card, vh.active, data1, data2);
		break;
	}
	
	case VIDEO_SET_SPU:
	{
		video_spu_t spu;
		
		if(copy_from_user(&spu, parg, sizeof(video_spu_t)))
			return -EFAULT;
		
		return DecoderSPUStream(card, spu.stream_id, spu.active);
		break;
	}
	
	case VIDEO_SET_SPU_PALETTE:
	{
		video_spu_palette_t spup;
		
		if(copy_from_user(&spup, parg, sizeof(video_spu_palette_t)))
			return -EFAULT;
		
		return DecoderSPUPalette(card, spup.length, spup.palette);
		break;
	}
	
	case VIDEO_GET_NAVI:
	{
		video_navi_pack_t navi;
		
		navi.length = DecoderGetNavi(card, (u8 *)&(navi.data));
		if(copy_to_user(parg, &navi, sizeof(video_navi_pack_t)))
			return -EFAULT;
	}
	break;
	
	case VIDEO_SET_ATTRIBUTES:
	{
		if (!card->ChannelBuffersAllocated) {
			DecoderStreamReset(card);
			MargiFlush(card);
			
			card->setup.streamtype = stream_DVD;
			card->setup.videoID = 0;
			DecoderPrepareVideo(card);
			DecoderPreparePS(card, 0, 0, 2, 2, 3, 1);
		}
		
		SetVideoAttr(card, arg);
		card->startingDVDV = 1;	
	}
	break;
	
        case VIDEO_CLEAR_BUFFER:
		/* FIXME */
		break;

	default:
		return -ENOIOCTLCMD;
	}
	return 0;
}

static int 
dvb_audio_ioctl(struct inode *inode, struct file *file,
		unsigned int cmd, void *parg)
{               
	dvb_device_t *dvbdev=*(dvb_device_t **) file->private_data;
        unsigned long arg=(unsigned long) parg;
	struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
	uint16_t attr;

	if (((file->f_flags&O_ACCMODE)==O_RDONLY) &&
	    (cmd!=AUDIO_GET_STATUS))
		return -EPERM;