← Back to branch summary

~ubuntu-dev/mplayer/upstream-ubuntu

« back to all changes in this revision

Viewing changes to libmpdemux/vcd_read_darwin.h

  • Committer: Reinhard Tartler
  • Date: 2006-07-08 08:45:33 UTC
  • Revision ID: siretart@tauware.de-20060708084533-dbc155bde7122e78
imported mplayer_0.99+1.0pre7try2+cvs20060117

Show diffs side-by-side

added added

removed removed

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