[BACK]Return to cvdv.c CVS log [TXT] [DIR] Up to [DVB] / margi2

Diff for /margi2/cvdv.c between versions 1.12 and 1.13

version 1.12, 2001/03/29 23:12:01 version 1.13, 2001/04/06 09:03:53
Line 1 Line 1
 /*   /* 
     cvdv.c      cvdv.c
   
     Copyright (C) Christian Wolff for convergence integrated media.      Copyright (C) Christian Wolff 
                     Marcus Metzler for convergence integrated media.
   
     This program is free software; you can redistribute it and/or modify      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      it under the terms of the GNU General Public License as published by
Line 577  static long margi_write(struct cvdv_card Line 578  static long margi_write(struct cvdv_card
                                        !card->nonblock && out < count){                                         !card->nonblock && out < count){
                                         wc++;                                          wc++;
                                         out += MargiPush(card, count, data);                                          out += MargiPush(card, count, data);
                                         if (out < count || card->DMAABusy){                                          if (out < count){
                                                 interruptible_sleep_on(&card->wqA);                                                  interruptible_sleep_on(&card->wqA);
                                         }                                          }
                                 }                                  }
Line 604  static long margi_write(struct cvdv_card Line 605  static long margi_write(struct cvdv_card
 void pes_write(uint8_t *buf, int count, void *priv)  void pes_write(uint8_t *buf, int count, void *priv)
 {  {
         struct cvdv_cards *card = (struct cvdv_cards *) priv;          struct cvdv_cards *card = (struct cvdv_cards *) priv;
           int out;
   
           out = margi_write(card, buf, count, 0);
   #if 0
           if (out != count)
                   printk(KERN_ERR LOGNAME ": Yikes\n");
           printk(KERN_ERR LOGNAME " l: 0x%X  0x%02X 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\n" , count,
                  buf[0],buf[1],buf[2],buf[3],buf[4],buf[5]);
   #endif
   
         margi_write(card, buf, count, 0);  
 }  }
   
   
Line 631  static unsigned int PSpoll(struct file * Line 640  static unsigned int PSpoll(struct file *
                 return POLLERR;                  return POLLERR;
 }  }
   
   static int
   OSD_DrawCommand(struct cvdv_cards *card,osd_cmd_t *dc)
   {
   
           switch (dc->cmd) {
           case OSD_Close:
                   printk(KERN_DEBUG LOGNAME
                          ": 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 PSioctl(struct inode *inode, struct file *file,  static int PSioctl(struct inode *inode, struct file *file,
                    unsigned int cmd, unsigned long arg)                     unsigned int cmd, unsigned long arg)
 {  {
         struct cvdv_cards *card = minorlist[MINOR(inode->i_rdev) % MAXDEV];     // minor number modulo 16          struct cvdv_cards *card = minorlist[MINOR(inode->i_rdev) % MAXDEV];     // minor number modulo 16
         struct drawcmd *dc;          osd_cmd_t *dc;
         struct decodercmd *command;          struct decodercmd *command;
         uint16_t attr;          uint16_t attr;
   
Line 644  static int PSioctl(struct inode *inode, Line 735  static int PSioctl(struct inode *inode,
                 if (_IOC_TYPE(cmd) == CVDV_IOCTL_MAGIC)                  if (_IOC_TYPE(cmd) == CVDV_IOCTL_MAGIC)
                         switch (_IOC_NR(cmd)) {                          switch (_IOC_NR(cmd)) {
                         case IOCTL_DRAW:        // Drawing commands                          case IOCTL_DRAW:        // Drawing commands
                                 dc = (struct drawcmd *) arg;                                  dc = (osd_cmd_t *) arg;
                                 switch (dc->cmd) {                                  return OSD_DrawCommand(card,dc);
                                 case OSD_Close:                                  break;
                                         printk(KERN_DEBUG LOGNAME  
                                                ": 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))  
 //printk(KERN_DEBUG LOGNAME ": OSD SetColor(%d,%d,%d,%d,%d)\n",  
 //dc->color,dc->x0,dc->y0,dc->x1,dc->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;  
                                 }  
                         case IOCTL_DECODER:                          case IOCTL_DECODER:
                                 command = (struct decodercmd *) arg;                                  command = (struct decodercmd *) arg;
                                 switch (command->cmd) {                                  switch (command->cmd) {
Line 829  static int PSioctl(struct inode *inode, Line 844  static int PSioctl(struct inode *inode,
                                                 if (card->videoffwd)                                                  if (card->videoffwd)
                                                         card->videoffwd = 0;                                                          card->videoffwd = 0;
                                                 else                                                  else
                                                         card->videoffwd = 2;                                                          card->videoffwd = 3;
                                         } else {                                          } else {
                                                 if (!command->param1)                                                  if (!command->param1)
                                                         card->videoffwd = 0;                                                          card->videoffwd = 0;
                                                 else                                                  else
                                                         card->videoffwd = 2;                                                          card->videoffwd = 3;
                                         }                                          }
                                         return 0;                                          return 0;
   
Line 1143  dvbdev_close(struct dvb_device *dvbdev, Line 1158  dvbdev_close(struct dvb_device *dvbdev,
         return ret;          return ret;
 }  }
   
   
 static ssize_t   static ssize_t 
 dvbdev_write(struct dvb_device *dvbdev, int num,  dvbdev_write(struct dvb_device *dvbdev, int num,
              struct file *file,                struct file *file, 
Line 1303  dvbdev_ioctl(struct dvb_device *dvbdev, Line 1319  dvbdev_ioctl(struct dvb_device *dvbdev,
                         if (card->videostate.streamSource !=                          if (card->videostate.streamSource !=
                             VIDEO_SOURCE_MEMORY)                              VIDEO_SOURCE_MEMORY)
                                 return -EPERM;                                  return -EPERM;
                         card->videoffwd = 2;                          card->videoffwd = 3;
                         break;                          break;
   
                 case VIDEO_SLOWMOTION:                  case VIDEO_SLOWMOTION:
Line 1430  dvbdev_ioctl(struct dvb_device *dvbdev, Line 1446  dvbdev_ioctl(struct dvb_device *dvbdev,
   
         case DVB_DEVICE_DEMUX_0:          case DVB_DEVICE_DEMUX_0:
                 return DmxDevIoctl(&card->dmxdev, file, cmd, arg);                  return DmxDevIoctl(&card->dmxdev, file, cmd, arg);
                   break;
   
         case DVB_DEVICE_OSD_0:          case DVB_DEVICE_OSD_0:
                 {                  {
                   /*    switch (cmd) {                          switch (cmd) {
                         case OSD_SEND_CMD:                          case OSD_SEND_CMD:
                                 {                          {
                                         osd_cmd_t doc;                                  osd_cmd_t doc;
                                                                           
                                         if(copy_from_user(&doc, parg,                                   if(copy_from_user(&doc, parg, 
                                                           sizeof(osd_cmd_t)))                                                    sizeof(osd_cmd_t)))
                                                 return -EFAULT;                                          return -EFAULT;
                                         return OSD_DrawCommand(dvb, &doc);                                  return OSD_DrawCommand(card, &doc);
                                 }                          }
                         default:                          default:
                                 return -EINVAL;                                  return -EINVAL;
                                 }*/                          }
                         break;                          break;
                 }                  }
         default:          default:
Line 1509  static dvb_devs_t mdvb_devs = { Line 1526  static dvb_devs_t mdvb_devs = {
                 -1, -1,                  -1, -1,
                 DVB_DEVICE_DEMUX_0, DVB_DEVICE_DVR_0,                  DVB_DEVICE_DEMUX_0, DVB_DEVICE_DVR_0,
                 -1, -1,                  -1, -1,
                 -1//DVB_DEVICE_OSD,                  DVB_DEVICE_OSD_0,
         },          },
         { INFU, INFU, INFU, INFU, INFU, 1, 1, INFU, 1 },          { INFU, INFU, INFU, INFU, INFU, 1, 1, INFU, 1 },
         { 1, 1, 1, 1, INFU, 1, 1, 1, 1}          { 1, 1, 1, 1, INFU, 1, 1, 1, 1}
Line 1634  dvb_write_to_decoder(dvb_demux_feed_t *d Line 1651  dvb_write_to_decoder(dvb_demux_feed_t *d
         if (count != TS_SIZE) return -1;          if (count != TS_SIZE) return -1;
   
         ts_to_pes( p, buf); // don't need count (=188)          ts_to_pes( p, buf); // don't need count (=188)
         card->audiostate.AVSyncState=0;  
   
         return 0;          return 0;
 }  }
   
Removed from v.1.12  
changed lines
  Added in v.1.13

LinuxTV legacy CVS <linuxtv.org/cvs>