home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 4 / hacker04 / 04_HACK04.ISO / src / PHP / mp3info.php3.txt < prev    next >
Encoding:
Text File  |  2002-05-06  |  16.6 KB  |  624 lines
  1. Mp3 Info Function 
  2.  
  3. This function returns MP3 file info as an array. It is extremely new code so it may not be 100% stable. 
  4.  
  5.  
  6.  
  7. <?php 
  8.  
  9. // 
  10. // This code made possible by Jim Beam black label bourbon. 
  11. // and the info found on http://www.dv.co.yu/mpgscript/mpeghdr.htm . 
  12. // 
  13. // Coded by Chester@hackster.com 
  14. // 
  15. // Returns a single demensional array.  
  16. // 
  17. // filename,filesize,length in seconds,bitrate,sample rate,channel mode,mpeg version,layer,crc,copyright,original 
  18. // 
  19. // Enjoy... Oh BTW this code REALLY sucks 
  20. // 
  21.  
  22. function padd (&$inf) 
  23.  
  24. // Dodgy ass function to pad binary strings so they represent the correct 8 bits. 
  25.      
  26.     { 
  27.         while (strlen($inf)<8) 
  28.             { 
  29.                 $inf =  "0".$inf; 
  30.             } 
  31.     } 
  32.  
  33. function js_alert($msg)  
  34.  
  35. // Function to spit out little window when an error occur's 
  36.  
  37. { 
  38. echo ( 
  39. "\n<script language='javascript'>\n" . 
  40. "    <!-- \n" . 
  41. "    alert (\"$msg\");\n" . 
  42. "    // --> \n" . 
  43. "</script>\n" 
  44. ); 
  45. } 
  46.      
  47. function mp3info($filename) 
  48.  
  49. { 
  50.  
  51. // Ensure file exists! 
  52.      
  53. if (!$file = fopen($filename, "rb")) 
  54.     { 
  55.         js_alert( 'Yo I cant find\\n$filename'); 
  56.         exit; 
  57.     } 
  58.  
  59. // Checking to make sure I can find Frame Sync 
  60.  
  61. while (!feof($file)) 
  62.     { 
  63.         $tmp=fgetc($file); 
  64.         if (ord($tmp)==255) 
  65.             { 
  66.                 $tmp=fgetc($file); 
  67.                 if (substr((decbin(ord($tmp))),0,3)== "111") 
  68.                     { 
  69.                         break; 
  70.                     } 
  71.             } 
  72.     } 
  73.  
  74. // If end of file is reached before Frame Sync is found then bail... 
  75.  
  76. if (feof($file)) 
  77.     { 
  78.         js_alert( 'Ummmm are you sure this is a MP3 ??'); 
  79.         fclose($file); 
  80.         return(1); 
  81.     } 
  82.  
  83. // We have declared all engines go. 
  84.  
  85. // Assign filesize 
  86.  
  87. $filesize=filesize($filename); 
  88.  
  89. // Assign all important information to $bitstream variable. 
  90.  
  91. $inf=decbin(ord($tmp)); 
  92. padd($inf); 
  93. $bitstream = $inf; 
  94. $tmp=fgetc($file); 
  95. $inf=decbin(ord($tmp)); 
  96. padd($inf); 
  97. $bitstream = $bitstream.$inf; 
  98. $tmp=fgetc($file); 
  99. $inf=decbin(ord($tmp)); 
  100. padd($inf); 
  101. $bitstream = $bitstream.$inf; 
  102.  
  103. // $bitstream now totals the 3 important bytes of the header of this frame. 
  104.  
  105. // Determine Version of Mpeg. 
  106.  
  107. switch (substr($bitstream,3,2)) 
  108.     { 
  109.         case  "00": 
  110.             $version= "2.5"; 
  111.             break; 
  112.         case  "01": 
  113.             $version= "0"; 
  114.             break; 
  115.         case  "10": 
  116.             $version= "2"; 
  117.             break; 
  118.         case  "11": 
  119.             $version= "1"; 
  120.             break; 
  121.     } 
  122.  
  123. // Determine Layer. 
  124.  
  125. switch (substr($bitstream,5,2)) 
  126.     { 
  127.         case  "00": 
  128.             $layer= "0"; 
  129.             break; 
  130.         case  "01": 
  131.             $layer= "3"; 
  132.             break; 
  133.         case  "10": 
  134.             $layer= "2"; 
  135.             break; 
  136.         case  "11": 
  137.             $layer= "1"; 
  138.             break; 
  139.     } 
  140.  
  141. // Determine CRC checking enabled / disabled 1==disabled 
  142.  
  143. $crc = substr($bitstream,7,1); 
  144.  
  145. // Determine Bitrate 
  146.  
  147. // Setting an index variable ... trust me in this state tis the only way I can think of doing it... 
  148.  
  149. if (($version== "1")&($layer== "1")) 
  150.     { 
  151.         $index= "1"; 
  152.     } 
  153. elseif (($version== "1")&($layer== "2")) 
  154.     { 
  155.         $index= "2"; 
  156.     } 
  157. elseif ($version== "1") 
  158.     { 
  159.         $index= "3"; 
  160.     } 
  161. elseif ($layer== "1") 
  162.     { 
  163.         $index= "4"; 
  164.     } 
  165. else     
  166.     { 
  167.         $index= "5"; 
  168.     } 
  169.  
  170. switch (substr($bitstream,8,4)) 
  171.     { 
  172.         case  "0000": 
  173.             $bitrate= "free"; 
  174.             break; 
  175.         case  "0001": 
  176.             if (($layer>1)and($version>1)) 
  177.                 { 
  178.                     $bitrate= "8000"; 
  179.                 } 
  180.             else 
  181.                 { 
  182.                     $bitrate= "32000"; 
  183.                 } 
  184.             break; 
  185.         case  "0010": 
  186.             switch ($index) 
  187.                 { 
  188.                     case  "1": 
  189.                         $bitrate= "64000"; 
  190.                         break; 
  191.                     case  "2": 
  192.                         $bitrate= "48000"; 
  193.                         break; 
  194.                     case  "3": 
  195.                         $bitrate= "40000"; 
  196.                         break; 
  197.                     case  "4": 
  198.                         $bitrate= "48000"; 
  199.                         break; 
  200.                     case  "5": 
  201.                         $bitrate= "16000"; 
  202.                         break; 
  203.                 } 
  204.             break; 
  205.         case  "0011": 
  206.             switch ($index) 
  207.                 { 
  208.                     case  "1": 
  209.                         $bitrate= "96000"; 
  210.                         break; 
  211.                     case  "2": 
  212.                         $bitrate= "56000"; 
  213.                         break; 
  214.                     case  "3": 
  215.                         $bitrate= "48000"; 
  216.                         break; 
  217.                     case  "4": 
  218.                         $bitrate= "56000"; 
  219.                         break; 
  220.                     case  "5": 
  221.                         $bitrate= "24000"; 
  222.                         break; 
  223.                 } 
  224.             break; 
  225.         case  "0100": 
  226.             switch ($index) 
  227.                 { 
  228.                     case  "1": 
  229.                         $bitrate= "128000"; 
  230.                         break; 
  231.                     case  "2": 
  232.                         $bitrate= "64000"; 
  233.                         break; 
  234.                     case  "3": 
  235.                         $bitrate= "56000"; 
  236.                         break; 
  237.                     case  "4": 
  238.                         $bitrate= "64000"; 
  239.                         break; 
  240.                     case  "5": 
  241.                         $bitrate= "32000"; 
  242.                         break; 
  243.                 } 
  244.             break; 
  245.         case  "0101": 
  246.             switch ($index) 
  247.                 { 
  248.                     case  "1": 
  249.                         $bitrate= "160000"; 
  250.                         break; 
  251.                     case  "2": 
  252.                         $bitrate= "80000"; 
  253.                         break; 
  254.                     case  "3": 
  255.                         $bitrate= "64000"; 
  256.                         break; 
  257.                     case  "4": 
  258.                         $bitrate= "80000"; 
  259.                         break; 
  260.                     case  "5": 
  261.                         $bitrate= "40000"; 
  262.                         break; 
  263.                 } 
  264.             break; 
  265.         case  "0110": 
  266.             switch ($index) 
  267.                 { 
  268.                     case  "1": 
  269.                         $bitrate= "192000"; 
  270.                         break; 
  271.                     case  "2": 
  272.                         $bitrate= "96000"; 
  273.                         break; 
  274.                     case  "3": 
  275.                         $bitrate= "80000"; 
  276.                         break; 
  277.                     case  "4": 
  278.                         $bitrate= "96000"; 
  279.                         break; 
  280.                     case  "5": 
  281.                         $bitrate= "48000"; 
  282.                         break; 
  283.                 } 
  284.             break; 
  285.         case  "0111": 
  286.             switch ($index) 
  287.                 { 
  288.                     case  "1": 
  289.                         $bitrate= "224000"; 
  290.                         break; 
  291.                     case  "2": 
  292.                         $bitrate= "112000"; 
  293.                         break; 
  294.                     case  "3": 
  295.                         $bitrate= "96000"; 
  296.                         break; 
  297.                     case  "4": 
  298.                         $bitrate= "112000"; 
  299.                         break; 
  300.                     case  "5": 
  301.                         $bitrate= "56000"; 
  302.                         break; 
  303.                 } 
  304.             break; 
  305.         case  "1000": 
  306.             switch ($index) 
  307.                 { 
  308.                     case  "1": 
  309.                         $bitrate= "256000"; 
  310.                         break; 
  311.                     case  "2": 
  312.                         $bitrate= "128000"; 
  313.                         break; 
  314.                     case  "3": 
  315.                         $bitrate= "112000"; 
  316.                         break; 
  317.                     case  "4": 
  318.                         $bitrate= "128000"; 
  319.                         break; 
  320.                     case  "5": 
  321.                         $bitrate= "64000"; 
  322.                         break; 
  323.                 } 
  324.             break; 
  325.         case  "1001": 
  326.             switch ($index) 
  327.                 { 
  328.                     case  "1": 
  329.                         $bitrate= "288000"; 
  330.                         break; 
  331.                     case  "2": 
  332.                         $bitrate= "160000"; 
  333.                         break; 
  334.                     case  "3": 
  335.                         $bitrate= "128000"; 
  336.                         break; 
  337.                     case  "4": 
  338.                         $bitrate= "144000"; 
  339.                         break; 
  340.                     case  "5": 
  341.                         $bitrate= "80000"; 
  342.                         break; 
  343.                 } 
  344.             break; 
  345.         case  "1010": 
  346.             switch ($index) 
  347.                 { 
  348.                     case  "1": 
  349.                         $bitrate= "320000"; 
  350.                         break; 
  351.                     case  "2": 
  352.                         $bitrate= "192000"; 
  353.                         break; 
  354.                     case  "3": 
  355.                         $bitrate= "160000"; 
  356.                         break; 
  357.                     case  "4": 
  358.                         $bitrate= "160000"; 
  359.                         break; 
  360.                     case  "5": 
  361.                         $bitrate= "96000"; 
  362.                         break; 
  363.                 } 
  364.             break; 
  365.         case  "1011": 
  366.             switch ($index) 
  367.                 { 
  368.                     case  "1": 
  369.                         $bitrate= "352000"; 
  370.                         break; 
  371.                     case  "2": 
  372.                         $bitrate= "224000"; 
  373.                         break; 
  374.                     case  "3": 
  375.                         $bitrate= "192000"; 
  376.                         break; 
  377.                     case  "4": 
  378.                         $bitrate= "176000"; 
  379.                         break; 
  380.                     case  "5": 
  381.                         $bitrate= "112000"; 
  382.                         break; 
  383.                 } 
  384.             break; 
  385.         case  "1100": 
  386.             switch ($index) 
  387.                 { 
  388.                     case  "1": 
  389.                         $bitrate= "384000"; 
  390.                         break; 
  391.                     case  "2": 
  392.                         $bitrate= "256000"; 
  393.                         break; 
  394.                     case  "3": 
  395.                         $bitrate= "224000"; 
  396.                         break; 
  397.                     case  "4": 
  398.                         $bitrate= "192000"; 
  399.                         break; 
  400.                     case  "5": 
  401.                         $bitrate= "128000"; 
  402.                         break; 
  403.                 } 
  404.             break; 
  405.         case  "1101": 
  406.             switch ($index) 
  407.                 { 
  408.                     case  "1": 
  409.                         $bitrate= "416000"; 
  410.                         break; 
  411.                     case  "2": 
  412.                         $bitrate= "320000"; 
  413.                         break; 
  414.                     case  "3": 
  415.                         $bitrate= "256000"; 
  416.                         break; 
  417.                     case  "4": 
  418.                         $bitrate= "224000"; 
  419.                         break; 
  420.                     case  "5": 
  421.                         $bitrate= "144000"; 
  422.                         break; 
  423.                 } 
  424.             break; 
  425.         case  "1110": 
  426.             switch ($index) 
  427.                 { 
  428.                     case  "1": 
  429.                         $bitrate= "448000"; 
  430.                         break; 
  431.                     case  "2": 
  432.                         $bitrate= "384000"; 
  433.                         break; 
  434.                     case  "3": 
  435.                         $bitrate= "320000"; 
  436.                         break; 
  437.                     case  "4": 
  438.                         $bitrate= "256000"; 
  439.                         break; 
  440.                     case  "5": 
  441.                         $bitrate= "160000"; 
  442.                         break; 
  443.                 } 
  444.             break; 
  445.         case  "1111": 
  446.             $bitrate= "bad"; 
  447.             break; 
  448.     } 
  449.  
  450. // Determine Sample Rate 
  451.  
  452. switch ($version) 
  453.     { 
  454.         case  "1": 
  455.             switch (substr($bitstream,12,2)) 
  456.                 { 
  457.                     case  "00": 
  458.                         $sample= "44100"; 
  459.                         break; 
  460.                     case  "01": 
  461.                         $sample= "48000"; 
  462.                         break; 
  463.                     case  "10": 
  464.                         $sample= "32000"; 
  465.                         break; 
  466.                     case  "11": 
  467.                         $sample= "reserved"; 
  468.                         break; 
  469.                 } 
  470.             break; 
  471.         case  "2": 
  472.             switch (substr($bitstream,12,2)) 
  473.                 { 
  474.                     case  "00": 
  475.                         $sample= "22050"; 
  476.                         break; 
  477.                     case  "01": 
  478.                         $sample= "24000"; 
  479.                         break; 
  480.                     case  "10": 
  481.                         $sample= "16000"; 
  482.                         break; 
  483.                     case  "11": 
  484.                         $sample= "reserved"; 
  485.                         break; 
  486.                 } 
  487.             break; 
  488.         case  "2.5": 
  489.             switch (substr($bitstream,12,2)) 
  490.                 { 
  491.                     case  "00": 
  492.                         $sample= "11025"; 
  493.                         break; 
  494.                     case  "01": 
  495.                         $sample= "12000"; 
  496.                         break; 
  497.                     case  "10": 
  498.                         $sample= "8000"; 
  499.                         break; 
  500.                     case  "11": 
  501.                         $sample= "reserved"; 
  502.                         break; 
  503.                 } 
  504.             break; 
  505.     } 
  506.  
  507. // Determine whether padding is set on. 0 == no & 1 == yes 
  508.  
  509. $padding = substr($bitstream,14,1); 
  510.  
  511. // Determine the private bit's value. Dont know what for though? 
  512.  
  513. $private = substr($bitstream,15,1); 
  514.  
  515. // Determine Channel mode 
  516.  
  517. switch (substr($bitstream,16,2)) 
  518.     { 
  519.         case  "00": 
  520.             $cmode= "Stereo"; 
  521.             break; 
  522.         case  "01": 
  523.             $cmode= "Joint Stereo"; 
  524.             break; 
  525.         case  "10": 
  526.             $cmode= "Dual Channel"; 
  527.             break; 
  528.         case  "11": 
  529.             $cmode= "Mono"; 
  530.             break; 
  531.     } 
  532.      
  533. /* 
  534.  
  535. // Determine Mode Extension, actually who cares for the moment 
  536.  
  537. switch (substr($bitstream,18,2)) 
  538.     { 
  539.         case "00": 
  540.             $mext="0"; 
  541.             break; 
  542.         case "01": 
  543.             $mext="3"; 
  544.             break; 
  545.         case "10": 
  546.             $mext="2"; 
  547.             break; 
  548.         case "11": 
  549.             $mext="1"; 
  550.             break; 
  551.     } 
  552.  
  553. */ 
  554.      
  555. // Determine Copyright 0 == no & 1 == yes 
  556.  
  557. $copyright = substr($bitstream,20,1); 
  558.  
  559. // Determine Original 0 == Copy & 1 == Original 
  560.  
  561. $original = substr($bitstream,21,1); 
  562.  
  563. // Determine Emphasis 
  564.  
  565. switch (substr($bitstream,22,2)) 
  566.     { 
  567.         case  "00": 
  568.             $emphasis= "none"; 
  569.             break; 
  570.         case  "01": 
  571.             $emphasis= "50/15 ms"; 
  572.             break; 
  573.         case  "10": 
  574.             $emphasis= "reserved"; 
  575.             break; 
  576.         case  "11": 
  577.             $emphasis= "CCIT J.17"; 
  578.             break; 
  579.     } 
  580.  
  581. // Determine number of frames. 
  582.  
  583. if ((isset($sample)) and (isset($bitrate))) 
  584. { 
  585. if ($layer== "1") 
  586.     { 
  587.         $frames=floor($filesize/(floor(((12*$bitrate)/($sample+$padding))*4)));     
  588.     } 
  589. else 
  590.     { 
  591.         $frames=floor($filesize/(floor((144*$bitrate)/($sample)))); 
  592.     } 
  593.      
  594. // Determine number of seconds in song. 
  595.  
  596. if ($layer== "1") 
  597.     { 
  598.         $seconds=floor((384/$sample)*$frames); 
  599.     } 
  600. else 
  601.     { 
  602.         $seconds=floor((1152/$sample)*$frames); 
  603.     } 
  604. } 
  605. fclose($file); 
  606.  
  607. $fred[]=$filename; 
  608. $fred[]=$filesize; 
  609. $fred[]=$seconds; 
  610. $fred[]=$bitrate; 
  611. $fred[]=$sample; 
  612. $fred[]=$cmode; 
  613. $fred[]=$version; 
  614. $fred[]=$layer; 
  615. $fred[]=$crc; 
  616. $fred[]=$copyright; 
  617. $fred[]=$original; 
  618.  
  619. return($fred); 
  620.  
  621. } 
  622.  
  623. ?>
  624.