部分源代码资料

最新推荐文章于 2024-09-17 20:00:16 发布
最新推荐文章于 2024-09-17 20:00:16 发布
阅读量3.2k 收藏 3
点赞数
分类专栏： Windows Media Format SDK编程资料 文章标签： null buffer file output stream windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rageliu/article/details/642899
版权 
//
// Wma2Mp3: A basic audio file converter that uses the Windows Media Format SDK 
// and the GPL "Lame" MPEG library to convert a Windows Media Audio file to an
// MP3.  This was quickly hacked together from all kinds of sample code from all
// kinds of places.  I take no credit for anything...  and no responsibility
// either :).
//

#include <windows.h>
#include <string.h>
#include <stdio.h>

#include <io.h>
#include <fcntl.h>
#include <sys/stat.h>

//
// The wmsdk.h header file comes with the Windows Media Format SDK.
// This code compiles with the Windows Media Format SDK v9.  It will
// probably compile fine with later versions as well.  You need
// to have installed Windows Media Player 9 or the Windows Media
// Format Runtime v9 to use this utilit.
//

#include <wmsdk.h>

//
// The BladeMP3EncDll.h header file comes with the Lame MP3 library.
// More info can be found at http://www.mp3dev.org/.
//

#include "BladeMP3EncDll.h"

BEINITSTREAM        beInitStream=NULL;
BEENCODECHUNK       beEncodeChunk=NULL;
BEDEINITSTREAM      beDeinitStream=NULL;
BECLOSESTREAM       beCloseStream=NULL;
BEVERSION           beVersion=NULL;
BEWRITEVBRHEADER    beWriteVBRHeader=NULL;
BEWRITEINFOTAG      beWriteInfoTag=NULL;

IWMSyncReader*      gpSyncReader=NULL;
INSSBuffer*         gpWmaBuffer=NULL;
PSHORT              gpBufferHead=NULL;
PSHORT              gpBufferNow=NULL;
DWORD               gdwBytesRemaining=0;
bool                gWmaDone=false;

WCHAR               g_wszSourceFileName[1024];
WCHAR               g_wszDestFileName[1024];

bool CreateAndOpenSyncReader();
void CloseSyncReader();
DWORD FillAudioBuffer( PSHORT pAudioBuffer, DWORD dwSamplesWanted );
void TransferMetadata();
HRESULT TransferSingleItem( IWMHeaderInfo *pSrc, IWMHeaderInfo *pDest, WCHAR *pwszName );



int main( int argc, char *argv[] )
{   
    HINSTANCE   hDLL            =NULL;
    FILE*       pFileIn         =NULL;
    FILE*       pFileOut        =NULL;
    BE_VERSION  Version         ={0,};
    BE_CONFIG   beConfig        ={0,};

    CHAR        strFileIn[255]  ={'0',};
    CHAR        strFileOut[255] ={'0',};

    DWORD       dwBitrate       =0;
    DWORD       dwSamples       =0;
    DWORD       dwMP3Buffer     =0;
    HBE_STREAM  hbeStream       =0;
    BE_ERR      err             =0;

    PBYTE       pMP3Buffer      =NULL;
    PSHORT      pWAVBuffer      =NULL;

    HRESULT hr = S_OK;

    CoInitialize(NULL);

    if(argc != 3)
    {
        fprintf(stderr, "Wma2Mp3: Please specify a WMA file to convert./n");
        fprintf(stderr, "Usage: %s <filename> <target bitrate in kbs>/n", argv[0] );
        return -1;
    }

    //
    // Get the bitrate and make it something useful.
    //

    dwBitrate = atoi(argv[2]);
    if( dwBitrate <= 56 ) dwBitrate = 56;
    else if( (56 < dwBitrate) && (dwBitrate <= 128) ) dwBitrate = 128;
    else if( (128 < dwBitrate) && (dwBitrate <= 256) ) dwBitrate = 256;
    else if( dwBitrate > 256 ) dwBitrate = 320;

    //
    // Set up the file names.  If there's an extention on the input
    // file, replace it with mp3.  Otherwise, just append mp3.
    //

    ZeroMemory( g_wszSourceFileName, sizeof( g_wszSourceFileName ) );
    ZeroMemory( g_wszDestFileName, sizeof( g_wszDestFileName ) );

    strcpy(strFileIn ,argv[1]);

    if( 0 == MultiByteToWideChar( CP_ACP, 0, strFileIn, (int)strlen(strFileIn) + 1,
                 g_wszSourceFileName, sizeof( g_wszSourceFileName ) / sizeof(WCHAR) ) )
    {
        return -1;
    }

    char* cCurrent = &(strFileOut[254]);
    ZeroMemory( strFileOut, sizeof( strFileOut ) );
    strcpy(strFileOut,argv[1]);
    while( *cCurrent != '.' && (cCurrent >= strFileOut) ) cCurrent--;
    if( *cCurrent == '.' ) *cCurrent = 0;
    strcat(strFileOut,".mp3");

    if( 0 == MultiByteToWideChar( CP_ACP, 0, strFileOut, (int)strlen(strFileOut) + 1,
                 g_wszDestFileName, sizeof( g_wszDestFileName ) / sizeof(WCHAR) ) )
    {
        return -1;
    }

    //
    // Load the lame_enc.dll library.
    //

    hDLL = LoadLibrary("lame_enc.dll");
    if( NULL == hDLL )
    {
        fprintf(stderr,"Error loading lame_enc.DLL - you can probably find this somewhere on the web./n");
        return -1;
    }

    beInitStream    = (BEINITSTREAM) GetProcAddress(hDLL, TEXT_BEINITSTREAM);
    beEncodeChunk   = (BEENCODECHUNK) GetProcAddress(hDLL, TEXT_BEENCODECHUNK);
    beDeinitStream  = (BEDEINITSTREAM) GetProcAddress(hDLL, TEXT_BEDEINITSTREAM);
    beCloseStream   = (BECLOSESTREAM) GetProcAddress(hDLL, TEXT_BECLOSESTREAM);
    beVersion       = (BEVERSION) GetProcAddress(hDLL, TEXT_BEVERSION);
    beWriteVBRHeader= (BEWRITEVBRHEADER) GetProcAddress(hDLL,TEXT_BEWRITEVBRHEADER);
    beWriteInfoTag  = (BEWRITEINFOTAG) GetProcAddress(hDLL,TEXT_BEWRITEINFOTAG);

    if( !beInitStream || !beEncodeChunk || !beDeinitStream || 
        !beCloseStream || !beVersion || !beWriteVBRHeader )
    {
        printf("Unable to get LAME interfaces: your lame_enc.dll is bad?/n");
        return -1;
    }

    beVersion( &Version );

    //
    // Print out an informative welcome.
    //

    printf( "Wma2Mp3 v1.0/n/n"
            "lame_enc.dll version %u.%02u (%u/%u/%u)/n"
            "lame_enc Engine %u.%02u/n"
            "lame_enc homepage at %s/n/n"
            "source file: %s/n"
            "dest file: %s/n"
            "bitrate: %d kbs/n/n",  
            Version.byDLLMajorVersion, Version.byDLLMinorVersion,
            Version.byDay, Version.byMonth, Version.wYear,
            Version.byMajorVersion, Version.byMinorVersion,
            Version.zHomepage,
            strFileIn,
            strFileOut,
            dwBitrate );
    
    if( !CreateAndOpenSyncReader() )
    {
        fprintf( stderr, "Error opening input file %s", argv[1] );
        return -1;
    }

    //
    // Open the output MP3 file.
    //

    pFileOut= fopen(strFileOut,"wb+");
    if(pFileOut == NULL)
    {
        fprintf( stderr, "Error creating output file %s/n", strFileOut );
        return -1;
    }

    //
    // Configure the LAME encoder the to do the conversion.
    //

    memset(&beConfig,0,sizeof(beConfig));

    beConfig.dwConfig = BE_CONFIG_LAME;

    beConfig.format.LHV1.dwStructVersion    = 1;
    beConfig.format.LHV1.dwStructSize       = sizeof(beConfig);     
    beConfig.format.LHV1.dwSampleRate       = 44100;                // INPUT FREQUENCY
    beConfig.format.LHV1.dwReSampleRate     = 0;                    // DON'T RESAMPLE
    beConfig.format.LHV1.nMode              = BE_MP3_MODE_JSTEREO;  // OUTPUT IN STREO
    beConfig.format.LHV1.dwBitrate          = dwBitrate;            // MINIMUM BIT RATE
    beConfig.format.LHV1.nPreset            = LQP_VERYHIGH_QUALITY; // QUALITY PRESET SETTING
    beConfig.format.LHV1.dwMpegVersion      = MPEG1;                // MPEG VERSION (I or II)
    beConfig.format.LHV1.dwPsyModel         = 0;                    // USE DEFAULT PSYCHOACOUSTIC MODEL 
    beConfig.format.LHV1.dwEmphasis         = 0;                    // NO EMPHASIS TURNED ON
    beConfig.format.LHV1.bOriginal          = TRUE;                 // SET ORIGINAL FLAG
    beConfig.format.LHV1.bWriteVBRHeader    = TRUE;                 // Write INFO tag
    beConfig.format.LHV1.bNoRes             = TRUE;                 // No Bit resorvoir
    beConfig.format.LHV1.bCRC               = TRUE;                 // INSERT CRC

    //  Other possibilities?
    //  beConfig.format.LHV1.dwMaxBitrate       = 320;                  // MAXIMUM BIT RATE
    //  beConfig.format.LHV1.bCopyright         = TRUE;                 // SET COPYRIGHT FLAG   
    //  beConfig.format.LHV1.bPrivate           = TRUE;                 // SET PRIVATE FLAG
    //  beConfig.format.LHV1.bWriteVBRHeader    = TRUE;                 // YES, WRITE THE XING VBR HEADER
    //  beConfig.format.LHV1.bEnableVBR         = TRUE;                 // USE VBR
    //  beConfig.format.LHV1.nVBRQuality        = 5;                    // SET VBR QUALITY

    err = beInitStream(&beConfig, &dwSamples, &dwMP3Buffer, &hbeStream);
    if(err != BE_ERR_SUCCESSFUL)
    {
        fprintf(stderr,"Error opening encoding stream (%lu)/n", err);
        return -1;
    }

    //
    // Allocate the work buffers and do the conversion.
    //

    pMP3Buffer = new BYTE[dwMP3Buffer];
    pWAVBuffer = new SHORT[dwSamples];
    if( !pMP3Buffer || !pWAVBuffer )
    {
        printf("Out of memory/n");
        return -1;
    }

    DWORD dwRead=0;
    DWORD dwWrite=0;
    DWORD dwDone=0;

    DWORD dwClick = 80;
    while ( (dwRead = FillAudioBuffer( pWAVBuffer, dwSamples )) > 0 )
    {
        dwClick--;
        if( !dwClick )
        {
            printf(".");
            dwClick = 80;
        }

        err = beEncodeChunk( hbeStream, dwRead, pWAVBuffer, pMP3Buffer, &dwWrite );
        if(err != BE_ERR_SUCCESSFUL)
        {
            beCloseStream(hbeStream);
            fprintf(stderr,"beEncodeChunk() failed (%lu)/n", err);
            return -1;
        }
        
        if(fwrite(pMP3Buffer,1,dwWrite,pFileOut) != dwWrite)
        {
            fprintf(stderr,"Output file write error/n");
            return -1;
        }

        dwDone += dwRead*sizeof(SHORT);
    }
    printf("/n");
    
    //
    // Complete the stream encode and shut down.  Note that de-initializing the
    // stream may flush out a few final bytes.
    //

    err = beDeinitStream(hbeStream, pMP3Buffer, &dwWrite);
    if(err != BE_ERR_SUCCESSFUL)
    {

        beCloseStream(hbeStream);
        fprintf(stderr,"beExitStream failed (%lu)/n", err);
        return -1;
    }

    if( dwWrite )
    {
        if( fwrite( pMP3Buffer, 1, dwWrite, pFileOut ) != dwWrite )
        {
            fprintf(stderr,"Output file write error/n");
            return -1;
        }
    }

    beCloseStream( hbeStream );

    delete [] pWAVBuffer;
    delete [] pMP3Buffer;
    fclose( pFileOut );

    if ( beWriteInfoTag )
    {
        beWriteInfoTag( hbeStream, strFileOut );
    }
    else
    {
        beWriteVBRHeader( strFileOut );
    }

    CloseSyncReader();
    TransferMetadata();
    return 0;
}



bool
CreateAndOpenSyncReader(void)
{
    HRESULT hr = S_OK;

    //
    // Create a sync reader object and open the file.
    // We just assume we're going to have only a single ASF stream, 
    // and that it's an audio stream.  This could be smarter,
    // of course...
    //

    hr = WMCreateSyncReader( NULL, 0, &gpSyncReader );
    if( (S_OK != hr) || !gpSyncReader )
    {
        hr = E_UNEXPECTED;
        goto CleanExit;
    }
    
    hr = gpSyncReader->Open( g_wszSourceFileName );
    if( S_OK != hr )
    {
        hr = E_UNEXPECTED;
        goto CleanExit;
    }
    
    IWMOutputMediaProps *pProps = NULL;
    hr = gpSyncReader->GetOutputFormat( 0, 0, &pProps );
    if( (S_OK != hr) || !pProps )
    {
        hr = E_UNEXPECTED;
        goto CleanExit;
    }

    BYTE rgMediaProps[2048];
    DWORD dwMediaType = 2048;
    ZeroMemory( rgMediaProps, sizeof( rgMediaProps ) );
    WM_MEDIA_TYPE *pMT = (WM_MEDIA_TYPE*)rgMediaProps;

    hr = pProps->GetMediaType( pMT, &dwMediaType );
    if( S_OK != hr )
    {
        hr = E_UNEXPECTED;
        goto CleanExit;
    }

    //
    // Validate the wave format.  Should we try and set the output
    // format if it's not what we're expecting?  After all, the format
    // SDK is capable of resampling both the sample rate and the
    // bit depth if necessary.
    //

    WAVEFORMATEX *pWfEx = (WAVEFORMATEX*)pMT->pbFormat;
    
    if( (pWfEx->wFormatTag != WAVE_FORMAT_PCM) ||
        (pWfEx->nChannels != 2) ||
        (pWfEx->nSamplesPerSec != 44100) ||
        (pWfEx->wBitsPerSample != 16) )
    {
        hr = E_UNEXPECTED;
        goto CleanExit;
    }

    DWORD dwMaxSampleSize = 0;
    hr = gpSyncReader->GetMaxOutputSampleSize( 0, &dwMaxSampleSize );
    if( S_OK != hr )
    {
        hr = E_UNEXPECTED;
        goto CleanExit;
    }

CleanExit:

    if( pProps ) pProps->Release();

    if( S_OK != hr )
    {
        if( gpSyncReader ) gpSyncReader->Release();      
        return( false );
    }

    return( true );
}



DWORD
FillAudioBuffer(
    PSHORT pAudioBuffer,
    DWORD dwSamplesWanted )
{
    HRESULT hr = S_OK;
    DWORD dwBytesRemaining = dwSamplesWanted*sizeof(SHORT);
    PSHORT pCurrentSample = pAudioBuffer;
    DWORD dwSamplesWritten = 0;

    if( gWmaDone ) return( 0 );

    while( dwBytesRemaining )
    {
        //
        // If we've consumed the sample we're currently working on,
        // or if this is the first time around, grab the next sample.
        //
             
        if( !gdwBytesRemaining || !gpWmaBuffer )
        {
            QWORD qwSampleTime = 0;
            QWORD qwDuration = 0;
            DWORD dwFlags = 0;
            DWORD dwOutputNum = 0;
            WORD wStream = 0;

            if( gpWmaBuffer ) 
                gpWmaBuffer->Release();

            hr = gpSyncReader->GetNextSample( 0, &gpWmaBuffer, &qwSampleTime, &qwDuration,
                                              &dwFlags, &dwOutputNum, &wStream );
            if( (S_OK != hr) || !gpWmaBuffer )
            {
                if( NS_E_NO_MORE_SAMPLES == hr )
                {
                    gWmaDone = true;
                }
                else
                {
                    hr = E_UNEXPECTED;
                }

                goto CleanExit;
            }

            hr = gpWmaBuffer->GetBufferAndLength( (BYTE**)&gpBufferHead, &gdwBytesRemaining );
            if( S_OK != hr )
            {
                hr = E_UNEXPECTED;
                goto CleanExit;
            }
            gpBufferNow = gpBufferHead;
        }
        
        //
        // There are samples available so process them.
        //

        DWORD dwInputBytesReady = gdwBytesRemaining;
        if( dwInputBytesReady > dwBytesRemaining )
        {
            dwInputBytesReady = dwBytesRemaining;
        }

        memcpy( (BYTE*)pCurrentSample, (BYTE*)gpBufferNow, dwInputBytesReady );
        dwBytesRemaining -= dwInputBytesReady;
        gdwBytesRemaining -= dwInputBytesReady;
        gpBufferNow += (dwInputBytesReady/sizeof(SHORT));
        pCurrentSample += (dwInputBytesReady/sizeof(SHORT));
        dwSamplesWritten += (dwInputBytesReady/sizeof(SHORT));
    }    

CleanExit:

    return( dwSamplesWritten );
}



void
CloseSyncReader()
{
    if( gpSyncReader )
    {
        gpSyncReader->Close();
        gpSyncReader->Release();
    }
}



void TransferMetadata()
{
    HRESULT hr = S_OK;
    IWMMetadataEditor *pSrc = NULL;
    IWMMetadataEditor *pDest = NULL;

    IWMHeaderInfo *pHISrc = NULL;
    IWMHeaderInfo *pHIDest = NULL;
    
    do
    {
        //
        // Open the source and destination file.
        //

        hr = WMCreateEditor( &pSrc );
        if( SUCCEEDED( hr ) )
        {
            hr = pSrc->Open( g_wszSourceFileName );
            if( SUCCEEDED( hr ) )
            {
                hr = pSrc->QueryInterface( IID_IWMHeaderInfo, (void**)&pHISrc );
            }
        }


        if( FAILED( hr ) )
        {
            printf( "Failed to open source file for metadata transfer./n" );
            break;
        }

        hr = WMCreateEditor( &pDest );
        if( SUCCEEDED( hr ) )
        {
            hr = pDest->Open( g_wszDestFileName );
            if( SUCCEEDED( hr ) )
            {
                hr = pDest->QueryInterface( IID_IWMHeaderInfo, (void**)&pHIDest );
            }
        }

        if( FAILED( hr ) )
        {
            printf( "Failed to open destination file for metadata transfer./n" );
            break;
        }

        //
        // Migrate over the metadata items that the portable player can display.
        //

        TransferSingleItem( pHISrc, pHIDest, (WCHAR*)g_wszWMTitle );
        TransferSingleItem( pHISrc, pHIDest, (WCHAR*)g_wszWMAuthor );
        TransferSingleItem( pHISrc, pHIDest, (WCHAR*)g_wszWMDescription );
        TransferSingleItem( pHISrc, pHIDest, (WCHAR*)g_wszWMAlbumTitle );
        TransferSingleItem( pHISrc, pHIDest, (WCHAR*)g_wszWMTrack );
        TransferSingleItem( pHISrc, pHIDest, (WCHAR*)g_wszWMTrackNumber );

    }
    while( FALSE );

    if( pSrc )
    { 
        pSrc->Close();
        pSrc->Release();
    }

    if( pDest )
    {
        pDest->Flush();
        pDest->Close();
        pDest->Release();
    }

    return;
}



HRESULT TransferSingleItem( IWMHeaderInfo *pSrc, IWMHeaderInfo *pDest, WCHAR *pwszName )
{
    HRESULT hr = S_OK;

    WORD wStream = -1;
    WMT_ATTR_DATATYPE wmType = WMT_TYPE_STRING;
    BYTE rgData[2048];
    WORD wLen = 2048;

    hr = pSrc->GetAttributeByName( &wStream,
                                   pwszName,
                                   &wmType,
                                   rgData,
                                   &wLen );
    if( SUCCEEDED( hr ) )
    {
        hr = pDest->SetAttribute( wStream,
                                  pwszName,
                                  wmType,
                                  rgData,
                                  wLen );
    }
        
    return( hr );
}
rageliu
关注
专栏目录
mysql源代码相关资料
燕窝
06-03 686
Mysql源代码分析系列(1): 编译和调试--转载 Mysql源代码方式安装
类C语言编译器设计、源码及资料汇编(一)
人世如潮人如水的博客
04-11 9603
我相信有不少的人对编译器的有很大兴趣，但是虎书(《编译原理》)上的理论知识虽然很全面很详细，但是相当的枯燥无味，让人难以下决心钻研。我就是被虎书吓坏了，各种看不懂(本人非CS专业，全靠自己啃)。。。《程序语言设计》也太厚了，后来在图书馆找书的时候，发现了一本适合入门PLT的书籍，拥有基本的C语言、操作系统和数据结构的功底就能完全看懂的书籍。这本书叫《自己动手写编译器链接器》，建议想了解PL...
Windows源代码部分公开
爱.NET
06-24 1738
Windows源代码部分公开 对于Windows的技术爱好者，以及基于Windows平台的研究人员来说，能够探访到Windows的内核源代码无疑是一件具有里程碑意义的大好事。尽管去年就看到Microsoft有这样的计划要问世，但一直没有真正看到源代码公布出来(至少我没有看到)。不过，这一计划很快就要兑现了，Microsoft也在大步走向Open Source。 我已经初窥到这一代码包，...
银行管理系统源代码资料
06-09
本压缩包包含的“银行管理系统源代码资料”是理解此类系统开发的重要资源，通过分析源代码，可以学习到软件工程在金融领域的应用。 一、系统架构与设计 银行管理系统的架构通常采用三层架构：表现层（用户界面）、...
家庭多媒体播放器源代码资料
06-07
在IT领域，家庭多媒体播放器源代码资料是一个重要的学习资源，尤其对于软件开发者和电子娱乐系统爱好者来说。这些源代码通常包含了实现多媒体播放功能的各种技术和算法，有助于理解多媒体处理、视频解码、音频渲染等...
Mybatis部分【第1天相关资料及源代码】
05-14
本资源包包含了Mybatis学习的第1天相关资料及源代码，是初学者快速入门和理解Mybatis的宝贵资料。 1. **Mybatis概述**：Mybatis是由Apache基金会维护的轻量级框架，它的核心是基于XML或注解的SQL映射文件，将SQL...
25个经典网站源代码
06-09
5. 前端框架：部分源代码可能基于流行的前端框架，如Bootstrap、Angular或React，这可以帮助开发者快速构建界面，同时保持代码的整洁和可维护性。 6. 数据交互：网站可能使用AJAX（异步JavaScript和XML）与服务器...
平衡小车全部资料带源代码
01-20
这个主题包含的“平衡小车全部资料带源代码”提供了制作平衡小车的完整资源，包括源代码和电路原理图，对于学习者来说是一份宝贵的实践资料。 首先，我们需要了解平衡小车的核心原理。平衡小车的工作依赖于陀螺仪和...
vs2010音频文件压缩 调用lame_enc.dll将WAV格式转换成MP3
weixin_30457065的博客
05-27 453
/* //My_lame.h */ #pragma once#include "stdafx.h"#include <windows.h>#include <stdio.h>#include <stdlib.h>#include <string>#include "BladeMP3EncDLL.h"class My_lame{public: M...
实时录音&实时MP3压缩组件源码
被遗忘的遐想空间
07-06 937
unit Lame_Enc; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls; const BE_CONFIG_MP3 = 0; BE_CONFIG_LAME = 256; type THBESTREAM = ULONG; PHBESTREAM = ^
java 视频处理 mencoder
旺仔专栏
07-26 6665
本系列文章导航Windows下FFmpeg快速入门ffmpeg参数解释mencoder和ffmpeg参数详解（Java处理视频）Java 生成视频缩略图(ffmpeg)使用ffmpeg进行视频文件转换成FLV整理java 视频处理 mencoderjava 视频处理 ffmped+mencoder Mencoder是Mplayer自带的编码工具（Mplayer是
Windows 10 源码一览！
热门推荐
程序员之家
04-22 1万+
链接：https://www.quora.com/Which-programming-language-is-used-for-making-Windows-10/ans...
mp3编码--PCM转MP3，PCM编码为MP3，如何实现多路同时MP3编码-VC,MFC实现---QQ35744025
xjb2006的专栏
10-31 1791
看你又猴急了 别急，先来张图片暖暖身 看惯了美女图片 这次来张萌娃 前面一篇文章，实现了mp3解码，经测试也具备多路同时解码的能力。 在这之前，本人一直用的是BladeMP3EncDLL的动态库进行编码，其实也没什么问题，就是不能进行多线程编码。。。 __declspec(dllexport) BE_ERR beInitStream(PBE_CONFIG pbeConf
c/c++ 网络资源
^_^纯一狼^o^
05-27 2120
作者：xyzboard.com原地址：http://xyzboard.com/?q=node/102我是一个C/C++开发者，我收集的代码相关网站也是以C/C++为主的，这都是我在开发过程中查找资料时用到或发现的一些网站。现在我把它们列出来，希望对大家有帮助，也希望能够与大家多多交流代码相关的网上资源。所以我在此抛砖了:)另外声明一下，那些要收费的源码网站，特别是国内的，绝不收录。因为它们的代
VB 常用代码
TJT999
03-04 2959
1. 打开文件对话框工程-->部件-->Microsoft Common Dialog Control 6.0 2.回车换行符 vbCrLf 是VB回车换行符 chr(10) & chr(13) 用 vbCrLf 会空出一行，用chr(13)就正好 3. 正则表达式
数据类型自动转换的解决方案
最新发布
qq_41623592的博客
09-17 634
为方便测试框架数据处理以及方便查看一些数据，弄了一个工具类，部分要点简要说明。
springboot从分层到解耦
不起眼小菜菜的博客
09-13 615
注释很详细，直接上代码……
深入探索Linux内核源代码
"这份资料主要讲解了Linux内核源代码，涵盖了操作系统的基本概念、I386系统的基础知识，以及源码阅读和项目环境的设置。内容包括Linux内核的功能、I386系统的代码运行、堆栈、内核态与用户态、中断/异常/系统调用和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值