modules/demux/adaptive/http/Chunk.cpp

   1 /*
   2  * Chunk.cpp
   3  *****************************************************************************
   4  * Copyright (C) 2010 - 2011 Klagenfurt University
   5  *
   6  * Created on: Aug 10, 2010
   7  * Authors: Christopher Mueller <christopher.mueller@itec.uni-klu.ac.at>
   8  *          Christian Timmerer  <christian.timmerer@itec.uni-klu.ac.at>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published
  12  * by the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24 #ifdef HAVE_CONFIG_H
  25 # include "config.h"
  26 #endif
  27
  28 #include "Chunk.h"
  29 #include "HTTPConnection.hpp"
  30 #include "HTTPConnectionManager.h"
  31 #include "Downloader.hpp"
  32
  33 #include <vlc_common.h>
  34 #include <vlc_block.h>
  35
  36 #include <algorithm>
  37
  38 using namespace adaptive::http;
  39
  40 AbstractChunkSource::AbstractChunkSource()
  41 {
  42     contentLength = 0;
  43 }
  44
  45 AbstractChunkSource::~AbstractChunkSource()
  46 {
  47
  48 }
  49
  50 void AbstractChunkSource::setBytesRange(const BytesRange &range)
  51 {
  52     bytesRange = range;
  53     if(bytesRange.isValid() && bytesRange.getEndByte())
  54         contentLength = bytesRange.getEndByte() - bytesRange.getStartByte();
  55 }
  56
  57 const BytesRange & AbstractChunkSource::getBytesRange() const
  58 {
  59     return bytesRange;
  60 }
  61
  62 AbstractChunk::AbstractChunk(AbstractChunkSource *source_)
  63 {
  64     bytesRead = 0;
  65     source = source_;
  66 }
  67
  68 AbstractChunk::~AbstractChunk()
  69 {
  70     delete source;
  71 }
  72
  73 size_t AbstractChunk::getBytesRead() const
  74 {
  75     return this->bytesRead;
  76 }
  77
  78 uint64_t AbstractChunk::getStartByteInFile() const
  79 {
  80     if(!source || !source->getBytesRange().isValid())
  81         return 0;
  82
  83     return source->getBytesRange().getStartByte();
  84 }
  85
  86 block_t * AbstractChunk::doRead(size_t size, bool b_block)
  87 {
  88     if(!source)
  89         return NULL;
  90
  91     block_t *block = (b_block) ? source->readBlock() : source->read(size);
  92     if(block)
  93     {
  94         if(bytesRead == 0)
  95             block->i_flags |= BLOCK_FLAG_HEADER;
  96         bytesRead += block->i_buffer;
  97         onDownload(&block);
  98         block->i_flags &= ~BLOCK_FLAG_HEADER;
  99     }
 100
 101     return block;
 102 }
 103
 104 bool AbstractChunk::isEmpty() const
 105 {
 106     return !source->hasMoreData();
 107 }
 108
 109 block_t * AbstractChunk::readBlock()
 110 {
 111     return doRead(0, true);
 112 }
 113
 114 block_t * AbstractChunk::read(size_t size)
 115 {
 116     return doRead(size, false);
 117 }
 118
 119 HTTPChunkSource::HTTPChunkSource(const std::string& url, AbstractConnectionManager *manager,
 120                                  const adaptive::ID &id) :
 121     AbstractChunkSource(),
 122     connection   (NULL),
 123     connManager  (manager),
 124     consumed     (0)
 125 {
 126     prepared = false;
 127     eof = false;
 128     sourceid = id;
 129     if(!init(url))
 130         eof = true;
 131 }
 132
 133 HTTPChunkSource::~HTTPChunkSource()
 134 {
 135     if(connection)
 136         connection->setUsed(false);
 137 }
 138
 139 bool HTTPChunkSource::init(const std::string &url)
 140 {
 141     params = ConnectionParams(url);
 142
 143     if(params.getScheme() != "http" && params.getScheme() != "https")
 144         return false;
 145
 146     if(params.getPath().empty() || params.getHostname().empty())
 147         return false;
 148
 149     return true;
 150 }
 151
 152 bool HTTPChunkSource::hasMoreData() const
 153 {
 154     if(eof)
 155         return false;
 156     else if(contentLength)
 157         return consumed < contentLength;
 158     else return true;
 159 }
 160
 161 block_t * HTTPChunkSource::read(size_t readsize)
 162 {
 163     if(!prepare())
 164     {
 165         eof = true;
 166         return NULL;
 167     }
 168
 169     if(consumed == contentLength && consumed > 0)
 170     {
 171         eof = true;
 172         return NULL;
 173     }
 174
 175     if(contentLength && readsize > contentLength - consumed)
 176         readsize = contentLength - consumed;
 177
 178     block_t *p_block = block_Alloc(readsize);
 179     if(!p_block)
 180     {
 181         eof = true;
 182         return NULL;
 183     }
 184
 185     mtime_t time = mdate();
 186     ssize_t ret = connection->read(p_block->p_buffer, readsize);
 187     time = mdate() - time;
 188     if(ret < 0)
 189     {
 190         block_Release(p_block);
 191         p_block = NULL;
 192         eof = true;
 193     }
 194     else
 195     {
 196         p_block->i_buffer = (size_t) ret;
 197         consumed += p_block->i_buffer;
 198         if((size_t)ret < readsize)
 199             eof = true;
 200         connManager->updateDownloadRate(sourceid, p_block->i_buffer, time);
 201     }
 202
 203     return p_block;
 204 }
 205
 206 bool HTTPChunkSource::prepare(int i_redir)
 207 {
 208     if(prepared)
 209         return true;
 210
 211     if(!connManager)
 212         return false;
 213
 214     if(!connection)
 215     {
 216         connection = connManager->getConnection(params);
 217         if(!connection)
 218             return false;
 219     }
 220
 221     int i_ret = connection->request(params.getPath(), bytesRange);
 222     if(i_ret != VLC_SUCCESS)
 223     {
 224         if(i_ret == VLC_ETIMEOUT && i_redir < 3)
 225             return HTTPChunkSource::prepare(i_redir + 1);
 226         return false;
 227     }
 228     /* Because we don't know Chunk size at start, we need to get size
 229            from content length */
 230     contentLength = connection->getContentLength();
 231     prepared = true;
 232
 233     return true;
 234 }
 235
 236 block_t * HTTPChunkSource::readBlock()
 237 {
 238     return read(HTTPChunkSource::CHUNK_SIZE);
 239 }
 240
 241 HTTPChunkBufferedSource::HTTPChunkBufferedSource(const std::string& url, AbstractConnectionManager *manager,
 242                                                  const adaptive::ID &sourceid) :
 243     HTTPChunkSource(url, manager, sourceid),
 244     p_head     (NULL),
 245     pp_tail    (&p_head),
 246     buffered     (0)
 247 {
 248     vlc_mutex_init(&lock);
 249     vlc_cond_init(&avail);
 250     done = false;
 251     eof = false;
 252     downloadstart = 0;
 253 }
 254
 255 HTTPChunkBufferedSource::~HTTPChunkBufferedSource()
 256 {
 257     vlc_mutex_lock(&lock);
 258     if(p_head)
 259     {
 260         block_ChainRelease(p_head);
 261         p_head = NULL;
 262         pp_tail = &p_head;
 263     }
 264     done = true;
 265     buffered = 0;
 266     vlc_mutex_unlock(&lock);
 267
 268     connManager->cancel(this);
 269
 270     vlc_cond_destroy(&avail);
 271     vlc_mutex_destroy(&lock);
 272 }
 273
 274 bool HTTPChunkBufferedSource::isDone() const
 275 {
 276     bool b_done;
 277     vlc_mutex_lock(const_cast<vlc_mutex_t *>(&lock));
 278     b_done = done;
 279     vlc_mutex_unlock(const_cast<vlc_mutex_t *>(&lock));
 280     return b_done;
 281 }
 282
 283 void HTTPChunkBufferedSource::bufferize(size_t readsize)
 284 {
 285     vlc_mutex_lock(&lock);
 286     if(!prepare())
 287     {
 288         done = true;
 289         eof = true;
 290         vlc_cond_signal(&avail);
 291         vlc_mutex_unlock(&lock);
 292         return;
 293     }
 294
 295     if(readsize < HTTPChunkSource::CHUNK_SIZE)
 296         readsize = HTTPChunkSource::CHUNK_SIZE;
 297
 298     if(contentLength && readsize > contentLength - buffered)
 299         readsize = contentLength - buffered;
 300
 301     vlc_mutex_unlock(&lock);
 302
 303     block_t *p_block = block_Alloc(readsize);
 304     if(!p_block)
 305     {
 306         eof = true;
 307         return;
 308     }
 309
 310     struct
 311     {
 312         size_t size;
 313         mtime_t time;
 314     } rate = {0,0};
 315
 316     ssize_t ret = connection->read(p_block->p_buffer, readsize);
 317     if(ret <= 0)
 318     {
 319         block_Release(p_block);
 320         vlc_mutex_lock(&lock);
 321         done = true;
 322         rate.size = buffered + consumed;
 323         rate.time = mdate() - downloadstart;
 324         downloadstart = 0;
 325         vlc_mutex_unlock(&lock);
 326     }
 327     else
 328     {
 329         p_block->i_buffer = (size_t) ret;
 330         vlc_mutex_lock(&lock);
 331         buffered += p_block->i_buffer;
 332         block_ChainLastAppend(&pp_tail, p_block);
 333         if((size_t) ret < readsize)
 334         {
 335             done = true;
 336             rate.size = buffered + consumed;
 337             rate.time = mdate() - downloadstart;
 338             downloadstart = 0;
 339         }
 340         vlc_mutex_unlock(&lock);
 341     }
 342
 343     if(rate.size)
 344     {
 345         connManager->updateDownloadRate(sourceid, rate.size, rate.time);
 346     }
 347
 348     vlc_cond_signal(&avail);
 349 }
 350
 351 bool HTTPChunkBufferedSource::prepare()
 352 {
 353     if(!prepared)
 354     {
 355         downloadstart = mdate();
 356         return HTTPChunkSource::prepare();
 357     }
 358     return true;
 359 }
 360
 361 bool HTTPChunkBufferedSource::hasMoreData() const
 362 {
 363     bool b_hasdata;
 364     vlc_mutex_lock(const_cast<vlc_mutex_t *>(&lock));
 365     b_hasdata = !eof;
 366     vlc_mutex_unlock(const_cast<vlc_mutex_t *>(&lock));
 367     return b_hasdata;
 368 }
 369
 370 block_t * HTTPChunkBufferedSource::readBlock()
 371 {
 372     block_t *p_block = NULL;
 373
 374     vlc_mutex_lock(&lock);
 375
 376     while(!p_head && !done)
 377         vlc_cond_wait(&avail, &lock);
 378
 379     if(!p_head && done)
 380     {
 381         if(!eof)
 382             p_block = block_Alloc(0);
 383         eof = true;
 384         vlc_mutex_unlock(&lock);
 385         return p_block;
 386     }
 387
 388     /* dequeue */
 389     p_block = p_head;
 390     p_head = p_head->p_next;
 391     if(p_head == NULL)
 392     {
 393         pp_tail = &p_head;
 394         if(done)
 395             eof = true;
 396     }
 397     p_block->p_next = NULL;
 398
 399     consumed += p_block->i_buffer;
 400     buffered -= p_block->i_buffer;
 401
 402     vlc_mutex_unlock(&lock);
 403
 404     return p_block;
 405 }
 406
 407 block_t * HTTPChunkBufferedSource::read(size_t readsize)
 408 {
 409     vlc_mutex_lock(&lock);
 410
 411     while(readsize > buffered && !done)
 412         vlc_cond_wait(&avail, &lock);
 413
 414     block_t *p_block = NULL;
 415     if(!readsize || !buffered || !(p_block = block_Alloc(readsize)) )
 416     {
 417         eof = true;
 418         vlc_mutex_unlock(&lock);
 419         return NULL;
 420     }
 421
 422     size_t copied = 0;
 423     while(buffered && readsize)
 424     {
 425         const size_t toconsume = std::min(p_head->i_buffer, readsize);
 426         memcpy(&p_block->p_buffer[copied], p_head->p_buffer, toconsume);
 427         copied += toconsume;
 428         readsize -= toconsume;
 429         buffered -= toconsume;
 430         p_head->i_buffer -= toconsume;
 431         p_head->p_buffer += toconsume;
 432         if(p_head->i_buffer == 0)
 433         {
 434             block_t *next = p_head->p_next;
 435             p_head->p_next = NULL;
 436             block_Release(p_head);
 437             p_head = next;
 438             if(next == NULL)
 439                 pp_tail = &p_head;
 440         }
 441     }
 442
 443     consumed += copied;
 444     p_block->i_buffer = copied;
 445
 446     if(copied < readsize)
 447         eof = true;
 448
 449     vlc_mutex_unlock(&lock);
 450
 451     return p_block;
 452 }
 453
 454 HTTPChunk::HTTPChunk(const std::string &url, AbstractConnectionManager *manager,
 455                      const adaptive::ID &id):
 456     AbstractChunk(new HTTPChunkSource(url, manager, id))
 457 {
 458
 459 }
 460
 461 HTTPChunk::~HTTPChunk()
 462 {
 463
 464 }