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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
CPI_Player_CoDec_MPEG.c
资源名称：Visual C++视频音频开发实用工程案例精选.rar　[点击查看]
上传用户：tuheem
上传日期：2007-05-01
资源大小：21889k
文件大小：17k
源码类别：

多媒体编程

开发平台：

Visual C++

CPI_Player_CoDec_MPEG.c：源码内容
  1. /*
  2.  * MPEG 音频解码 (using MAD)
  3.  */
  4. #include "stdafx.h"
  5. #include "globals.h"
  6. #include "CPI_Player_CoDec.h"
  7. #include "libmad/mad.h"
  8. // #include "mmsystem.h"
  9. #include "CPI_Stream.h"
  10. #include "CPI_ID3.h"
  11. #pragma comment(lib, "winmm.lib")
  13. # define SAMPLE_DEPTH 16
  14. # define scale(x, y) dither((x), (y))
  16. struct xing {
  17.     long flags;
  18.     unsigned long frames;
  19.     unsigned long bytes;
  20.     unsigned char toc[100];
  21.     long scale;
  22. };
  24. enum {
  25.     XING_FRAMES = 0x00000001L,
  26.     XING_BYTES  = 0x00000002L,
  27.     XING_TOC    = 0x00000004L,
  28.     XING_SCALE  = 0x00000008L
  29. };
  31. # define XING_MAGIC (('X' << 24) | ('i' << 16) | ('n' << 8) | 'g')
  33. struct dither {
  34.     mad_fixed_t error[3];
  35.     mad_fixed_t random;
  36. };
  38. typedef struct {
  39.     CPs_InStream* m_pInStream;
  41.     unsigned long size;
  43.     CPs_CoDecOptions options;
  45.     struct xing xing;
  47.     struct mad_stream stream;
  48.     struct mad_frame frame;
  49.     struct mad_synth synth;
  51.     unsigned int samplecount;
  53.     mad_timer_t timer;
  54.     mad_timer_t length;
  55.     unsigned long rate;
  56.     unsigned long frames;
  58.     CPs_FileInfo info;
  60.     unsigned char buffer[40000];
  61.     unsigned int buflen;
  62. } CPs_CoDec_MPEG;
  65. static
  66. int parse_xing(struct xing *xing, struct mad_bitptr ptr, unsigned int bitlen)
  67. {
  68.     if (bitlen < 64 || mad_bit_read(&ptr, 32) != XING_MAGIC)
  69.         goto fail;
  71.     xing->flags = mad_bit_read(&ptr, 32);
  72.     bitlen -= 64;
  74.     if (xing->flags & XING_FRAMES) {
  75.         if (bitlen < 32)
  76.             goto fail;
  78.         xing->frames = mad_bit_read(&ptr, 32);
  79.         bitlen -= 32;
  80.     }
  82.     if (xing->flags & XING_BYTES) {
  83.         if (bitlen < 32)
  84.             goto fail;
  86.         xing->bytes = mad_bit_read(&ptr, 32);
  87.         bitlen -= 32;
  88.     }
  90.     if (xing->flags & XING_TOC) {
  91.         int i;
  93.         if (bitlen < 800)
  94.             goto fail;
  96.         for (i = 0; i < 100; ++i)
  97.             xing->toc[i] = (unsigned char) mad_bit_read(&ptr, 8);
  99.         bitlen -= 800;
  100.     }
  102.     if (xing->flags & XING_SCALE) {
  103.         if (bitlen < 32)
  104.             goto fail;
  106.         xing->scale = mad_bit_read(&ptr, 32);
  107.         bitlen -= 32;
  108.     }
  110.     return 0;
  112. fail:
  113.     xing->flags = 0;
  114.     return -1;
  115. }
  118. static
  119. int scan_header(CPs_InStream* pInStream, struct mad_header *header, struct xing *xing)
  120. {
  121.     struct mad_stream stream;
  122.     struct mad_frame frame;
  123.     unsigned char buffer[8192];
  124.     unsigned int buflen = 0;
  125.     int count = 0, result = 0;
  127.     mad_stream_init(&stream);
  128.     mad_frame_init(&frame);
  130.     if (xing)
  131.         xing->flags = 0;
  133.     while (1) {
  134.         if (buflen < sizeof(buffer)) {
  135.             DWORD bytes;
  137.             if(pInStream->Read(pInStream, buffer + buflen, sizeof(buffer) - buflen, &bytes) == FALSE
  138.                     || bytes == 0)
  139.             {
  140.                 result = -1;
  141.                 break;
  142.             }
  144.             buflen += bytes;
  145.         }
  147.         mad_stream_buffer(&stream, buffer, buflen);
  149.         while (1) {
  150.             if (mad_frame_decode(&frame, &stream) == -1) {
  151.                 if (!MAD_RECOVERABLE(stream.error))
  152.                     break;
  154.                 continue;
  155.             }
  157.             if (count++ ||
  158.                     (xing && parse_xing(xing, stream.anc_ptr,
  159.                                         stream.anc_bitlen) == 0))
  160.                 break;
  161.         }
  163.         if (count || stream.error != MAD_ERROR_BUFLEN)
  164.             break;
  166.         memmove(buffer, stream.next_frame,
  167.                 buflen = &buffer[buflen] - stream.next_frame);
  168.     }
  170.     if (count) {
  171.         if (header)
  172.             *header = frame.header;
  173.     }
  174.     else
  175.         result = -1;
  177.     mad_frame_finish(&frame);
  178.     mad_stream_finish(&stream);
  180.     return result;
  181. }
  185. static __inline
  186. unsigned long prng(unsigned long state)
  187. {
  188.     return (state * 0x0019660dL + 0x3c6ef35fL) & 0xffffffffL;
  189. }
  192. static __inline
  193. signed int dither(mad_fixed_t sample, struct dither *dither)
  194. {
  195.     unsigned int scalebits;
  196.     mad_fixed_t output, mask, random;
  198.     enum {
  199.         MIN = -MAD_F_ONE,
  200.         MAX =  MAD_F_ONE - 1
  201.     };
  203.     sample += dither->error[0] - dither->error[1] + dither->error[2];
  205.     dither->error[2] = dither->error[1];
  206.     dither->error[1] = dither->error[0] / 2;
  208.     output = sample + (1L << (MAD_F_FRACBITS + 1 - SAMPLE_DEPTH - 1));
  210.     scalebits = MAD_F_FRACBITS + 1 - SAMPLE_DEPTH;
  211.     mask = (1L << scalebits) - 1;
  213.     random  = prng(dither->random);
  214.     output += (random & mask) - (dither->random & mask);
  216.     dither->random = random;
  218.     if (output > MAX) {
  219.         output = MAX;
  221.         if (sample > MAX)
  222.             sample = MAX;
  223.     }
  224.     else if (output < MIN) {
  225.         output = MIN;
  227.         if (sample < MIN)
  228.             sample = MIN;
  229.     }
  231.     output &= ~mask;
  233.     dither->error[0] = sample - output;
  235.     return output >> scalebits;
  236. }
  239. static
  240. void pack_pcm(unsigned char **pcm, unsigned int nsamples,
  241.               mad_fixed_t const *ch1, mad_fixed_t const *ch2)
  242. {
  243.     register signed int s0, s1;
  244.     static struct dither d0, d1;
  246.     if (ch2) {  /* stereo */
  247.         while (nsamples--) {
  248.             s0 = scale(*ch1++, &d0);
  249.             s1 = scale(*ch2++, &d1);
  250. # if SAMPLE_DEPTH == 16
  251.             (*pcm)[0 + 0] = s0 >> 0;
  252.             (*pcm)[0 + 1] = s0 >> 8;
  253.             (*pcm)[2 + 0] = s1 >> 0;
  254.             (*pcm)[2 + 1] = s1 >> 8;
  256.             *pcm += 2 * 2;
  257. # elif SAMPLE_DEPTH == 8
  258.             (*pcm)[0] = s0 ^ 0x80;
  259.             (*pcm)[1] = s1 ^ 0x80;
  261.             *pcm += 2;
  262. # else
  263. #  error "bad SAMPLE_DEPTH"
  264. # endif
  265.         }
  266.     }
  267.     else {  /* mono */
  268.         while (nsamples--) {
  269.             s0 = scale(*ch1++, &d0);
  271. # if SAMPLE_DEPTH == 16
  272.             (*pcm)[0] = s0 >> 0;
  273.             (*pcm)[1] = s0 >> 8;
  275.             *pcm += 2;
  276. # elif SAMPLE_DEPTH == 8
  277.             *(*pcm)++ = s0 ^ 0x80;
  278. # endif
  279.         }
  280.     }
  281. }
  284. static void cleanup(CPs_CoDec_MPEG *context)
  285. {
  286.     if(context->m_pInStream)
  287.     {
  288.         context->m_pInStream->Uninitialise(context->m_pInStream);
  289.         context->m_pInStream = NULL;
  291.         mad_synth_finish(&context->synth);
  292.         mad_frame_finish(&context->frame);
  293.         mad_stream_finish(&context->stream);
  294.     }
  295. }
  297. void CPP_OMMP3_Uninitialise(CPs_CoDecModule* pModule);
  298. BOOL CPP_OMMP3_OpenFile(CPs_CoDecModule* pModule, const char* pcFilename, DWORD dwCookie, HWND hWndOwner);
  299. void CPP_OMMP3_CloseFile(CPs_CoDecModule* pModule);
  300. void CPP_OMMP3_Seek(CPs_CoDecModule* pModule, const int iNumerator, const int iDenominator);
  301. void CPP_OMMP3_GetFileInfo(CPs_CoDecModule* pModule, CPs_FileInfo* pInfo);
  302. //
  303. BOOL CPP_OMMP3_GetPCMBlock(CPs_CoDecModule* pModule, void* pBlock, DWORD* pdwBlockSize);
  304. int CPP_OMMP3_GetCurrentPos_secs(CPs_CoDecModule* pModule);
  305. //
  306. void CP_InitialiseCodec_MPEG(CPs_CoDecModule* pCoDec)
  307. {
  308.     CPs_CoDec_MPEG *pContext;
  310.     pCoDec->Uninitialise = CPP_OMMP3_Uninitialise;
  311.     pCoDec->OpenFile = CPP_OMMP3_OpenFile;
  312.     pCoDec->CloseFile = CPP_OMMP3_CloseFile;
  313.     pCoDec->Seek = CPP_OMMP3_Seek;
  314.     pCoDec->GetFileInfo = CPP_OMMP3_GetFileInfo;
  316.     pCoDec->GetPCMBlock = CPP_OMMP3_GetPCMBlock;
  317.     pCoDec->GetCurrentPos_secs = CPP_OMMP3_GetCurrentPos_secs;
  319.     pCoDec->m_pModuleCookie = malloc(sizeof(CPs_CoDec_MPEG));
  320.     pContext = (CPs_CoDec_MPEG*)pCoDec->m_pModuleCookie;
  321.     pContext->m_pInStream = NULL;
  322.     pContext->size = 0;
  324.     pContext->options.m_iPretendOption = 42;
  326.     pContext->xing.flags = 0;
  328.     pContext->samplecount = 0;
  330.     pContext->timer  = mad_timer_zero;
  331.     pContext->length = mad_timer_zero;
  332.     pContext->rate   = 0;
  333.     pContext->frames = 0;
  335.     pContext->info.m_iFileLength_Secs = 0;
  336.     pContext->info.m_iBitRate_Kbs     = 0;
  337.     pContext->info.m_iFreq_Hz         = 0;
  338.     pContext->info.m_bStereo          = TRUE;
  339.     pContext->info.m_b16bit           = (SAMPLE_DEPTH == 16);
  341.     pContext->buflen = 0;
  343.     CPFA_InitialiseFileAssociations(pCoDec);
  344.     CPFA_AddFileAssociation(pCoDec, "MP3", 0L);
  345.     CPFA_AddFileAssociation(pCoDec, "MP2", 0L);
  346.     CPFA_AddFileAssociation(pCoDec, "MP1", 0L);
  347. }
  351. void CPP_OMMP3_Uninitialise(CPs_CoDecModule* pModule)
  352. {
  353.     CPs_CoDec_MPEG *context = (CPs_CoDec_MPEG *)pModule->m_pModuleCookie;
  354.     CP_CHECKOBJECT(context);
  356.     cleanup(context);
  358.     free(context);
  360.     CPFA_EmptyFileAssociations(pModule);
  361. }
  364. BOOL CPP_OMMP3_OpenFile(CPs_CoDecModule* pModule, char const *path, DWORD dwCookie, HWND hWndOwner)
  365. {
  366.     CPs_CoDec_MPEG *context = (CPs_CoDec_MPEG *)pModule->m_pModuleCookie;
  367.     int iStreamStart = 0;
  369.     CP_CHECKOBJECT(context);
  371.     cleanup(context);
  373.     CP_TRACE1("CPI_CoDec__OpenFile: "%s"", path);
  375.     context->m_pInStream = CP_CreateInStream(path, hWndOwner);
  376.     if(!context->m_pInStream)
  377.     {
  378.         CP_TRACE0("CPI_CoDec__OpenFile: failed");
  379.         return FALSE;
  380.     }
  382.     if(context->m_pInStream->IsSeekable(context->m_pInStream) == TRUE)
  383.     {
  384.         CIs_ID3v2Tag tag;
  385.         unsigned int iBytesRead;
  387.         memset(&tag, 0, sizeof(tag));
  388.         context->m_pInStream->Read(context->m_pInStream, &tag, sizeof(tag), &iBytesRead);
  390.         if(memcmp(tag.m_cTAG, "ID3", 3) == 0)
  391.         {
  392.             iStreamStart = sizeof(CIs_ID3v2Tag);
  393.             iStreamStart += (tag.m_cSize_Encoded[0] << 21)
  394.                             | (tag.m_cSize_Encoded[1] << 14)
  395.                             | (tag.m_cSize_Encoded[2] << 7)
  396.                             | tag.m_cSize_Encoded[3];
  397.         }
  399.         context->m_pInStream->Seek(context->m_pInStream, iStreamStart);
  400.     }
  402.     mad_stream_init(&context->stream);
  403.     mad_frame_init(&context->frame);
  404.     mad_synth_init(&context->synth);
  406.     if (scan_header(context->m_pInStream,
  407.                     &context->frame.header, &context->xing) == -1) {
  408.         CP_TRACE0("CPI_CoDec__OpenFile: failed to read file header");
  409.         cleanup(context);
  410.         return FALSE;
  411.     }
  413.     context->m_pInStream->Seek(context->m_pInStream, iStreamStart);
  415.     context->size             = context->m_pInStream->GetLength(context->m_pInStream);
  416.     context->synth.pcm.length = 0;
  417.     context->samplecount      = 0;
  418.     context->timer            = mad_timer_zero;
  420.     if (context->xing.flags & XING_FRAMES) {
  421.         context->length = context->frame.header.duration;
  422.         mad_timer_multiply(&context->length, context->xing.frames);
  423.     }
  424.     else {
  426.         mad_timer_set(&context->length, 0,
  427.                       1, context->frame.header.bitrate / 8);
  428.         mad_timer_multiply(&context->length, context->size);
  429.     }
  431.     context->rate   = 0;
  432.     context->frames = 0;
  434.     context->info.m_iFileLength_Secs =
  435.         mad_timer_count(context->length, MAD_UNITS_SECONDS);
  436.     context->info.m_iBitRate_Kbs     = context->frame.header.bitrate / 1000;
  437.     context->info.m_iFreq_Hz         = context->frame.header.samplerate;
  438.     context->info.m_bStereo          =
  439.         context->frame.header.mode == MAD_MODE_SINGLE_CHANNEL ? FALSE : TRUE;
  440.     context->info.m_b16bit           = (SAMPLE_DEPTH == 16);
  442.     context->buflen = 0;
  444.     return TRUE;
  445. }
  448. void CPP_OMMP3_CloseFile(CPs_CoDecModule* pModule)
  449. {
  450.     CPs_CoDec_MPEG *context = (CPs_CoDec_MPEG *)pModule->m_pModuleCookie;
  451.     CP_CHECKOBJECT(context);
  452.     CP_TRACE0("Close MPEG file");
  454.     cleanup(context);
  455. }
  458. void CPP_OMMP3_Seek(CPs_CoDecModule* pModule, int const numer, int const denom)
  459. {
  460.     CPs_CoDec_MPEG *context = (CPs_CoDec_MPEG *)pModule->m_pModuleCookie;
  461.     double fraction;
  462.     unsigned long position;
  464.     CP_CHECKOBJECT(context);
  465.     CP_ASSERT(context->m_pInStream);
  466.     CP_ASSERT(numer >= 0 && denom > 0);
  468.     if(context->m_pInStream->IsSeekable(context->m_pInStream) == FALSE)
  469.         return;
  471.     fraction = (double) numer / denom;
  472.     position = (unsigned long)
  473.                (mad_timer_count(context->length, MAD_UNITS_MILLISECONDS) * fraction);
  475.     mad_timer_set(&context->timer, position / 1000, position % 1000, 1000);
  477.     if (context->xing.flags & XING_TOC) {
  478.         int percent, p1, p2;
  480.         percent = (int) (fraction * 100);
  481.         p1 = (percent < 100) ? context->xing.toc[percent    ] : 0x100;
  482.         p2 = (percent <  99) ? context->xing.toc[percent + 1] : 0x100;
  484.         fraction = (p1 + (p2 - p1) * (fraction * 100 - percent)) / 0x100;
  485.     }
  487.     context->m_pInStream->Seek(context->m_pInStream, (LONG) (context->size * fraction));
  488.     if(context->m_pInStream->Read(context->m_pInStream, context->buffer, sizeof(context->buffer),&context->buflen) == FALSE)
  489.         context->buflen = 0;
  491.     mad_stream_buffer(&context->stream, context->buffer, context->buflen);
  493.     mad_frame_mute(&context->frame);
  494.     mad_synth_mute(&context->synth);
  496.     if (numer) {
  497.         int skip;
  499.         skip = 2;
  500.         do {
  501.             if (mad_frame_decode(&context->frame, &context->stream) == 0) {
  502.                 mad_timer_add(&context->timer, context->frame.header.duration);
  503.                 if (--skip == 0)
  504.                     mad_synth_frame(&context->synth, &context->frame);
  505.             }
  506.             else if (!MAD_RECOVERABLE(context->stream.error))
  507.                 break;
  508.         }
  509.         while (skip);
  510.     }
  512.     context->synth.pcm.length = 0;
  513.     context->samplecount      = 0;
  514. }
  518. BOOL CPP_OMMP3_GetPCMBlock(CPs_CoDecModule* pModule, void *block, DWORD *size)
  519. {
  520.     CPs_CoDec_MPEG *context = (CPs_CoDec_MPEG *)pModule->m_pModuleCookie;
  521.     unsigned char *samples = block;
  522.     unsigned int nsamples;
  524.     CP_CHECKOBJECT(context);
  525.     CP_ASSERT(context->m_pInStream);
  527.     nsamples = (*size / (SAMPLE_DEPTH / 8)) >>
  528.                (context->info.m_bStereo ? 1 : 0);
  529.     *size = 0;
  531.     while (nsamples) {
  532.         unsigned int count, bitrate;
  534.         count = context->synth.pcm.length - context->samplecount;
  535.         if (count > nsamples)
  536.             count = nsamples;
  538.         if (count) {
  539.             mad_fixed_t const *ch1, *ch2;
  541.             ch1 = context->synth.pcm.samples[0] + context->samplecount;
  542.             ch2 = context->synth.pcm.samples[1] + context->samplecount;
  544.             if (context->info.m_bStereo == FALSE)
  545.                 ch2 = 0;
  546.             else if (context->synth.pcm.channels == 1)
  547.                 ch2 = ch1;
  549.             pack_pcm(&samples, count, ch1, ch2);
  551.             context->samplecount += count;
  552.             nsamples             -= count;
  554.             if (nsamples == 0)
  555.                 break;
  556.         }
  558.         while (mad_frame_decode(&context->frame, &context->stream) == -1) {
  559.             DWORD bytes;
  561.             if (MAD_RECOVERABLE(context->stream.error))
  562.                 continue;
  564.             if (context->stream.next_frame) {
  565.                 memmove(context->buffer, context->stream.next_frame,
  566.                         context->buflen = context->buffer +
  567.                                           context->buflen - context->stream.next_frame);
  568.             }
  570.             if(context->m_pInStream->Read(context->m_pInStream,
  571.                                           context->buffer + context->buflen,
  572.                                           sizeof(context->buffer) - context->buflen, &bytes) == FALSE
  573.                     || bytes == 0)
  574.             {
  575.                 return FALSE;
  576.             }
  578.             mad_stream_buffer(&context->stream,
  579.                               context->buffer, context->buflen += bytes);
  580.         }
  582.         bitrate = context->frame.header.bitrate / 1000;
  584.         context->rate += bitrate;
  585.         context->frames++;
  587.         context->info.m_iBitRate_Kbs = bitrate;
  589.         mad_synth_frame(&context->synth, &context->frame);
  591.         context->samplecount = 0;
  593.         mad_timer_add(&context->timer, context->frame.header.duration);
  594.     }
  596.     *size = samples - (unsigned char *) block;
  598.     return TRUE;
  599. }
  602. void CPP_OMMP3_GetFileInfo(CPs_CoDecModule* pModule, CPs_FileInfo *info)
  603. {
  604.     CPs_CoDec_MPEG *context = (CPs_CoDec_MPEG *)pModule->m_pModuleCookie;
  606.     CP_CHECKOBJECT(context);
  608.     if (!(context->xing.flags & XING_FRAMES) && context->frames) {
  610.         mad_timer_set(&context->length, 0,
  611.                       1, (context->rate / context->frames) * (1000 / 8));
  612.         mad_timer_multiply(&context->length, context->size);
  614.         if (mad_timer_compare(context->timer, context->length) > 0)
  615.         {
  616.             context->length = context->timer;
  617.             context->size   = context->m_pInStream->GetLength(context->m_pInStream);
  618.         }
  620.         context->info.m_iFileLength_Secs =
  621.             mad_timer_count(context->length, MAD_UNITS_SECONDS);
  622.     }
  624.     *info = context->info;
  625. }
  628. int CPP_OMMP3_GetCurrentPos_secs(CPs_CoDecModule* pModule)
  629. {
  630.     CPs_CoDec_MPEG *context = (CPs_CoDec_MPEG *)pModule->m_pModuleCookie;
  632.     CP_CHECKOBJECT(context);
  634.     return mad_timer_count(context->timer, MAD_UNITS_SECONDS);
  635. }