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

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

version 1.11, 2001/03/19 23:49:15 version 1.12, 2001/03/29 23:12:01
Line 41  unsigned int major_device_number; Line 41  unsigned int major_device_number;
   
   
 // my little random function for memory test  // my little random function for memory test
 u16 rnd_seed;  uint16_t rnd_seed;
 u16 rnd(u16 range)  uint16_t rnd(uint16_t range)
 {                               // returns random 0..(range-1) range<=872  {                               // returns random 0..(range-1) range<=872
         u32 b = 75 * (rnd_seed + 1) - 1;          uint32_t b = 75 * (rnd_seed + 1) - 1;
         rnd_seed = (u16) (b & 0xFFFF);          rnd_seed = (uint16_t) (b & 0xFFFF);
         return ((b * range) / 0xFFFF) - ((b / 0xFFFF) * range);          return ((b * range) / 0xFFFF) - ((b / 0xFFFF) * range);
 }  }
 void rnd_omize(void)  void rnd_omize(void)
 {  {
         rnd_seed = (u16) jiffies;          rnd_seed = (uint16_t) jiffies;
 }  }
   
 static char *cimlogo[] = {  static char *cimlogo[] = {
Line 103  static char *cimlogo[] = { Line 103  static char *cimlogo[] = {
 int OSDTest(struct cvdv_cards *card)  int OSDTest(struct cvdv_cards *card)
 {  {
         int i, j, col, x0, y0, x1, y1,aspx;          int i, j, col, x0, y0, x1, y1,aspx;
         u8 b;          uint8_t b;
   
   
         if (!card->OSD.open)          if (!card->OSD.open)
Line 216  void SetVideoSystem(struct cvdv_cards *c Line 216  void SetVideoSystem(struct cvdv_cards *c
         L64021Setup(card);          L64021Setup(card);
 }  }
   
 int SetVideoAttr(struct cvdv_cards *card, u16 vattr)  int SetVideoAttr(struct cvdv_cards *card, uint16_t vattr)
 {  {
         u8 video_compression_mode;          uint8_t video_compression_mode;
         u8 tv_system;          uint8_t tv_system;
         u8 aspect_ratio;          uint8_t aspect_ratio;
         u8 display_mode;          uint8_t display_mode;
         u8 line_21_switch_1;          uint8_t line_21_switch_1;
         u8 line_21_switch_2;          uint8_t line_21_switch_2;
         u8 source_picture_resolution;          uint8_t source_picture_resolution;
         u8 source_picture_letterboxed;          uint8_t source_picture_letterboxed;
         u8 reserved;          uint8_t reserved;
         u8 film_camera_mode;          uint8_t film_camera_mode;
         u16 hsize, vsize;          uint16_t hsize, vsize;
         if (vattr != card->lastvattr) {          if (vattr != card->lastvattr) {
                 video_compression_mode = (vattr >> 14) & 0x03;                  video_compression_mode = (vattr >> 14) & 0x03;
                 tv_system = (vattr >> 12) & 0x03;                  tv_system = (vattr >> 12) & 0x03;
Line 265  int SetVideoAttr(struct cvdv_cards *card Line 265  int SetVideoAttr(struct cvdv_cards *card
         return 0;          return 0;
 }  }
   
 int SetAudioAttr(struct cvdv_cards *card, u16 aattr)  int SetAudioAttr(struct cvdv_cards *card, uint16_t aattr)
 {  {
         u8 audio_coding_mode;          uint8_t audio_coding_mode;
         u8 multichannel_extension;          uint8_t multichannel_extension;
         u8 audio_type;          uint8_t audio_type;
         u8 audio_application_mode;          uint8_t audio_application_mode;
         u8 quantization_drc;          uint8_t quantization_drc;
         u8 fs;          uint8_t fs;
         u8 reserved;          uint8_t reserved;
         u8 num_audio_ch;          uint8_t num_audio_ch;
         if (aattr) {          if (aattr) {
                 if (aattr != card->lastaattr) {                  if (aattr != card->lastaattr) {
                         audio_coding_mode = (aattr >> 13) & 0x07;                          audio_coding_mode = (aattr >> 13) & 0x07;
Line 404  int Prepare(struct cvdv_cards *card) Line 404  int Prepare(struct cvdv_cards *card)
         return 0;          return 0;
 }  }
   
 int SetSCRstart(struct cvdv_cards *card, u32 SCR_base)  int SetSCRstart(struct cvdv_cards *card, uint32_t SCR_base)
 {  {
         u32 SCR_compare;          uint32_t SCR_compare;
         u32 SCR_compareA;          uint32_t SCR_compareA;
         u32 SCR_compareV;          uint32_t SCR_compareV;
         if (card->startingV) {          if (card->startingV) {
                 printk(KERN_ERR LOGNAME ": SCR in DVD Pack: 0x%08X\n",                  printk(KERN_ERR LOGNAME ": SCR in DVD Pack: 0x%08X\n",
                        SCR_base);                         SCR_base);
Line 443  int SetSCRstart(struct cvdv_cards *card, Line 443  int SetSCRstart(struct cvdv_cards *card,
                 VideoSetBackground(card, 1, 0, 0, 0);   // black                  VideoSetBackground(card, 1, 0, 0, 0);   // black
                 SCR_base = DecoderReadByte(card, 0x009);                  SCR_base = DecoderReadByte(card, 0x009);
                 SCR_base =                  SCR_base =
                     SCR_base | ((u32) DecoderReadByte(card, 0x00A) << 8);                      SCR_base | ((uint32_t) DecoderReadByte(card, 0x00A) << 8);
                 SCR_base =                  SCR_base =
                     SCR_base | ((u32) DecoderReadByte(card, 0x00B) << 16);                      SCR_base | ((uint32_t) DecoderReadByte(card, 0x00B) << 16);
                 SCR_base =                  SCR_base =
                     SCR_base | ((u32) DecoderReadByte(card, 0x00C) << 24);                      SCR_base | ((uint32_t) DecoderReadByte(card, 0x00C) << 24);
                 SCR_compareA = DecoderReadByte(card, 0x014);                  SCR_compareA = DecoderReadByte(card, 0x014);
                 SCR_compareA =                  SCR_compareA =
                     SCR_compareA | ((u32) DecoderReadByte(card, 0x015) <<                      SCR_compareA | ((uint32_t) DecoderReadByte(card, 0x015) <<
                                     8);                                      8);
                 SCR_compareA =                  SCR_compareA =
                     SCR_compareA | ((u32) DecoderReadByte(card, 0x016) <<                      SCR_compareA | ((uint32_t) DecoderReadByte(card, 0x016) <<
                                     16);                                      16);
                 SCR_compareA =                  SCR_compareA =
                     SCR_compareA | ((u32) DecoderReadByte(card, 0x017) <<                      SCR_compareA | ((uint32_t) DecoderReadByte(card, 0x017) <<
                                     24);                                      24);
                 SCR_compareV = DecoderReadByte(card, 0x00D);                  SCR_compareV = DecoderReadByte(card, 0x00D);
                 SCR_compareV =                  SCR_compareV =
                     SCR_compareV | ((u32) DecoderReadByte(card, 0x00E) <<                      SCR_compareV | ((uint32_t) DecoderReadByte(card, 0x00E) <<
                                     8);                                      8);
                 SCR_compareV =                  SCR_compareV =
                     SCR_compareV | ((u32) DecoderReadByte(card, 0x00F) <<                      SCR_compareV | ((uint32_t) DecoderReadByte(card, 0x00F) <<
                                     16);                                      16);
                 SCR_compareV =                  SCR_compareV =
                     SCR_compareV | ((u32) DecoderReadByte(card, 0x010) <<                      SCR_compareV | ((uint32_t) DecoderReadByte(card, 0x010) <<
                                     24);                                      24);
                 if (DecoderReadByte(card, 0x013) & 0x03)                  if (DecoderReadByte(card, 0x013) & 0x03)
                         printk(KERN_DEBUG LOGNAME                          printk(KERN_DEBUG LOGNAME
Line 478  int SetSCRstart(struct cvdv_cards *card, Line 478  int SetSCRstart(struct cvdv_cards *card,
         return 0;          return 0;
 }  }
   
 int DecoderWriteBlock(struct cvdv_cards *card, u8 * data, int size,  int DecoderWriteBlock(struct cvdv_cards *card, uint8_t * data, int size,
                       int initial, int setSCR)                        int initial, int setSCR)
 {  {
         //int a,v,as,vs,ap,vp;          //int a,v,as,vs,ap,vp;
         int res;          int res;
         u32 SCR_base;          uint32_t SCR_base;
         int co = 0;          int co = 0;
         //  u32 SCR_compare;          //  uint32_t SCR_compare;
         res = 0;          res = 0;
                   
         Prepare(card);          Prepare(card);
Line 554  static long margi_write(struct cvdv_card Line 554  static long margi_write(struct cvdv_card
         int res;          int res;
         int channel=0;          int channel=0;
         long int out=0;          long int out=0;
           int wc = 0;
   
         card->nonblock = nonblock;          card->nonblock = nonblock;
   
Line 572  static long margi_write(struct cvdv_card Line 573  static long margi_write(struct cvdv_card
                                         MargiSetBuffers(card, NBBUF*                                          MargiSetBuffers(card, NBBUF*
                                                          CHANNELBUFFERSIZE);                                                           CHANNELBUFFERSIZE);
                                                                   
                                 while (!card->nonblock && out < count){                                  while (wc < 100 &&
                                          !card->nonblock && out < count){
                                           wc++;
                                         out += MargiPush(card, count, data);                                          out += MargiPush(card, count, data);
                                         if (out < count || card->DMAABusy){                                          if (out < count || card->DMAABusy){
                                                 interruptible_sleep_on(&card->wqA);                                                  interruptible_sleep_on(&card->wqA);
Line 598  static long margi_write(struct cvdv_card Line 601  static long margi_write(struct cvdv_card
         }          }
 }         }       
   
   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 ssize_t PSwrite(struct file *file, const char *data, size_t count,  static ssize_t PSwrite(struct file *file, const char *data, size_t count,
                        loff_t * offset)                         loff_t * offset)
Line 628  static int PSioctl(struct inode *inode, Line 638  static int PSioctl(struct inode *inode,
         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;          struct drawcmd *dc;
         struct decodercmd *command;          struct decodercmd *command;
         u16 attr;          uint16_t attr;
   
         if (card != NULL) {          if (card != NULL) {
                 if (_IOC_TYPE(cmd) == CVDV_IOCTL_MAGIC)                  if (_IOC_TYPE(cmd) == CVDV_IOCTL_MAGIC)
Line 666  static int PSioctl(struct inode *inode, Line 676  static int PSioctl(struct inode *inode,
                                 case OSD_SetPalette:    // SetPalette(firstcolor{color},lastcolor{x0},data)                                  case OSD_SetPalette:    // SetPalette(firstcolor{color},lastcolor{x0},data)
                                         return OSDSetPalette(card,                                          return OSDSetPalette(card,
                                                              dc->color,                                                               dc->color,
                                                              dc->x0, (u8 *)                                                               dc->x0, (uint8_t *)
                                                              dc->data);                                                               dc->data);
                                 case OSD_SetTrans:      // SetTrans(transparency{color})                                  case OSD_SetTrans:      // SetTrans(transparency{color})
                                         return OSDSetTrans(card,                                          return OSDSetTrans(card,
Line 679  static int PSioctl(struct inode *inode, Line 689  static int PSioctl(struct inode *inode,
                                 case OSD_GetPixel:      // GetPixel(x0,y0);                                  case OSD_GetPixel:      // GetPixel(x0,y0);
                                         return OSDGetPixel(card, dc->x0,                                          return OSDGetPixel(card, dc->x0,
                                                            dc->y0);                                                             dc->y0);
                                 case OSD_SetRow:        // SetRow(x0,y0,x1,(u8*)data)                                  case OSD_SetRow:        // SetRow(x0,y0,x1,(uint8_t*)data)
                                         return OSDSetRow(card, dc->x0,                                          return OSDSetRow(card, dc->x0,
                                                          dc->y0, dc->x1,                                                           dc->y0, dc->x1,
                                                          (u8 *) dc->data);                                                           (uint8_t *) dc->data);
                                 case OSD_SetBlock:      // SetBlock(x0,y0,x1,y1,(u8*)data)                                  case OSD_SetBlock:      // SetBlock(x0,y0,x1,y1,(uint8_t*)data)
                                         return OSDSetBlock(card, dc->x0,                                          return OSDSetBlock(card, dc->x0,
                                                            dc->y0, dc->x1,                                                             dc->y0, dc->x1,
                                                            dc->y1,                                                             dc->y1,
                                                            dc->color,                                                             dc->color,
                                                            (u8 *)                                                             (uint8_t *)
                                                            dc->data);                                                             dc->data);
                                 case OSD_FillRow:       // FillRow(x0,y0,x1,color)                                  case OSD_FillRow:       // FillRow(x0,y0,x1,color)
                                         return OSDFillRow(card, dc->x0,                                          return OSDFillRow(card, dc->x0,
Line 1076  dvbdev_open(struct dvb_device *dvbdev, i Line 1086  dvbdev_open(struct dvb_device *dvbdev, i
                 ret=DmxDevFilterAlloc(&card->dmxdev, file);                  ret=DmxDevFilterAlloc(&card->dmxdev, file);
                 break;                  break;
         case DVB_DEVICE_DVR_0:          case DVB_DEVICE_DVR_0:
                   margi_open(card, 0);
                 ret=DmxDevDVROpen(&card->dmxdev, file);                  ret=DmxDevDVROpen(&card->dmxdev, file);
                 break;                  break;
                   
Line 1116  dvbdev_close(struct dvb_device *dvbdev, Line 1127  dvbdev_close(struct dvb_device *dvbdev,
   
         case DVB_DEVICE_DVR_0:          case DVB_DEVICE_DVR_0:
                 ret=DmxDevDVRClose(&card->dmxdev, file);                  ret=DmxDevDVRClose(&card->dmxdev, file);
                   if (card->open)
                           all_margi_close(card);
                 break;                  break;
         case DVB_DEVICE_OSD_0:          case DVB_DEVICE_OSD_0:
                 break;                  break;
Line 1158  dvbdev_write(struct dvb_device *dvbdev, Line 1171  dvbdev_write(struct dvb_device *dvbdev,
         return 0;          return 0;
 }  }
   
   static ssize_t 
   dvbdev_read(struct dvb_device *dvbdev, int num, 
               struct file *file, char *buf, size_t count, loff_t *ppos)
   {
           struct cvdv_cards *card=(struct cvdv_cards *) dvbdev->priv;
           int type=num2type(card, num);
   
           switch (type) {
           case DVB_DEVICE_VIDEO_0:
                   break;
           case DVB_DEVICE_AUDIO_0:
                   break;
           case DVB_DEVICE_DEMUX_0:
                   return DmxDevRead(&card->dmxdev, file, buf, count, ppos);
           case DVB_DEVICE_DVR_0:
                   return DmxDevDVRRead(&card->dmxdev, file, buf, count, ppos);
           case DVB_DEVICE_CA_0:
                   break;
           default:
                   return -EOPNOTSUPP;
           }
           return 0;
   }
   
   
   
   
 static int   static int 
 dvbdev_ioctl(struct dvb_device *dvbdev, int num,   dvbdev_ioctl(struct dvb_device *dvbdev, int num, 
Line 1226  dvbdev_ioctl(struct dvb_device *dvbdev, Line 1265  dvbdev_ioctl(struct dvb_device *dvbdev,
                 case VIDEO_SET_DISPLAY_FORMAT:                  case VIDEO_SET_DISPLAY_FORMAT:
                 {                  {
                         videoDisplayFormat_t format=(videoDisplayFormat_t) arg;                          videoDisplayFormat_t format=(videoDisplayFormat_t) arg;
                         u16 val=0;                          uint16_t val=0;
                                                   
                         switch(format) {                          switch(format) {
                         case VIDEO_PAN_SCAN:                          case VIDEO_PAN_SCAN:
Line 1476  static dvb_devs_t mdvb_devs = { Line 1515  static dvb_devs_t mdvb_devs = {
         { 1, 1, 1, 1, INFU, 1, 1, 1, 1}          { 1, 1, 1, 1, INFU, 1, 1, 1, 1}
 };  };
   
   
   static int 
   dvb_start_feed(dvb_demux_feed_t *dvbdmxfeed)
   {
           dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
           struct cvdv_cards * card = (struct cvdv_cards *)dvbdmx->priv;
    
           if (!dvbdmx->dmx.frontend || !card)
                   return -EINVAL;
           
           if (dvbdmxfeed->type == DMX_TYPE_TS) {
                   if ((dvbdmxfeed->ts_type & TS_DECODER) 
                       && (dvbdmxfeed->pes_type<DMX_TS_PES_OTHER)) {
                           switch (dvbdmx->dmx.frontend->source) {
                           case DMX_MEMORY_FE: 
                                   if (dvbdmxfeed->ts_type & TS_DECODER)
                                          if (dvbdmxfeed->pes_type<2 && 
                                              dvbdmx->pids[0]!=0xffff &&
                                               dvbdmx->pids[1]!=0xffff) {
                                                  
                                                  setup_ts2pes( &card->tsa, 
                                                                &card->tsv,
                                                                dvbdmx->pids,
                                                                dvbdmx->pids+1, 
                                                                pes_write,
                                                                (void *)card);
   
                                                  dvbdmx->playing=1;
                                          }
                                   break;
                           default:
                                   return -EINVAL;
                                   break;
                           }
                   } 
           }
           
           if (dvbdmxfeed->type == DMX_TYPE_SEC) {
                   int i;
   
                   for (i=0; i<dvbdmx->filternum; i++) {
                           if (dvbdmx->filter[i].state!=DMX_STATE_READY)
                                   continue;
                           if (dvbdmx->filter[i].type!=DMX_TYPE_SEC)
                                   continue;
                           if (dvbdmx->filter[i].filter.parent!=
                               &dvbdmxfeed->feed.sec)
                                   continue;
   
                           dvbdmxfeed->feed.sec.is_filtering=1;
                           dvbdmx->filter[i].state=DMX_STATE_GO;
                   }
           }
   
           return 0;
   }
   
   
   static int 
   dvb_stop_feed(dvb_demux_feed_t *dvbdmxfeed)
   {
           dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
           struct cvdv_cards * card = (struct cvdv_cards *)dvbdmx->priv;
           if (!card)
                   return -EINVAL;
   
           if (dvbdmxfeed->type == DMX_TYPE_TS) {
                   if ((dvbdmxfeed->ts_type & TS_DECODER) 
                       && (dvbdmxfeed->pes_type<=1)) {
                           if (dvbdmx->playing) {
                                   free_p2p(&card->tsa);
                                   free_p2p(&card->tsv);
                                   DecoderPause(card);
                                   dvbdmx->playing=0;
                           }
                   } 
   
           }
           if (dvbdmxfeed->type == DMX_TYPE_SEC) {
                   int i;
                   
                   for (i=0; i<dvbdmx->filternum; i++)
                           if (dvbdmx->filter[i].state==DMX_STATE_GO && 
                               dvbdmx->filter[i].filter.parent==
                               &dvbdmxfeed->feed.sec) {
                                   dvbdmx->filter[i].state=DMX_STATE_READY;
                   }
                   
           }
           return 0;
   }
   
   
   static int 
   dvb_write_to_decoder(dvb_demux_feed_t *dvbdmxfeed, uint8_t *buf, size_t count)
   {
           dvb_demux_t *dvbdmx=dvbdmxfeed->demux;
           struct cvdv_cards * card = (struct cvdv_cards *)dvbdmx->priv;
           uint16_t pid = 0;
   
           p2p *p;
   
           if (!card)
                   return -EINVAL;
           
           pid = get_pid(buf+1);
                           
           if (pid == *(card->tsa.pid)) p = &(card->tsa);
           else if (pid == *(card->tsv.pid)) p = &(card->tsv);
           else return 0;
   
           if (dvbdmxfeed->pes_type>1)
                   return -1;
           if (!(buf[3]&0x10)) // no payload?
                   return -1;
   
           if (count != TS_SIZE) return -1;
   
           ts_to_pes( p, buf); // don't need count (=188)
           card->audiostate.AVSyncState=0;
   
           return 0;
   }
   
 int dvb_register(struct cvdv_cards *card)  int dvb_register(struct cvdv_cards *card)
 {  {
         int i;          int i,ret;
         struct dvb_device *dvbd=&card->dvb_dev;          struct dvb_device *dvbd=&card->dvb_dev;
           
           dvb_demux_t *dvbdemux = (dvb_demux_t *)&card->demux;
   
         if (card->dvb_registered)          if (card->dvb_registered)
                 return -1;                  return -1;
Line 1499  int dvb_register(struct cvdv_cards *card Line 1664  int dvb_register(struct cvdv_cards *card
         card->videostate.displayFormat=VIDEO_CENTER_CUT_OUT;          card->videostate.displayFormat=VIDEO_CENTER_CUT_OUT;
   
         // init and register demuxes          // init and register demuxes
           memcpy(card->demux_id, "demux0_0", 9);
           card->demux_id[7] = 1+0x30;
           dvbdemux->priv = (void *) card;
           dvbdemux->filternum = 32;
           dvbdemux->feednum = 32;
           dvbdemux->start_feed = dvb_start_feed;
           dvbdemux->stop_feed = dvb_stop_feed;
           dvbdemux->write_to_decoder = dvb_write_to_decoder;
                   
           dvbdemux->dmx.vendor="CIM";
           dvbdemux->dmx.model="sw";
           dvbdemux->dmx.id=card->demux_id;
           dvbdemux->dmx.capabilities=(DMX_TS_FILTERING|
                                       DMX_SECTION_FILTERING|
                                       DMX_MEMORY_BASED_FILTERING);
           
           DvbDmxInit(&card->demux);
   
           card->dmxdev.filternum=32;
           card->dmxdev.demux=&dvbdemux->dmx;
           card->dmxdev.capabilities=0;
   
           DmxDevInit(&card->dmxdev);
                   
           card->mem_frontend.id="mem_frontend";
           card->mem_frontend.vendor="memory";
           card->mem_frontend.model="sw";
           card->mem_frontend.source=DMX_MEMORY_FE;
           ret=dvbdemux->dmx.add_frontend(&dvbdemux->dmx, 
                                           &card->mem_frontend);
           if (ret<0)
                   return ret;
           ret=dvbdemux->dmx.connect_frontend(&dvbdemux->dmx, 
                                              &card->mem_frontend);
           if (ret<0)
                   return ret;
   
         // init and register dvb device structure          // init and register dvb device structure
         dvbd->priv=(void *) card;          dvbd->priv=(void *) card;
         dvbd->open=dvbdev_open;          dvbd->open=dvbdev_open;
         dvbd->close=dvbdev_close;          dvbd->close=dvbdev_close;
         dvbd->write=dvbdev_write;          dvbd->write=dvbdev_write;
           dvbd->read=dvbdev_read;
         dvbd->ioctl=dvbdev_ioctl;          dvbd->ioctl=dvbdev_ioctl;
         dvbd->poll=dvbdev_poll;          dvbd->poll=dvbdev_poll;
         dvbd->device_type=dvbdev_device_type;          dvbd->device_type=dvbdev_device_type;
Line 1515  int dvb_register(struct cvdv_cards *card Line 1716  int dvb_register(struct cvdv_cards *card
   
         card->dvb_devs=0;          card->dvb_devs=0;
         card->dvb_devs=&mdvb_devs;          card->dvb_devs=&mdvb_devs;
           
         return dvb_register_device(dvbd);          return dvb_register_device(dvbd);
 }  }
   
 void dvb_unregister(struct cvdv_cards *card)  void dvb_unregister(struct cvdv_cards *card)
 {  {
           dvb_demux_t *dvbdemux=&card->demux;
   
           dvbdemux->dmx.close(&dvbdemux->dmx);
           dvbdemux->dmx.remove_frontend(&dvbdemux->dmx, &card->mem_frontend);
           DmxDevRelease(&card->dmxdev);
           DvbDmxRelease(&card->demux);
         dvb_unregister_device(&card->dvb_dev);          dvb_unregister_device(&card->dvb_dev);
 }  }
 #endif  #endif
Removed from v.1.11  
changed lines
  Added in v.1.12

LinuxTV legacy CVS <linuxtv.org/cvs>