f992c3c3766bb34dd6e46fd0e743b301d0de027b
[vlc.git] / modules / access / mms / mmsh.c
1 /*****************************************************************************
2  * mmsh.c:
3  *****************************************************************************
4  * Copyright (C) 2001, 2002 VideoLAN
5  * $Id$
6  *
7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
22  *****************************************************************************/
23
24 /*****************************************************************************
25  * Preamble
26  *****************************************************************************/
27 #include <stdlib.h>
28
29 #include <vlc/vlc.h>
30 #include <vlc/input.h>
31
32 #include "vlc_playlist.h"
33
34 #include "network.h"
35 #include "asf.h"
36 #include "buffer.h"
37
38 #include "mms.h"
39 #include "mmsh.h"
40
41 /* TODO:
42  *  - http_proxy
43  *  - authentication
44  */
45
46 /*****************************************************************************
47  * Local prototypes
48  *****************************************************************************/
49 int  E_(MMSHOpen)  ( input_thread_t * );
50 void E_(MMSHClose) ( input_thread_t * );
51
52 static ssize_t  Read( input_thread_t *, byte_t *, size_t );
53 static ssize_t  ReadRedirect( input_thread_t *, byte_t *, size_t );
54 static void     Seek( input_thread_t *, off_t );
55
56 static int      Describe( input_thread_t  *, char **ppsz_location );
57 static int      Start( input_thread_t *, off_t );
58 static void     Stop( input_thread_t * );
59 static int      GetPacket( input_thread_t *, chunk_t * );
60
61 /****************************************************************************
62  * Open: connect to ftp server and ask for file
63  ****************************************************************************/
64 int  E_( MMSHOpen )  ( input_thread_t *p_input )
65 {
66     access_sys_t    *p_sys;
67
68     char            *psz_location = NULL;
69
70     vlc_value_t     val;
71
72     /* init p_sys */
73     p_input->p_access_data = p_sys = malloc( sizeof( access_sys_t ) );
74     p_sys->i_proto = MMS_PROTO_HTTP;
75
76     p_sys->fd       = -1;
77     p_sys->i_pos  = 0;
78     p_sys->i_start= 0;
79
80     /* open a tcp connection */
81     vlc_UrlParse( &p_sys->url, p_input->psz_name, 0 );
82     if( p_sys->url.psz_host == NULL && *p_sys->url.psz_host == '\0' )
83     {
84         msg_Err( p_input, "invalid host" );
85         vlc_UrlClean( &p_sys->url );
86         free( p_sys );
87         return VLC_EGENERIC;
88     }
89     if( p_sys->url.i_port <= 0 )
90     {
91         p_sys->url.i_port = 80;
92     }
93
94     if( Describe( p_input, &psz_location ) )
95     {
96         vlc_UrlClean( &p_sys->url );
97         free( p_sys );
98         return VLC_EGENERIC;
99     }
100     /* Handle redirection */
101     if( psz_location && *psz_location )
102     {
103         playlist_t * p_playlist = vlc_object_find( p_input, VLC_OBJECT_PLAYLIST, FIND_PARENT );
104
105         msg_Dbg( p_input, "redirection to %s", psz_location );
106
107         if( !p_playlist )
108         {
109             msg_Err( p_input, "redirection failed: can't find playlist" );
110             free( psz_location );
111             return VLC_EGENERIC;
112         }
113         p_playlist->pp_items[p_playlist->i_index]->b_autodeletion = VLC_TRUE;
114         playlist_Add( p_playlist, psz_location, psz_location,
115                       PLAYLIST_INSERT | PLAYLIST_GO,
116                       p_playlist->i_index + 1 );
117         vlc_object_release( p_playlist );
118
119         free( psz_location );
120
121         p_input->pf_read = ReadRedirect;
122         p_input->pf_seek = NULL;
123         p_input->pf_set_program = input_SetProgram;
124         p_input->pf_set_area = NULL;
125
126         /* *** finished to set some variable *** */
127         vlc_mutex_lock( &p_input->stream.stream_lock );
128         p_input->stream.b_pace_control = 0;
129         p_input->stream.p_selected_area->i_size = 0;
130         p_input->stream.b_seekable = 0;
131         p_input->stream.p_selected_area->i_tell = 0;
132         p_input->stream.i_method = INPUT_METHOD_NETWORK;
133         vlc_mutex_unlock( &p_input->stream.stream_lock );
134
135         return VLC_SUCCESS;
136     }
137
138     /* Start playing */
139     if( Start( p_input, 0 ) )
140     {
141         msg_Err( p_input, "cannot start stream" );
142         free( p_sys->p_header );
143         vlc_UrlClean( &p_sys->url );
144         free( p_sys );
145         return VLC_EGENERIC;
146     }
147
148     /* *** set exported functions *** */
149     p_input->pf_read = Read;
150     p_input->pf_seek = Seek;
151     p_input->pf_set_program = input_SetProgram;
152     p_input->pf_set_area = NULL;
153
154     p_input->p_private = NULL;
155     p_input->i_mtu = 3 * p_sys->asfh.i_min_data_packet_size;
156
157     /* *** finished to set some variable *** */
158     vlc_mutex_lock( &p_input->stream.stream_lock );
159     p_input->stream.b_pace_control = 0;
160     if( p_sys->b_broadcast )
161     {
162         p_input->stream.p_selected_area->i_size = 0;
163         p_input->stream.b_seekable = 0;
164     }
165     else
166     {
167         p_input->stream.p_selected_area->i_size = p_sys->asfh.i_file_size;
168         p_input->stream.b_seekable = 1;
169     }
170     p_input->stream.p_selected_area->i_tell = 0;
171     p_input->stream.i_method = INPUT_METHOD_NETWORK;
172     vlc_mutex_unlock( &p_input->stream.stream_lock );
173
174     /* Update default_pts to a suitable value for mms access */
175     var_Get( p_input, "mms-caching", &val );
176     p_input->i_pts_delay = val.i_int * 1000;
177
178     return VLC_SUCCESS;
179 }
180
181 /*****************************************************************************
182  * Close: free unused data structures
183  *****************************************************************************/
184 void E_( MMSHClose )( input_thread_t *p_input )
185 {
186     access_sys_t    *p_sys   = p_input->p_access_data;
187
188     msg_Dbg( p_input, "stopping stream" );
189
190     Stop( p_input );
191
192
193     free( p_sys );
194 }
195
196 /*****************************************************************************
197  * Seek: try to go at the right place
198  *****************************************************************************/
199 static void Seek( input_thread_t * p_input, off_t i_pos )
200 {
201     access_sys_t *p_sys = p_input->p_access_data;
202     chunk_t      ck;
203     off_t        i_offset;
204     off_t        i_packet;
205
206     i_packet = ( i_pos - p_sys->i_header ) / p_sys->asfh.i_min_data_packet_size;
207     i_offset = ( i_pos - p_sys->i_header ) % p_sys->asfh.i_min_data_packet_size;
208
209     msg_Dbg( p_input, "seeking to "I64Fd, i_pos );
210
211     vlc_mutex_lock( &p_input->stream.stream_lock );
212
213     Stop( p_input );
214     Start( p_input, i_packet * p_sys->asfh.i_min_data_packet_size );
215
216     for( ;; )
217     {
218         if( GetPacket( p_input, &ck ) )
219         {
220             break;
221         }
222
223         /* skip headers */
224         if( ck.i_type != 0x4824 )
225         {
226             break;
227         }
228         msg_Warn( p_input, "skipping header" );
229     }
230
231     p_sys->i_pos = i_pos;
232     p_sys->i_packet_used += i_offset;
233
234     p_input->stream.p_selected_area->i_tell = i_pos;
235     vlc_mutex_unlock( &p_input->stream.stream_lock );
236 }
237
238 /*****************************************************************************
239  * Read:
240  *****************************************************************************/
241 static ssize_t ReadRedirect( input_thread_t *p_input, byte_t *p, size_t i )
242 {
243     return 0;
244 }
245
246 /*****************************************************************************
247  * Read:
248  *****************************************************************************/
249 static ssize_t Read        ( input_thread_t * p_input, byte_t * p_buffer,
250                              size_t i_len )
251 {
252     access_sys_t *p_sys = p_input->p_access_data;
253     size_t       i_copy;
254     size_t       i_data = 0;
255
256     while( i_data < i_len )
257     {
258         if( p_sys->i_pos < p_sys->i_start + p_sys->i_header )
259         {
260             int i_offset = p_sys->i_pos - p_sys->i_start;
261             i_copy = __MIN( p_sys->i_header - i_offset, i_len - i_data );
262             memcpy( &p_buffer[i_data], &p_sys->p_header[i_offset], i_copy );
263
264             i_data += i_copy;
265             p_sys->i_pos += i_copy;
266         }
267         else if( p_sys->i_packet_used < p_sys->i_packet_length )
268         {
269             i_copy = __MIN( p_sys->i_packet_length - p_sys->i_packet_used,
270                             i_len - i_data );
271
272             memcpy( &p_buffer[i_data],
273                     &p_sys->p_packet[p_sys->i_packet_used],
274                     i_copy );
275
276             i_data += i_copy;
277             p_sys->i_packet_used += i_copy;
278             p_sys->i_pos += i_copy;
279         }
280         else if( p_sys->i_packet_length > 0 &&
281                  (int)p_sys->i_packet_used < p_sys->asfh.i_min_data_packet_size )
282         {
283             i_copy = __MIN( p_sys->asfh.i_min_data_packet_size - p_sys->i_packet_used,
284                             i_len - i_data );
285
286             memset( &p_buffer[i_data], 0, i_copy );
287
288             i_data += i_copy;
289             p_sys->i_packet_used += i_copy;
290             p_sys->i_pos += i_copy;
291         }
292         else
293         {
294             chunk_t ck;
295             if( GetPacket( p_input, &ck ) )
296             {
297                 if( ck.i_type == 0x4524 && ck.i_sequence != 0 && p_sys->b_broadcast )
298                 {
299                     char *psz_location = NULL;
300
301                     p_sys->i_start = p_sys->i_pos;
302
303                     msg_Dbg( p_input, "stoping the stream" );
304                     Stop( p_input );
305
306                     msg_Dbg( p_input, "describe the stream" );
307                     if( Describe( p_input, &psz_location ) )
308                     {
309                         msg_Err( p_input, "describe failed" );
310                         return -1;
311                     }
312                     if( Start( p_input, 0 ) )
313                     {
314                         msg_Err( p_input, "Start failed" );
315                         return -1;
316                     }
317                 }
318                 else
319                 {
320                     return -1;
321                 }
322             }
323             if( ck.i_type != 0x4424 )
324             {
325                 p_sys->i_packet_used = 0;
326                 p_sys->i_packet_length = 0;
327             }
328         }
329     }
330
331     return( i_data );
332 }
333
334 /*****************************************************************************
335  * Describe:
336  *****************************************************************************/
337 static int Describe( input_thread_t  *p_input, char **ppsz_location )
338 {
339     access_sys_t *p_sys = p_input->p_access_data;
340     char         *psz_location = NULL;
341     char         *psz;
342     int          i_code;
343
344     /* Reinit context */
345     p_sys->b_broadcast = VLC_TRUE;
346     p_sys->i_request_context = 1;
347     p_sys->i_packet_sequence = 0;
348     p_sys->i_packet_used = 0;
349     p_sys->i_packet_length = 0;
350     p_sys->p_packet = NULL;
351     E_( GenerateGuid )( &p_sys->guid );
352
353     if( ( p_sys->fd = net_OpenTCP( p_input, p_sys->url.psz_host,
354                                             p_sys->url.i_port ) ) < 0 )
355     {
356         msg_Err( p_input, "cannot connect to%s:%d", p_sys->url.psz_host, p_sys->url.i_port );
357         goto error;
358     }
359
360     /* send first request */
361     net_Printf( VLC_OBJECT(p_input), p_sys->fd,
362                 "GET %s HTTP/1.0\r\n"
363                 "Accept: */*\r\n"
364                 "User-Agent: NSPlayer/4.1.0.3856\r\n"
365                 "Host: %s:%d\r\n"
366                 "Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=0:0,request-context=%d,max-duration=0\r\n"
367                 "Pragma: xClientGUID={"GUID_FMT"}\r\n"
368                 "Connection: Close\r\n",
369                 ( p_sys->url.psz_path == NULL || *p_sys->url.psz_path == '\0' ) ? "/" : p_sys->url.psz_path,
370                 p_sys->url.psz_host, p_sys->url.i_port,
371                 p_sys->i_request_context++,
372                 GUID_PRINT( p_sys->guid ) );
373
374     if( net_Printf( VLC_OBJECT(p_input), p_sys->fd, "\r\n" ) < 0 )
375     {
376         msg_Err( p_input, "failed to send request" );
377         goto error;
378     }
379
380     /* Receive the http header */
381     if( ( psz = net_Gets( VLC_OBJECT(p_input), p_sys->fd ) ) == NULL )
382     {
383         msg_Err( p_input, "failed to read answer" );
384         goto error;
385     }
386     if( strncmp( psz, "HTTP/1.", 7 ) )
387     {
388         msg_Err( p_input, "invalid HTTP reply '%s'", psz );
389         free( psz );
390         goto error;
391     }
392     i_code = atoi( &psz[9] );
393     if( i_code >= 400 )
394     {
395         msg_Err( p_input, "error: %s", psz );
396         free( psz );
397         goto error;
398     }
399
400     msg_Dbg( p_input, "HTTP reply '%s'", psz );
401     free( psz );
402     for( ;; )
403     {
404         char *psz = net_Gets( p_input, p_sys->fd );
405         char *p;
406
407         if( psz == NULL )
408         {
409             msg_Err( p_input, "failed to read answer" );
410             goto error;
411         }
412
413         if( *psz == '\0' )
414         {
415             free( psz );
416             break;
417         }
418
419         if( ( p = strchr( psz, ':' ) ) == NULL )
420         {
421             msg_Err( p_input, "malformed header line: %s", psz );
422             free( psz );
423             goto error;
424         }
425         *p++ = '\0';
426         while( *p == ' ' ) p++;
427
428         /* FIXME FIXME test Content-Type to see if it's a plain stream or an
429          * asx FIXME */
430         if( !strcasecmp( psz, "Pragma" ) )
431         {
432             if( strstr( p, "features" ) )
433             {
434                 /* FIXME, it is a bit badly done here ..... */
435                 if( strstr( p, "broadcast" ) )
436                 {
437                     msg_Dbg( p_input, "stream type = broadcast" );
438                     p_sys->b_broadcast = VLC_TRUE;
439                 }
440                 else if( strstr( p, "seekable" ) )
441                 {
442                     msg_Dbg( p_input, "stream type = seekable" );
443                     p_sys->b_broadcast = VLC_FALSE;
444                 }
445                 else
446                 {
447                     msg_Warn( p_input, "unknow stream types (%s)", p );
448                     p_sys->b_broadcast = VLC_FALSE;
449                 }
450             }
451         }
452         else if( !strcasecmp( psz, "Location" ) )
453         {
454             psz_location = strdup( p );
455         }
456
457         free( psz );
458     }
459
460     /* Handle the redirection */
461     if( ( i_code == 301 || i_code == 302 ||
462           i_code == 303 || i_code == 307 ) &&
463         psz_location && *psz_location )
464     {
465         msg_Dbg( p_input, "redirection to %s", psz_location );
466         net_Close( p_sys->fd ); p_sys->fd = -1;
467
468         *ppsz_location = psz_location;
469         return VLC_SUCCESS;
470     }
471
472     /* Read the asf header */
473     p_sys->i_header = 0;
474     p_sys->p_header = NULL;
475     for( ;; )
476     {
477         chunk_t ck;
478         if( GetPacket( p_input, &ck ) ||
479             ck.i_type != 0x4824 )
480         {
481             break;
482         }
483
484         if( ck.i_data > 0 )
485         {
486             p_sys->i_header += ck.i_data;
487             p_sys->p_header = realloc( p_sys->p_header, p_sys->i_header );
488             memcpy( &p_sys->p_header[p_sys->i_header - ck.i_data],
489                     ck.p_data, ck.i_data );
490         }
491     }
492     msg_Dbg( p_input, "complete header size=%d", p_sys->i_header );
493     if( p_sys->i_header <= 0 )
494     {
495         msg_Err( p_input, "header size == 0" );
496         goto error;
497     }
498     /* close this connection */
499     net_Close( p_sys->fd ); p_sys->fd = -1;
500
501     /* *** parse header and get stream and their id *** */
502     /* get all streams properties,
503      *
504      * TODO : stream bitrates properties(optional)
505      *        and bitrate mutual exclusion(optional) */
506     E_( asf_HeaderParse )( &p_sys->asfh,
507                            p_sys->p_header, p_sys->i_header );
508     msg_Dbg( p_input, "packet count=%lld packet size=%d",
509              p_sys->asfh.i_data_packets_count,
510              p_sys->asfh.i_min_data_packet_size );
511
512     E_( asf_StreamSelect)( &p_sys->asfh,
513                            config_GetInt( p_input, "mms-maxbitrate" ),
514                            config_GetInt( p_input, "mms-all" ),
515                            config_GetInt( p_input, "audio" ),
516                            config_GetInt( p_input, "video" ) );
517
518     return VLC_SUCCESS;
519
520 error:
521     if( p_sys->fd > 0 )
522     {
523         net_Close( p_sys->fd  );
524         p_sys->fd = -1;
525     }
526     return VLC_EGENERIC;
527 }
528
529 /*****************************************************************************
530  *
531  *****************************************************************************/
532 static int Start( input_thread_t *p_input, off_t i_pos )
533 {
534     access_sys_t *p_sys = p_input->p_access_data;
535     int  i_streams = 0;
536     int  i;
537     char *psz;
538
539     msg_Dbg( p_input, "starting stream" );
540
541     if( ( p_sys->fd = net_OpenTCP( p_input, p_sys->url.psz_host,
542                                             p_sys->url.i_port ) ) < 0 )
543     {
544         /* should not occur */
545         msg_Err( p_input, "cannot connect to the server" );
546         return VLC_EGENERIC;
547     }
548
549     for( i = 1; i < 128; i++ )
550     {
551         if( p_sys->asfh.stream[i].i_selected )
552         {
553             i_streams++;
554         }
555     }
556
557     if( i_streams <= 0 )
558     {
559         msg_Err( p_input, "no stream selected" );
560         return VLC_EGENERIC;
561     }
562     net_Printf( VLC_OBJECT(p_input), p_sys->fd,
563                 "GET %s HTTP/1.0\r\n"
564                 "Accept: */*\r\n"
565                 "User-Agent: NSPlayer/4.1.0.3856\r\n"
566                 "Host: %s:%d\r\n",
567                 ( p_sys->url.psz_path == NULL || *p_sys->url.psz_path == '\0' ) ? "/" : p_sys->url.psz_path,
568                 p_sys->url.psz_host, p_sys->url.i_port );
569     if( p_sys->b_broadcast )
570     {
571         net_Printf( VLC_OBJECT(p_input), p_sys->fd,
572                     "Pragma: no-cache,rate=1.000000,request-context=%d\r\n",
573                     p_sys->i_request_context++ );
574     }
575     else
576     {
577         net_Printf( VLC_OBJECT(p_input), p_sys->fd,
578                     "Pragma: no-cache,rate=1.000000,stream-time=0,stream-offset=%u:%u,request-context=%d,max-duration=0\r\n",
579                     (uint32_t)((i_pos >> 32)&0xffffffff),
580                     (uint32_t)(i_pos&0xffffffff),
581                     p_sys->i_request_context++ );
582     }
583     net_Printf( VLC_OBJECT(p_input), p_sys->fd,
584                 "Pragma: xPlayStrm=1\r\n"
585                 "Pragma: xClientGUID={"GUID_FMT"}\r\n"
586                 "Pragma: stream-switch-count=%d\r\n"
587                 "Pragma: stream-switch-entry=",
588                 GUID_PRINT( p_sys->guid ),
589                 i_streams);
590
591     for( i = 1; i < 128; i++ )
592     {
593         if( p_sys->asfh.stream[i].i_cat != ASF_STREAM_UNKNOWN )
594         {
595             int i_select = 2;
596             if( p_sys->asfh.stream[i].i_selected )
597             {
598                 i_select = 0;
599             }
600
601             net_Printf( VLC_OBJECT(p_input), p_sys->fd,
602                         "ffff:%d:%d ", i, i_select );
603         }
604     }
605     net_Printf( VLC_OBJECT(p_input), p_sys->fd, "\r\n" );
606     net_Printf( VLC_OBJECT(p_input), p_sys->fd, "Connection: Close\r\n" );
607
608     if( net_Printf( VLC_OBJECT(p_input), p_sys->fd, "\r\n" ) < 0 )
609     {
610         msg_Err( p_input, "failed to send request" );
611         return VLC_EGENERIC;
612     }
613
614     if( ( psz = net_Gets( VLC_OBJECT(p_input), p_sys->fd ) ) == NULL )
615     {
616         msg_Err( p_input, "cannot read data" );
617         return VLC_EGENERIC;
618     }
619     if( atoi( &psz[9] ) >= 400 )
620     {
621         msg_Err( p_input, "error: %s", psz );
622         free( psz );
623         return VLC_EGENERIC;
624     }
625     msg_Dbg( p_input, "HTTP reply '%s'", psz );
626     free( psz );
627
628     /* FIXME check HTTP code */
629     for( ;; )
630     {
631         char *psz = net_Gets( p_input, p_sys->fd );
632         if( psz == NULL )
633         {
634             msg_Err( p_input, "cannot read data" );
635             return VLC_EGENERIC;
636         }
637         if( *psz == '\0' )
638         {
639             free( psz );
640             break;
641         }
642         msg_Dbg( p_input, "%s", psz );
643         free( psz );
644     }
645
646     p_sys->i_packet_used   = 0;
647     p_sys->i_packet_length = 0;
648
649     return VLC_SUCCESS;
650 }
651
652 /*****************************************************************************
653  *
654  *****************************************************************************/
655 static void Stop( input_thread_t *p_input )
656 {
657     access_sys_t *p_sys = p_input->p_access_data;
658
659     msg_Dbg( p_input, "closing stream" );
660     if( p_sys->fd > 0 )
661     {
662         net_Close( p_sys->fd );
663         p_sys->fd = -1;
664     }
665 }
666
667 /*****************************************************************************
668  *
669  *****************************************************************************/
670 static int GetPacket( input_thread_t * p_input, chunk_t *p_ck )
671 {
672     access_sys_t *p_sys = p_input->p_access_data;
673
674     /* chunk_t */
675     memset( p_ck, 0, sizeof( chunk_t ) );
676
677     /* Read the chunk header */
678     if( net_Read( p_input, p_sys->fd, p_sys->buffer, 12, VLC_TRUE ) < 12 )
679     {
680         /* msg_Err( p_input, "cannot read data" ); */
681         return VLC_EGENERIC;
682     }
683
684     p_ck->i_type      = GetWLE( p_sys->buffer);
685     p_ck->i_size      = GetWLE( p_sys->buffer + 2);
686     p_ck->i_sequence  = GetDWLE( p_sys->buffer + 4);
687     p_ck->i_unknown   = GetWLE( p_sys->buffer + 8);
688     p_ck->i_size2     = GetWLE( p_sys->buffer + 10);
689     p_ck->p_data      = p_sys->buffer + 12;
690     p_ck->i_data      = p_ck->i_size2 - 8;
691
692     if( p_ck->i_type == 0x4524 )   // Transfer complete
693     {
694         if( p_ck->i_sequence == 0 )
695         {
696             msg_Warn( p_input, "EOF" );
697             return VLC_EGENERIC;
698         }
699         else
700         {
701             msg_Warn( p_input, "Next stream follow but not supported" );
702             return VLC_EGENERIC;
703         }
704     }
705     else if( p_ck->i_type != 0x4824 && p_ck->i_type != 0x4424 )
706     {
707         msg_Err( p_input, "invalid chunk FATAL (0x%x)", p_ck->i_type );
708         return VLC_EGENERIC;
709     }
710
711     if( p_ck->i_data > 0 &&
712         net_Read( p_input, p_sys->fd, &p_sys->buffer[12], p_ck->i_data, VLC_TRUE ) < p_ck->i_data )
713     {
714         msg_Err( p_input, "cannot read data" );
715         return VLC_EGENERIC;
716     }
717
718     if( p_sys->i_packet_sequence != 0 &&
719         p_ck->i_sequence != p_sys->i_packet_sequence )
720     {
721         msg_Warn( p_input, "packet lost ? (%d != %d)", p_ck->i_sequence, p_sys->i_packet_sequence );
722     }
723
724     p_sys->i_packet_sequence = p_ck->i_sequence + 1;
725     p_sys->i_packet_used   = 0;
726     p_sys->i_packet_length = p_ck->i_data;
727     p_sys->p_packet        = p_ck->p_data;
728
729     return VLC_SUCCESS;
730 }