git.sesse.net Git - vlc/blob - modules/stream_filter/hds/hds.c

   1 /*****************************************************************************
   2  * hds.c: Http Dynamic Streaming (HDS) stream filter
   3  *****************************************************************************
   4  *
   5  * Author: Jonathan Thambidurai <jonathan _AT_ fastly _DOT_ com>
   6  * Heavily inspired by SMooth module of Frédéric Yhuel <fyhuel _AT_ viotech _DOT_ net>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA
  21  *****************************************************************************/
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include "config.h"
  25 #endif
  26
  27 #include <vlc_common.h>
  28 #include <vlc_plugin.h>
  29 #include <vlc_stream.h>
  30 #include <vlc_strings.h>            /* b64_decode */
  31 #include <vlc_xml.h>
  32 #include <vlc_charset.h>            /* FromCharset */
  33 #include <vlc_es.h>                 /* UNKNOWN_ES */
  34
  35 typedef struct chunk_s
  36 {
  37     int64_t     duration;   /* chunk duration in afrt timescale units */
  38     uint64_t    timestamp;
  39     uint32_t    frag_num;
  40     uint32_t    seg_num;
  41     uint32_t    frun_entry; /* Used to speed things up in vod situations */
  42
  43     uint32_t    data_len;
  44
  45     uint32_t    mdat_pos;   /* position in the mdat */
  46     uint32_t    mdat_len;
  47
  48     void        *next;
  49
  50     uint8_t     *mdat_data;
  51     uint8_t     *data;
  52     bool        failed;
  53     bool        eof;
  54 } chunk_t;
  55
  56 typedef struct segment_run_s
  57 {
  58     uint32_t first_segment;
  59     uint32_t fragments_per_segment;
  60 } segment_run_t;
  61
  62 typedef struct fragment_run_s
  63 {
  64     uint32_t fragment_number_start;
  65     uint32_t fragment_duration;
  66     uint64_t fragment_timestamp;
  67     uint8_t  discont;
  68 } fragment_run_t;
  69
  70 typedef struct hds_stream_s
  71 {
  72     /* linked-list of chunks */
  73     chunk_t        *chunks_head;
  74     chunk_t        *chunks_livereadpos;
  75     chunk_t        *chunks_downloadpos;
  76
  77     char*          quality_segment_modifier;
  78
  79     /* we can make this configurable */
  80     uint64_t       download_leadtime;
  81
  82     /* in timescale units */
  83     uint32_t       total_duration;
  84
  85     uint32_t       afrt_timescale;
  86
  87     /* these two values come from the abst */
  88     uint32_t       timescale;
  89     uint64_t       live_current_time;
  90
  91     vlc_mutex_t    abst_lock;
  92
  93     vlc_mutex_t    dl_lock;
  94     vlc_cond_t     dl_cond;
  95
  96     /* can be left as null */
  97     char*          abst_url;
  98
  99     /* this comes from the manifest media section  */
 100     char*          url;
 101
 102     /* this comes from the bootstrap info */
 103     char*          movie_id;
 104
 105 #define MAX_HDS_SERVERS 10
 106     char*          server_entries[MAX_HDS_SERVERS];
 107     uint8_t        server_entry_count;
 108
 109 #define MAX_HDS_SEGMENT_RUNS 256
 110     segment_run_t  segment_runs[MAX_HDS_SEGMENT_RUNS];
 111     uint8_t        segment_run_count;
 112
 113 #define MAX_HDS_FRAGMENT_RUNS 10000
 114     fragment_run_t fragment_runs[MAX_HDS_FRAGMENT_RUNS];
 115     uint32_t       fragment_run_count;
 116 } hds_stream_t;
 117
 118 /* this is effectively just a sanity check  mechanism */
 119 #define MAX_REQUEST_SIZE (50*1024*1024)
 120
 121 struct stream_sys_t
 122 {
 123     char         *base_url;    /* URL common part for chunks */
 124     vlc_thread_t live_thread;
 125     vlc_thread_t dl_thread;
 126
 127     /* we pend on peek until some number of segments arrives; otherwise
 128      * the downstream system dies in case of playback */
 129     uint64_t     chunk_count;
 130
 131     vlc_array_t  *hds_streams; /* available streams */
 132
 133     uint32_t     flv_header_bytes_sent;
 134     uint64_t     duration_seconds;
 135
 136     bool         live;
 137     bool         closed;
 138 };
 139
 140 typedef struct _bootstrap_info {
 141     uint8_t* data;
 142     char*    id;
 143     char*    url;
 144     char*    profile;
 145     int      data_len;
 146 } bootstrap_info;
 147
 148 typedef struct _media_info {
 149     char* stream_id;
 150     char* media_url;
 151     char* bootstrap_id;
 152 } media_info;
 153
 154 /*****************************************************************************
 155  * Module descriptor
 156  *****************************************************************************/
 157 static int  Open( vlc_object_t * );
 158 static void Close( vlc_object_t * );
 159
 160 vlc_module_begin()
 161     set_category( CAT_INPUT )
 162     set_subcategory( SUBCAT_INPUT_STREAM_FILTER )
 163     set_description( N_("HTTP Dynamic Streaming") )
 164     set_shortname( "Dynamic Streaming")
 165     add_shortcut( "hds" )
 166     set_capability( "stream_filter", 30 )
 167     set_callbacks( Open, Close )
 168 vlc_module_end()
 169
 170 static int   Read( stream_t *, void *, unsigned );
 171 static int   Peek( stream_t *, const uint8_t **, unsigned );
 172 static int   Control( stream_t *, int , va_list );
 173
 174 static inline bool isFQUrl( char* url )
 175 {
 176     return ( NULL != vlc_strcasestr( url, "https://") ||
 177              NULL != vlc_strcasestr( url, "http://" ) );
 178 }
 179
 180 static bool isHDS( stream_t *s )
 181 {
 182     const char *peek;
 183     int i_size = stream_Peek( s->p_source, (const uint8_t**) &peek, 200 );
 184     if( i_size < 200 )
 185         return false;
 186
 187     const char *str;
 188
 189     if( !memcmp( peek, "\xFF\xFE", 2 ) )
 190     {
 191         str = FromCharset( "UTF-16LE", peek, 512 );
 192     }
 193     else if( !memcmp( peek, "\xFE\xFF", 2 ) )
 194     {
 195         str = FromCharset( "UTF-16BE", peek, 512 );
 196     }
 197     else
 198         str = peek;
 199
 200     if( str == NULL )
 201         return false;
 202
 203     bool ret = strstr( str, "<manifest" ) != NULL;
 204     return ret;
 205 }
 206
 207 static uint8_t* parse_asrt( vlc_object_t* p_this,
 208                         hds_stream_t* s,
 209                         uint8_t* data,
 210                         uint8_t* data_end )
 211 {
 212     uint8_t* data_p = data;
 213
 214     uint32_t asrt_len = 0;
 215     asrt_len = U32_AT( data_p );
 216     if( asrt_len > data_end - data ||
 217         data_end - data <  14 )
 218     {
 219         msg_Err( p_this, "Not enough asrt data (%"PRIu32", %lu)", asrt_len, data_end - data );
 220         return NULL;
 221     }
 222
 223     data_p += sizeof(asrt_len);
 224
 225     if( 0 != memcmp( "asrt", data_p, 4 ) )
 226     {
 227         msg_Err( p_this, "Cant find asrt in bootstrap" );
 228         return NULL;
 229     }
 230     data_p += 4;
 231
 232     /* ignore flags and versions (we don't handle multiple updates) */
 233     data_p += 4;
 234
 235     uint8_t quality_entry_count = *data_p;
 236     bool quality_found = false;
 237     data_p++;
 238
 239     if( ! s->quality_segment_modifier )
 240     {
 241         quality_found = true;
 242     }
 243
 244     while( quality_entry_count-- > 0 )
 245     {
 246         char* str_start = (char*) data_p;
 247         data_p = memchr( data_p, '\0', data_end - data_p );
 248         if( ! data_p )
 249         {
 250             msg_Err( p_this, "Couldn't find quality entry string in asrt" );
 251             return NULL;
 252         }
 253         data_p++;
 254
 255         if( ! quality_found )
 256         {
 257             if( ! strncmp( str_start, s->quality_segment_modifier,
 258                            strlen(s->quality_segment_modifier) ) )
 259             {
 260                 quality_found = true;
 261             }
 262         }
 263
 264         if( data_p >= data_end )
 265         {
 266             msg_Err( p_this, "Premature end of asrt in quality entries" );
 267             return NULL;
 268         }
 269     }
 270
 271     if( data_end - data_p < 4 )
 272     {
 273         msg_Err( p_this, "Premature end of asrt after quality entries" );
 274         return NULL;
 275     }
 276
 277     uint32_t segment_run_entry_count = U32_AT( data_p );
 278     data_p += sizeof(segment_run_entry_count);
 279
 280     if( data_end - data_p < 8 * segment_run_entry_count )
 281     {
 282         msg_Err( p_this, "Not enough data in asrt for segment run entries" );
 283         return NULL;
 284     }
 285
 286     if( segment_run_entry_count >= MAX_HDS_SEGMENT_RUNS )
 287     {
 288         msg_Err( p_this, "Too many segment runs" );
 289         return NULL;
 290     }
 291
 292     while( segment_run_entry_count-- > 0 )
 293     {
 294         if( quality_found )
 295         {
 296             s->segment_runs[s->segment_run_count].first_segment = U32_AT(data_p);
 297         }
 298         data_p+=4;
 299
 300         if( quality_found )
 301         {
 302             s->segment_runs[s->segment_run_count].fragments_per_segment = U32_AT(data_p);
 303         }
 304         data_p+=4;
 305
 306         s->segment_run_count++;
 307     }
 308
 309     return data_p;
 310 }
 311
 312 static uint8_t* parse_afrt( vlc_object_t* p_this,
 313                         hds_stream_t* s,
 314                         uint8_t* data,
 315                         uint8_t* data_end )
 316 {
 317     uint8_t* data_p = data;
 318
 319     uint32_t afrt_len = U32_AT( data_p );
 320     if( afrt_len > data_end - data ||
 321         data_end - data <  9 )
 322     {
 323         msg_Err( p_this, "Not enough afrt data %u, %ld", afrt_len, data_end - data );
 324         return NULL;
 325     }
 326     data_p += sizeof(afrt_len);
 327
 328     if( 0 != memcmp( data_p, "afrt", 4 ) )
 329     {
 330         msg_Err( p_this, "Cant find afrt in bootstrap" );
 331         return NULL;
 332     }
 333     data_p += 4;
 334
 335     /* ignore flags and versions (we don't handle multiple updates) */
 336     data_p += 4;
 337
 338     if( data_end - data_p < 9 )
 339     {
 340         msg_Err( p_this, "afrt is too short" );
 341         return NULL;
 342     }
 343
 344     s->afrt_timescale = U32_AT( data_p );
 345     data_p += 4;
 346
 347     bool quality_found = false;
 348     if( ! s->quality_segment_modifier )
 349     {
 350         quality_found = true;
 351     }
 352
 353     uint32_t quality_entry_count = *data_p;
 354     data_p++;
 355     while( quality_entry_count-- > 0 )
 356     {
 357         char* str_start = (char*)data_p;
 358         data_p = memchr( data_p, '\0', data_end - data_p );
 359         if( ! data_p )
 360         {
 361             msg_Err( p_this, "Couldn't find quality entry string in afrt" );
 362             return NULL;
 363         }
 364         data_p++;
 365
 366         if( ! quality_found )
 367         {
 368             if( ! strncmp( str_start, s->quality_segment_modifier,
 369                            strlen(s->quality_segment_modifier) ) )
 370             {
 371                 quality_found = true;
 372             }
 373         }
 374     }
 375
 376     if( data_end - data_p < 5 )
 377     {
 378         msg_Err( p_this, "No more space in afrt after quality entries" );
 379         return NULL;
 380     }
 381
 382     uint32_t fragment_run_entry_count = U32_AT( data_p );
 383     data_p += sizeof(uint32_t);
 384
 385     while(fragment_run_entry_count-- > 0)
 386     {
 387         if( data_end - data_p < 16 )
 388         {
 389             msg_Err( p_this, "Not enough data in afrt" );
 390             return NULL;
 391         }
 392
 393         if( s->fragment_run_count >= MAX_HDS_FRAGMENT_RUNS )
 394         {
 395             msg_Err( p_this, "Too many fragment runs, exiting" );
 396             return NULL;
 397         }
 398
 399         s->fragment_runs[s->fragment_run_count].fragment_number_start = U32_AT(data_p);
 400         data_p += 4;
 401
 402         s->fragment_runs[s->fragment_run_count].fragment_timestamp = U64_AT( data_p );
 403         data_p += 8;
 404
 405         s->fragment_runs[s->fragment_run_count].fragment_duration = U32_AT( data_p );
 406         data_p += 4;
 407
 408         s->fragment_runs[s->fragment_run_count].discont = 0;
 409         if( s->fragment_runs[s->fragment_run_count].fragment_duration == 0 )
 410         {
 411             /* discontinuity flag */
 412             s->fragment_runs[s->fragment_run_count].discont = *(data_p++);
 413         }
 414
 415         s->fragment_run_count++;
 416     }
 417
 418     return data_p;
 419 }
 420
 421 static inline chunk_t* chunk_new()
 422 {
 423     chunk_t* chunk = calloc(1, sizeof(chunk_t));
 424     return chunk;
 425 }
 426
 427 static void chunk_free( chunk_t * chunk )
 428 {
 429     FREENULL( chunk->data );
 430     free( chunk );
 431 }
 432
 433 static void parse_BootstrapData( vlc_object_t* p_this,
 434                                  hds_stream_t * s,
 435                                  uint8_t* data,
 436                                  uint8_t* data_end )
 437 {
 438     uint8_t* data_p = data;
 439
 440     uint32_t abst_len = U32_AT( data_p );
 441     if( abst_len > data_end - data
 442         || data_end - data < 29 /* min size of data */ )
 443     {
 444         msg_Warn( p_this, "Not enough bootstrap data" );
 445         return;
 446     }
 447     data_p += sizeof(abst_len);
 448
 449     if( 0 != memcmp( data_p, "abst", 4 ) )
 450     {
 451         msg_Warn( p_this, "Cant find abst in bootstrap" );
 452         return;
 453     }
 454     data_p += 4;
 455
 456     /* version, flags*/
 457     data_p += 4;
 458
 459     /* we ignore the version */
 460     data_p += 4;
 461
 462     /* some flags we don't care about here because they are
 463      * in the manifest
 464      */
 465     data_p += 1;
 466
 467     /* timescale */
 468     s->timescale = U32_AT( data_p );
 469     data_p += sizeof(s->timescale);
 470
 471     s->live_current_time = U64_AT( data_p );
 472     data_p += sizeof(s->live_current_time);
 473
 474     /* smtpe time code offset */
 475     data_p += 8;
 476
 477     s->movie_id = strndup( (char*)data_p, data_end - data_p );
 478     data_p += ( strlen( s->movie_id ) + 1 );
 479
 480     if( data_end - data_p < 4 ) {
 481         msg_Warn( p_this, "Not enough bootstrap after Movie Identifier" );
 482         return;
 483     }
 484
 485     uint8_t server_entry_count = 0;
 486     server_entry_count = (uint8_t) *data_p;
 487     data_p++;
 488
 489     s->server_entry_count = 0;
 490     while( server_entry_count-- > 0 )
 491     {
 492         if( s->server_entry_count < MAX_HDS_SERVERS )
 493         {
 494             s->server_entries[s->server_entry_count++] = strndup( (char*)data_p,
 495                                                                   data_end - data_p );
 496             data_p += strlen( s->server_entries[s->server_entry_count-1] ) + 1;
 497         }
 498         else
 499         {
 500             msg_Warn( p_this, "Too many servers" );
 501             data_p = memchr( data_p, '\0', data_end - data_p );
 502             if( ! data_p )
 503             {
 504                 msg_Err( p_this, "Couldn't find server entry" );
 505                 return;
 506             }
 507             data_p++;
 508         }
 509
 510         if( data_p >= data_end )
 511         {
 512             msg_Warn( p_this, "Premature end of bootstrap info while reading servers" );
 513             return;
 514         }
 515     }
 516
 517     if( data_end - data_p < 3 ) {
 518         msg_Warn( p_this, "Not enough bootstrap after Servers" );
 519         return;
 520     }
 521
 522     s->quality_segment_modifier = NULL;
 523
 524     uint8_t quality_entry_count = *data_p;
 525     data_p++;
 526
 527     if( quality_entry_count > 1 )
 528     {
 529         msg_Err( p_this, "I don't know what to do with multiple quality levels in the bootstrap - shouldn't this be handled at the manifest level?" );
 530         return;
 531     }
 532
 533     s->quality_segment_modifier = NULL;
 534     while( quality_entry_count-- > 0 )
 535     {
 536         if( s->quality_segment_modifier )
 537         {
 538             s->quality_segment_modifier = strndup( (char*)data_p, data_end - data_p );
 539         }
 540         data_p += strnlen( (char*)data_p, data_end - data_p ) + 1;
 541     }
 542
 543     if( data_end - data_p < 2 ) {
 544         msg_Warn( p_this, "Not enough bootstrap after quality entries" );
 545         return;
 546     }
 547
 548     /* ignoring "DrmData" */
 549     data_p = memchr( data_p, '\0', data_end - data_p );
 550     if( ! data_p )
 551     {
 552         msg_Err( p_this, "Couldn't find DRM Data" );
 553         return;
 554     }
 555     data_p++;
 556
 557     if( data_end - data_p < 2 ) {
 558         msg_Warn( p_this, "Not enough bootstrap after drm data" );
 559         return;
 560     }
 561
 562     /* ignoring "metadata" */
 563     data_p = memchr( data_p, '\0', data_end - data_p );
 564     if( ! data_p )
 565     {
 566         msg_Err( p_this, "Couldn't find metadata");
 567         return;
 568     }
 569     data_p++;
 570
 571     if( data_end - data_p < 2 ) {
 572         msg_Warn( p_this, "Not enough bootstrap after drm data" );
 573         return;
 574     }
 575
 576     uint8_t asrt_count = *data_p;
 577     data_p++;
 578
 579     s->segment_run_count = 0;
 580     while( asrt_count-- > 0 &&
 581            data_end > data_p &&
 582            (data_p = parse_asrt( p_this, s, data_p, data_end )) );
 583
 584     uint8_t afrt_count = *data_p;
 585     data_p++;
 586
 587     s->fragment_run_count = 0;
 588     while( afrt_count-- > 0 &&
 589            data_end > data_p &&
 590            (data_p = parse_afrt( p_this, s, data_p, data_end )) );
 591 }
 592
 593 /* this only works with ANSI characters - this is ok
 594    for the bootstrapinfo field which this function is
 595    exclusively used for since it is merely a base64 encoding
 596 */
 597 static bool is_whitespace( char c )
 598 {
 599     return ( ' '  == c ||
 600              '\t' == c ||
 601              '\n' == c ||
 602              '\v' == c ||
 603              '\f' == c ||
 604              '\r' == c );
 605 }
 606
 607 /* see above note for is_whitespace */
 608 static void whitespace_substr( char** start,
 609                                char** end )
 610 {
 611     while( is_whitespace( **start ) && *start != *end ) {
 612         (*start)++;
 613     }
 614
 615     if( *start == *end )
 616         return;
 617
 618     while( is_whitespace(*(*end - 1) ) ) {
 619         end--;
 620     }
 621 }
 622
 623 /* returns length (could be zero, indicating all of remaining data) */
 624 /* ptr is to start of data, right after 'mdat' string */
 625 static uint32_t find_chunk_mdat( vlc_object_t* p_this,
 626                                  uint8_t* chunkdata, uint8_t* chunkdata_end,
 627                                  uint8_t** mdatptr )
 628 {
 629     uint8_t* boxname = NULL;
 630     uint8_t* boxdata = NULL;
 631     uint64_t boxsize = 0;
 632
 633     do {
 634         if( chunkdata_end < chunkdata ||
 635             chunkdata_end - chunkdata < 8 )
 636         {
 637             msg_Err( p_this, "Couldn't find mdat in box 1!" );
 638             *mdatptr = 0;
 639             return 0;
 640         }
 641
 642         boxsize = (uint64_t)U32_AT( chunkdata );
 643         chunkdata += 4;
 644
 645         boxname = chunkdata;
 646         chunkdata += 4;
 647
 648         if( boxsize == 1 )
 649         {
 650             if( chunkdata_end - chunkdata >= 12 )
 651             {
 652                 boxsize =  U64_AT(chunkdata);
 653                 chunkdata += 8;
 654             }
 655             else
 656             {
 657                 msg_Err( p_this, "Couldn't find mdat in box 2!");
 658                 *mdatptr = 0;
 659                 return 0;
 660             }
 661             boxdata = chunkdata;
 662             chunkdata += (boxsize - 16);
 663         }
 664         else
 665         {
 666             boxdata = chunkdata;
 667             chunkdata += (boxsize - 8);
 668         }
 669     } while ( 0 != memcmp( boxname, "mdat", 4 ) );
 670
 671     *mdatptr = boxdata;
 672
 673     return chunkdata_end - ((uint8_t*)boxdata);
 674 }
 675
 676 /* returns data ptr if valid (updating the chunk itself
 677    tells the reader that the chunk is safe to read, which is not yet correct)*/
 678 static uint8_t* download_chunk( stream_t *s,
 679                                 stream_sys_t* sys,
 680                                 hds_stream_t* stream, chunk_t* chunk )
 681 {
 682     const char* quality = "";
 683     char* server_base = sys->base_url;
 684     if( stream->server_entry_count > 0 &&
 685         strlen(stream->server_entries[0]) > 0 )
 686     {
 687         server_base = stream->server_entries[0];
 688     }
 689
 690     if( stream->quality_segment_modifier )
 691     {
 692         quality = stream->quality_segment_modifier;
 693     }
 694
 695     const char* movie_id = "";
 696     if( stream->url && strlen(stream->url) > 0 )
 697     {
 698         if( isFQUrl( stream->url ) )
 699         {
 700             server_base = stream->url;
 701         }
 702         else
 703         {
 704             movie_id = stream->url;
 705         }
 706     }
 707
 708     char* fragment_url;
 709     if( 0 > asprintf( &fragment_url, "%s/%s%sSeg%u-Frag%u",
 710               server_base,
 711               movie_id,
 712               quality,
 713               chunk->seg_num,
 714                       chunk->frag_num ) ) {
 715         msg_Err(s, "Failed to allocate memory for fragment url" );
 716         return NULL;
 717     }
 718
 719     msg_Info(s, "Downloading fragment %s",  fragment_url );
 720
 721     stream_t* download_stream = stream_UrlNew( s, fragment_url );
 722     if( ! download_stream )
 723     {
 724         msg_Err(s, "Failed to download fragment %s", fragment_url );
 725         free( fragment_url );
 726         chunk->failed = true;
 727         return NULL;
 728     }
 729     free( fragment_url );
 730
 731     int64_t size = stream_Size( download_stream );
 732     chunk->data_len = (uint32_t) size;
 733
 734     if( size > MAX_REQUEST_SIZE )
 735     {
 736         msg_Err(s, "Strangely-large chunk of %"PRIi64" Bytes", size );
 737         return NULL;
 738     }
 739
 740     uint8_t* data = malloc( size );
 741     if( ! data )
 742     {
 743         msg_Err(s, "Couldn't allocate chunk" );
 744         return NULL;
 745     }
 746
 747     int read = stream_Read( download_stream, data,
 748                             size );
 749     chunk->data_len = read;
 750
 751     if( read < size )
 752     {
 753         msg_Err( s, "Requested %"PRIi64" bytes, "\
 754                  "but only got %d", size, read );
 755         data = realloc( chunk->data, read );
 756         chunk->failed = true;
 757         return NULL;
 758     }
 759     else
 760     {
 761         chunk->failed = false;
 762     }
 763
 764     stream_Delete( download_stream );
 765     return data;
 766 }
 767
 768 static void* download_thread( void* p )
 769 {
 770     vlc_object_t* p_this = (vlc_object_t*)p;
 771     stream_t* s = (stream_t*) p_this;
 772     stream_sys_t* sys = s->p_sys;
 773
 774     if ( vlc_array_count( sys->hds_streams ) == 0 )
 775         return NULL;
 776
 777     // TODO: Change here for selectable stream
 778     hds_stream_t* hds_stream = sys->hds_streams->pp_elems[0];
 779
 780     int canc = vlc_savecancel();
 781
 782     vlc_mutex_lock( & hds_stream->dl_lock );
 783
 784     while( ! sys->closed )
 785     {
 786         if( ! hds_stream->chunks_downloadpos )
 787         {
 788             chunk_t* chunk = hds_stream->chunks_head;
 789             while(chunk && chunk->data )
 790             {
 791                 chunk = chunk->next;
 792             }
 793
 794             if( chunk && ! chunk->data )
 795                 hds_stream->chunks_downloadpos = chunk;
 796         }
 797
 798         while( hds_stream->chunks_downloadpos )
 799         {
 800             chunk_t *chunk = hds_stream->chunks_downloadpos;
 801
 802             uint8_t *data = download_chunk( (stream_t*)p_this,
 803                                             sys,
 804                                             hds_stream,
 805                                             chunk );
 806
 807             if( ! chunk->failed )
 808             {
 809                 chunk->mdat_len =
 810                     find_chunk_mdat( p_this,
 811                                      data,
 812                                      data + chunk->data_len,
 813                                      & chunk->mdat_data );
 814                 if( chunk->mdat_len == 0 ) {
 815                     chunk->mdat_len = chunk->data_len - (chunk->mdat_data - data);
 816                 }
 817                 hds_stream->chunks_downloadpos = chunk->next;
 818                 chunk->data = data;
 819
 820                 sys->chunk_count++;
 821             }
 822         }
 823
 824         vlc_cond_wait( & hds_stream->dl_cond,
 825                        & hds_stream->dl_lock );
 826     }
 827
 828     vlc_mutex_unlock( & hds_stream->dl_lock );
 829
 830     vlc_restorecancel( canc );
 831     return NULL;
 832 }
 833
 834 static chunk_t* generate_new_chunk(
 835     vlc_object_t* p_this,
 836     chunk_t* last_chunk,
 837     hds_stream_t* hds_stream )
 838 {
 839     stream_t* s = (stream_t*) p_this;
 840     stream_sys_t *sys = s->p_sys;
 841     chunk_t *chunk = chunk_new();
 842     unsigned int frun_entry = 0;
 843
 844     if( ! chunk ) {
 845         msg_Err( p_this, "Couldn't allocate new chunk!" );
 846         return NULL;
 847     }
 848
 849     if( last_chunk )
 850     {
 851         chunk->timestamp = last_chunk->timestamp + last_chunk->duration;
 852         chunk->frag_num = last_chunk->frag_num + 1;
 853
 854         if( ! sys->live )
 855         {
 856             frun_entry = last_chunk->frun_entry;
 857         }
 858     }
 859     else
 860     {
 861         fragment_run_t* first_frun  = hds_stream->fragment_runs;
 862         if( sys->live )
 863         {
 864             chunk->timestamp = (hds_stream->live_current_time * ((uint64_t)hds_stream->afrt_timescale)) / ((uint64_t)hds_stream->timescale);
 865         }
 866         else
 867         {
 868             chunk->timestamp = first_frun->fragment_timestamp;
 869             chunk->frag_num =  first_frun->fragment_number_start;
 870         }
 871     }
 872
 873     for( ; frun_entry < hds_stream->fragment_run_count;
 874          frun_entry++ )
 875     {
 876         /* check for discontinuity first */
 877         if( hds_stream->fragment_runs[frun_entry].fragment_duration == 0 )
 878         {
 879             if( frun_entry == hds_stream->fragment_run_count - 1 )
 880             {
 881                 msg_Err( p_this, "Discontinuity but can't find next timestamp!");
 882                 return NULL;
 883             }
 884
 885             chunk->frag_num = hds_stream->fragment_runs[frun_entry+1].fragment_number_start;
 886             chunk->duration = hds_stream->fragment_runs[frun_entry+1].fragment_duration;
 887             chunk->timestamp = hds_stream->fragment_runs[frun_entry+1].fragment_timestamp;
 888
 889             frun_entry++;
 890             break;
 891         }
 892
 893         if( chunk->frag_num == 0 )
 894         {
 895             if( frun_entry == hds_stream->fragment_run_count - 1 ||
 896                 ( chunk->timestamp >= hds_stream->fragment_runs[frun_entry].fragment_timestamp &&
 897                   chunk->timestamp < hds_stream->fragment_runs[frun_entry+1].fragment_timestamp )
 898                 )
 899             {
 900                 fragment_run_t* frun = hds_stream->fragment_runs + frun_entry;
 901                 chunk->frag_num = frun->fragment_number_start + ( (chunk->timestamp - frun->fragment_timestamp) /
 902                                                                   frun->fragment_duration );
 903                 chunk->duration = frun->fragment_duration;
 904             }
 905
 906         }
 907
 908         if( hds_stream->fragment_runs[frun_entry].fragment_number_start <=
 909             chunk->frag_num &&
 910             (frun_entry == hds_stream->fragment_run_count - 1 ||
 911              hds_stream->fragment_runs[frun_entry+1].fragment_number_start > chunk->frag_num ) )
 912         {
 913             chunk->duration = hds_stream->fragment_runs[frun_entry].fragment_duration;
 914             chunk->timestamp = hds_stream->fragment_runs[frun_entry].fragment_timestamp +
 915                 chunk->duration * (chunk->frag_num - hds_stream->fragment_runs[frun_entry].fragment_number_start);
 916             break;
 917         }
 918     }
 919
 920     if( frun_entry == hds_stream->fragment_run_count )
 921     {
 922         msg_Err( p_this, "Couldn'd find the fragment run!" );
 923         return NULL;
 924     }
 925
 926     int srun_entry = 0;
 927     unsigned int segment = 0;
 928     uint64_t fragments_accum = chunk->frag_num;
 929     for( srun_entry = 0; srun_entry < hds_stream->segment_run_count;
 930          srun_entry++ )
 931     {
 932         segment = hds_stream->segment_runs[srun_entry].first_segment +
 933             (chunk->frag_num - fragments_accum ) / hds_stream->segment_runs[srun_entry].fragments_per_segment;
 934
 935         if( srun_entry + 1 == hds_stream->segment_run_count ||
 936             hds_stream->segment_runs[srun_entry+1].first_segment > segment )
 937         {
 938             break;
 939         }
 940
 941         fragments_accum += (
 942             (hds_stream->segment_runs[srun_entry+1].first_segment -
 943              hds_stream->segment_runs[srun_entry].first_segment) *
 944             hds_stream->segment_runs[srun_entry].fragments_per_segment );
 945     }
 946
 947     chunk->seg_num = segment;
 948     chunk->frun_entry = frun_entry;
 949
 950     if( ! sys->live )
 951     {
 952         if( (chunk->timestamp + chunk->duration) / hds_stream->afrt_timescale  >= sys->duration_seconds )
 953         {
 954             chunk->eof = true;
 955         }
 956     }
 957
 958     return chunk;
 959 }
 960
 961 static void maintain_live_chunks(
 962     vlc_object_t* p_this,
 963     hds_stream_t* hds_stream
 964     )
 965 {
 966     if( ! hds_stream->chunks_head )
 967     {
 968         /* just start with the earliest in the abst
 969          * maybe it would be better to use the currentMediaTime?
 970          * but then we are right on the edge of buffering, esp for
 971          * small fragments */
 972         hds_stream->chunks_head = generate_new_chunk(
 973             p_this, 0, hds_stream );
 974         hds_stream->chunks_livereadpos = hds_stream->chunks_head;
 975     }
 976
 977     chunk_t* chunk = hds_stream->chunks_head;
 978     bool dl = false;
 979     while( chunk && ( chunk->timestamp * ((uint64_t)hds_stream->timescale) )
 980            / ((uint64_t)hds_stream->afrt_timescale)
 981            <= hds_stream->live_current_time )
 982     {
 983         if( chunk->next )
 984         {
 985             chunk = chunk->next;
 986         }
 987         else
 988         {
 989             chunk->next = generate_new_chunk( p_this, chunk, hds_stream );
 990             chunk = chunk->next;
 991             dl = true;
 992         }
 993     }
 994
 995     if( dl )
 996         vlc_cond_signal( & hds_stream->dl_cond );
 997
 998     chunk = hds_stream->chunks_head;
 999     while( chunk && chunk->data && chunk->mdat_pos >= chunk->mdat_len && chunk->next )
1000     {
1001         chunk_t* next_chunk = chunk->next;
1002         chunk_free( chunk );
1003         chunk = next_chunk;
1004     }
1005
1006     if( ! hds_stream->chunks_livereadpos )
1007         hds_stream->chunks_livereadpos = hds_stream->chunks_head;
1008
1009     hds_stream->chunks_head = chunk;
1010 }
1011
1012 #define SAFE_STRDUP( dest, src, ret )   \
1013     if( !( (dest) = strdup( (src) ) ) ) \
1014         return (ret)
1015
1016 static void* live_thread( void* p )
1017 {
1018     vlc_object_t* p_this = (vlc_object_t*)p;
1019     stream_t* s = (stream_t*) p_this;
1020     stream_sys_t* sys = s->p_sys;
1021
1022     if ( vlc_array_count( sys->hds_streams ) == 0 )
1023         return NULL;
1024
1025     // TODO: Change here for selectable stream
1026     hds_stream_t* hds_stream = sys->hds_streams->pp_elems[0];
1027
1028     int canc = vlc_savecancel();
1029
1030     char* abst_url;
1031
1032     if( hds_stream->abst_url &&
1033         ( isFQUrl( hds_stream->abst_url ) ) )
1034     {
1035         SAFE_STRDUP( abst_url, hds_stream->abst_url, NULL );
1036     }
1037     else
1038     {
1039         char* server_base = sys->base_url;
1040
1041
1042         if( 0 > asprintf( &abst_url, "%s/%s",
1043                           server_base,
1044                           hds_stream->abst_url ) )
1045         {
1046             return NULL;
1047         }
1048     }
1049
1050     mtime_t last_dl_start_time;
1051
1052     while( ! sys->closed )
1053     {
1054         last_dl_start_time = mdate();
1055         stream_t* download_stream = stream_UrlNew( p_this, abst_url );
1056         if( ! download_stream )
1057         {
1058             msg_Err( p_this, "Failed to download abst %s", abst_url );
1059         }
1060         else
1061         {
1062             int64_t size = stream_Size( download_stream );
1063             uint8_t* data = malloc( size );
1064             int read = stream_Read( download_stream, data,
1065                                     size );
1066             if( read < size )
1067             {
1068                 msg_Err( p_this, "Requested %"PRIi64" bytes, "  \
1069                          "but only got %d", size, read );
1070
1071             }
1072             else
1073             {
1074                 vlc_mutex_lock( & hds_stream->abst_lock );
1075                 parse_BootstrapData( p_this, hds_stream,
1076                                      data, data + read );
1077                 vlc_mutex_unlock( & hds_stream->abst_lock );
1078                 maintain_live_chunks( p_this, hds_stream );
1079             }
1080
1081             free( data );
1082
1083             stream_Delete( download_stream );
1084         }
1085
1086         mwait( last_dl_start_time + ( ((int64_t)hds_stream->fragment_runs[hds_stream->fragment_run_count-1].fragment_duration) * 1000000LL) / ((int64_t)hds_stream->afrt_timescale) );
1087
1088
1089     }
1090
1091     free( abst_url );
1092
1093     vlc_restorecancel( canc );
1094     return NULL;
1095 }
1096
1097 static int parse_Manifest( stream_t *s )
1098 {
1099     xml_t *vlc_xml = NULL;
1100     xml_reader_t *vlc_reader = NULL;
1101     int type = UNKNOWN_ES;
1102     stream_t *st = s->p_source;
1103
1104     msg_Dbg( s, "Manifest parsing\n" );
1105
1106     vlc_xml = xml_Create( st );
1107     if( !vlc_xml )
1108     {
1109         msg_Err( s, "Failed to open XML parser" );
1110         return VLC_EGENERIC;
1111     }
1112
1113     vlc_reader = xml_ReaderCreate( vlc_xml, st );
1114     if( !vlc_reader )
1115     {
1116         msg_Err( s, "Failed to open source for parsing" );
1117         xml_Delete( vlc_xml );
1118         return VLC_EGENERIC;
1119     }
1120
1121     char *node;
1122
1123     stream_sys_t *sys = s->p_sys;
1124
1125     sys->duration_seconds = 0;
1126
1127 #define MAX_BOOTSTRAP_INFO 10
1128     bootstrap_info bootstraps[MAX_BOOTSTRAP_INFO];
1129     uint8_t bootstrap_idx = 0;
1130     memset( bootstraps, 0, sizeof(bootstrap_info) * MAX_BOOTSTRAP_INFO );
1131
1132 #define MAX_MEDIA_ELEMENTS 10
1133     media_info medias[MAX_MEDIA_ELEMENTS];
1134     uint8_t media_idx = 0;
1135     memset( medias, 0, sizeof(media_info) * MAX_MEDIA_ELEMENTS );
1136
1137 #define MAX_XML_DEPTH 256
1138     char* element_stack[256];
1139     uint8_t current_element_idx = 0;
1140     char* current_element = NULL;
1141     memset( element_stack, 0, sizeof(char*) * MAX_XML_DEPTH );
1142
1143     const char* attr_name;
1144     const char* attr_value;
1145
1146     char* media_id = NULL;
1147
1148 #define TIMESCALE 10000000
1149     while( (type = xml_ReaderNextNode( vlc_reader, (const char**) &node )) > 0 )
1150     {
1151         switch( type )
1152         {
1153         case XML_READER_STARTELEM:
1154             if( current_element_idx == 0 && element_stack[current_element_idx] == 0 ) {
1155                 SAFE_STRDUP( element_stack[current_element_idx], node, VLC_ENOMEM );
1156             } else {
1157                 SAFE_STRDUP( element_stack[++current_element_idx], node, VLC_ENOMEM );
1158             }
1159
1160             break;
1161         case XML_READER_ENDELEM:
1162             if( ! strcmp( current_element, "bootstrapInfo") ) {
1163                 if( bootstrap_idx + 1 == MAX_BOOTSTRAP_INFO ) {
1164                     msg_Warn( (vlc_object_t*) s, "Too many bootstraps, ignoring" );
1165                 } else {
1166                     bootstrap_idx++;
1167                 }
1168             }
1169
1170             free( current_element );
1171             element_stack[current_element_idx--] = 0;
1172             break;
1173         }
1174
1175         if( ! element_stack[current_element_idx] ) {
1176             continue;
1177         }
1178
1179         current_element = element_stack[current_element_idx];
1180
1181         if( type == XML_READER_STARTELEM && ! strcmp( current_element, "media") )
1182         {
1183             if( media_idx == MAX_MEDIA_ELEMENTS )
1184             {
1185                 msg_Err( (vlc_object_t*) s, "Too many media elements, quitting" );
1186                 return VLC_EGENERIC;
1187             }
1188
1189             while( ( attr_name = xml_ReaderNextAttr( vlc_reader, &attr_value )) )
1190             {
1191                 if( !strcmp(attr_name, "streamId" ) )
1192                 {
1193                     SAFE_STRDUP( medias[media_idx].stream_id, attr_value, VLC_ENOMEM );
1194                 }
1195                 if( !strcmp(attr_name, "url" ) )
1196                 {
1197                     SAFE_STRDUP( medias[media_idx].media_url, attr_value, VLC_ENOMEM );
1198                 }
1199                 if( !strcmp(attr_name, "bootstrapInfoId" ) )
1200                 {
1201                     SAFE_STRDUP( medias[media_idx].bootstrap_id, attr_value, VLC_ENOMEM );
1202                 }
1203             }
1204
1205             media_idx++;
1206         }
1207
1208         if( type == XML_READER_STARTELEM && ! strcmp( current_element, "bootstrapInfo") )
1209         {
1210             while( ( attr_name = xml_ReaderNextAttr( vlc_reader, &attr_value )) )
1211             {
1212                 if( !strcmp(attr_name, "url" ) )
1213                 {
1214                     SAFE_STRDUP( bootstraps[bootstrap_idx].url, attr_value, VLC_ENOMEM );
1215                 }
1216                 if( !strcmp(attr_name, "id" ) )
1217                 {
1218                     SAFE_STRDUP( bootstraps[bootstrap_idx].id, attr_value, VLC_ENOMEM );
1219                 }
1220                 if( !strcmp(attr_name, "profile" ) )
1221                 {
1222                     SAFE_STRDUP( bootstraps[bootstrap_idx].profile, attr_value, VLC_ENOMEM );
1223                 }
1224             }
1225         }
1226
1227         if( type == XML_READER_TEXT )
1228         {
1229             if( ! strcmp( current_element, "bootstrapInfo" ) )
1230             {
1231                 char* start = node;
1232                 char* end = start + strlen(start);
1233                 whitespace_substr( &start, &end );
1234                 *end = '\0';
1235
1236                 bootstraps[bootstrap_idx].data_len =
1237                     vlc_b64_decode_binary( (uint8_t**)&bootstraps[bootstrap_idx].data, start );
1238                 if( ! bootstraps[bootstrap_idx].data )
1239                 {
1240                     msg_Err( (vlc_object_t*) s, "Couldn't decode bootstrap info" );
1241                 }
1242             }
1243             if( ! strcmp( current_element, "duration" ) )
1244             {
1245                 double shutup_gcc = atof( node );
1246                 sys->duration_seconds = (uint64_t) shutup_gcc;
1247             }
1248             if( ! strcmp( current_element, "id" ) )
1249             {
1250                 if( current_element &&
1251                     ! strcmp( element_stack[current_element_idx-1], "manifest" ) )
1252                 {
1253                     SAFE_STRDUP( media_id, node, VLC_ENOMEM );
1254                 }
1255             }
1256         }
1257     }
1258
1259     xml_ReaderDelete( vlc_reader );
1260     xml_Delete( vlc_xml );
1261
1262     for( int i = 0; i <= media_idx; i++ )
1263     {
1264         for( int j = 0; j < bootstrap_idx; j++ )
1265         {
1266             if( ( ! medias[i].bootstrap_id && ! bootstraps[j].id ) ||
1267                 (medias[i].bootstrap_id && bootstraps[j].id &&
1268                  ! strcmp( medias[i].bootstrap_id, bootstraps[j].id ) ) )
1269             {
1270                 hds_stream_t* new_stream = malloc(sizeof(hds_stream_t));
1271                 memset( new_stream, 0, sizeof(hds_stream_t));
1272
1273                 vlc_mutex_init( & new_stream->abst_lock );
1274                 vlc_mutex_init( & new_stream->dl_lock );
1275                 vlc_cond_init( & new_stream->dl_cond );
1276
1277                 if( sys->duration_seconds )
1278                 {
1279                     sys->live = false;
1280                 }
1281                 else
1282                 {
1283                     sys->live = true;
1284                 }
1285
1286                 if( medias[i].media_url )
1287                 {
1288                     SAFE_STRDUP( new_stream->url, medias[i].media_url, VLC_ENOMEM );
1289                 }
1290
1291                 if( ! sys->live )
1292                 {
1293                     parse_BootstrapData( (vlc_object_t*)s,
1294                                          new_stream,
1295                                          bootstraps[j].data,
1296                                          bootstraps[j].data + bootstraps[j].data_len );
1297
1298                     new_stream->download_leadtime = 15;
1299
1300                     new_stream->chunks_head = generate_new_chunk(
1301                         (vlc_object_t*) s, 0, new_stream );
1302                     chunk_t* chunk = new_stream->chunks_head;
1303                     uint64_t total_duration = chunk->duration;
1304                     while( chunk && total_duration/new_stream->afrt_timescale < new_stream->download_leadtime )
1305                     {
1306                         chunk->next = generate_new_chunk(
1307                             (vlc_object_t*) s, chunk, new_stream );
1308                         chunk = chunk->next;
1309                         if( chunk )
1310                             total_duration += chunk->duration;
1311                     }
1312                 }
1313                 else
1314                 {
1315                     SAFE_STRDUP( new_stream->abst_url, bootstraps[j].url, VLC_ENOMEM );
1316                 }
1317
1318                 vlc_array_append( sys->hds_streams, new_stream );
1319
1320                 msg_Info( (vlc_object_t*)s, "New track with quality_segment(%s), timescale(%u), movie_id(%s), segment_run_count(%d), fragment_run_count(%u)",
1321                           new_stream->quality_segment_modifier?"":new_stream->quality_segment_modifier, new_stream->timescale,
1322                           new_stream->movie_id, new_stream->segment_run_count, new_stream->fragment_run_count );
1323
1324             }
1325         }
1326     }
1327
1328     for( int i = 0; i < MAX_MEDIA_ELEMENTS; i++ )
1329     {
1330         FREENULL( medias[media_idx].stream_id );
1331         FREENULL( medias[media_idx].media_url );
1332         FREENULL( medias[media_idx].bootstrap_id );
1333     }
1334
1335     for( int i = 0; i < MAX_BOOTSTRAP_INFO; i++ )
1336     {
1337         FREENULL( bootstraps[i].data );
1338         FREENULL( bootstraps[i].id );
1339         FREENULL( bootstraps[i].url );
1340         FREENULL( bootstraps[i].profile );
1341     }
1342
1343     FREENULL( media_id );
1344
1345     return VLC_SUCCESS;
1346 }
1347
1348 #undef SAFE_STRDUP
1349
1350 static void hds_free( hds_stream_t *p_stream )
1351 {
1352     FREENULL( p_stream->quality_segment_modifier );
1353
1354     FREENULL( p_stream->abst_url );
1355
1356     FREENULL( p_stream->url );
1357     FREENULL( p_stream->movie_id );
1358     for( int i = 0; i < p_stream->server_entry_count; i++ )
1359     {
1360         FREENULL( p_stream->server_entries[i] );
1361     }
1362
1363     chunk_t* chunk = p_stream->chunks_head;
1364     while( chunk )
1365     {
1366         chunk_t* next = chunk->next;
1367         chunk_free( chunk );
1368         chunk = next;
1369     }
1370
1371     free( p_stream );
1372 }
1373
1374 static void SysCleanup( stream_sys_t *p_sys )
1375 {
1376     if ( p_sys->hds_streams )
1377     {
1378         for ( int i=0; i< p_sys->hds_streams->i_count ; i++ )
1379             hds_free( p_sys->hds_streams->pp_elems[i] );
1380         vlc_array_destroy( p_sys->hds_streams );
1381     }
1382     free( p_sys->base_url );
1383 }
1384
1385 static int Open( vlc_object_t *p_this )
1386 {
1387     stream_t *s = (stream_t*)p_this;
1388     stream_sys_t *p_sys;
1389
1390     if( !isHDS( s ) )
1391         return VLC_EGENERIC;
1392
1393     msg_Info( p_this, "HTTP Dynamic Streaming (%s)", s->psz_path );
1394
1395     s->p_sys = p_sys = calloc( 1, sizeof(*p_sys ) );
1396     if( unlikely( p_sys == NULL ) )
1397         return VLC_ENOMEM;
1398
1399     char *uri = NULL;
1400     if( unlikely( asprintf( &uri, "%s://%s", s->psz_access, s->psz_path ) < 0 ) )
1401     {
1402         free( p_sys );
1403         return VLC_ENOMEM;
1404     }
1405
1406     /* remove the last part of the url */
1407     char *pos = strrchr( uri, '/');
1408     *pos = '\0';
1409     p_sys->base_url = uri;
1410
1411     p_sys->flv_header_bytes_sent = 0;
1412
1413     p_sys->hds_streams = vlc_array_new();
1414
1415     if( parse_Manifest( s ) != VLC_SUCCESS )
1416     {
1417         goto error;
1418     }
1419
1420     s->pf_read = Read;
1421     s->pf_peek = Peek;
1422     s->pf_control = Control;
1423
1424     if( vlc_clone( &p_sys->dl_thread, download_thread, s, VLC_THREAD_PRIORITY_INPUT ) )
1425     {
1426         goto error;
1427     }
1428
1429     if( p_sys->live ) {
1430         msg_Info( p_this, "Live stream detected" );
1431
1432         if( vlc_clone( &p_sys->live_thread, live_thread, s, VLC_THREAD_PRIORITY_INPUT ) )
1433         {
1434             goto error;
1435         }
1436     }
1437
1438     return VLC_SUCCESS;
1439
1440 error:
1441     SysCleanup( p_sys );
1442     free( p_sys );
1443     return VLC_EGENERIC;
1444 }
1445
1446 static void Close( vlc_object_t *p_this )
1447 {
1448     stream_t *s = (stream_t*)p_this;
1449     stream_sys_t *p_sys = s->p_sys;
1450
1451     // TODO: Change here for selectable stream
1452     hds_stream_t *stream = vlc_array_count(p_sys->hds_streams) ?
1453         s->p_sys->hds_streams->pp_elems[0] : NULL;
1454
1455     p_sys->closed = true;
1456     if (stream)
1457         vlc_cond_signal( & stream->dl_cond );
1458
1459     vlc_join( p_sys->dl_thread, NULL );
1460
1461     if (stream)
1462     {
1463         vlc_mutex_destroy( &stream->dl_lock );
1464         vlc_cond_destroy( &stream->dl_cond );
1465         vlc_mutex_destroy( &stream->abst_lock );
1466     }
1467
1468     if( p_sys->live )
1469     {
1470         vlc_join( p_sys->live_thread, NULL );
1471     }
1472
1473     SysCleanup( p_sys );
1474     free( p_sys );
1475 }
1476
1477 static unsigned char flv_header[] = {
1478         'F',
1479         'L',
1480         'V',
1481         0x1, //version
1482         0x5, //indicates audio and video
1483         0x0, // length
1484         0x0, // length
1485         0x0, // length
1486         0x9, // length of header
1487         0x0,
1488         0x0,
1489         0x0,
1490         0x0, // initial "trailer"
1491 };
1492
1493 static int send_flv_header( stream_sys_t* p_sys, void* buffer, unsigned i_read,
1494                             bool peek )
1495 {
1496     uint32_t to_be_read = i_read;
1497     if( to_be_read > 13 - p_sys->flv_header_bytes_sent ) {
1498         to_be_read = 13 - p_sys->flv_header_bytes_sent;
1499     }
1500
1501     memcpy( buffer, flv_header + p_sys->flv_header_bytes_sent, to_be_read );
1502
1503     if( ! peek )
1504     {
1505         p_sys->flv_header_bytes_sent += to_be_read;
1506     }
1507     return to_be_read;
1508 }
1509
1510 static unsigned read_chunk_data(
1511     vlc_object_t* p_this,
1512     uint8_t* buffer, unsigned read_len,
1513     hds_stream_t* stream,
1514     bool* eof
1515     )
1516 {
1517     stream_t* s = (stream_t*) p_this;
1518     stream_sys_t* sys = s->p_sys;
1519     chunk_t* chunk = stream->chunks_head;
1520     uint8_t* buffer_start = buffer;
1521     bool dl = false;
1522
1523     if( chunk && chunk->eof && chunk->mdat_pos >= chunk->mdat_len ) {
1524         *eof = true;
1525         return 0;
1526     }
1527
1528     while( chunk && chunk->data && read_len > 0 && ! (chunk->eof && chunk->mdat_pos >= chunk->mdat_len ) )
1529     {
1530         /* in the live case, it is necessary to store the next
1531          * pointer here, since as soon as we increment the mdat_pos, that
1532          * chunk may be deleted */
1533         chunk_t* next = chunk->next;
1534
1535         if( chunk->mdat_pos < chunk->mdat_len )
1536         {
1537             unsigned cp_len = chunk->mdat_len - chunk->mdat_pos;
1538             if( cp_len > read_len )
1539                 cp_len = read_len;
1540             memcpy( buffer, chunk->mdat_data + chunk->mdat_pos,
1541                     cp_len );
1542
1543             read_len -= cp_len;
1544             buffer += cp_len;
1545             chunk->mdat_pos += cp_len;
1546         }
1547
1548         if( ! sys->live && (chunk->mdat_pos >= chunk->mdat_len || chunk->failed) )
1549         {
1550             if( chunk->eof )
1551             {
1552                 *eof = true;
1553             }
1554
1555             /* make sure there is at least one chunk in the queue */
1556             if( ! chunk->next && ! chunk->eof )
1557             {
1558                 chunk->next = generate_new_chunk( p_this, chunk,  stream );
1559                 dl = true;
1560             }
1561
1562             if( ! chunk->eof )
1563             {
1564                 chunk_free( chunk );
1565                 chunk = next;
1566                 stream->chunks_head = chunk;
1567             }
1568         }
1569         else if( sys->live && (chunk->mdat_pos >= chunk->mdat_len || chunk->failed) )
1570         {
1571             chunk = next;
1572         }
1573     }
1574
1575     if( sys->live )
1576     {
1577         stream->chunks_livereadpos = chunk;
1578     }
1579
1580     /* new chunk generation is handled by a different thread in live case */
1581     if( ! sys->live )
1582     {
1583         chunk = stream->chunks_head;
1584         if( chunk )
1585         {
1586             uint64_t total_duration = chunk->duration;
1587             while( chunk && total_duration/stream->afrt_timescale < stream->download_leadtime && ! chunk->eof )
1588             {
1589                 if( ! chunk->next && ! chunk->eof )
1590                 {
1591                     chunk->next = generate_new_chunk( p_this, chunk, stream );
1592                     dl = true;
1593                 }
1594
1595                 if( ! chunk->eof )
1596                 {
1597                     chunk = chunk->next;
1598                     if( chunk )
1599                     {
1600                         total_duration += chunk->duration;
1601                     }
1602                 }
1603             }
1604         }
1605
1606         if( dl )
1607             vlc_cond_signal( & stream->dl_cond );
1608     }
1609
1610     return ( ((uint8_t*)buffer) - ((uint8_t*)buffer_start));
1611 }
1612
1613 static int Read( stream_t *s, void *buffer, unsigned i_read )
1614 {
1615     stream_sys_t *p_sys = s->p_sys;
1616
1617     if ( vlc_array_count( p_sys->hds_streams ) == 0 )
1618         return 0;
1619
1620     // TODO: change here for selectable stream
1621     hds_stream_t *stream = s->p_sys->hds_streams->pp_elems[0];
1622     int length = 0;
1623
1624     uint8_t *buffer_uint8 = (uint8_t*) buffer;
1625
1626     unsigned hdr_bytes = send_flv_header( p_sys, buffer, i_read, false );
1627     length += hdr_bytes;
1628     i_read -= hdr_bytes;
1629     buffer_uint8 += hdr_bytes;
1630
1631     bool eof = false;
1632     while( i_read > 0 && ! eof )
1633     {
1634         int tmp_length = read_chunk_data( (vlc_object_t*)s, buffer_uint8, i_read, stream, &eof );
1635         buffer_uint8 += tmp_length;
1636         i_read -= tmp_length;
1637         length += tmp_length;
1638     }
1639
1640     return length;
1641 }
1642
1643 static int Peek( stream_t *s, const uint8_t **pp_peek, unsigned i_peek )
1644 {
1645     stream_sys_t *p_sys = s->p_sys;
1646
1647     if ( vlc_array_count( p_sys->hds_streams ) == 0 )
1648         return 0;
1649
1650     // TODO: change here for selectable stream
1651     hds_stream_t *stream = p_sys->hds_streams->pp_elems[0];
1652
1653     if( p_sys->flv_header_bytes_sent < 13 )
1654     {
1655         *pp_peek = flv_header + p_sys->flv_header_bytes_sent;
1656         return 13 - p_sys->flv_header_bytes_sent;
1657     }
1658
1659     if( stream->chunks_head && ! stream->chunks_head->failed && stream->chunks_head->data )
1660     {
1661         // TODO: change here for selectable stream
1662         chunk_t* chunk = stream->chunks_head;
1663         *pp_peek = chunk->mdat_data + chunk->mdat_pos;
1664         if( chunk->mdat_len - chunk->mdat_pos < i_peek )
1665         {
1666             return chunk->mdat_len - chunk->mdat_pos;
1667         }
1668         else
1669         {
1670             return i_peek;
1671         }
1672     } else
1673     {
1674         return 0;
1675     }
1676 }
1677
1678 static int Control( stream_t *s, int i_query, va_list args )
1679 {
1680     switch( i_query )
1681     {
1682         case STREAM_CAN_SEEK:
1683             *(va_arg( args, bool * )) = false;
1684             break;
1685         case STREAM_CAN_FASTSEEK:
1686         case STREAM_CAN_PAUSE: /* TODO */
1687             *(va_arg( args, bool * )) = false;
1688             break;
1689         case STREAM_CAN_CONTROL_PACE:
1690             *(va_arg( args, bool * )) = true;
1691             break;
1692         case STREAM_GET_PTS_DELAY:
1693             *va_arg (args, int64_t *) = INT64_C(1000) *
1694                 var_InheritInteger(s, "network-caching");
1695              break;
1696         default:
1697             return VLC_EGENERIC;
1698     }
1699     return VLC_SUCCESS;
1700 }