/AdobeHDS.php

Large files files are truncated, but you can click here to view the full file

<?php

  define('AUDIO', 0x08);

  define('VIDEO', 0x09);

  define('SCRIPT_DATA', 0x12);

  define('FRAME_TYPE_INFO', 0x05);

  define('CODEC_ID_AVC', 0x07);

  define('CODEC_ID_AAC', 0x0A);

  define('AVC_SEQUENCE_HEADER', 0x00);

  define('AAC_SEQUENCE_HEADER', 0x00);

  define('AVC_SEQUENCE_END', 0x02);

  define('FRAMEGAP_DURATION', 8);

  define('INVALID_TIMESTAMP', -1);



  class CLI

    {

      protected static $ACCEPTED = array(

          0 => array(

              'help'   => 'displays this help',

              'debug'  => 'show debug output',

              'delete' => 'delete fragments after processing',

              'fproxy' => 'force proxy for downloading of fragments',

              'play'   => 'dump stream to stdout for piping to media player',

              'rename' => 'rename fragments sequentially before processing',

              'update' => 'update the script to current git version'

          ),

          1 => array(

              'auth'      => 'authentication string for fragment requests',

              'duration'  => 'stop recording after specified number of seconds',

              'filesize'  => 'split output file in chunks of specified size (MB)',

              'fragments' => 'base filename for fragments',

              'fixwindow' => 'timestamp gap between frames to consider as timeshift',

              'manifest'  => 'manifest file for downloading of fragments',

              'outdir'    => 'destination folder for output file',

              'outfile'   => 'filename to use for output file',

              'parallel'  => 'number of fragments to download simultaneously',

              'proxy'     => 'proxy for downloading of manifest',

              'quality'   => 'selected quality level (low|medium|high) or exact bitrate',

              'referrer'  => 'Referer to use for emulation of browser requests',

              'start'     => 'start from specified fragment',

              'useragent' => 'User-Agent to use for emulation of browser requests'

          )

      );

      var $params = array();



      function __construct()

        {

          global $argc, $argv;



          // Parse params

          if ($argc > 1)

            {

              $paramSwitch = false;

              for ($i = 1; $i < $argc; $i++)

                {

                  $arg      = $argv[$i];

                  $isSwitch = preg_match('/^--/', $arg);



                  if ($isSwitch)

                      $arg = preg_replace('/^--/', '', $arg);



                  if ($paramSwitch && $isSwitch)

                      LogError("[param] expected after '$paramSwitch' switch (" . self::$ACCEPTED[1][$paramSwitch] . ")");

                  else if (!$paramSwitch && !$isSwitch)

                    {

                      if (isset($GLOBALS['baseFilename']) and (!$GLOBALS['baseFilename']))

                          $GLOBALS['baseFilename'] = $arg;

                      else

                          LogError("'$arg' is an invalid switch, use --help to display valid switches.");

                    }

                  else if (!$paramSwitch && $isSwitch)

                    {

                      if (isset($this->params[$arg]))

                          LogError("'$arg' switch cannot occur more than once");



                      $this->params[$arg] = true;

                      if (isset(self::$ACCEPTED[1][$arg]))

                          $paramSwitch = $arg;

                      else if (!isset(self::$ACCEPTED[0][$arg]))

                          LogError("there's no '$arg' switch, use --help to display all switches.");

                    }

                  else if ($paramSwitch && !$isSwitch)

                    {

                      $this->params[$paramSwitch] = $arg;

                      $paramSwitch                = false;

                    }

                }

            }



          // Final check

          foreach ($this->params as $k => $v)

              if (isset(self::$ACCEPTED[1][$k]) && $v === true)

                  LogError("[param] expected after '$k' switch (" . self::$ACCEPTED[1][$k] . ")");

        }



      function getParam($name)

        {

          if (isset($this->params[$name]))

              return $this->params[$name];

          else

              return "";

        }



      function displayHelp()

        {

          LogInfo("You can use script with following switches: \n");

          foreach (self::$ACCEPTED[0] as $key => $value)

              LogInfo(sprintf(" --%-18s%s", $key, $value));

          foreach (self::$ACCEPTED[1] as $key => $value)

              LogInfo(sprintf(" --%-9s%-9s%s", $key, " [param]", $value));

        }

    }



  class cURL

    {

      var $headers, $user_agent, $compression, $cookie_file;

      var $active, $cert_check, $fragProxy, $proxy, $response;

      var $mh, $ch, $mrc;

      static $ref = 0;



      function cURL($cookies = true, $cookie = 'Cookies.txt', $compression = 'gzip', $proxy = '')

        {

          $this->headers     = $this->headers();

          $this->user_agent  = 'Mozilla/5.0 (Windows NT 5.1; rv:17.0) Gecko/20100101 Firefox/17.0';

          $this->compression = $compression;

          $this->cookies     = $cookies;

          if ($this->cookies == true)

              $this->cookie($cookie);

          $this->cert_check = true;

          $this->fragProxy  = false;

          $this->proxy      = $proxy;

          self::$ref++;

        }



      function __destruct()

        {

          $this->stopDownloads();

          if ((self::$ref <= 1) and file_exists($this->cookie_file))

              unlink($this->cookie_file);

          self::$ref--;

        }



      function headers()

        {

          $headers[] = 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8';

          $headers[] = 'Connection: Keep-Alive';

          return $headers;

        }



      function cookie($cookie_file)

        {

          if (file_exists($cookie_file))

              $this->cookie_file = $cookie_file;

          else

            {

              $file = fopen($cookie_file, 'w') or $this->error('The cookie file could not be opened. Make sure this directory has the correct permissions.');

              $this->cookie_file = $cookie_file;

              fclose($file);

            }

        }



      function get($url)

        {

          $process = curl_init($url);

          curl_setopt($process, CURLOPT_HTTPHEADER, $this->headers);

          curl_setopt($process, CURLOPT_HEADER, 0);

          curl_setopt($process, CURLOPT_USERAGENT, $this->user_agent);

          if ($this->cookies == true)

            {

              curl_setopt($process, CURLOPT_COOKIEFILE, $this->cookie_file);

              curl_setopt($process, CURLOPT_COOKIEJAR, $this->cookie_file);

            }

          curl_setopt($process, CURLOPT_ENCODING, $this->compression);

          curl_setopt($process, CURLOPT_TIMEOUT, 60);

          if ($this->proxy)

              $this->setProxy($process, $this->proxy);

          curl_setopt($process, CURLOPT_RETURNTRANSFER, 1);

          curl_setopt($process, CURLOPT_FOLLOWLOCATION, 1);

          if (!$this->cert_check)

              curl_setopt($process, CURLOPT_SSL_VERIFYPEER, 0);

          $this->response = curl_exec($process);

          if ($this->response !== false)

              $status = curl_getinfo($process, CURLINFO_HTTP_CODE);

          curl_close($process);

          if (isset($status))

              return $status;

          else

              return false;

        }



      function post($url, $data)

        {

          $process   = curl_init($url);

          $headers   = $this->headers;

          $headers[] = 'Content-Type: application/x-www-form-urlencoded;charset=UTF-8';

          curl_setopt($process, CURLOPT_HTTPHEADER, $headers);

          curl_setopt($process, CURLOPT_HEADER, 1);

          curl_setopt($process, CURLOPT_USERAGENT, $this->user_agent);

          if ($this->cookies == true)

            {

              curl_setopt($process, CURLOPT_COOKIEFILE, $this->cookie_file);

              curl_setopt($process, CURLOPT_COOKIEJAR, $this->cookie_file);

            }

          curl_setopt($process, CURLOPT_ENCODING, $this->compression);

          curl_setopt($process, CURLOPT_TIMEOUT, 60);

          if ($this->proxy)

              $this->setProxy($process, $this->proxy);

          curl_setopt($process, CURLOPT_POSTFIELDS, $data);

          curl_setopt($process, CURLOPT_RETURNTRANSFER, 1);

          curl_setopt($process, CURLOPT_FOLLOWLOCATION, 1);

          curl_setopt($process, CURLOPT_POST, 1);

          if (!$this->cert_check)

              curl_setopt($process, CURLOPT_SSL_VERIFYPEER, 0);

          $return = curl_exec($process);

          curl_close($process);

          return $return;

        }



      function setProxy(&$process, $proxy)

        {

          $type = substr($proxy, 0, stripos($proxy, "://"));

          if ($type)

            {

              $type  = strtolower($type);

              $proxy = substr($proxy, stripos($proxy, "://") + 3);

            }

          switch ($type)

          {

              case "socks4":

                  $type = CURLPROXY_SOCKS4;

                  break;

              case "socks5":

                  $type = CURLPROXY_SOCKS5;

                  break;

              default:

                  $type = CURLPROXY_HTTP;

          }

          curl_setopt($process, CURLOPT_PROXY, $proxy);

          curl_setopt($process, CURLOPT_PROXYTYPE, $type);

        }



      function addDownload($url, $id)

        {

          if (!isset($this->mh))

              $this->mh = curl_multi_init();

          if (isset($this->ch[$id]))

              return;

          else

              $download =& $this->ch[$id];

          $download['id']  = $id;

          $download['url'] = $url;

          $download['ch']  = curl_init($url);

          curl_setopt($download['ch'], CURLOPT_HTTPHEADER, $this->headers);

          curl_setopt($download['ch'], CURLOPT_HEADER, 0);

          curl_setopt($download['ch'], CURLOPT_USERAGENT, $this->user_agent);

          if ($this->cookies == true)

            {

              curl_setopt($download['ch'], CURLOPT_COOKIEFILE, $this->cookie_file);

              curl_setopt($download['ch'], CURLOPT_COOKIEJAR, $this->cookie_file);

            }

          curl_setopt($download['ch'], CURLOPT_ENCODING, $this->compression);

          curl_setopt($download['ch'], CURLOPT_TIMEOUT, 300);

          if ($this->fragProxy and $this->proxy)

              $this->setProxy($download['ch'], $this->proxy);

          curl_setopt($download['ch'], CURLOPT_BINARYTRANSFER, 1);

          curl_setopt($download['ch'], CURLOPT_RETURNTRANSFER, 1);

          curl_setopt($download['ch'], CURLOPT_FOLLOWLOCATION, 1);

          if (!$this->cert_check)

              curl_setopt($download['ch'], CURLOPT_SSL_VERIFYPEER, 0);

          curl_multi_add_handle($this->mh, $download['ch']);

          do

            {

              $this->mrc = curl_multi_exec($this->mh, $this->active);

            } while ($this->mrc == CURLM_CALL_MULTI_PERFORM);

        }



      function checkDownloads()

        {

          if (isset($this->mh))

            {

              curl_multi_select($this->mh);

              $this->mrc = curl_multi_exec($this->mh, $this->active);

              if ($this->mrc != CURLM_OK)

                  return false;

              while ($info = curl_multi_info_read($this->mh))

                {

                  foreach ($this->ch as $download)

                      if ($download['ch'] == $info['handle'])

                          break;

                  $info         = curl_getinfo($download['ch']);

                  $array['id']  = $download['id'];

                  $array['url'] = $download['url'];

                  if ($info['http_code'] == 200)

                    {

                      if ($info['size_download'] >= $info['download_content_length'])

                        {

                          $array['status']   = $info['http_code'];

                          $array['response'] = curl_multi_getcontent($download['ch']);

                        }

                      else

                        {

                          $array['status']   = false;

                          $array['response'] = "";

                        }

                    }

                  else

                    {

                      $array['status']   = $info['http_code'];

                      $array['response'] = curl_multi_getcontent($download['ch']);

                    }

                  $downloads[] = $array;

                  curl_multi_remove_handle($this->mh, $download['ch']);

                  curl_close($download['ch']);

                  unset($this->ch[$download['id']]);

                }

              if (isset($downloads) and (count($downloads) > 0))

                  return $downloads;

            }

          return false;

        }



      function stopDownloads()

        {

          if (isset($this->mh))

            {

              if (isset($this->ch))

                {

                  foreach ($this->ch as $download)

                    {

                      curl_multi_remove_handle($this->mh, $download['ch']);

                      curl_close($download['ch']);

                    }

                  unset($this->ch);

                }

              curl_multi_close($this->mh);

              unset($this->mh);

            }

        }



      function error($error)

        {

          LogError("cURL Error : $error");

        }

    }



  class F4F

    {

      var $audio, $auth, $baseFilename, $baseTS, $bootstrapUrl, $baseUrl, $debug, $duration, $fileCount, $filesize;

      var $fixWindow, $format, $live, $media, $outDir, $outFile, $parallel, $play, $processed, $quality, $rename, $video;

      var $prevTagSize, $tagHeaderLen;

      var $segTable, $fragTable, $segNum, $fragNum, $frags, $fragCount, $fragsPerSeg, $lastFrag, $fragUrl, $discontinuity;

      var $prevAudioTS, $prevVideoTS, $pAudioTagLen, $pVideoTagLen, $pAudioTagPos, $pVideoTagPos;

      var $prevAVC_Header, $prevAAC_Header, $AVC_HeaderWritten, $AAC_HeaderWritten;



      function __construct()

        {

          $this->auth          = "";

          $this->baseFilename  = "";

          $this->bootstrapUrl  = "";

          $this->debug         = false;

          $this->duration      = 0;

          $this->fileCount     = 1;

          $this->fixWindow     = 1000;

          $this->format        = "";

          $this->live          = false;

          $this->outDir        = "";

          $this->outFile       = "";

          $this->parallel      = 8;

          $this->play          = false;

          $this->processed     = false;

          $this->quality       = "high";

          $this->rename        = false;

          $this->segTable      = array();

          $this->fragTable     = array();

          $this->segStart      = false;

          $this->fragStart     = false;

          $this->frags         = array();

          $this->fragCount     = 0;

          $this->fragsPerSeg   = 0;

          $this->lastFrag      = 0;

          $this->discontinuity = "";

          $this->InitDecoder();

        }



      function InitDecoder()

        {

          $this->audio             = false;

          $this->baseAudioTS       = INVALID_TIMESTAMP;

          $this->baseVideoTS       = INVALID_TIMESTAMP;

          $this->filesize          = 0;

          $this->video             = false;

          $this->prevTagSize       = 4;

          $this->tagHeaderLen      = 11;

          $this->prevAudioTS       = INVALID_TIMESTAMP;

          $this->prevVideoTS       = INVALID_TIMESTAMP;

          $this->pAudioTagLen      = 0;

          $this->pVideoTagLen      = 0;

          $this->pAudioTagPos      = 0;

          $this->pVideoTagPos      = 0;

          $this->prevAVC_Header    = false;

          $this->prevAAC_Header    = false;

          $this->AVC_HeaderWritten = false;

          $this->AAC_HeaderWritten = false;

        }



      function GetManifest($cc, $manifest)

        {

          $status = $cc->get($manifest);

          if ($status == 403)

              LogError("Access Denied! Unable to download the manifest.");

          else if ($status != 200)

              LogError("Unable to download the manifest");

          $xml = simplexml_load_string(trim($cc->response));

          if (!$xml)

              LogError("Failed to load xml");

          $namespace = $xml->getDocNamespaces();

          $namespace = $namespace[''];

          $xml->registerXPathNamespace("ns", $namespace);

          return $xml;

        }



      function ParseManifest($cc, $manifest)

        {

          LogInfo("Processing manifest info....");

          $xml     = $this->GetManifest($cc, $manifest);

          $baseUrl = $xml->xpath("/ns:manifest/ns:baseURL");

          if (isset($baseUrl[0]))

            {

              $baseUrl = GetString($baseUrl[0]);

              if (substr($baseUrl, -1) != "/")

                  $baseUrl .= "/";

            }

          else

              $baseUrl = "";

          $url = $xml->xpath("/ns:manifest/ns:media[@*]");

          if (isset($url[0]['href']))

            {

              foreach ($url as $manifest)

                {

                  $bitrate = (int) $manifest['bitrate'];

                  $entry =& $manifests[$bitrate];

                  $entry['bitrate'] = $bitrate;

                  $href             = GetString($manifest['href']);

                  if (substr($href, 0, 1) == "/")

                      $href = substr($href, 1);

                  $entry['url'] = NormalizePath($baseUrl . $href);

                  $entry['xml'] = $this->GetManifest($cc, $entry['url']);

                }

            }

          else

            {

              $manifests[0]['bitrate'] = 0;

              $manifests[0]['url']     = $manifest;

              $manifests[0]['xml']     = $xml;

            }



          foreach ($manifests as $manifest)

            {

              $xml = $manifest['xml'];



              // Extract baseUrl from manifest url

              $baseUrl = $xml->xpath("/ns:manifest/ns:baseURL");

              if (isset($baseUrl[0]))

                {

                  $baseUrl = GetString($baseUrl[0]);

                  if (substr($baseUrl, -1) == "/")

                      $baseUrl = substr($baseUrl, 0, -1);

                }

              else

                {

                  $baseUrl = $manifest['url'];

                  if (strpos($baseUrl, '?') !== false)

                      $baseUrl = substr($baseUrl, 0, strpos($baseUrl, '?'));

                  $baseUrl = substr($baseUrl, 0, strrpos($baseUrl, '/'));

                }

              if (!isHttpUrl($baseUrl))

                  LogError("Provided manifest is not a valid HDS manifest");



              $streams = $xml->xpath("/ns:manifest/ns:media");

              foreach ($streams as $stream)

                {

                  $array = array();

                  foreach ($stream->attributes() as $k => $v)

                      $array[strtolower($k)] = GetString($v);

                  $array['metadata'] = GetString($stream->{'metadata'});

                  $stream            = $array;



                  $bitrate  = isset($stream['bitrate']) ? (int) $stream['bitrate'] : $manifest['bitrate'];

                  $streamId = isset($stream[strtolower('streamId')]) ? $stream[strtolower('streamId')] : "";

                  $mediaEntry =& $this->media[$bitrate];



                  $mediaEntry['baseUrl'] = $baseUrl;

                  if (substr($stream['url'], 0, 1) == "/")

                      $mediaEntry['url'] = substr($stream['url'], 1);

                  else

                      $mediaEntry['url'] = $stream['url'];

                  if (isset($stream[strtolower('bootstrapInfoId')]))

                      $bootstrap = $xml->xpath("/ns:manifest/ns:bootstrapInfo[@id='" . $stream[strtolower('bootstrapInfoId')] . "']");

                  else

                      $bootstrap = $xml->xpath("/ns:manifest/ns:bootstrapInfo");

                  if (isset($bootstrap[0]['url']))

                    {

                      $bootstrapUrl = GetString($bootstrap[0]['url']);

                      if (!isHttpUrl($bootstrapUrl))

                          $bootstrapUrl = $mediaEntry['baseUrl'] . "/$bootstrapUrl";

                      $mediaEntry['bootstrapUrl'] = NormalizePath($bootstrapUrl);

                      if ($cc->get($mediaEntry['bootstrapUrl']) != 200)

                          LogError("Failed to get bootstrap info");

                      $mediaEntry['bootstrap'] = $cc->response;

                    }

                  else

                      $mediaEntry['bootstrap'] = base64_decode(GetString($bootstrap[0]));

                  if (isset($stream['metadata']))

                      $mediaEntry['metadata'] = base64_decode($stream['metadata']);

                  else

                      $mediaEntry['metadata'] = "";

                }

            }



          // Available qualities

          $bitrates = array();

          if (!count($this->media))

              LogError("No media entry found");

          krsort($this->media, SORT_NUMERIC);

          LogDebug("Manifest Entries:\n");

          LogDebug(sprintf(" %-8s%s", "Bitrate", "URL"));

          for ($i = 0; $i < count($this->media); $i++)

            {

              $key        = KeyName($this->media, $i);

              $bitrates[] = $key;

              LogDebug(sprintf(" %-8d%s", $key, $this->media[$key]['url']));

            }

          LogDebug("");

          LogInfo("Quality Selection:\n Available: " . implode(' ', $bitrates));



          // Quality selection

          if (is_numeric($this->quality) and isset($this->media[$this->quality]))

            {

              $key         = $this->quality;

              $this->media = $this->media[$key];

            }

          else

            {

              $this->quality = strtolower($this->quality);

              switch ($this->quality)

              {

                  case "low":

                      $this->quality = 2;

                      break;

                  case "medium":

                      $this->quality = 1;

                      break;

                  default:

                      $this->quality = 0;

              }

              while ($this->quality >= 0)

                {

                  $key = KeyName($this->media, $this->quality);

                  if ($key !== NULL)

                    {

                      $this->media = $this->media[$key];

                      break;

                    }

                  else

                      $this->quality -= 1;

                }

            }

          LogInfo(" Selected : " . $key);



          $this->baseUrl = $this->media['baseUrl'];

          if (isset($this->media['bootstrapUrl']))

              $this->bootstrapUrl = $this->media['bootstrapUrl'];

          $bootstrapInfo = $this->media['bootstrap'];

          ReadBoxHeader($bootstrapInfo, $pos, $boxType, $boxSize);

          if ($boxType == "abst")

              $this->ParseBootstrapBox($bootstrapInfo, $pos);

          else

              LogError("Failed to parse bootstrap info");

        }



      function UpdateBootstrapInfo($cc, $bootstrapUrl)

        {

          $fragNum = $this->fragCount;

          $retries = 0;

          while (($fragNum == $this->fragCount) and ($retries < 30))

            {

              $bootstrapPos = 0;

              LogDebug("Updating bootstrap info, Available fragments: " . $this->fragCount);

              if ($cc->get($bootstrapUrl) != 200)

                  LogError("Failed to refresh bootstrap info");

              $bootstrapInfo = $cc->response;

              ReadBoxHeader($bootstrapInfo, $bootstrapPos, $boxType, $boxSize);

              if ($boxType == "abst")

                  $this->ParseBootstrapBox($bootstrapInfo, $bootstrapPos);

              else

                  LogError("Failed to parse bootstrap info");

              LogDebug("Update complete, Available fragments: " . $this->fragCount);

              if ($fragNum == $this->fragCount)

                {

                  LogInfo("Updating bootstrap info, Retries: " . ++$retries, true);

                  usleep(4000000);

                }

            }

        }



      function ParseBootstrapBox($bootstrapInfo, $pos)

        {

          $version          = ReadByte($bootstrapInfo, $pos);

          $flags            = ReadInt24($bootstrapInfo, $pos + 1);

          $bootstrapVersion = ReadInt32($bootstrapInfo, $pos + 4);

          $byte             = ReadByte($bootstrapInfo, $pos + 8);

          $profile          = ($byte & 0xC0) >> 6;

          if (($byte & 0x20) >> 5)

              $this->live = true;

          $update              = ($byte & 0x10) >> 4;

          $timescale           = ReadInt32($bootstrapInfo, $pos + 9);

          $currentMediaTime    = ReadInt64($bootstrapInfo, 13);

          $smpteTimeCodeOffset = ReadInt64($bootstrapInfo, 21);

          $pos += 29;

          $movieIdentifier  = ReadString($bootstrapInfo, $pos);

          $serverEntryCount = ReadByte($bootstrapInfo, $pos++);

          for ($i = 0; $i < $serverEntryCount; $i++)

              $serverEntryTable[$i] = ReadString($bootstrapInfo, $pos);

          $qualityEntryCount = ReadByte($bootstrapInfo, $pos++);

          for ($i = 0; $i < $qualityEntryCount; $i++)

              $qualityEntryTable[$i] = ReadString($bootstrapInfo, $pos);

          $drmData          = ReadString($bootstrapInfo, $pos);

          $metadata         = ReadString($bootstrapInfo, $pos);

          $segRunTableCount = ReadByte($bootstrapInfo, $pos++);

          for ($i = 0; $i < $segRunTableCount; $i++)

            {

              ReadBoxHeader($bootstrapInfo, $pos, $boxType, $boxSize);

              if ($boxType == "asrt")

                  $this->ParseAsrtBox($bootstrapInfo, $pos);

              $pos += $boxSize;

            }

          $fragRunTableCount = ReadByte($bootstrapInfo, $pos++);

          for ($i = 0; $i < $fragRunTableCount; $i++)

            {

              ReadBoxHeader($bootstrapInfo, $pos, $boxType, $boxSize);

              if ($boxType == "afrt")

                  $this->ParseAfrtBox($bootstrapInfo, $pos);

              $pos += $boxSize;

            }

        }



      function ParseAsrtBox($asrt, $pos)

        {

          $version           = ReadByte($asrt, $pos);

          $flags             = ReadInt24($asrt, $pos + 1);

          $qualityEntryCount = ReadByte($asrt, $pos + 4);

          $pos += 5;

          for ($i = 0; $i < $qualityEntryCount; $i++)

              $qualitySegmentUrlModifiers[$i] = ReadString($asrt, $pos);

          $segCount = ReadInt32($asrt, $pos);

          $pos += 4;

          LogDebug(sprintf("%s:\n\n %-8s%-10s", "Segment Entries", "Number", "Fragments"));

          for ($i = 0; $i < $segCount; $i++)

            {

              $firstSegment = ReadInt32($asrt, $pos);

              $segEntry =& $this->segTable[$firstSegment];

              $segEntry['firstSegment']        = $firstSegment;

              $segEntry['fragmentsPerSegment'] = ReadInt32($asrt, $pos + 4);

              if ($segEntry['fragmentsPerSegment'] & 0x80000000)

                  $segEntry['fragmentsPerSegment'] = 0;

              $pos += 8;

            }

          unset($segEntry);

          foreach ($this->segTable as $segEntry)

              LogDebug(sprintf(" %-8s%-10s", $segEntry['firstSegment'], $segEntry['fragmentsPerSegment']));

          LogDebug("");

          $lastSegment = end($this->segTable);

          if ($this->segStart === false)

              $this->segStart = $lastSegment['firstSegment'];

          $this->fragCount = $lastSegment['fragmentsPerSegment'];



          // Use segment table in case of multiple segments

          if (count($this->segTable) > 1)

            {

              $secondLastSegment = prev($this->segTable);

              if ($this->fragStart === false)

                {

                  $this->fragsPerSeg = $secondLastSegment['fragmentsPerSegment'];

                  $this->fragStart   = $secondLastSegment['firstSegment'] * $this->fragsPerSeg + $this->fragCount - 2;

                  $this->fragCount   = $secondLastSegment['firstSegment'] * $this->fragsPerSeg + $this->fragCount;

                }

              else

                  $this->fragCount = $secondLastSegment['firstSegment'] * $this->fragsPerSeg + $this->fragCount;

            }

        }



      function ParseAfrtBox($afrt, $pos)

        {

          $version           = ReadByte($afrt, $pos);

          $flags             = ReadInt24($afrt, $pos + 1);

          $timescale         = ReadInt32($afrt, $pos + 4);

          $qualityEntryCount = ReadByte($afrt, $pos + 8);

          $pos += 9;

          for ($i = 0; $i < $qualityEntryCount; $i++)

              $qualitySegmentUrlModifiers[$i] = ReadString($afrt, $pos);

          $fragEntries = ReadInt32($afrt, $pos);

          $pos += 4;

          LogDebug(sprintf("%s:\n\n %-8s%-16s%-16s%-16s", "Fragment Entries", "Number", "Timestamp", "Duration", "Discontinuity"));

          for ($i = 0; $i < $fragEntries; $i++)

            {

              $firstFragment = ReadInt32($afrt, $pos);

              $fragEntry =& $this->fragTable[$firstFragment];

              $fragEntry['firstFragment']          = $firstFragment;

              $fragEntry['firstFragmentTimestamp'] = ReadInt64($afrt, $pos + 4);

              $fragEntry['fragmentDuration']       = ReadInt32($afrt, $pos + 12);

              $fragEntry['discontinuityIndicator'] = "";

              $pos += 16;

              if ($fragEntry['fragmentDuration'] == 0)

                  $fragEntry['discontinuityIndicator'] = ReadByte($afrt, $pos++);

            }

          unset($fragEntry);

          foreach ($this->fragTable as $fragEntry)

              LogDebug(sprintf(" %-8s%-16s%-16s%-16s", $fragEntry['firstFragment'], $fragEntry['firstFragmentTimestamp'], $fragEntry['fragmentDuration'], $fragEntry['discontinuityIndicator']));

          LogDebug("");



          // Use fragment table in case of single segment

          if (count($this->segTable) == 1)

            {

              $firstFragment = reset($this->fragTable);

              $lastFragment  = end($this->fragTable);

              if ($this->fragStart === false)

                {

                  if ($this->live)

                      $this->fragStart = $lastFragment['firstFragment'] - 2;

                  else

                      $this->fragStart = $firstFragment['firstFragment'] - 1;

                  if ($this->fragStart < 0)

                      $this->fragStart = 0;

                }

              if ($this->fragCount > 0)

                  $this->fragCount += $firstFragment['firstFragment'] - 1;

              if ($this->fragCount < $lastFragment['firstFragment'])

                  $this->fragCount = $lastFragment['firstFragment'];

            }

        }



      function DownloadFragments($cc, $manifest, $opt = array())

        {

          $start = 0;

          extract($opt, EXTR_IF_EXISTS);



          $this->ParseManifest($cc, $manifest);

          $segNum  = $this->segStart;

          $fragNum = $this->fragStart;

          if ($start)

            {

              if ($segNum > 1)

                  if ($start % $this->fragsPerSeg)

                      $segNum = (int) ($start / $this->fragsPerSeg + 1);

                  else

                      $segNum = (int) ($start / $this->fragsPerSeg);

              $fragNum         = $start - 1;

              $this->segStart  = $segNum;

              $this->fragStart = $fragNum;

            }

          $this->lastFrag  = $fragNum;

          $opt['cc']       = $cc;

          $opt['duration'] = 0;



          // Extract baseFilename

          $this->baseFilename = $this->media['url'];

          if (substr($this->baseFilename, -1) == '/')

              $this->baseFilename = substr($this->baseFilename, 0, -1);

          $this->baseFilename = RemoveExtension($this->baseFilename);

          if (strrpos($this->baseFilename, '/'))

              $this->baseFilename = substr($this->baseFilename, strrpos($this->baseFilename, '/') + 1);

          if (strpos($manifest, "?"))

              $this->baseFilename = md5(substr($manifest, 0, strpos($manifest, "?"))) . "_" . $this->baseFilename;

          else

              $this->baseFilename = md5($manifest) . "_" . $this->baseFilename;

          $this->baseFilename .= "Seg" . $segNum . "-Frag";



          if ($fragNum >= $this->fragCount)

              LogError("No fragment available for downloading");



          if (isHttpUrl($this->media['url']))

              $this->fragUrl = $this->media['url'];

          else

              $this->fragUrl = $this->baseUrl . "/" . $this->media['url'];

          $this->fragUrl = NormalizePath($this->fragUrl);

          LogDebug("Base Fragment Url:\n" . $this->fragUrl . "\n");

          LogDebug("Downloading Fragments:\n");



          while (($fragNum < $this->fragCount) or $cc->active)

            {

              while ((count($cc->ch) < $this->parallel) and ($fragNum < $this->fragCount))

                {

                  $frag       = array();

                  $fragNum    = $fragNum + 1;

                  $frag['id'] = $fragNum;

                  LogInfo("Downloading $fragNum/$this->fragCount fragments", true);

                  if (in_array_field($fragNum, "firstFragment", $this->fragTable, true))

                      $this->discontinuity = value_in_array_field($fragNum, "firstFragment", "discontinuityIndicator", $this->fragTable, true);

                  else

                    {

                      $closest = 1;

                      foreach ($this->fragTable as $item)

                        {

                          if ($item['firstFragment'] < $fragNum)

                              $closest = $item['firstFragment'];

                          else

                              break;

                        }

                      $this->discontinuity = value_in_array_field($closest, "firstFragment", "discontinuityIndicator", $this->fragTable, true);

                    }

                  if (($this->discontinuity == 1) or ($this->discontinuity == 3))

                    {

                      LogDebug("Skipping fragment $fragNum due to discontinuity");

                      $frag['response'] = false;

                      $this->rename     = true;

                    }

                  else if (file_exists($this->baseFilename . $fragNum))

                    {

                      LogDebug("Fragment $fragNum is already downloaded");

                      $frag['response'] = file_get_contents($this->baseFilename . $fragNum);

                    }

                  if (isset($frag['response']))

                    {

                      if ($this->WriteFragment($frag, $opt) === 2)

                          break 2;

                      else

                          continue;

                    }



                  /* Increase or decrease segment number if current fragment is not available */

                  /* in selected segment range                                                */

                  if (count($this->segTable) > 1)

                    {

                      if ($fragNum > ($segNum * $this->fragsPerSeg))

                          $segNum++;

                      else if ($fragNum <= (($segNum - 1) * $this->fragsPerSeg))

                          $segNum--;

                    }



                  LogDebug("Adding fragment $fragNum to download queue");

                  $cc->addDownload($this->fragUrl . "Seg" . $segNum . "-Frag" . $fragNum . $this->auth, $fragNum);

                }



              $downloads = $cc->checkDownloads();

              if ($downloads !== false)

                {

                  for ($i = 0; $i < count($downloads); $i++)

                    {

                      $frag       = array();

                      $download   = $downloads[$i];

                      $frag['id'] = $download['id'];

                      if ($download['status'] == 200)

                        {

                          if ($this->VerifyFragment($download['response']))

                            {

                              LogDebug("Fragment " . $this->baseFilename . $download['id'] . " successfully downloaded");

                              if (!($this->live or $this->play))

                                  file_put_contents($this->baseFilename . $download['id'], $download['response']);

                              $frag['response'] = $download['response'];

                            }

                          else

                            {

                              LogDebug("Fragment " . $download['id'] . " failed to verify");

                              LogDebug("Adding fragment " . $download['id'] . " to download queue");

                              $cc->addDownload($download['url'], $download['id']);

                            }

                        }

                      else if ($download['status'] === false)

                        {

                          LogDebug("Fragment " . $download['id'] . " failed to download");

                          LogDebug("Adding fragment " . $download['id'] . " to download queue");

                          $cc->addDownload($download['url'], $download['id']);

                        }

                      else if ($download['status'] == 403)

                          LogError("Access Denied! Unable to download fragments.");

                      else

                        {

                          LogDebug("Fragment " . $download['id'] . " doesn't exist, Status: " . $download['status']);

                          $frag['response'] = false;

                          $this->rename     = true;



                          /* Resync with latest available fragment when we are left behind due to */

                          /* slow connection and short live window on streaming server. make sure */

                          /* to reset the last written fragment.                                  */

                          if ($this->live and ($i + 1 == count($downloads)) and !$cc->active)

                            {

                              LogDebug("Trying to resync with latest available fragment");

                              if ($this->WriteFragment($frag, $opt) === 2)

                                  break 2;

                              unset($frag['response']);

                              $this->UpdateBootstrapInfo($cc, $this->bootstrapUrl);

                              $fragNum        = $this->fragCount - 1;

                              $this->lastFrag = $fragNum;

                            }

                        }

                      if (isset($frag['response']))

                          if ($this->WriteFragment($frag, $opt) === 2)

                              break 2;

                    }

                  unset($downloads, $download);

                }

              if ($this->live and ($fragNum >= $this->fragCount) and !$cc->active)

                  $this->UpdateBootstrapInfo($cc, $this->bootstrapUrl);

            }



          LogInfo("");

          LogDebug("\nAll fragments downloaded successfully\n");

          $cc->stopDownloads();

          $this->processed = true;

        }



      function VerifyFragment(&$frag)

        {

          $fragPos = 0;

          $fragLen = strlen($frag);



          /* Some moronic servers add wrong boxSize in header causing fragment verification *

           * to fail so we have to fix the boxSize before processing the fragment.          */

          while ($fragPos < $fragLen)

            {

              ReadBoxHeader($frag, $fragPos, $boxType, $boxSize);

              if ($boxType == "mdat")

                {

                  $len = strlen(substr($frag, $fragPos, $boxSize));

                  if ($boxSize and ($len == $boxSize))

                      return true;

                  else

                    {

                      $boxSize = $fragLen - $fragPos;

                      WriteBoxSize($frag, $boxType, $boxSize);

                      return true;

                    }

                }

              $fragPos += $boxSize;

            }

          return false;

        }



      function RenameFragments($baseFilename, $fragNum, $fileExt)

        {

          $files   = array();

          $retries = 0;



          while (true)

            {

              if ($retries >= 50)

                  break;

              $file = $baseFilename . ++$fragNum;

              if (file_exists($file))

                {

                  $files[] = $file;

                  $retries = 0;

                }

              else if (file_exists($file . $fileExt))

                {

                  $files[] = $file;

                  $retries = 0;

                }

              else

                  $retries++;

            }



          $fragCount = count($files);

          natsort($files);

          for ($i = 0; $i < $fragCount; $i++)

              rename($files[$i], $baseFilename . ($i + 1));

        }



      function WriteMetadata($flv = false)

        {

          if (isset($this->media) and $this->media['metadata'])

            {

              $metadataSize = strlen($this->media['metadata']);

              WriteByte($metadata, 0, SCRIPT_DATA);

              WriteInt24($metadata, 1, $metadataSize);

              WriteInt24($metadata, 4, 0);

              WriteInt32($metadata, 7, 0);

              $metadata = implode("", $metadata) . $this->media['metadata'];

              WriteByte($metadata, $this->tagHeaderLen + $metadataSize - 1, 0x09);

              WriteInt32($metadata, $this->tagHeaderLen + $metadataSize, $this->tagHeaderLen + $metadataSize);

              if (is_resource($flv))

                {

                  fwrite($flv, $metadata, $this->tagHeaderLen + $metadataSize + $this->prevTagSize);

                  return true;

                }

              else

                  return $metadata;

            }

          return false;

        }



      function WriteFlvTimestamp(&$frag, $fragPos, $packetTS)

        {

          WriteInt24($frag, $fragPos + 4, ($packetTS & 0x00FFFFFF));

          WriteByte($frag, $fragPos + 7, ($packetTS & 0xFF000000) >> 24);

        }



      function DecodeFragment($frag, $fragNum, $opt = array())

        {

          $debug = $this->debug;

          $flv   = false;

          extract($opt, EXTR_IF_EXISTS);



          $flvData  = "";

          $fragPos  = 0;

          $packetTS = 0;

          $fragLen  = strlen($frag);



          if (!$this->VerifyFragment($frag))

            {

              LogInfo("Skipping fragment number $fragNum");

              return false;

            }



          while ($fragPos < $fragLen)

            {

              ReadBoxHeader($frag, $fragPos, $boxType, $boxSize);

              if ($boxType == "mdat")

                {

                  $fragLen = $fragPos + $boxSize;

                  break;

                }

              $fragPos += $boxSize;

            }



          LogDebug(sprintf("\nFragment %d:\n" . $this->format . "%-16s", $fragNum, "Type", "CurrentTS", "PreviousTS", "Size", "Position"), $debug);

          while ($fragPos < $fragLen)

            {

              $packetType = ReadByte($frag, $fragPos);

              $packetSize = ReadInt24($frag, $fragPos + 1);

              $packetTS   = ReadInt24($frag, $fragPos + 4);

              $packetTS   = $packetTS | (ReadByte($frag, $fragPos + 7) << 24);

              if ($packetTS & 0x80000000)

                  $packetTS &= 0x7FFFFFFF;

              $totalTagLen = $this->tagHeaderLen + $packetSize + $this->prevTagSize;



              // Try to fix the odd timestamps and make them zero based

              switch ($packetType)

              {

                  case AUDIO:

                      if ($this->baseAudioTS == INVALID_TIMESTAMP)

                          $this->baseAudioTS = $packetTS;

                      if ($this->baseAudioTS > 1000)

                        {

                          if ($packetTS >= $this->baseAudioTS)

                              $packetTS -= $this->baseAudioTS;

                          else

                              $packetTS = $this->prevAudioTS + FRAMEGAP_DURATION * 5;

                        }

                      if ($this->prevAudioTS != INVALID_TIMESTAMP)

                        {

                          $timeShift = $packetTS - $this->prevAudioTS;

                          if ($timeShift > $this->fixWindow)

                            {

                              $this->baseAudioTS += $timeShift - FRAMEGAP_DURATION * 5;

                              $packetTS = $this->prevAudioTS + FRAMEGAP_DURATION * 5;

                            }

                        }

                      $this->WriteFlvTimestamp($frag, $fragPos, $packetTS);

                      break;

                  case VIDEO:

                      if ($this->baseVideoTS == INVALID_TIMESTAMP)

                          $this->baseVideoTS = $packetTS;

                      if ($this->baseVideoTS > 1000)

                        {

                          if ($packetTS >= $this->baseVideoTS)

                              $packetTS -= $this->baseVideoTS;

                          else

                              $packetTS = $this->prevVideoTS + FRAMEGAP_DURATION * 5;

                        }

                      if ($this->prevVideoTS != INVALID_TIMESTAMP)

                        {

                          $timeShift = $packetTS - $this->prevVideoTS;

                          if ($timeShift > $this->fixWindow)

                            {

                              $this->baseVideoTS += $timeShift - FRAMEGAP_DURATION * 5;

                              $packetTS = $this->prevVideoTS + FRAMEGAP_DURATION * 5;

                            }

                        }

                      $this->WriteFlvTimestamp($frag, $fragPos, $packetTS);

                      break;

              }



              switch ($packetType)

              {

                  case AUDIO:

                      if ($packetTS > $this->prevAudioTS - $this->fixWindow)

                        {

                          $FrameInfo = ReadByte($frag, $fragPos + $this->tagHeaderLen);

                          $CodecID   = ($FrameInfo & 0xF0) >> 4;

                          if ($CodecID == CODEC_ID_AAC)

                            {

                              $AAC_PacketType = ReadByte($frag, $fragPos + $this->tagHeaderLen + 1);

                              if ($AAC_PacketType == AAC_SEQUENCE_HEADER)

                                {

                                  if ($this->AAC_HeaderWritten)

                                    {

                                      LogDebug(sprintf("%s\n" . $this->format, "Skipping AAC sequence header", "AUDIO", $packetTS, $this->prevAudioTS, $packetSize), $debug);

                                      break;

                                    }

                                  else

                                    {

                                      LogDebug("Writing AAC sequence header", $debug);

                                      $this->AAC_HeaderWritten = true;

                                    }

                                }

                              else if (!$this->AAC_HeaderWritten)

                                {

                                  LogDebug(sprintf("%s\n" . $this->format, "Discarding audio packet received before AAC sequence header", "AUDIO", $packetTS, $this->prevAudioTS, $packetSize), $debug);

                                  break;

                                }

                            }

                          if ($packetSize > 0)

                            {

                              // Check for packets with non-monotonic audio timestamps and fix them

                              if (!(($CodecID == CODEC_ID_AAC) and (($AAC_PacketType == AAC_SEQUENCE_HEADER) or $this->prevAAC_Header)))

                                  if (($this->prevAudioTS != INVALID_TIMESTAMP) and ($packetTS <= $this->prevAudioTS))

                                    {

                                      LogDebug(sprintf("%s\n" . $this->format, "Fixing audio timestamp", "AUDIO", $packetTS, $this->prevAudioTS, $packetSize), $debug);

                                      $packetTS += FRAMEGAP_DURATION + ($this->prevAudioTS - $packetTS);

                                      $this->WriteFlvTimestamp($frag, $fragPos, $packetTS);

                                    }

                              if (is_resource($flv))

                                {

                                  $this->pAudioTagPos = ftell($flv);

                                  $status             = fwrite($flv, substr($frag, $fragPos, $totalTagLen), $totalTagLen);

                                  if…