Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. #include "mp3dec.h"
  2. #include <string.h>
  3. #include <math.h>
  4.  
  5. typedef unsigned char byte;
  6. typedef unsigned int uint;
  7. typedef unsigned short ushort;
  8.  
  9. static const int br_tbl[3][3][16] = {
  10. {// MPEG-1
  11.         // Layer1
  12.         { 0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0 },
  13.         // Layer2
  14.         { 0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0 },
  15.         // Layer3
  16.         { 0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0 },
  17. },
  18. {// MPEG-2
  19.         // Layer1
  20.         { 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0 },
  21.         // Layer2
  22.         { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
  23.         // Layer3
  24.         { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
  25. },
  26. {// MPEG-2.5
  27.         // Layer1 (not available)
  28.         { 0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0 },
  29.         // Layer2 (not available)
  30.         { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
  31.         // Layer3
  32.         { 0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0 },
  33. },
  34. };
  35.  
  36. static const int fr_tbl[3][4] = {
  37.         // MPEG-1
  38.         { 44100, 48000, 32000, 0/*reserved*/ },
  39.         // MPEG-2
  40.         { 22050, 24000, 16000, 0/*reserved*/ },
  41.         // MPEG-2.5
  42.         { 11025, 12000, 8000, 0/*reserved*/ },
  43. };
  44. /* 1999/11/01íœ
  45. static const double ms_p_f_table[3][3] =
  46. {
  47.         // Layer1
  48.         {8.707483f, 8.0f, 12.0f},
  49.         // Layer2
  50.         {26.12245f, 24.0f, 36.0f},
  51.         // Layer3
  52.         {26.12245f, 24.0f, 36.0f},
  53. };
  54. */
  55. typedef void (*FRAME_PROC) (MPEG_HEADER* h, byte* mpeg, byte* pcm);
  56.  
  57. MPEG_DECODE_OPTION m_option;
  58. FRAME_PROC m_frame_proc;
  59. int m_last_error;
  60. int m_frequency;
  61. int m_frame_size, m_pcm_size;
  62. int m_enableEQ;
  63. float m_equalizer[32];
  64. //float m_band_tbl[2][32];
  65.  
  66. void L1table_init();
  67. void L2table_init();
  68. void L3table_init();
  69. void L1decode_start(MPEG_HEADER* h);
  70. void L2decode_start(MPEG_HEADER* h);
  71. void L3decode_start(MPEG_HEADER* h);
  72. void L1decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm);
  73. void L2decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm);
  74. void L3decode_frame(MPEG_HEADER* h, byte* mpeg, byte* pcm);
  75.  
  76. void _stdcall debug_out_hex(unsigned int val);
  77. void debug_out_str(char* str);
  78.  
  79.  
  80. void mp3DecodeInit()
  81. {
  82. //   _set_SSE2_enable(0);
  83.  
  84.         m_option.reduction = 0;
  85.         m_option.convert = 0;
  86.         m_option.freqLimit = 24000;
  87.  
  88.         L1table_init();
  89.         L2table_init();
  90.         L3table_init();
  91. }
  92.  
  93. int mp3GetHeader(byte* buf, MPEG_HEADER* h)
  94. {
  95.         h->version              = (buf[1] & 0x08) >> 3;
  96.         h->layer                = (buf[1] & 0x06) >> 1;
  97.         h->error_prot   = (buf[1] & 0x01);
  98.         h->br_index             = (buf[2] & 0xf0) >> 4;
  99.         h->fr_index             = (buf[2] & 0x0c) >> 2;
  100.         h->padding              = (buf[2] & 0x02) >> 1;
  101.         h->extension    = (buf[2] & 0x01);
  102.         h->mode                 = (buf[3] & 0xc0) >> 6;
  103.         h->mode_ext             = (buf[3] & 0x30) >> 4;
  104.         h->copyright    = (buf[3] & 0x08) >> 3;
  105.         h->original             = (buf[3] & 0x04) >> 2;
  106.         h->emphasis             = (buf[3] & 0x03);
  107.  
  108.         if (buf[0] != 0xFF)     {//sync error
  109.                 m_last_error = MP3_ERROR_INVALID_SYNC;
  110.                 return 0;
  111.         }
  112.         if ((buf[1] & 0xF0) == 0xF0)            //MPEG-1, MPEG-2
  113.                 h->version = (h->version) ? 1 : 2;
  114.         else if ((buf[1] & 0xF0) == 0xE0)       //MPEG-2.5
  115.                 h->version = 3;
  116.         else {
  117.                 m_last_error = MP3_ERROR_INVALID_SYNC;
  118.                 return 0;
  119.         }
  120.         if (h->fr_index >= 3 ||
  121.                         h->br_index == 0 || h->br_index >= 15 ||
  122.                         h->layer == 0 || h->layer >= 4) {
  123.                 m_last_error = MP3_ERROR_INVALID_HEADER;
  124.                 return 0;
  125.         }
  126.         h->layer = 4 - h->layer;
  127.         h->error_prot = (h->error_prot) ? 0 : 1;
  128.  
  129.         return 1;
  130. }
  131.  
  132. int mp3GetLastError()
  133. {
  134.         return m_last_error;
  135. }
  136.  
  137. int mp3FindSync(byte* buf, int size, int* sync)
  138. {
  139.         int i;
  140.  
  141.         *sync = 0;
  142.         size -= 3;
  143.         if (size <= 0) {
  144.                 m_last_error = MP3_ERROR_OUT_OF_BUFFER;
  145.                 return 0;
  146.         }
  147.         for (i = 0; i < size; i ++) {
  148.                 if (buf[i] == 0xFF) {
  149.                         if ((buf[i + 1] & 0xF0) == 0xF0) {
  150.                                 break;
  151.                         }
  152.                         else if ((buf[i + 1] & 0xF0) == 0xE0) {
  153.                                 break;
  154.                         }
  155.                 }
  156.         }
  157.         if (i == size) {
  158.                 m_last_error = MP3_ERROR_OUT_OF_BUFFER;
  159.                 return 0;
  160.         }
  161.         *sync = i;
  162.         return 1;
  163. }
  164.  
  165. void mp3GetDecodeOption(MPEG_DECODE_OPTION* option)
  166. {
  167.     *option = m_option;
  168. }
  169.  
  170. int mp3SetDecodeOption(MPEG_DECODE_OPTION* option)
  171. {
  172.         m_option = *option;
  173.         return 1;
  174. }
  175.  
  176. int mp3SetEqualizer(int* value)
  177. {
  178.         int i;
  179.         if (value == (void*)0) {
  180.                 m_enableEQ = 0;
  181.                 return 1;
  182.         }
  183.         m_enableEQ = 1;
  184.         //60, 170, 310, 600, 1K, 3K
  185.         for (i = 0; i < 6; i ++) {
  186.                 m_equalizer[i] = (float)pow_test(10,(double)value[i]/200);
  187.         }
  188.         //6K
  189.         m_equalizer[6] = (float)pow_test(10,(double)value[6]/200);
  190.         m_equalizer[7] = m_equalizer[6];
  191.         //12K
  192.         m_equalizer[8] = (float)pow_test(10,(double)value[7]/200);
  193.         m_equalizer[9] = m_equalizer[8];
  194.         m_equalizer[10] = m_equalizer[8];
  195.         m_equalizer[11] = m_equalizer[8];
  196.         //14K
  197.         m_equalizer[12] = (float)pow_test(10,(double)value[8]/200);
  198.         m_equalizer[13] = m_equalizer[12];
  199.         m_equalizer[14] = m_equalizer[12];
  200.         m_equalizer[15] = m_equalizer[12];
  201.         m_equalizer[16] = m_equalizer[12];
  202.         m_equalizer[17] = m_equalizer[12];
  203.         m_equalizer[18] = m_equalizer[12];
  204.         m_equalizer[19] = m_equalizer[12];
  205.         //16K
  206.         m_equalizer[20] = (float)pow_test(10,(double)value[9]/200);
  207.         m_equalizer[21] = m_equalizer[20];
  208.         m_equalizer[22] = m_equalizer[20];
  209.         m_equalizer[23] = m_equalizer[20];
  210.         m_equalizer[24] = m_equalizer[20];
  211.         m_equalizer[25] = m_equalizer[20];
  212.         m_equalizer[26] = m_equalizer[20];
  213.         m_equalizer[27] = m_equalizer[20];
  214.         m_equalizer[28] = m_equalizer[20];
  215.         m_equalizer[29] = m_equalizer[20];
  216.         m_equalizer[30] = m_equalizer[20];
  217.         m_equalizer[31] = m_equalizer[20];
  218.         return 1;
  219. }
  220.  
  221. #define VBR_FRAMES_FLAG         0x0001
  222. #define VBR_BYTES_FLAG          0x0002
  223. #define VBR_TOC_FLAG            0x0004
  224. #define VBR_SCALE_FLAG          0x0008
  225.  
  226. static int extractInt4(byte* buf)
  227. {// big endian extract
  228.         return buf[3] | (buf[2] << 8) |
  229.                         (buf[1] << 16) | (buf[0] << 24);
  230. }
  231.  
  232. int mp3GetDecodeInfo(byte* mpeg, int size, MPEG_DECODE_INFO* info, int decFlag)
  233. {
  234.         MPEG_HEADER* h = &info->header;
  235.         byte* p = mpeg;
  236.         int vbr;
  237.         uint minBitRate, maxBitRate;
  238.         uint i, j, flags;
  239.  
  240.  
  241.         //int bitRate;
  242.         //int frame_size;
  243.  
  244.         if (size < 156) {//max vbr header size
  245.                 m_last_error = MP3_ERROR_OUT_OF_BUFFER;
  246.                 return 0;
  247.         }
  248.         if (!mp3GetHeader(p, h)) {
  249.                 return 0;
  250.         }
  251. //check VBR Header
  252.         p += 4;//skip mpeg header
  253.         if (h->error_prot) p += 2;//skip crc
  254.         if (h->layer == 3) {//skip side info
  255.                 if (h->version == 1) {//MPEG-1
  256.                         if (h->mode != 3) p += 32;
  257.                         else p += 17;
  258.                 }
  259.                 else {//MPEG-2, MPEG-2.5
  260.                         if (h->mode != 3) p += 17;
  261.                         else p += 9;
  262.                 }
  263.         }
  264.  
  265.         info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
  266.         info->frequency = fr_tbl[h->version-1][h->fr_index];
  267.         if (memcmp(p, "Xing", 4) == 0) {//VBR
  268.                 p += 4;
  269.                 flags = extractInt4(p);
  270.                 p += 4;
  271.                 if (!(flags & (VBR_FRAMES_FLAG | VBR_BYTES_FLAG))) {
  272.                         m_last_error = MP3_ERROR_INVALID_HEADER;
  273.                         return 0;
  274.                 }
  275.                 info->frames = extractInt4(p);
  276.                 p += 4;
  277.                 info->dataSize = extractInt4(p);
  278.                 p += 4;
  279.                 if (flags & VBR_TOC_FLAG) p += 100;
  280.                 if (flags & VBR_SCALE_FLAG) p += 4;
  281.  
  282.                 /*/////////////////////////////////
  283.                 //•W€VBR‘Ήž
  284.                 if ( p[0] == mpeg[0] && p[1] == mpeg[1] ) {
  285.                         info->skipSize = (int)(p - mpeg);
  286.                 } else {
  287.                         info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
  288.                         switch (h->layer) {
  289.                         case 1://layer1
  290.                                 m_frame_size = (12 * info->bitRate / fr_tbl[h->version-1][h->fr_index]) * 4;//one slot is 4 bytes long
  291.                                 if (h->padding) m_frame_size += 4;
  292.                                 break;
  293.                         case 2://layer2
  294.                                 m_frame_size = 144 * info->bitRate / fr_tbl[h->version-1][h->fr_index];
  295.                                 if (h->padding) m_frame_size ++;
  296.                                 break;
  297.                         case 3://layer3
  298.                                 m_frame_size = 144 * info->bitRate / fr_tbl[h->version-1][h->fr_index];
  299.                                 if (h->version != 1) //MPEG-2, MPEG-2.5
  300.                                         m_frame_size /= 2;
  301.                                 if (h->padding) m_frame_size;
  302.                                 break;
  303.                         }
  304.                         info->skipSize = (int)(m_frame_size);
  305.                 }
  306.                 info->bitRate = 0;
  307.                 /////////////////////////////////*/
  308.  
  309.                 vbr = 1;
  310.                 minBitRate = 0xffffffff;
  311.                 maxBitRate = 0;
  312.                 for (i = 1; i < 15; i ++) {
  313.                         j = br_tbl[h->version-1][h->layer-1][i] * 1000;
  314.                         if (j < minBitRate) minBitRate = j;
  315.                         if (j > maxBitRate) maxBitRate = j;
  316.                 }
  317.         }
  318.         else if (memcmp(p, "VBRI", 4) == 0) {//VBRI
  319.                 p += 10;
  320.                 info->dataSize = extractInt4(p);
  321.                 p += 4;
  322.                 info->frames = extractInt4(p);
  323.                 p += 4;
  324.                 vbr = 1;
  325.                 minBitRate = 0xffffffff;
  326.                 maxBitRate = 0;
  327.                 for (i = 1; i < 15; i ++) {
  328.                         j = br_tbl[h->version-1][h->layer-1][i] * 1000;
  329.                         if (j < minBitRate) minBitRate = j;
  330.                         if (j > maxBitRate) maxBitRate = j;
  331.                 }
  332.         }
  333.         else {//not VBR
  334.                 vbr = 0;
  335.                 info->frames = 0;
  336.                 //info->skipSize = 0;
  337.                 info->dataSize = 0;
  338.                 //info->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
  339.         }
  340.  
  341. //      info->frequency = fr_tbl[h->version-1][h->fr_index];
  342. //      info->msPerFrame = ms_p_f_table[h->layer-1][h->fr_index];
  343. //      if (h->version == 3) info->msPerFrame *= 2;
  344.         switch (h->layer) {
  345.         case 1://layer1
  346.                 info->outputSize = 384 >> m_option.reduction;
  347.                 //if (info->bitRate) {
  348.                 if (!vbr) {
  349.                         info->skipSize = 0;
  350.                         info->minInputSize = (12 * info->bitRate / info->frequency) * 4;//one slot is 4 bytes long
  351.                         info->maxInputSize = info->minInputSize + 4;
  352.                 }
  353.                 else {
  354.                         info->skipSize = (12 * info->bitRate / info->frequency + h->padding) * 4;
  355.                         info->minInputSize = (12 * minBitRate / info->frequency) * 4;
  356.                         info->maxInputSize = (12 * maxBitRate / info->frequency) * 4 + 4;
  357.                 }
  358.                 break;
  359.         case 2://layer2
  360.                 info->outputSize = 1152 >> m_option.reduction;
  361.                 //if (info->bitRate) {
  362.                 if (!vbr) {
  363.                         info->skipSize = 0;
  364.                         info->minInputSize = 144 * info->bitRate / info->frequency;
  365.                         info->maxInputSize = info->minInputSize + 1;
  366.                 }
  367.                 else {
  368.                         info->skipSize = 144 * info->bitRate / info->frequency + h->padding;
  369.                         info->minInputSize = 144 * minBitRate / info->frequency;
  370.                         info->maxInputSize = 144 * maxBitRate / info->frequency + 1;
  371.                 }
  372.                 break;
  373.         case 3://layer3
  374.                 i = (h->version == 1) ? 1 : 2;
  375.                 //info->outputSize = 1152 >> m_option.reduction;
  376.                 info->outputSize = (1152 >> m_option.reduction) / i;
  377.                 //if (info->bitRate) {
  378.                 if (!vbr) {
  379.                         info->skipSize = 0;
  380.                         info->minInputSize = 144 * info->bitRate / info->frequency / i;
  381.                         info->maxInputSize = info->minInputSize + 1;
  382.                 }
  383.                 else {
  384.                         info->skipSize = 144 * info->bitRate / info->frequency / i + h->padding;
  385.                         info->minInputSize = 144 * minBitRate / info->frequency / i;
  386.                         info->maxInputSize = 144 * maxBitRate / info->frequency / i + 1;
  387.                 }
  388.                 break;
  389.  
  390.         /*
  391.             if (h->version != 1) {
  392.                         //MPEG-2, MPEG-2.5
  393.                         info->outputSize /= 2;
  394.                         info->minInputSize /= 2;
  395.                         info->maxInputSize /= 2;
  396.                 }
  397.                 info->maxInputSize ++;
  398.                 break; */
  399.        
  400.         }
  401.  
  402.         if ((h->mode == 3) || (m_option.convert & 3))
  403.                 info->channels = 1;
  404.         else
  405.                 info->channels = 2;
  406.         if (m_option.convert & 8) {
  407.                 //not available
  408.                 info->bitsPerSample = 8;
  409.                 info->outputSize *= info->channels;
  410.         }
  411.         else {
  412.                 info->bitsPerSample = 16;
  413.                 info->outputSize *= info->channels * 2;
  414.         }
  415.         if ( decFlag == 1 ) {
  416.                 m_frequency = info->frequency;
  417.                 m_pcm_size = info->outputSize;
  418.         }
  419.         info->frequency >>= m_option.reduction;
  420.         if (vbr) info->bitRate = 0;
  421.  
  422.         return 1;
  423. }
  424.  
  425. void sbt_init();
  426.  
  427. int mp3DecodeStart(byte* mpeg, int size)
  428. {
  429.         MPEG_DECODE_INFO info;
  430.         MPEG_HEADER* h = &info.header;
  431.  
  432.         if (!mp3GetDecodeInfo(mpeg, size, &info, 1)) {
  433.                 return 0;
  434.         }
  435.         sbt_init();
  436.         switch (h->layer) {
  437.         case 1:
  438.                 L1decode_start(h);
  439.                 m_frame_proc = L1decode_frame;
  440.                 break;
  441.         case 2:
  442.                 L2decode_start(h);
  443.                 m_frame_proc = L2decode_frame;
  444.                 break;
  445.         case 3:
  446.                 L3decode_start(h);
  447.                 m_frame_proc = L3decode_frame;
  448.                 break;
  449.         }
  450.         return 1;
  451. }
  452.  
  453. int mp3DecodeFrame(MPEG_DECODE_PARAM* param)
  454. {
  455.         MPEG_HEADER* h = &param->header;
  456.  
  457.         if (param->inputSize <= 4) {
  458.                 m_last_error = MP3_ERROR_OUT_OF_BUFFER;
  459.                 return 0;
  460.         }
  461.         if (!mp3GetHeader(param->inputBuf, h)) {
  462.                 return 0;
  463.         }
  464.  
  465.         param->bitRate = br_tbl[h->version-1][h->layer-1][h->br_index] * 1000;
  466.         switch (h->layer) {
  467.         case 1://layer1
  468.                 m_frame_size = (12 * param->bitRate / m_frequency + h->padding) * 4;
  469.                 break;
  470.         case 2://layer2
  471.                 m_frame_size = 144 * param->bitRate / m_frequency + h->padding;
  472.                 break;
  473.         case 3://layer3
  474.                 if (h->version == 1) m_frame_size = 144 * param->bitRate / m_frequency + h->padding;
  475.                 else m_frame_size = (144 * param->bitRate / m_frequency) / 2 + h->padding;
  476.                 break;
  477.         }
  478.         if (param->inputSize < m_frame_size) {
  479.                 m_last_error = MP3_ERROR_OUT_OF_BUFFER;
  480.                 return 0;
  481.         }
  482.  
  483.         m_frame_proc(h, param->inputBuf, param->outputBuf);
  484.         param->inputSize = m_frame_size;
  485.         param->outputSize = m_pcm_size;
  486.         return 1;
  487. }
  488.  
  489. void null_frame_proc(MPEG_HEADER* h, byte* mpeg, byte* pcm) {}
  490. void L3decode_reset();
  491.  
  492. void mp3MuteStart(MPEG_DECODE_PARAM* param)
  493. {
  494.         m_frame_proc = null_frame_proc;
  495. }
  496.  
  497. void mp3MuteEnd(MPEG_DECODE_PARAM* param)
  498. {
  499.         MPEG_HEADER* h = &param->header;
  500.  
  501.         switch (h->layer) {
  502.         case 1:
  503.                 m_frame_proc = L1decode_frame;
  504.                 break;
  505.         case 2:
  506.                 m_frame_proc = L2decode_frame;
  507.                 break;
  508.         case 3:
  509.                 L3decode_reset();
  510.                 m_frame_proc = L3decode_frame;
  511.                 break;
  512.         }
  513. }
  514.