stream_big_files.php

<?php

    /**
     * Stream or Download big files using php (support multipart and remote url)
     * @param $file is the path or remote url
     * @param $size is the filesize of the file
     */
    function streamDownload($file,$size,$mime='video/mp4') {
       header('Content-type: ' . $mime);
       header('Content-Disposition: attachment; filename="' . basename($file) . '"'); 
       $fp = @fopen($file, 'rb');
    
       $length = $size;           // Content length
       $start  = 0;               // Start byte
       $end    = $size - 1;       // End byte
       // Now that we've gotten so far without errors we send the accept range header
       /* At the moment we only support single ranges.
        * Multiple ranges requires some more work to ensure it works correctly
        * and comply with the spesifications: http://www.w3.org/Protocols/rfc2616/rfc2616-sec19.html#sec19.2
        *
        * Multirange support annouces itself with:
        * header('Accept-Ranges: bytes');
        *
        * Multirange content must be sent with multipart/byteranges mediatype,
        * (mediatype = mimetype)
        * as well as a boundry header to indicate the various chunks of data.
        */
       //header("Accept-Ranges: 0-$length");
        header('Accept-Ranges: bytes');
       // multipart/byteranges
       // http://www.w3.org/Protocols/rfc2616/rfc2616-sec19.html#sec19.2
       if (isset($_SERVER['HTTP_RANGE'])) {
       
           $c_start = $start;
           $c_end   = $end;
           // Extract the range string
           list(, $range) = explode('=', $_SERVER['HTTP_RANGE'], 2);
           // Make sure the client hasn't sent us a multibyte range
           if (strpos($range, ',') !== false) {
           
               // (?) Shoud this be issued here, or should the first
               // range be used? Or should the header be ignored and
               // we output the whole content?
               header('HTTP/1.1 416 Requested Range Not Satisfiable');
               header("Content-Range: bytes $start-$end/$size");
               // (?) Echo some info to the client?
               exit;
           }
           // If the range starts with an '-' we start from the beginning
           // If not, we forward the file pointer
           // And make sure to get the end byte if spesified
           if ($range0 == '-') {
           
               // The n-number of the last bytes is requested
               $c_start = $size - substr($range, 1);
           }
           else {
           
               $range  = explode('-', $range);
               $c_start = $range[0];
               $c_end   = (isset($range[1]) && is_numeric($range[1])) ? $range[1] : $size;
           }
           /* Check the range and make sure it's treated according to the specs.
            * http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html
            */
           // End bytes can not be larger than $end.
           $c_end = ($c_end > $end) ? $end : $c_end;
           // Validate the requested range and return an error if it's not correct.
           if ($c_start > $c_end || $c_start > $size - 1 || $c_end >= $size) {
           
               header('HTTP/1.1 416 Requested Range Not Satisfiable');
               header("Content-Range: bytes $start-$end/$size");
               // (?) Echo some info to the client?
               exit;
           }
           $start  = $c_start;
           $end    = $c_end;
           $length = $end - $start + 1; // Calculate new content length
           fseek($fp, $start);
           header('HTTP/1.1 206 Partial Content');
       }
       // Notify the client the byte range we'll be outputting
       header("Content-Range: bytes $start-$end/$size");
       header("Content-Length: $length");
    
       // Start buffered download
       $buffer = 1024 * 8;
       while(!feof($fp) && ($p = ftell($fp)) <= $end) {
       
           if ($p + $buffer > $end) {
           
               // In case we're only outputtin a chunk, make sure we don't
               // read past the length
               $buffer = $end - $p + 1;
           }
           set_time_limit(0); // Reset time limit for big files
           echo fread($fp, $buffer);
           flush(); // Free up memory. Otherwise large files will trigger PHP's memory limit.
       }
    
       fclose($fp);
                     
   }
         
   function curl_get_file_size( $url ) {
      // Assume failure.
      $result = -1;

      $curl = curl_init( $url );

      // Issue a HEAD request and follow any redirects.
      curl_setopt( $curl, CURLOPT_NOBODY, true );
      curl_setopt( $curl, CURLOPT_HEADER, true );
      curl_setopt( $curl, CURLOPT_RETURNTRANSFER, true );
      curl_setopt( $curl, CURLOPT_FOLLOWLOCATION, true );

      $data = curl_exec( $curl );
      curl_close( $curl );

      if( $data ) {
        $content_length = "unknown";
        $status = "unknown";
  
        if( preg_match( "/^HTTP\/1\.[01] (\d\d\d)/", $data, $matches ) ) {
          $status = (int)$matches[1];
        }

        if( preg_match( "/Content-Length: (\d+)/", $data, $matches ) ) {
          $content_length = (int)$matches[1];
        }

        // http://en.wikipedia.org/wiki/List_of_HTTP_status_codes
        if( $status == 200 || ($status > 300 && $status <= 308) ) {
          $result = $content_length;
        }
      }

      return $result;
    }
         
   //Example how to use:
   $filelink = 'http://commondatastorage.googleapis.com/gtv-videos-bucket/sample/BigBuckBunny.mp4';
   $filesize = curl_get_file_size($filelink);
   
   streamDownload($filelink,$filesize);
         
?>