mhead.cpp
上传用户:zhongxx05
上传日期:2007-06-06
资源大小:33641k
文件大小:11k
源码类别:

Symbian

开发平台:

C/C++

  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  35. #include "hlxclib/stdlib.h"
  36. #include "hlxclib/stdio.h"
  37. #include "hlxclib/float.h"
  38. #include "hlxclib/math.h"
  39. #include "hlxclib/string.h"
  40. #include "mhead.h"     /* mpeg header structure */
  41. static const int mp_br_table[2][16]=
  42.     {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,0,
  43.      0,32,48,56,64,80,96,112,128,160,192,224,256,320,384,0};
  44. static const int mp_sr20_table[2][4]={441,480,320,-999, 882,960,640,-999};
  45. static const int mp_br_tableL1[2][16]=
  46.     {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,0,    /* mpeg2 */
  47.      0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,0};
  48. static const int mp_br_tableL3[2][16]=
  49.     {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,0,    /* mpeg 2 */
  50.      0,32,40,48,56,64,80,96,112,128,160,192,224,256,320,0};
  51. static int find_sync(unsigned char *buf, int n);
  52. static int sync_scan(unsigned char *buf, int n, int i0);
  53. static int sync_test(unsigned char *buf, int n, int isync, int padbytes);
  54. /*--------------------------------------------------------------*/
  55. int head_info(unsigned char *buf, unsigned int n, MPEG_HEAD *h, int trustFrame)
  56. {
  57. int framebytes;
  58. int mpeg25_flag;
  59. if( n > 10000 )  n = 10000;   /* limit scan for free format */
  60. h->sync = 0;
  61. if( (buf[0] == 0xFF) && ((buf[1] & 0xF0) == 0xF0) ) {
  62.     mpeg25_flag = 0;            // mpeg 1 & 2
  63. }
  64. else if( (buf[0] == 0xFF) && ((buf[1] & 0xF0) == 0xE0) ) {
  65.     mpeg25_flag = 1;            // mpeg 2.5
  66. }
  67. else return 0;      // sync fail
  68. h->sync = 1;
  69. if( mpeg25_flag ) h->sync = 2; //low bit clear signals mpeg25 (as in 0xFFE)
  70. h->id         = (buf[1] & 0x08) >> 3;
  71. h->option     = (buf[1] & 0x06) >> 1;
  72. h->prot       = (buf[1] & 0x01);
  73. h->br_index   = (buf[2] & 0xf0) >> 4;
  74. h->sr_index   = (buf[2] & 0x0c) >> 2;
  75. h->pad        = (buf[2] & 0x02) >> 1;
  76. h->private_bit   = (buf[2] & 0x01);
  77. h->mode       = (buf[3] & 0xc0) >> 6;
  78. h->mode_ext   = (buf[3] & 0x30) >> 4;
  79. h->cr         = (buf[3] & 0x08) >> 3;
  80. h->original   = (buf[3] & 0x04) >> 2;
  81. h->emphasis   = (buf[3] & 0x03);
  82. //if( mpeg25_flag ) {
  83. //    if( h->sr_index == 2 ) return 0;   // fail 8khz
  84. //}
  85. /* Found a clip with a bad emphasis value.  Let this slide for now */
  86. /*if (h->emphasis == 2)
  87.     return 0;
  88. */
  89. /* do some error checking */
  90. if (h->br_index == 0xFF ||
  91.     h->sr_index == 3 ||
  92.     h->option < 1 ||
  93.     h->option > 3)
  94. {
  95.     memset(h, 0, sizeof(*h));
  96.     return 0;
  97. }
  98. framebytes = 0;
  99. if( h->br_index > 0 )
  100. {
  101.   if( h->option == 3 ) {    /* layer I */
  102.     framebytes =
  103.     240 *  mp_br_tableL1[h->id][h->br_index]
  104.               /mp_sr20_table[h->id][h->sr_index];
  105.     framebytes = 4*framebytes;
  106.   }
  107.   else if( h->option == 2 ) {     /* layer II */
  108.     framebytes =
  109.     2880 * mp_br_table[h->id][h->br_index]
  110.           /mp_sr20_table[h->id][h->sr_index];
  111.   }
  112.   else if( h->option == 1 ) {     /* layer III */
  113.     if( h->id )  {       // mpeg1
  114.             framebytes =
  115.                 2880 * mp_br_tableL3[h->id][h->br_index]
  116.                          / mp_sr20_table[h->id][h->sr_index];
  117.     }
  118.     else  {              // mpeg2
  119.         if( mpeg25_flag ) {     // mpeg2.2
  120.             framebytes =
  121.                 2880 *  mp_br_tableL3[h->id][h->br_index]
  122.                           / mp_sr20_table[h->id][h->sr_index];
  123.         }
  124.         else {
  125.             framebytes =
  126.                 1440 *  mp_br_tableL3[h->id][h->br_index]
  127.                         / mp_sr20_table[h->id][h->sr_index];
  128.         }
  129.     }
  130.   }
  131. }
  132. else
  133. {
  134.     framebytes = find_sync(buf, n);    /* free format */
  135.     // If trustFrame != 0, that means we know that we only
  136.     // have valid frames in this buffer (i.e. - we know
  137.     // we are being called from the renderer where our
  138.     // fileformat has already parsed out the frames).
  139.     // Therefore, if find_sync() did not find any frames
  140.     // and trustFrame != 0, then accept the rest of the buffer
  141.     // as valid.
  142.     if (framebytes == 0 && trustFrame != 0)
  143.     {
  144.         // Accept the rest of the buffer as a frame
  145.         framebytes = n - h->pad;
  146.     }
  147.     // The spec states "The decoder is also not required to support bitrates
  148.     // higher than 448 kbits/s, 384 kbits/sec, 320 kbits/sec in respect to Layer I,
  149.     // II, and III when in free format mode."
  150.     if (framebytes)
  151.     {
  152.         // Compute the bitrate
  153.         int lBitrate = 0;
  154.         if(h->option == 1)
  155.         {
  156.             /* layer III */
  157.             if (h->br_index > 0)
  158.                 lBitrate = 1000 * mp_br_tableL3[h->id][h->br_index];
  159.             else
  160.             {
  161.                 if(h->id) // mpeg1
  162.                     lBitrate = 1000 * framebytes * mp_sr20_table[h->id][h->sr_index]/(144*20);
  163.                 else
  164.                 {
  165.                     // mpeg2
  166.                     if((h->sync & 1) == 0) //  flags mpeg25
  167.                         lBitrate = 500*framebytes*mp_sr20_table[h->id][h->sr_index]/(72*20);
  168.                     else
  169.                         lBitrate = 1000*framebytes*mp_sr20_table[h->id][h->sr_index]/(72*20);
  170.                 }
  171.             }
  172.             // Cap the bitrate
  173.             if (lBitrate > 320000 || lBitrate < 0) framebytes = 0;
  174.         }
  175.         if (h->option == 2)
  176.         {
  177.             /* layer II */
  178.             if (h->br_index > 0)
  179.                 lBitrate = 1000*mp_br_table[h->id][h->br_index];
  180.             else
  181.                 lBitrate = 1000*framebytes*mp_sr20_table[h->id][h->sr_index] / (144*20);
  182.             // Cap the bitrate
  183.             if (lBitrate > 384000 || lBitrate < 0) framebytes = 0;
  184.         }
  185.         if (h->option == 3)
  186.         {
  187.             /* layer I */
  188.             if(h->br_index > 0)
  189.                 lBitrate = 1000 * mp_br_tableL1[h->id][h->br_index];
  190.             else
  191.                 lBitrate = 1000*framebytes*mp_sr20_table[h->id][h->sr_index] / (48*20);
  192.             // Cap the bitrate
  193.             if (lBitrate > 448000 || lBitrate < 0) framebytes = 0;
  194.         }
  195.     }
  196. }
  197. return framebytes;
  198. }
  199. /*--------------------------------------------------------------*/
  200. int head_info2(unsigned char *buf, unsigned int n, MPEG_HEAD *h, int *br, int trustFrame)
  201. {
  202. int framebytes;
  203. /*---  return br (in bits/sec) in addition to frame bytes ---*/
  204. *br = 0;         /*-- assume fail --*/
  205. framebytes =  head_info(buf, n, h, trustFrame);
  206. if( framebytes == 0 ) return 0;
  207. if( h->option == 1 ) {     /* layer III */
  208.     if( h->br_index > 0 )
  209.              *br = 1000*mp_br_tableL3[h->id][h->br_index];
  210.     else {
  211.         if( h->id )   // mpeg1
  212.         *br = 1000*framebytes*mp_sr20_table[h->id][h->sr_index]/(144*20);
  213.         else  {        // mpeg2
  214.             if( (h->sync & 1) == 0 )    //  flags mpeg25
  215.                 *br = 500*framebytes*mp_sr20_table[h->id][h->sr_index]/(72*20);
  216.             else
  217.                 *br = 1000*framebytes*mp_sr20_table[h->id][h->sr_index]/(72*20);
  218.         }
  219.     }
  220. }
  221. if( h->option == 2 ) {     /* layer II */
  222.     if( h->br_index > 0 )
  223.              *br = 1000*mp_br_table[h->id][h->br_index];
  224.     else  *br = 1000*framebytes*mp_sr20_table[h->id][h->sr_index]
  225.                        / (144*20);
  226. }
  227. if( h->option == 3 ) {    /* layer I */
  228.     if( h->br_index > 0 )
  229.              *br = 1000*mp_br_tableL1[h->id][h->br_index];
  230.     else  *br = 1000*framebytes*mp_sr20_table[h->id][h->sr_index]
  231.                        / (48*20);
  232. }
  233. return framebytes;
  234. }
  235. /*--------------------------------------------------------------*/
  236. static int compare( unsigned char *buf, unsigned char *buf2)
  237. {
  238. if( buf[0] != buf2[0] )  return 0;
  239. if( buf[1] != buf2[1] )  return 0;
  240. return 1;
  241. }
  242. /*----------------------------------------------------------*/
  243. /*-- does not scan for initial sync, initial sync assumed --*/
  244. static int find_sync(unsigned char *buf, int n)
  245. {
  246. int i0, isync, nmatch, pad;
  247. int padbytes, option;
  248. /* mod 4/12/95 i0 change from 72, allows as low as 8kbits for mpeg1 */
  249. i0 = 24;
  250. padbytes = 1;
  251. option = (buf[1] & 0x06) >> 1;
  252. if( option == 3 )  {
  253.    padbytes = 4;
  254.    i0 = 24;            /* for shorter layer I frames */
  255.    }
  256. pad  = (buf[2] & 0x02) >> 1;
  257. n -= 3;             /*  need 3 bytes of header  */
  258. while( i0 < 2000 ) {
  259.   isync = sync_scan(buf, n, i0);
  260.   i0 = isync +1;
  261.   isync -= pad;
  262.   if( isync <= 0 ) return 0;
  263.   nmatch = sync_test(buf, n, isync, padbytes);
  264.   if( nmatch > 0 ) return isync;
  265.   }
  266. return 0;
  267. }
  268. /*------------------------------------------------------*/
  269. /*---- scan for next sync, assume start is valid -------*/
  270. /*---- return number bytes to next sync ----------------*/
  271. static int sync_scan(unsigned char *buf, int n, int i0)
  272. {
  273. int i;
  274. for(i=i0; i<n; i++)
  275.     if( compare(buf, buf+i) ) return i;
  276. return 0;
  277. }
  278. /*------------------------------------------------------*/
  279. /*- test consecutative syncs, input isync without pad --*/
  280. static int sync_test(unsigned char *buf, int n, int isync, int padbytes)
  281. {
  282. int i, nmatch, pad;
  283. nmatch = 0;
  284. for(i=0; ; ) {
  285.     pad  = padbytes*( (buf[i+2] & 0x02) >> 1);
  286.     i += (pad + isync);
  287.     if( i > n ) break;
  288.     if( !compare(buf,buf+i) ) return -nmatch;
  289.     nmatch++;
  290. }
  291. return nmatch;
  292. }