stream/vcd_read_darwin.h

   1 #ifndef MPLAYER_VCD_READ_DARWIN_H
   2 #define MPLAYER_VCD_READ_DARWIN_H
   3
   4 #define _XOPEN_SOURCE 500
   5
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <errno.h>
   9 #include <sys/types.h>
  10 #include <sys/uio.h>
  11 #include <unistd.h>
  12 #include <CoreFoundation/CFBase.h>
  13 #include <IOKit/IOKitLib.h>
  14 #include <IOKit/storage/IOCDTypes.h>
  15 #include <IOKit/storage/IOCDMedia.h>
  16 #include <IOKit/storage/IOCDMediaBSDClient.h>
  17 #include "mpbswap.h"
  18 #include "mp_msg.h"
  19 #include "stream.h"
  20
  21 //=================== VideoCD ==========================
  22 #define CDROM_LEADOUT   0xAA
  23
  24 typedef struct
  25 {
  26         uint8_t sync            [12];
  27         uint8_t header          [4];
  28         uint8_t subheader       [8];
  29         uint8_t data            [2324];
  30         uint8_t spare           [4];
  31 } cdsector_t;
  32
  33 typedef struct mp_vcd_priv_st
  34 {
  35         int fd;
  36         cdsector_t buf;
  37         dk_cd_read_track_info_t entry;
  38         struct CDDiscInfo hdr;
  39         CDMSF msf;
  40 } mp_vcd_priv_t;
  41
  42 static inline void vcd_set_msf(mp_vcd_priv_t* vcd, unsigned int sect)
  43 {
  44   vcd->msf = CDConvertLBAToMSF(sect);
  45 }
  46
  47 static inline unsigned int vcd_get_msf(mp_vcd_priv_t* vcd)
  48 {
  49   return CDConvertMSFToLBA(vcd->msf);
  50 }
  51
  52 int vcd_seek_to_track(mp_vcd_priv_t* vcd, int track)
  53 {
  54         struct CDTrackInfo entry;
  55
  56         memset( &vcd->entry, 0, sizeof(vcd->entry));
  57         vcd->entry.addressType = kCDTrackInfoAddressTypeTrackNumber;
  58         vcd->entry.address = track;
  59         vcd->entry.bufferLength = sizeof(entry);
  60         vcd->entry.buffer = &entry;
  61
  62         if (ioctl(vcd->fd, DKIOCCDREADTRACKINFO, &vcd->entry))
  63         {
  64                 mp_msg(MSGT_STREAM,MSGL_ERR,"ioctl dif1: %s\n",strerror(errno));
  65                 return -1;
  66         }
  67         vcd->msf = CDConvertLBAToMSF(be2me_32(entry.trackStartAddress));
  68         return VCD_SECTOR_DATA*vcd_get_msf(vcd);
  69 }
  70
  71 int vcd_get_track_end(mp_vcd_priv_t* vcd, int track)
  72 {
  73         struct CDTrackInfo entry;
  74
  75         if (track > vcd->hdr.lastTrackNumberInLastSessionLSB) {
  76                 mp_msg(MSGT_OPEN, MSGL_ERR,
  77                        "track number %d greater than last track number %d\n",
  78                        track, vcd->hdr.lastTrackNumberInLastSessionLSB);
  79                 return -1;
  80         }
  81
  82         //read track info
  83         memset( &vcd->entry, 0, sizeof(vcd->entry));
  84         vcd->entry.addressType = kCDTrackInfoAddressTypeTrackNumber;
  85         vcd->entry.address = track<vcd->hdr.lastTrackNumberInLastSessionLSB?track+1:vcd->hdr.lastTrackNumberInLastSessionLSB;
  86         vcd->entry.bufferLength = sizeof(entry);
  87         vcd->entry.buffer = &entry;
  88
  89         if (ioctl(vcd->fd, DKIOCCDREADTRACKINFO, &vcd->entry))
  90         {
  91                 mp_msg(MSGT_STREAM,MSGL_ERR,"ioctl dif2: %s\n",strerror(errno));
  92                 return -1;
  93         }
  94         if (track == vcd->hdr.lastTrackNumberInLastSessionLSB)
  95                 vcd->msf = CDConvertLBAToMSF(be2me_32(entry.trackStartAddress) +
  96                                              be2me_32(entry.trackSize));
  97         else
  98         vcd->msf = CDConvertLBAToMSF(be2me_32(entry.trackStartAddress));
  99         return VCD_SECTOR_DATA*vcd_get_msf(vcd);
 100 }
 101
 102 mp_vcd_priv_t* vcd_read_toc(int fd)
 103 {
 104         dk_cd_read_disc_info_t tochdr;
 105         struct CDDiscInfo hdr;
 106
 107         dk_cd_read_track_info_t tocentry;
 108         struct CDTrackInfo entry;
 109         CDMSF trackMSF;
 110
 111         mp_vcd_priv_t* vcd;
 112         int i, min = 0, sec = 0, frame = 0;
 113
 114         //read toc header
 115     memset(&tochdr, 0, sizeof(tochdr));
 116     tochdr.buffer = &hdr;
 117     tochdr.bufferLength = sizeof(hdr);
 118
 119     if (ioctl(fd, DKIOCCDREADDISCINFO, &tochdr) < 0)
 120         {
 121                 mp_msg(MSGT_OPEN,MSGL_ERR,"read CDROM toc header: %s\n",strerror(errno));
 122                 return NULL;
 123     }
 124
 125         //print all track info
 126         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VCD_START_TRACK=%d\n", hdr.firstTrackNumberInLastSessionLSB);
 127         mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VCD_END_TRACK=%d\n", hdr.lastTrackNumberInLastSessionLSB);
 128         for (i=hdr.firstTrackNumberInLastSessionLSB ; i<=hdr.lastTrackNumberInLastSessionLSB + 1; i++)
 129         {
 130                 if (i <= hdr.lastTrackNumberInLastSessionLSB) {
 131                 memset( &tocentry, 0, sizeof(tocentry));
 132                 tocentry.addressType = kCDTrackInfoAddressTypeTrackNumber;
 133                 tocentry.address = i;
 134                 tocentry.bufferLength = sizeof(entry);
 135                 tocentry.buffer = &entry;
 136
 137                 if (ioctl(fd,DKIOCCDREADTRACKINFO,&tocentry)==-1)
 138                 {
 139                         mp_msg(MSGT_OPEN,MSGL_ERR,"read CDROM toc entry: %s\n",strerror(errno));
 140                         return NULL;
 141                 }
 142
 143                 trackMSF = CDConvertLBAToMSF(be2me_32(entry.trackStartAddress));
 144                 }
 145                 else
 146                         trackMSF = CDConvertLBAToMSF(be2me_32(entry.trackStartAddress)
 147                                                      + be2me_32(entry.trackSize));
 148
 149                 //mp_msg(MSGT_OPEN,MSGL_INFO,"track %02d:  adr=%d  ctrl=%d  format=%d  %02d:%02d:%02d\n",
 150                 if (i<=hdr.lastTrackNumberInLastSessionLSB)
 151                 mp_msg(MSGT_OPEN,MSGL_INFO,"track %02d: format=%d  %02d:%02d:%02d\n",
 152           (int)tocentry.address,
 153           //(int)tocentry.entry.addr_type,
 154           //(int)tocentry.entry.control,
 155           (int)tocentry.addressType,
 156           (int)trackMSF.minute,
 157           (int)trackMSF.second,
 158           (int)trackMSF.frame
 159                 );
 160
 161                 if (mp_msg_test(MSGT_IDENTIFY, MSGL_INFO))
 162                 {
 163                   if (i > hdr.firstTrackNumberInLastSessionLSB)
 164                   {
 165                     min = trackMSF.minute - min;
 166                     sec = trackMSF.second - sec;
 167                     frame = trackMSF.frame - frame;
 168                     if ( frame < 0 )
 169                     {
 170                       frame += 75;
 171                       sec --;
 172                     }
 173                     if ( sec < 0 )
 174                     {
 175                       sec += 60;
 176                       min --;
 177                     }
 178                     mp_msg(MSGT_IDENTIFY, MSGL_INFO, "ID_VCD_TRACK_%d_MSF=%02d:%02d:%02d\n", i - 1, min, sec, frame);
 179                   }
 180                   min = trackMSF.minute;
 181                   sec = trackMSF.second;
 182                   frame = trackMSF.frame;
 183                 }
 184         }
 185
 186         vcd = malloc(sizeof(mp_vcd_priv_t));
 187         vcd->fd = fd;
 188         vcd->hdr = hdr;
 189         vcd->msf = trackMSF;
 190         return vcd;
 191 }
 192
 193 static int vcd_read(mp_vcd_priv_t* vcd,char *mem)
 194 {
 195         if (pread(vcd->fd,&vcd->buf,VCD_SECTOR_SIZE,vcd_get_msf(vcd)*VCD_SECTOR_SIZE) != VCD_SECTOR_SIZE)
 196                 return 0;  // EOF?
 197
 198         vcd->msf.frame++;
 199         if (vcd->msf.frame==75)
 200         {
 201                 vcd->msf.frame=0;
 202                 vcd->msf.second++;
 203
 204                 if (vcd->msf.second==60)
 205                 {
 206                         vcd->msf.second=0;
 207                         vcd->msf.minute++;
 208         }
 209       }
 210
 211       memcpy(mem,vcd->buf.data,VCD_SECTOR_DATA);
 212       return VCD_SECTOR_DATA;
 213 }
 214
 215 #endif /* MPLAYER_VCD_READ_DARWIN_H */