开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > DVD > 查看源码
bit_rate.c
资源名称：8202s.rar　[点击查看]
上传用户：poi891205
上传日期：2013-07-15
资源大小：9745k
文件大小：12k
源码类别：

DVD

开发平台：

C/C++

bit_rate.c：源码内容
  1. /*
  2. *  Terry,2004/3/25 04:10PM
  3. */
  5. #include "bit_rate.h"
  6. #include "global.h"
  7. #include "util.h"
  8. #include "atapi_if.h"
  9. #include "image.h"
  10. #include "kinf.h"
  11. #include "stc.h"
  13. #ifndef DVDRELEASE
  14.     //#define DBG_BIT_RATE    1
  15. #endif
  17. #ifdef DBG_BIT_RATE
  18.     //#define DBG_PRE_PARSE_MP3
  19.     //#define DBG_MP3_HEADER_STREAM
  20.     //#define DBG_AV_BITRATE
  21. #endif
  23. #ifndef DBG_BIT_RATE
  24.     #undef printf
  25.     #undef print_block
  26.     #define printf(f, a...) do {} while (0)
  27.     #define print_block(x,y) do {} while (0)
  28. #endif
  30. // **************************************************************************************** //
  31. #ifdef DISPLAY_DATA_BIT_RATE
  33. UINT16 bit_rate_val = 0;
  34. UINT32 sample_addr  = 0;
  36. // **************************************************************************************** //
  37. void init_bit_rate(void)
  38. {
  39.     bit_rate_val    =   0;
  40.     sample_addr     =   0;
  41. }
  43. // **************************************************************************************** //
  44. //bit-rate range: 8K ~ 10Mbits
  45. //bit_rate_val:   8~10K 
  46. #define MAX_BIT_RATE  (10*1024*1024)
  47. #define MAX_BYTE_RATE (MAX_BIT_RATE/8)
  48. #define MAX_SECTOR_NS (MAX_BYTE_RATE/2048)
  49. #define MAX_KB_NS     (MAX_BYTE_RATE/1024) //1280
  51. #define MIN_BIT_RATE  (8*1024)
  52. #define MIN_BYTE_RATE (MIN_BIT_RATE/8)
  53. #define MIN_SECTOR_NS (MIN_BYTE_RATE/2048)
  54. #define MIN_KB_NS     (MIN_BYTE_RATE/1024) //1
  56. // **************************************************************************************** //
  57. void sample_bit_rate_per_sec(void)
  58. {
  59.     int tmp;
  60.     
  61.     if( adv_search_time == 0 )
  62.     {
  63.         if( cd_type_loaded == CDDVD ) 
  64.             tmp = play_abs_addr;
  65.         else 
  66.             tmp = msf2l( s_msf );
  67.         
  68.         if( tmp > sample_addr )
  69.         {
  70.             tmp = ( tmp - sample_addr ) * 2;
  71.             if( ( tmp >= MIN_KB_NS ) && ( tmp <= MAX_KB_NS ) )
  72.             {
  73.                 bit_rate_val = tmp * 8; // 8 ~ 10240
  74.                 printf( "<%d>n", bit_rate_val );
  75.             }
  76.         }
  77.         
  78.         sample_addr = tmp;
  79.     }
  80. }
  82. // **************************************************************************************** //
  83. #else
  85. void    init_bit_rate(void)             {}
  86. void    sample_bit_rate_per_sec(void)   {}
  88. #endif
  91. #ifdef SUPPORT_PRECALCULATE_VIDEOBITRATE_FOR_FILE_MODE
  92. // **************************************************************************************** //
  93. UINT32 GetBPS()
  94. {
  95.     if( adv_search_time != 0 )
  96.         return 0;
  97.         
  98.     UINT32 video_bitrate    = ki_get_video_bitrate();
  99.     if( video_bitrate == 0 )
  100.         return 0;
  101.     
  102.     UINT32 audio_bitrate    = ( ( *(bpcm_ya_ptr+44) | ( *(bpcm_ya_ptr+43) << 8) ) ) << 10;
  104.     UINT32 uiBitrate;
  105.     if( pDSV->dAv_AST_Ns > 0 )
  106.         uiBitrate = video_bitrate + audio_bitrate * pDSV->dAv_AST_Ns;
  107.     else
  108.         uiBitrate = video_bitrate + audio_bitrate;
  110.     #ifdef DBG_AV_BITRATE
  111.     printf("tt: %d, v: %d, a: %dn", uiBitrate, video_bitrate, audio_bitrate );
  112.     #endif
  113.         
  114.     return uiBitrate;
  115. }
  117. #else
  118. // **************************************************************************************** //
  119. extern void     StartBPS( UINT8 uiInterval )    { uiInterval = uiInterval; }
  120. extern UINT32   GetBPS()                        { return 0; }
  122. // **************************************************************************************** //
  123. #endif
  126. #ifdef REMAIN_TIME
  127. // **************************************************************************************** //
  128. typedef enum 
  129. {
  130.     VBR_MP3_PARSE_FIRST_FRAME,
  131.     VBR_MP3_PARSE_ALL_FRAME,
  132. }   VBR_MP3_FRAME_TYPE;
  134. typedef struct{
  135.     int bitrate;
  136.     char *nextHeaderPtr;
  137. }   MP3INFORM;
  139. // **************************************************************************************** //
  140. static void GetBitRateInform( MP3INFORM* pHeaderInform,UINT32 length )
  141. {
  142.     if( !pHeaderInform || length == 0 )
  143.         return;
  145.     UINT8   layerTable[4] = {0,3,2,1};
  146.     
  147.     UINT16  freqTable[9] = { 44100, 48000, 32000, 22050, 24000, 16000 , 11025 , 12000 , 8000 };
  148.     
  149.     UINT16  bitrateTable[2][3][16] = { 
  150.        { {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,},
  151.          {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,},
  152.          {0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,} },
  153.     
  154.        { {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,},
  155.          {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,},
  156.          {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,} }
  157.     };
  158.     
  159.     char*   stream          = pHeaderInform->nextHeaderPtr;
  160.     UINT32  Header          = 0xFFFFFFFF;
  161.     UINT32  NextHeader      = 0xFFFFFFFF;
  162.     UINT32  syncwordMask    = 0xFFF00000;
  163.     UINT32  layerMask       = 0x00060000;
  164.     UINT32  bitrateMask     = 0x0000F000;
  165.     UINT32  sampleMask      = 0x00000C00;
  166.     char*   NextSyncPtr     = NULL;
  167.     int     syncshift       = 20;
  168.     int     layershift      = 17;
  169.     int     bitrateshift    = 12;
  170.     int     sampleshift     = 10;
  171.     int     hitSyncWord     = 0;
  172.     int     layerNo         = 0;
  173.     int     bitrate         = 0;
  174.     int     freqs           = 0;
  175.     int     bitrateIndex, ID,slotNo;
  176.     UINT32  syncLag;
  177.     
  178.     Header=((unsigned int)(*stream))<<24;                   stream++;
  179.     Header=Header|((((unsigned int)(*stream))<<24)>>8);     stream++;
  180.     Header=Header|((((unsigned int)(*stream))<<24)>>16);    stream++;
  181.     Header=Header|(((unsigned int)(*stream)<<24)>>24);      stream++;
  182.     length=length-4;
  184.     #ifdef DBG_MP3_HEADER_STREAM    
  185.     printf("Header = %x n", Header);
  186.     #endif
  188.     //find the sync word
  189.     while((hitSyncWord==0)&&(length!=0))
  190.     {
  191.         if(((Header&syncwordMask)>>syncshift)==0xFFF) //check sync word
  192.         {
  193.          layerNo=layerTable[((Header&layerMask)>>layershift)];
  194.          if(layerNo!=0)  //check layer No
  195.          {
  196.          bitrateIndex=((Header&bitrateMask)>>bitrateshift);
  197.          if(bitrateIndex!=0xf&&bitrateIndex!=0x0)//check bitrate index
  198.          {
  199.          ID=(Header & (1<<19)) ? 0x0 : 0x1;
  200.          bitrate=bitrateTable[ID][layerNo-1][bitrateIndex];
  201.          if(((Header&sampleMask)>>sampleshift)!=0x3) //check sampling frequency
  202.          {
  203.          freqs=freqTable[((Header&sampleMask)>>sampleshift)];
  204.          if(layerNo==1)
  205.          {//layer I
  206.          syncLag=12*bitrate*1000/freqs;
  207.          }
  208.          else
  209.          {//layer II,III
  210.          syncLag=144*bitrate*1000/freqs;
  211.          }
  212.          for(slotNo=0;slotNo<2;slotNo++)
  213.          {
  214.          NextSyncPtr=stream-4+syncLag+slotNo;
  215.          if(length>syncLag)
  216.          {
  217.          NextHeader=((unsigned int)(*NextSyncPtr))<<24;                      NextSyncPtr++;
  218.          NextHeader=NextHeader|((((unsigned int)(*NextSyncPtr))<<24)>>8);    NextSyncPtr++;
  219.          NextHeader=NextHeader|((((unsigned int)(*NextSyncPtr))<<24)>>16);   NextSyncPtr++;
  220.          NextHeader=NextHeader|(((unsigned int)(*NextSyncPtr)<<24)>>24);     NextSyncPtr++;
  221.         
  222.          if(((NextHeader&syncwordMask)>>syncshift)==0xFFF) //confirm sync word
  223.          {
  224.          if(((NextHeader&layerMask)>>layershift)!=0x0)
  225.          {
  226.          if(((NextHeader&bitrateMask)>>bitrateshift)!=0xf&&((NextHeader&bitrateMask)>>bitrateshift)!=0x0)
  227.          {
  228.          if(((NextHeader&sampleMask)>>sampleshift)!=0x3)
  229.          {
  230.          hitSyncWord=1;
  231.         
  232.     #ifdef DBG_MP3_HEADER_STREAM
  233.          printf("len=%d,header=%x ",length,Header);
  234.     #endif
  235.     break;
  236.          }
  237.               }
  238.                                  }
  239.          }
  240.          }
  241.          else
  242.          {
  243.     #ifdef DBG_MP3_HEADER_STREAM
  244.              printf("syncLag=%d,length=%dn",syncLag,length);
  245.     #endif
  246.              bitrate=0;
  247.          }
  248.          }
  249.          }
  250.          }
  251.          }
  252.         }
  253.         
  254.         if(hitSyncWord==0) //shift
  255.         {
  256.             Header=Header<<8;  
  257.             Header=Header|(((unsigned int)(*stream)<<24)>>24);
  258.             stream++;
  259.             length--;
  260.         }
  261.     }
  262.     
  263.     #ifdef DBG_PRE_PARSE_MP3    
  264.     printf("bitrate =%d,layer=%d,freq=%d n",bitrate,layerNo,freqs);
  265.     #endif    
  266.     
  267.     if( hitSyncWord == 1 )
  268.     {
  269.      pHeaderInform->bitrate          = bitrate;
  270.      pHeaderInform->nextHeaderPtr    = stream;
  271.     }
  272.     else
  273.     {
  274.      pHeaderInform->bitrate          = 0;
  275.      pHeaderInform->nextHeaderPtr    = 0;
  276.     }
  277. }
  279. // **************************************************************************************** //
  280. static UINT32 ParseMP3BitRateFromAudioStream( VBR_MP3_FRAME_TYPE enType, char* pBuf, UINT32 uiLen )
  281. {
  282.     if( !pBuf || uiLen == 0 )
  283.         return 0;
  285.     MP3INFORM HeaderInform;
  286.     HeaderInform.nextHeaderPtr = pBuf;
  287.     
  288.     if( enType == VBR_MP3_PARSE_FIRST_FRAME )
  289.     {   
  290.         GetBitRateInform( &HeaderInform, uiLen );
  291.         return HeaderInform.bitrate;
  292.     }
  293.     else if( enType == VBR_MP3_PARSE_ALL_FRAME )
  294.     {
  295.         int     lastpBuf        = (int)pBuf + uiLen;
  296.         int     sumBitRate      = 0;
  297.         UINT32  uiBitRateCount  = 0;
  299.         GetBitRateInform( &HeaderInform, uiLen );
  300.         
  301.         while( HeaderInform.bitrate != 0 )
  302.         {
  303.             sumBitRate += HeaderInform.bitrate;
  304.             uiBitRateCount++;
  305.             int lengthRemain = lastpBuf - (UINT32)(HeaderInform.nextHeaderPtr);
  306.             GetBitRateInform( &HeaderInform, lengthRemain );
  307.         }
  309.     #ifdef DBG_PRE_PARSE_MP3
  310.         printf( "average bitrate of LBA %dn", ( uiBitRateCount > 0 ) ? ( sumBitRate / uiBitRateCount ) : 0 );
  311.     #endif    
  312.         return ( uiBitRateCount > 0 ) ? ( sumBitRate / uiBitRateCount ) : 0;    
  313.     }
  314.     
  315.     return 0;
  316. }
  318. // **************************************************************************************** //
  319. UINT32 PreParseMP3BitRate( VBR_MP3_LBA_TYPE enType, UINT32 uiParam, UINT32 uiLba, UINT32 uiLen )
  320. {
  321.     int     i           = 0;
  322.     UINT32  uiLbaOffset = 0;
  323.     UINT32  uiBitRate   = 0;
  324.     UINT32  uiCount     = 0;
  325.     UINT32  uiLbaCount  = 0;
  326.     UINT32  uiStart     = uiLba;
  327.         
  328.     switch( enType )
  329.     {
  330.     case VBR_MP3_INTERVAL_N_LBA:
  331.         uiLbaCount  = uiLen;
  332.         uiLbaOffset = uiParam;
  333.         break;
  334.         
  335.     case VBR_MP3_FIRST_N_LBA:
  336.         uiLbaCount  = uiParam > uiLen ? uiLen : uiParam;
  337.         uiLbaOffset = 1;
  338.         break;
  340.     case VBR_MP3_CENTER_N_LBA:  // 2004/08/10 yltseng
  341.     {
  342.         UINT32 uiTmp = ( uiLen + uiParam ) >> 1;
  343.         uiLbaCount  = uiParam > uiTmp ? uiTmp : uiParam;
  344.         uiLbaOffset = 1;
  345.         uiStart     = uiLba + ( ( uiLen - uiParam ) > 1 );
  346.     }
  347.         break;
  348.         
  349.     case VBR_MP3_N_LBA:
  350.         uiLbaCount  = uiLen;
  351.         uiLbaOffset = uiLen / uiParam;
  352.         break;
  353.     }
  354.   
  355.     while( i < (int) uiLbaCount )
  356.     {
  357.         if( ran_read( pwb, l2msf( ( uiStart + i ) ), 2048 ) == ATAPI_OK )
  358.         {
  359.             UINT32 uiCurLbaBitRate = ParseMP3BitRateFromAudioStream( VBR_MP3_PARSE_FIRST_FRAME, pwb, 2048 );    // 2004/12/17 yltseng
  360.             if( uiCurLbaBitRate )
  361.             {
  362.                 uiBitRate += uiCurLbaBitRate;
  363.                 uiCount++;
  364.             }
  365.         }
  367.         i += uiLbaOffset;
  368.     }
  369.     
  370.     #ifdef DBG_PRE_PARSE_MP3
  371.     printf( "average bitrate of MP3 file %dn", ( uiCount > 0 ) ? ( uiBitRate / uiCount ) : 0 );
  372.     #endif
  374.     return ( uiCount > 0 ) ? ( uiBitRate / uiCount ) : 0;
  375. }
  377. // **************************************************************************************** //
  378. #else
  380. UINT32 PreParseMP3BitRate( VBR_MP3_LBA_TYPE enType, UINT32 uiParam, UINT32 uiLba, UINT32 uiLen ) 
  381. { enType = enType; uiParam = uiParam; uiLba = uiLba, uiLen = uiLen; return 0; }
  383. #endif
  385. // **************************************************************************************** //