Mercurial > mplayer.hg
comparison libmpdemux/dvdnav_stream.c @ 18712:cb7da1894b00
restored support for dvdnav only in the stream layer; all other functionalities are disabled
author | nicodvb |
---|---|
date | Wed, 14 Jun 2006 21:58:17 +0000 |
parents | 6ff3379a0862 |
children | 5c8acc972551 |
comparison
equal
deleted
inserted
replaced
18711:4d87a5c4611c | 18712:cb7da1894b00 |
---|---|
1 #include "config.h" | 1 #include "config.h" |
2 | 2 |
3 #ifdef USE_DVDNAV | 3 #ifdef USE_DVDNAV |
4 #include <dvdnav_internal.h> | |
5 #include <stdlib.h> | 4 #include <stdlib.h> |
6 #include <stdio.h> | 5 #include <stdio.h> |
7 #include <unistd.h> | 6 #include <unistd.h> |
8 #include <string.h> | 7 #include <string.h> |
9 #include "mp_msg.h" | 8 #include "mp_msg.h" |
10 #include "osdep/timer.h" | 9 #include "osdep/timer.h" |
11 #include "input/input.h" | 10 #include "input/input.h" |
12 #include "stream.h" | 11 #include "stream.h" |
12 #include "demuxer.h" | |
13 #include "dvdnav_stream.h" | 13 #include "dvdnav_stream.h" |
14 #include "libvo/video_out.h" | 14 #include "libvo/video_out.h" |
15 #include "spudec.h" | 15 #include "spudec.h" |
16 #include "m_option.h" | 16 #include "m_option.h" |
17 #include "m_struct.h" | 17 #include "m_struct.h" |
18 #include "help_mp.h" | |
19 | |
20 extern char *dvd_device; | |
21 extern char *audio_lang, *dvdsub_lang; | |
18 | 22 |
19 static struct stream_priv_s { | 23 static struct stream_priv_s { |
20 int track; | 24 int track; |
21 char* device; | 25 char* device; |
22 } stream_priv_dflts = { | 26 } stream_priv_dflts = { |
25 }; | 29 }; |
26 | 30 |
27 #define ST_OFF(f) M_ST_OFF(struct stream_priv_s,f) | 31 #define ST_OFF(f) M_ST_OFF(struct stream_priv_s,f) |
28 /// URL definition | 32 /// URL definition |
29 static m_option_t stream_opts_fields[] = { | 33 static m_option_t stream_opts_fields[] = { |
34 {"filename", ST_OFF(device), CONF_TYPE_STRING, 0, 0, 0, NULL }, | |
35 {"hostname", ST_OFF(track), CONF_TYPE_INT, 0, 0, 0, NULL}, | |
30 { NULL, NULL, 0, 0, 0, 0, NULL } | 36 { NULL, NULL, 0, 0, 0, 0, NULL } |
31 }; | 37 }; |
32 static struct m_struct_st stream_opts = { | 38 static struct m_struct_st stream_opts = { |
33 "dvd", | 39 "dvd", |
34 sizeof(struct stream_priv_s), | 40 sizeof(struct stream_priv_s), |
71 if (!dvdnav_priv->dvdnav) { | 77 if (!dvdnav_priv->dvdnav) { |
72 free(dvdnav_priv); | 78 free(dvdnav_priv); |
73 return NULL; | 79 return NULL; |
74 } | 80 } |
75 | 81 |
76 dvdnav_stream_ignore_timers(dvdnav_priv,dvd_nav_skip_opening); | 82 if(1) //from vlc: if not used dvdnav from cvs will fail |
77 | 83 { |
84 int len, event; | |
85 char buf[2048]; | |
86 | |
87 dvdnav_get_next_block(dvdnav_priv->dvdnav,buf,&event,&len); | |
88 } | |
89 | |
78 /* turn on dvdnav caching */ | 90 /* turn on dvdnav caching */ |
79 dvdnav_set_readahead_flag(dvdnav_priv->dvdnav,1); | 91 dvdnav_set_readahead_flag(dvdnav_priv->dvdnav, 0); |
80 | 92 if(dvdnav_set_PGC_positioning_flag(dvdnav_priv->dvdnav, 1) != DVDNAV_STATUS_OK) |
93 mp_msg(MSGT_OPEN,MSGL_ERR,"stream_dvdnav, failed to set PGC positioning\n"); | |
94 #if 1 | |
81 /* report the title?! */ | 95 /* report the title?! */ |
82 if (dvdnav_get_title_string(dvdnav_priv->dvdnav,&title_str)==DVDNAV_STATUS_OK) { | 96 if (dvdnav_get_title_string(dvdnav_priv->dvdnav,&title_str)==DVDNAV_STATUS_OK) { |
83 mp_msg(MSGT_OPEN,MSGL_INFO,"Title: '%s'\n",title_str); | 97 mp_msg(MSGT_IDENTIFY, MSGL_INFO,"Title: '%s'\n",title_str); |
84 } | 98 } |
99 #endif | |
100 | |
101 //dvdnav_event_clear(dvdnav_priv); | |
85 | 102 |
86 return dvdnav_priv; | 103 return dvdnav_priv; |
87 } | 104 } |
88 | 105 |
89 int dvdnav_stream_reset(dvdnav_priv_t * dvdnav_priv) { | 106 int dvdnav_stream_reset(dvdnav_priv_t * dvdnav_priv) { |
93 return 0; | 110 return 0; |
94 | 111 |
95 dvdnav_priv->started=0; | 112 dvdnav_priv->started=0; |
96 | 113 |
97 return 1; | 114 return 1; |
98 } | |
99 | |
100 void free_dvdnav_stream(dvdnav_priv_t * dvdnav_priv) { | |
101 if (!dvdnav_priv) return; | |
102 | |
103 dvdnav_close(dvdnav_priv->dvdnav); | |
104 dvdnav_priv->dvdnav=NULL; | |
105 free(dvdnav_priv); | |
106 } | |
107 | |
108 void dvdnav_stream_ignore_timers(dvdnav_priv_t * dvdnav_priv, int ignore) { | |
109 if (!dvdnav_priv) return; | |
110 | |
111 dvdnav_priv->ignore_timers=ignore; | |
112 } | 115 } |
113 | 116 |
114 int dvdnav_stream_sleeping(dvdnav_priv_t * dvdnav_priv) { | 117 int dvdnav_stream_sleeping(dvdnav_priv_t * dvdnav_priv) { |
115 unsigned int now; | 118 unsigned int now; |
116 | 119 |
124 // usec_sleep(1000); /* 1ms granularity */ | 127 // usec_sleep(1000); /* 1ms granularity */ |
125 return 1; | 128 return 1; |
126 } | 129 } |
127 dvdnav_still_skip(dvdnav_priv->dvdnav); // continue past... | 130 dvdnav_still_skip(dvdnav_priv->dvdnav); // continue past... |
128 dvdnav_priv->sleeping=0; | 131 dvdnav_priv->sleeping=0; |
129 printf("%s: woke up!\n",__FUNCTION__); | 132 mp_msg(MSGT_OPEN,MSGL_V, "%s: woke up!\n",__FUNCTION__); |
130 } | 133 } |
131 dvd_nav_still=0; | 134 dvd_nav_still=0; |
132 printf("%s: active\n",__FUNCTION__); | 135 mp_msg(MSGT_OPEN,MSGL_V, "%s: active\n",__FUNCTION__); |
133 return 0; | 136 return 0; |
134 } | 137 } |
135 | 138 |
136 void dvdnav_stream_sleep(dvdnav_priv_t * dvdnav_priv, int seconds) { | 139 void dvdnav_stream_sleep(dvdnav_priv_t * dvdnav_priv, int seconds) { |
137 if (!dvdnav_priv) return; | 140 if (!dvdnav_priv) return; |
141 dvdnav_priv->sleeping=0; | 144 dvdnav_priv->sleeping=0; |
142 switch (seconds) { | 145 switch (seconds) { |
143 case 0: | 146 case 0: |
144 return; | 147 return; |
145 case 0xff: | 148 case 0xff: |
146 printf( "Sleeping indefinately\n" ); | 149 mp_msg(MSGT_OPEN,MSGL_V, "Sleeping indefinately\n" ); |
147 dvdnav_priv->sleeping=2; | 150 dvdnav_priv->sleeping=2; |
148 break; | 151 break; |
149 default: | 152 default: |
150 printf( "Sleeping %d sec(s)\n", seconds ); | 153 mp_msg(MSGT_OPEN,MSGL_V, "Sleeping %d sec(s)\n", seconds ); |
151 dvdnav_priv->sleep_until = GetTimer();// + seconds*1000000; | 154 dvdnav_priv->sleep_until = GetTimer();// + seconds*1000000; |
152 dvdnav_priv->sleeping=1; | 155 dvdnav_priv->sleeping=1; |
153 break; | 156 break; |
154 } | 157 } |
155 //if (dvdnav_priv->started) dvd_nav_still=1; | 158 //if (dvdnav_priv->started) dvd_nav_still=1; |
162 mp_cmd_t * cmd; | 165 mp_cmd_t * cmd; |
163 | 166 |
164 if (!dvdnav_priv->started) return; | 167 if (!dvdnav_priv->started) return; |
165 | 168 |
166 if (!(dvdnav_event=(dvdnav_event_t*)calloc(1,sizeof(*dvdnav_event)))) { | 169 if (!(dvdnav_event=(dvdnav_event_t*)calloc(1,sizeof(*dvdnav_event)))) { |
167 printf("%s: dvdnav_event: out of memory!\n",__FUNCTION__); | 170 mp_msg(MSGT_OPEN,MSGL_V, "%s: dvdnav_event: out of memory!\n",__FUNCTION__); |
168 return; | 171 return; |
169 } | 172 } |
170 dvdnav_event->event=event; | 173 dvdnav_event->event=event; |
171 dvdnav_event->details=calloc(1,len); | 174 dvdnav_event->details=calloc(1,len); |
172 memcpy(dvdnav_event->details,buf,len); | 175 memcpy(dvdnav_event->details,buf,len); |
173 dvdnav_event->len=len; | 176 dvdnav_event->len=len; |
174 | 177 |
175 if (!(cmd = (mp_cmd_t*)calloc(1,sizeof(*cmd)))) { | 178 if (!(cmd = (mp_cmd_t*)calloc(1,sizeof(*cmd)))) { |
176 printf("%s: mp_cmd_t: out of memory!\n",__FUNCTION__); | 179 mp_msg(MSGT_OPEN,MSGL_V, "%s: mp_cmd_t: out of memory!\n",__FUNCTION__); |
177 free(dvdnav_event->details); | 180 free(dvdnav_event->details); |
178 free(dvdnav_event); | 181 free(dvdnav_event); |
179 return; | 182 return; |
180 } | 183 } |
181 cmd->id=MP_CMD_DVDNAV_EVENT; // S+event; | 184 cmd->id=MP_CMD_DVDNAV_EVENT; // S+event; |
182 cmd->name=strdup("dvdnav_event"); // FIXME: do I really need a 'name'? | 185 cmd->name=strdup("dvdnav_event"); // FIXME: do I really need a 'name'? |
183 cmd->nargs=1; | 186 cmd->nargs=1; |
184 cmd->args[0].v.v=dvdnav_event; | 187 cmd->args[0].v.v=dvdnav_event; |
185 | 188 } |
186 mp_input_queue_cmd(cmd); | 189 |
187 } | 190 int dvdnav_stream_read(dvdnav_priv_t * dvdnav_priv, unsigned char *buf, int *len) { |
188 | |
189 void dvdnav_stream_read(dvdnav_priv_t * dvdnav_priv, unsigned char *buf, int *len) { | |
190 int event = DVDNAV_NOP; | 191 int event = DVDNAV_NOP; |
191 | 192 |
192 if (!len) return; | 193 if (!len) return -1; |
193 *len=-1; | 194 *len=-1; |
194 if (!dvdnav_priv) return; | 195 if (!dvdnav_priv) return -1; |
195 if (!buf) return; | 196 if (!buf) return -1; |
196 | 197 |
197 if (dvd_nav_still) { | 198 if (dvd_nav_still) { |
198 printf("%s: got a stream_read while I should be asleep!\n",__FUNCTION__); | 199 mp_msg(MSGT_OPEN,MSGL_V, "%s: got a stream_read while I should be asleep!\n",__FUNCTION__); |
199 *len=0; | 200 *len=0; |
200 return; | 201 return -1; |
201 } | 202 } |
202 | 203 |
203 if (dvdnav_get_next_block(dvdnav_priv->dvdnav,buf,&event,len)!=DVDNAV_STATUS_OK) { | 204 if (dvdnav_get_next_block(dvdnav_priv->dvdnav,buf,&event,len)!=DVDNAV_STATUS_OK) { |
204 printf( "Error getting next block from DVD (%s)\n",dvdnav_err_to_string(dvdnav_priv->dvdnav) ); | 205 mp_msg(MSGT_OPEN,MSGL_V, "Error getting next block from DVD %d (%s)\n",event, dvdnav_err_to_string(dvdnav_priv->dvdnav) ); |
205 *len=-1; | 206 *len=-1; |
206 } | 207 } |
207 else if (event!=DVDNAV_BLOCK_OK) { | 208 else if (event!=DVDNAV_BLOCK_OK) { |
208 | 209 |
209 // need to handle certain events internally (like skipping stills) | 210 // need to handle certain events internally (like skipping stills) |
210 switch (event) { | 211 switch (event) { |
211 case DVDNAV_STILL_FRAME: { | 212 case DVDNAV_STILL_FRAME: { |
212 dvdnav_still_event_t *still_event = (dvdnav_still_event_t*)(buf); | 213 dvdnav_still_event_t *still_event = (dvdnav_still_event_t*)(buf); |
213 | |
214 printf("************************************************************ STILL \n"); | |
215 | |
216 //if (dvdnav_priv->started) dvd_nav_still=1; | 214 //if (dvdnav_priv->started) dvd_nav_still=1; |
217 //else | 215 //else |
218 dvdnav_still_skip(dvdnav_priv->dvdnav); // don't let dvdnav stall on this image | 216 dvdnav_still_skip(dvdnav_priv->dvdnav); // don't let dvdnav stall on this image |
219 | 217 |
220 break; | 218 break; |
224 // got an event, repeat the read | 222 // got an event, repeat the read |
225 dvdnav_stream_add_event(dvdnav_priv,event,buf,*len); | 223 dvdnav_stream_add_event(dvdnav_priv,event,buf,*len); |
226 *len=0; | 224 *len=0; |
227 } | 225 } |
228 // printf("%s: got %d\n",__FUNCTION__,*len); | 226 // printf("%s: got %d\n",__FUNCTION__,*len); |
227 return event; | |
229 } | 228 } |
230 | 229 |
231 void dvdnav_stream_fullstart(dvdnav_priv_t * dvdnav_priv) { | 230 void dvdnav_stream_fullstart(dvdnav_priv_t * dvdnav_priv) { |
232 if (dvdnav_priv && !dvdnav_priv->started) { | 231 if (dvdnav_priv && !dvdnav_priv->started) { |
233 dvdnav_stream_reset(dvdnav_priv); | 232 dvdnav_stream_reset(dvdnav_priv); |
235 } | 234 } |
236 } | 235 } |
237 | 236 |
238 unsigned int * dvdnav_stream_get_palette(dvdnav_priv_t * dvdnav_priv) { | 237 unsigned int * dvdnav_stream_get_palette(dvdnav_priv_t * dvdnav_priv) { |
239 if (!dvdnav_priv) { | 238 if (!dvdnav_priv) { |
240 printf("%s: NULL dvdnav_priv\n",__FUNCTION__); | 239 mp_msg(MSGT_OPEN,MSGL_V, "%s: NULL dvdnav_priv\n",__FUNCTION__); |
241 return NULL; | 240 return NULL; |
242 } | 241 } |
243 if (!dvdnav_priv->dvdnav) { | 242 if (!dvdnav_priv->dvdnav) { |
244 printf("%s: NULL dvdnav_priv->dvdnav\n",__FUNCTION__); | 243 mp_msg(MSGT_OPEN,MSGL_V, "%s: NULL dvdnav_priv->dvdnav\n",__FUNCTION__); |
245 return NULL; | 244 return NULL; |
246 } | 245 } |
246 #if 0 | |
247 if (!dvdnav_priv->dvdnav->vm) { | 247 if (!dvdnav_priv->dvdnav->vm) { |
248 printf("%s: NULL dvdnav_priv->dvdnav->vm\n",__FUNCTION__); | 248 mp_msg(MSGT_OPEN,MSGL_V, "%s: NULL dvdnav_priv->dvdnav->vm\n",__FUNCTION__); |
249 return NULL; | 249 return NULL; |
250 } | 250 } |
251 if (!dvdnav_priv->dvdnav->vm->state.pgc) { | 251 if (!dvdnav_priv->dvdnav->vm->state.pgc) { |
252 printf("%s: NULL dvdnav_priv->dvdnav->vm->state.pgc\n",__FUNCTION__); | 252 printf("%s: NULL dvdnav_priv->dvdnav->vm->state.pgc\n",__FUNCTION__); |
253 return NULL; | 253 return NULL; |
254 } | 254 } |
255 return dvdnav_priv->dvdnav->vm->state.pgc->palette; | 255 return dvdnav_priv->dvdnav->vm->state.pgc->palette; |
256 #endif | |
257 } | |
258 | |
259 static void update_title_len(stream_t *stream) { | |
260 dvdnav_priv_t *priv = stream->priv; | |
261 dvdnav_status_t status; | |
262 uint32_t pos = 0, len = 0; | |
263 | |
264 status = dvdnav_get_position(priv->dvdnav, &pos, &len); | |
265 if(status == DVDNAV_STATUS_OK && len) | |
266 stream->end_pos = (off_t) len * 2048; | |
256 } | 267 } |
257 | 268 |
258 | 269 |
259 static int seek(stream_t *s, off_t newpos) { | 270 static int seek(stream_t *s, off_t newpos) { |
271 uint32_t pos = 0, len = 0, sector = 0; | |
272 dvdnav_priv_t *priv = s->priv; | |
273 | |
260 if(newpos==0) { | 274 if(newpos==0) { |
261 if(dvdnav_stream_reset((dvdnav_priv_t*)s->priv)) | 275 if(dvdnav_stream_reset(priv->dvdnav)) |
262 s->pos=0; | 276 s->pos=0; |
263 } | 277 } |
264 if(newpos!=s->pos) | 278 else { |
265 mp_msg(MSGT_STREAM,MSGL_INFO,"Cannot seek in DVDNAV streams yet!\n"); | 279 if(s->end_pos && newpos > s->end_pos) |
266 | 280 newpos = s->end_pos; |
281 sector = newpos / 2048ULL; | |
282 if(dvdnav_sector_search(priv->dvdnav, (uint64_t) sector, SEEK_SET) != DVDNAV_STATUS_OK) | |
283 goto fail; | |
284 | |
285 s->pos = newpos; | |
286 } | |
287 | |
267 return 1; | 288 return 1; |
268 } | 289 |
269 | 290 fail: |
270 static void stream_dvd_close(stream_t *s) { | 291 mp_msg(MSGT_STREAM,MSGL_INFO,"dvdnav_stream, seeking to %"PRIu64" failed: %s\n", newpos, dvdnav_err_to_string(priv->dvdnav)); |
271 dvd_close(s->priv); | 292 |
293 return 1; | |
294 } | |
295 | |
296 static void stream_dvdnav_close(stream_t *s) { | |
297 dvdnav_priv_t *priv = s->priv; | |
298 dvdnav_close(priv->dvdnav); | |
299 priv->dvdnav = NULL; | |
300 free(priv); | |
301 } | |
302 | |
303 | |
304 static int fill_buffer(stream_t *s, char *but, int len) | |
305 { | |
306 int event; | |
307 dvdnav_priv_t* dvdnav_priv=s->priv; | |
308 len=0; | |
309 if(!s->end_pos) | |
310 update_title_len(s); | |
311 while(!len) /* grab all event until DVDNAV_BLOCK_OK (len=2048), DVDNAV_STOP or DVDNAV_STILL_FRAME */ | |
312 { | |
313 if(-1==(event=dvdnav_stream_read(dvdnav_priv, s->buffer, &len)) || len==-1) | |
314 { | |
315 mp_msg(MSGT_CPLAYER,MSGL_ERR, "DVDNAV stream read error!\n"); | |
316 return 0; | |
317 } | |
318 switch (event) { | |
319 case DVDNAV_STOP: return len; | |
320 case DVDNAV_BLOCK_OK: return len; | |
321 #if 0 | |
322 case DVDNAV_STILL_FRAME: { | |
323 if(!dvdnav_priv->stillok) dvdnav_priv->stillcounter++; | |
324 dvdnav_priv->lockstillcounter++; | |
325 return len; | |
326 break; | |
327 } | |
328 | |
329 case DVDNAV_WAIT: { | |
330 if(dvdnav_priv->waitcounter>=DVDNAV_MAX_WAIT_FRAME) return len; | |
331 break; | |
332 } | |
333 #endif | |
334 } | |
335 #if 0 | |
336 if(dvdnav_priv->event.cell_really_change && | |
337 dvdnav_priv->started && | |
338 !dvdnav_priv->vts_domain) | |
339 return len; | |
340 #endif | |
341 } | |
342 mp_msg(MSGT_STREAM,MSGL_DBG2,"DVDNAV fill_buffer len: %d\n",len); | |
343 return len; | |
272 } | 344 } |
273 | 345 |
274 static int open_s(stream_t *stream,int mode, void* opts, int* file_format) { | 346 static int open_s(stream_t *stream,int mode, void* opts, int* file_format) { |
275 struct stream_priv_s* p = (struct stream_priv_s*)opts; | 347 struct stream_priv_s* p = (struct stream_priv_s*)opts; |
276 char *filename, *name; | 348 char *filename; |
277 int event,len,tmplen=0; | 349 int event,len,tmplen=0; |
350 uint32_t pos, l2; | |
278 dvdnav_priv_t *dvdnav_priv; | 351 dvdnav_priv_t *dvdnav_priv; |
279 | 352 dvdnav_status_t status; |
280 mp_msg(MSGT_OPEN,MSGL_INFO,"URL: %s\n", filename); | 353 |
281 filename = strdup(stream->url); | 354 //mp_msg(MSGT_OPEN,MSGL_INFO,"URL: %s\n", filename); |
282 name = (filename[9] == '\0') ? NULL : filename + 9; | 355 |
283 if(!name) name=DEFAULT_DVD_DEVICE; | 356 if(p->device) filename = p->device; |
284 if(!(dvdnav_priv=new_dvdnav_stream(name))) { | 357 else if(dvd_device) filename= dvd_device; |
285 mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_CantOpenDVD,name); | 358 else filename = DEFAULT_DVD_DEVICE; |
359 if(!(dvdnav_priv=new_dvdnav_stream(filename))) { | |
360 mp_msg(MSGT_OPEN,MSGL_ERR,MSGTR_CantOpenDVD,filename); | |
361 return STREAM_UNSUPORTED; | |
362 } | |
363 | |
364 if(dvdnav_title_play(dvdnav_priv->dvdnav, p->track) != DVDNAV_STATUS_OK) { | |
365 mp_msg(MSGT_OPEN,MSGL_FATAL,"dvdnav_stream, couldn't select title %d, error '%s'\n", p->track, dvdnav_err_to_string(dvdnav_priv->dvdnav)); | |
286 return STREAM_UNSUPORTED; | 366 return STREAM_UNSUPORTED; |
287 } | 367 } |
288 | 368 |
289 stream->sector_size = 2048; | 369 stream->sector_size = 2048; |
290 stream->flags = STREAM_READ | STREAM_SEEK; | 370 stream->flags = STREAM_READ | STREAM_SEEK; |
291 stream->fill_buffer = fill_buffer; | 371 stream->fill_buffer = fill_buffer; |
292 stream->seek = seek; | 372 stream->seek = seek; |
293 stream->close = stream_dvd_close; | 373 stream->close = stream_dvdnav_close; |
294 stream->type = STREAMTYPE_DVDNAV; | 374 stream->type = STREAMTYPE_DVDNAV; |
295 stream->priv=(void*)dvdnav_priv; | 375 stream->priv=(void*)dvdnav_priv; |
376 *file_format = DEMUXER_TYPE_MPEG_PS; | |
377 | |
378 update_title_len(stream); | |
379 if(!stream->pos) | |
380 mp_msg(MSGT_OPEN,MSGL_ERR, "INIT ERROR: %d, couldn't get init pos %s\r\n", status, dvdnav_err_to_string(dvdnav_priv->dvdnav)); | |
296 | 381 |
297 return STREAM_OK; | 382 return STREAM_OK; |
298 } | 383 } |
299 | 384 |
300 stream_info_t stream_info_dvdnav = { | 385 stream_info_t stream_info_dvdnav = { |