灵魂守卫

存档

‘Win32’ 分类的存档

OBS的插件-画板实现（基于Qt)

2023年8月28日 niesongsong 评论已被关闭

简介

OBS基于OpenGL和D3D11实现了一个通用的图形库，可以利用这个图形库来实现简单的画板，至于更复杂的画板实现的原理也是一样的。实现图如下。

原理

说明一下，因为OBS自带的做图非常麻烦且无法满足要求，这里使用Qt自带的QPainter进行内存做画，然后输出RGBA像素数据。

在使用插件之前我们要对插件进行注册

static void RegisterInkCanvasSource()
{
    struct obs_source_info info = {};

    info.id = "ink_canvas_source";
    info.type = OBS_SOURCE_TYPE_INPUT;
    info.output_flags = OBS_SOURCE_ASYNC_VIDEO | 
        OBS_SOURCE_INTERACTION |
        OBS_SOURCE_DO_NOT_DUPLICATE | OBS_SOURCE_SRGB;
    ...

    info.mouse_click = [](void *data, const struct obs_mouse_event *ev,
        int32_t type, bool mouse_up, uint32_t click_count) {
        ...
    };
    info.mouse_move = [](void *data, const struct obs_mouse_event *ev,
        bool mouse_leave) {
        ...
    };

    obs_register_source(&amp;info);
}

bool obs_module_load(void)
{
    RegisterInkCanvasSource();
    return true;
}

static void RegisterInkCanvasSource()

{

struct obs_source_info info = {};

info.id = "ink_canvas_source";

info.type = OBS_SOURCE_TYPE_INPUT;

info.output_flags = OBS_SOURCE_ASYNC_VIDEO |

OBS_SOURCE_INTERACTION |

OBS_SOURCE_DO_NOT_DUPLICATE | OBS_SOURCE_SRGB;

...

info.mouse_click = [](void *data, const struct obs_mouse_event *ev,

int32_t type, bool mouse_up, uint32_t click_count) {

...

};

info.mouse_move = [](void *data, const struct obs_mouse_event *ev,

bool mouse_leave) {

...

};

obs_register_source(&info);

}

bool obs_module_load(void)

{

RegisterInkCanvasSource();

return true;

}

实现方式一：obs_source_output_video

使用异步视频源，注意插件的output_flags使用OBS_SOURCE_ASYNC_VIDEO这个标志，当画面需要更新时，使用obs_source_output_video将帧输出源中。

大致代码如下：

QPoint last = QPoint(), moved = QPoint();

void mousePress(QPoint p) 
{// 起笔
    last = p;
}

void mouseMove(QPoint p)
{// 移动绘制
    QPainter p(&amp;image);

    moved = p;

    p-&gt;drawLine(last, moved);
    updateRect(QRect(last, moved); 

    last = moved;
    moved = QPoint();
}

void mouseRelease()
{// 收笔
    last = QPoint();
    last = QPoint();
}

// 当需要更新时输出视频帧
void updateRect(QRect rt) {
    obs_source_frame frame;
    memset(&amp;frame, 0, sizeof(frame);

    frame.width = image.width();
    frame.height = image.height();
    frame.format = VIDEO_FORMAT_RGBA;

    m_frame.linesize[0] = image.width() * 4;
    m_frame.data[0] = (uint8_t *)m_backImage.constBits();

    obs_source_output_video(m_source, &amp;m_frame);
}

QPoint last = QPoint(), moved = QPoint();

void mousePress(QPoint p)

{// 起笔

last = p;

}

void mouseMove(QPoint p)

{// 移动绘制

QPainter p(&image);

moved = p;

p->drawLine(last, moved);

updateRect(QRect(last, moved);

last = moved;

moved = QPoint();

}

void mouseRelease()

{// 收笔

last = QPoint();

}

// 当需要更新时输出视频帧

void updateRect(QRect rt) {

obs_source_frame frame;

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

frame.width = image.width();

frame.height = image.height();

frame.format = VIDEO_FORMAT_RGBA;

m_frame.linesize[0] = image.width() * 4;

m_frame.data[0] = (uint8_t *)m_backImage.constBits();

obs_source_output_video(m_source, &m_frame);

}

上述代码很好地展示了绘制后立即输出到源上，但上面的代码有一定的性能问题。

问题：当鼠标事件瞬时非常多时，会出现fps过高导致CPU和内存暴涨，那么这时候，我们可以加一个定时器解决，比如我们限定最多30fps。

QTimer updateTimer;
bool timerInited = false;
QRect dirtyRect;

// 当需要更新时输出视频帧
void updateRect(QRect rt) {
    dirtyRect = dirtyRect.united(rt); // 求并集
    if (updateTimer.isActive()) {
        return;
    }

    if (!timerInited) {
        updateTimer.setSingleShot(true); // 只触发一次

        connnect(&amp;updateTimer, &amp;QTimer::timeout, this, [](){
            obs_source_frame frame;
            memset(&amp;frame, 0, sizeof(frame);

            frame.width = image.width();
            frame.height = image.height();
            frame.format = VIDEO_FORMAT_RGBA;

            m_frame.linesize[0] = image.width() * 4;
            m_frame.data[0] = (uint8_t *)m_backImage.constBits();

            obs_source_output_video(m_source, &amp;m_frame);
            dirtyRect = QRect();
        });

        timerInited = true;
    }

    updateTimer.start(33);  // 33ms
}

QTimer updateTimer;

bool timerInited = false;

QRect dirtyRect;

// 当需要更新时输出视频帧

void updateRect(QRect rt) {

dirtyRect = dirtyRect.united(rt); // 求并集

if (updateTimer.isActive()) {

return;

}

if (!timerInited) {

updateTimer.setSingleShot(true); // 只触发一次

connnect(&updateTimer, &QTimer::timeout, this, [](){

obs_source_frame frame;

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

frame.width = image.width();

frame.height = image.height();

frame.format = VIDEO_FORMAT_RGBA;

m_frame.linesize[0] = image.width() * 4;

m_frame.data[0] = (uint8_t *)m_backImage.constBits();

obs_source_output_video(m_source, &m_frame);

dirtyRect = QRect();

});

timerInited = true;

}

updateTimer.start(33); // 33ms

}

我们修改了updateRect代码，使得将更新的频率固定住，这样不管鼠标事件多么的多，我们最多只会33ms更新一次(fps=30)。

上面的代码看上去比之前还要好了，但还是有优化的空间，因为每一次更新的是局部图片，但是输出却是完整的像素，会重复拷贝内存像素数据到显存，分辨率较小时体现不出来，一是分辨率稍微大一点也会有严重的内存和CPU性能问题，此时这种方法已经无法满足要求了。

实现方式二：使用纹理

第一种方式使用了异步视频源，这种方式在需要的时候输出帧就可以了，但是有一定的性能问题，那么可以可以使用纹理贴图的方法。如果要使用纹理贴图我们首先要指定插件的渲染回调函数。

static void RegisterInkCanvasSource()
{
    struct obs_source_info info = {};
    ....
    info.video_render = [](void *data, gs_effect_t *effect) {
        VideoRender(data,effect);
    };

    obs_register_source(&amp;info);
}

bool obs_module_load(void)
{
    RegisterInkCanvasSource();
    return true;
}

static void RegisterInkCanvasSource()

{

struct obs_source_info info = {};

....

info.video_render = [](void *data, gs_effect_t *effect) {

VideoRender(data,effect);

};

obs_register_source(&info);

}

bool obs_module_load(void)

{

RegisterInkCanvasSource();

return true;

}

接下来，我们将将内存数据贴到纹理上。

void InkCavasSource::VideoRender(gs_effect *effect)
{
    char *buffer;

    // 如果纹理为nullptr,那么进行初始化
    if (texure == nullptr) {
        obs_enter_graphics();
        buffer = (char *)m_image.constBits();
        m_texure = gs_texture_create(width, height, GS_RGBA, 1,
           (const uint8_t **)&amp;buffer, GS_DYNAMIC);
        obs_leave_graphics();
    }

    buffer = (char *)m_image.constBits();
    if (!dirtyRect.isEmpty()) {
        gs_texture_set_image(texure, (const uint8_t *)buffer, width * 4, false);
        dirtyRect = QRectF();
    }
    ....
    gs_eparam_t *const param = gs_effect_get_param_by_name(effect, "image");
    gs_effect_set_texture_srgb(param, texure);
    gs_draw_sprite(texure, 0, width, height);
    ...
}

void InkCavasSource::VideoRender(gs_effect *effect)

{

char *buffer;

// 如果纹理为nullptr,那么进行初始化

if (texure == nullptr) {

obs_enter_graphics();

buffer = (char *)m_image.constBits();

m_texure = gs_texture_create(width, height, GS_RGBA, 1,

(const uint8_t **)&buffer, GS_DYNAMIC);

obs_leave_graphics();

}

buffer = (char *)m_image.constBits();

if (!dirtyRect.isEmpty()) {

gs_texture_set_image(texure, (const uint8_t *)buffer, width * 4, false);

dirtyRect = QRectF();

}

....

gs_eparam_t *const param = gs_effect_get_param_by_name(effect, "image");

gs_effect_set_texture_srgb(param, texure);

gs_draw_sprite(texure, 0, width, height);

...

}

这样就实现了对纹理的贴图，但是上面的方法还有一个性能问题。问题在于，只要渲染就将所有像素数据拷贝到显存，显然是没有必要的。我们应该使用局部更新，在需要更新的时候将那些需要更新的像素拷贝到显卡。也就是dirtyRect那个部分。很遗憾的事OBS没有这个接口，所以我们自己实现一个。

在实现之前我们看一下全局更新的代码，gs_texture_set_image如下。

void gs_texture_set_image(gs_texture_t *tex, const uint8_t *data,
              uint32_t linesize, bool flip)
{
    ...
    if (!gs_texture_map(tex, &amp;ptr, &amp;linesize_out))
        return;
    row_copy = (linesize &lt; linesize_out) ? linesize : linesize_out;
    height = gs_texture_get_height(tex);
    if (flip) {// 是否翻转拷贝
        uint8_t *const end = ptr + height * linesize_out;
        data += (height - 1) * linesize;
        while (ptr &lt; end) {
            memcpy(ptr, data, row_copy);
            ptr += linesize_out;
            data -= linesize;
        }
    } else if (linesize == linesize_out) { // 行大小是否一样
        memcpy(ptr, data, row_copy * height);
    } else { // 按行拷贝
        uint8_t *const end = ptr + height * linesize_out;
        while (ptr &lt; end) {
            memcpy(ptr, data, row_copy);
            ptr += linesize_out;
            data += linesize;
        }
    }
    gs_texture_unmap(tex);
}

void gs_texture_set_image(gs_texture_t *tex, const uint8_t *data,

uint32_t linesize, bool flip)

{

...

if (!gs_texture_map(tex, &ptr, &linesize_out))

return;

row_copy = (linesize < linesize_out) ? linesize : linesize_out;

height = gs_texture_get_height(tex);

if (flip) {// 是否翻转拷贝

uint8_t *const end = ptr + height * linesize_out;

data += (height - 1) * linesize;

while (ptr < end) {

memcpy(ptr, data, row_copy);

ptr += linesize_out;

data -= linesize;

}

} else if (linesize == linesize_out) { // 行大小是否一样

memcpy(ptr, data, row_copy * height);

} else { // 按行拷贝

uint8_t *const end = ptr + height * linesize_out;

while (ptr < end) {

memcpy(ptr, data, row_copy);

ptr += linesize_out;

data += linesize;

}

gs_texture_unmap(tex);

}

通过观察代码，我们看到obs使用内存映射的方式进行拷贝，并且区分了是否翻转，这里我们没有这个需求，正着拷贝就可以了，所以我们就可以按照上面的方式使用局部拷贝。核心操作无非就是按行复制，需要注意整张图的行大小和局部矩形的行大小，以及起始地址的对齐。

void gs_texture_set_image(gs_texture_t *tex, const uint8_t *data, 
    uint32_t x, uint32_t y, uint32_t cx, uint32_t cy,
    uint32_t linesize)
{
    ...
    if (!gs_texture_map(tex, &amp;ptr, &amp;linesize_out))
        return;
    row_copy = (linesize &lt; linesize_out) ? linesize : linesize_out;
    height = gs_texture_get_height(tex);
    
    ptr = ptr + y * linesize_out + x * 4; //起始位置 
    uint8_t *const end = ptr + y + cy * linesize_out; // 结束位置

    while (ptr &lt; end) {
        memcpy(ptr, data, row_copy);
        ptr += linesize_out;
        data += linesize;
    }
    
    gs_texture_unmap(tex);
}

void gs_texture_set_image(gs_texture_t *tex, const uint8_t *data,

uint32_t x, uint32_t y, uint32_t cx, uint32_t cy,

uint32_t linesize)

{

...

if (!gs_texture_map(tex, &ptr, &linesize_out))

return;

row_copy = (linesize < linesize_out) ? linesize : linesize_out;

height = gs_texture_get_height(tex);

ptr = ptr + y * linesize_out + x * 4; //起始位置

uint8_t *const end = ptr + y + cy * linesize_out; // 结束位置

while (ptr < end) {

memcpy(ptr, data, row_copy);

ptr += linesize_out;

data += linesize;

}

gs_texture_unmap(tex);

}

然后在调用的时间传入dirtyRect就可以了。

void InkCavasSource::VideoRender(gs_effect *effect) 
{
    .... 
    buffer = (char *)m_image.constBits();
    if (!dirtyRect.isEmpty()) {
        int x = dirtyRect.x();
        int 
        gs_texture_set_sub_image(m_texure, (const uint8_t *)buffer,
                dirtyRect.x(), dirtyRect.y(), 
                dirtyRect.width(), dirtyRect.height(), 
                width * 4, false);
        dirtyRect = QRectF();
    }
    ....
}

void InkCavasSource::VideoRender(gs_effect *effect)

{

....

buffer = (char *)m_image.constBits();

if (!dirtyRect.isEmpty()) {

int x = dirtyRect.x();

int

gs_texture_set_sub_image(m_texure, (const uint8_t *)buffer,

dirtyRect.x(), dirtyRect.y(),

dirtyRect.width(), dirtyRect.height(),

width * 4, false);

dirtyRect = QRectF();

}

....

}

到此，所以优化就结束啦。

实现

代码整理中，即将扩充各种图形，联系nie950@gmail.com

分类: C/C++, OBS, Win32 标签:

Win32选择保存文件路径和打开文件夹的函数

2014年9月30日 admin 评论已被关闭

有时候我们需要拾取打开或者保存的路径，浏览文件夹，下面是win32的接口。

#include <shlobj.h>
#include <windows.h>

int GetOpenOrSaveFileDialog(HWND hwnd,TCHAR filename[],int maxlen)
{
    OPENFILENAME ofn;
    BOOL  rc;
    memset(&ofn,0,sizeof(ofn));

    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = hwnd;
    ofn.lpstrFile = filename;
    ofn.nMaxFile  = maxlen*sizeof(filename[0]);
    ofn.nFilterIndex = 1;
    ofn.Flags = OFN_PATHMUSTEXIST ;

    ofn.lpstrFilter = TEXT("MPG file(*.mpg)\0*.mpg\0")
                      TEXT("MP4 file(*.mpg)\0*.mp4\0");

    rc = GetSaveFileName(&ofn);  /*Save As*/
    /*   GetOpenFileName(&ofn);*//*Open*/

    return rc;
}

int GetOpenFolderDialog(HWND hwnd,TCHAR* folder)
{
    BROWSEINFO bi = {0};
    LPITEMIDLIST pIDList;
    IMalloc * imalloc = 0;

    bi.hwndOwner = hwnd;
    bi.lpszTitle = TEXT("select a folder");
    bi.ulFlags = BIF_RETURNONLYFSDIRS|BIF_EDITBOX;
    pIDList = SHBrowseForFolder(&bi);

    if(pIDList) {
        SHGetPathFromIDList(pIDList,folder);
        if (SUCCEEDED(SHGetMalloc(&imalloc))) {
            imalloc->lpVtbl->Free (imalloc,pIDList);
            imalloc->lpVtbl->Release(imalloc);
            return TRUE;
        }
    }
    return FALSE;
}

#include <shlobj.h>

#include <windows.h>

int GetOpenOrSaveFileDialog(HWND hwnd,TCHAR filename[],int maxlen)

{

OPENFILENAME ofn;

BOOL rc;

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

ofn.lStructSize = sizeof(ofn);

ofn.hwndOwner = hwnd;

ofn.lpstrFile = filename;

ofn.nMaxFile = maxlen*sizeof(filename[0]);

ofn.nFilterIndex = 1;

ofn.Flags = OFN_PATHMUSTEXIST ;

ofn.lpstrFilter = TEXT("MPG file(*.mpg)\0*.mpg\0")

TEXT("MP4 file(*.mpg)\0*.mp4\0");

rc = GetSaveFileName(&ofn); /*Save As*/

/* GetOpenFileName(&ofn);*//*Open*/

return rc;

}

int GetOpenFolderDialog(HWND hwnd,TCHAR* folder)

{

BROWSEINFO bi = {0};

LPITEMIDLIST pIDList;

IMalloc * imalloc = 0;

bi.hwndOwner = hwnd;

bi.lpszTitle = TEXT("select a folder");

bi.ulFlags = BIF_RETURNONLYFSDIRS|BIF_EDITBOX;

pIDList = SHBrowseForFolder(&bi);

if(pIDList) {

SHGetPathFromIDList(pIDList,folder);

if (SUCCEEDED(SHGetMalloc(&imalloc))) {

imalloc->lpVtbl->Free (imalloc,pIDList);

imalloc->lpVtbl->Release(imalloc);

return TRUE;

}

return FALSE;

}

MSDN：GetSaveFileName
MSDN：SHBrowseForFolder

分类: Win32 标签:

使用librtmp进行H264与AAC直播

2014年1月3日 admin 评论已被关闭

libx264版本是128
libfaac版本是1.28

1、帧的划分

1.1 H.264帧

对于H.264而言每帧的界定符为00 00 00 01或者00 00 01。

比如下面的h264文件片断这就包函三帧数据

00 00 00 01 67 42 C0 28 DA 01 E0 08 9F 96 10 00
00 03 00 10 00 00 03 01 48 F1 83 2A 00 00 00 01
68 CE 3C 80 00 00 01 06 05 FF FF 5D DC 45 E9 BD
E6 D9 48 B7 96 2C D8 20 D9 23 EE EF …

第一帧是00 00 00 01 67 42 C0 28 DA 01 E0 08 9F 96 10 00 00 03 00 10 00 00 03 01 48 F1 83 2A
第二帧是00 00 00 01 68 CE 3C 80
第三帧是00 00 01 06 05 FF FF 5D DC 45 E9 BD E6 D9 48 B7 96 2C D8 20 D9 23 EE EF ..

帧类型有：
NAL_SLICE = 1
NAL_SLICE_DPA = 2
NAL_SLICE_DPB = 3
NAL_SLICE_DPC = 4
NAL_SLICE_IDR = 5
NAL_SEI = 6
NAL_SPS = 7
NAL_PPS = 8
NAL_AUD = 9
NAL_FILLER = 12,

我们发送RTMP数据时只需要知道四种帧类型，其它类型我都把它规类成非关键帧。
分别是
NAL_SPS(7), sps帧
NAL_PPS(8), pps帧
NAL_SLICE_IDR(5), 关键帧
NAL_SLICE(1) 非关键帧

帧类型的方式判断为界面符后首字节的低四位。
第一帧的帧类型为: 0x67 & 0x1F = 7，这是一个SPS帧
第二帧的帧类型为: 0x68 & 0x1F = 8，这是一个PPS帧
第三帧的帧类型为: 0x06 & 0x1F = 6，这是一个SEI帧

以上是我们利用帧界定符划分帧，并可以判断每一个帧的类型。

注意：如果是压缩图像成H264帧，我们就可不必进行帧界定，因为每一次压缩的输出都明确了该帧的大小（包括界定符），每一次的压缩的结果可能包函多帧。一会具体讨论。

1.2 AAC帧

对于AAC帧它的界定符是FF F1

这里我就不举例了，可通过查看AAC的二进制文件可以看到如下的帧结构。
FF F1 50 80 24 9F FD DE 04 00 00 6C 69 62 66 61 61 63 20 31 2E 32 38 00 00 42 15 95 ..

注意：那么对于AAC而言加上界定符每一帧的前7字节是帧的描述信息，也就是说AAC的祼数据是除去前面的7个字节的，在发送RTMP时，我们要去掉这7个字节。同样，如果我们是一边压缩一边发送RTMP，我们同样不需要界定帧，因为libfaac每次压缩完成的输出就是一个完整的帧数据，我们只需要将该帧打包发送即可。

综合上面的所述，如果我们只是一边压缩一边将压缩结果发送到RTMP服务器，那我们就可以不用对帧进行界定，如果我们是发送H264与AAC文件，那我们就要对帧进行界定。

2.视频与音频的编码信息

如果我们只是简答的将压缩数据打包发送给RTMP服务器，那么RTMP服务器是不可以对数据进行解码和播放的，在这之前我们要将音视频的视频的编码信息发送给RTMP服务器。很多人可能苦于寻找下面的三个编码参数而不得要领。其实要想得到也是很简单的。阅读全文…

分类: C/C++, Win32 标签:

GBK编码与UTF-8之间的转化。
第一种是先将 GBK->Unicode->UTF-8;
第二种是通过iconv库，直接GBK->UTF-8;
Unicode编码包含所有字符集，而GBK（GB2312是GBK的一个子集）,UTF-8等等都称为多字节集(Multibyte)，两个多字节字符集之间的转换首先将源字符集映射到Unicode上，再将Unicode映射到目标多字节字符集上。有一个问题就是源字符集与目标字符集不可能是一一对应的，所以在转换的时候往往会有一个参数表示如果未找到对应的字符的处理情况。另外Unicode中的表示字符用wchar_t,而多字节的字符用char表示（也有多个char表示一个字符）。

windows下

static int str_utf82gbk(const char * uft8,char *gbk,int maxlen)
{
        int wlen,clen;
        wchar_t buffer[1024];

        /*utf8 to wide char*/
        wlen = MultiByteToWideChar(CP_UTF8,0,uft8,-1,NULL,0);
        if (wlen >= 1024) {
                return -1;
        }
        MultiByteToWideChar(CP_UTF8,0,uft8,-1,buffer,wlen);

        /*wide char to c string*/
        clen = WideCharToMultiByte(CP_ACP,0,buffer,wlen,NULL,0,0,0);
        if (clen >= maxlen) {
                return -2;
        }
        WideCharToMultiByte(CP_ACP,0,buffer,wlen,gbk,maxlen,0,0);
        gbk[clen] = '\0';

        return clen;
}

static int str_utf82gbk(const char * uft8,char *gbk,int maxlen)

{

int wlen,clen;

wchar_t buffer[1024];

/*utf8 to wide char*/

wlen = MultiByteToWideChar(CP_UTF8,0,uft8,-1,NULL,0);

if (wlen >= 1024) {

return -1;

}

MultiByteToWideChar(CP_UTF8,0,uft8,-1,buffer,wlen);

/*wide char to c string*/

clen = WideCharToMultiByte(CP_ACP,0,buffer,wlen,NULL,0,0,0);

if (clen >= maxlen) {

return -2;

}

WideCharToMultiByte(CP_ACP,0,buffer,wlen,gbk,maxlen,0,0);

gbk[clen] = '\0';

return clen;

}

C语言中有与WideCharToMultByte对应的接口是wctomb,MultiByteToWideChar对应的接口是mbtowc，但是对应的转化不能将正确的转换UTF-8。具体实现是先将当前语言为源字节集，将源字节集转化成Unicode，然后将语言设置成目标字节集将Unicode转化成目标字节集，具体参见：
setlocale: http://msdn.microsoft.com/en-us/library/aa272906(v=vs.60).aspx

利用第三方库实现，它就是大名鼎鼎的libiconv,有一个值得小心的地方，就是当目标字符集中没有源串中对的字符是可以选择继续还是忽略，所以及在open时会带上参数”//IGNORE”,要不然就遇到这种情况会停止转化。

static int str_utf82gbk(const char * uft8,char *gbk,int maxlen)
{
        iconv_t ic;
        int clen,last;

        ic = iconv_open("GBK//IGNORE","UTF-8");
        if (ic == (iconv_t)(-1)) {
                return -1;
        }
        clen = strlen(uft8);

        last = maxlen;
        iconv(ic,&uft8,&clen,&gbk,&maxlen);

        last -= maxlen;
        gbk[0] = '\0';

        iconv_close(ic);

        return last;
}

static int str_utf82gbk(const char * uft8,char *gbk,int maxlen)

{

iconv_t ic;

int clen,last;

ic = iconv_open("GBK//IGNORE","UTF-8");

if (ic == (iconv_t)(-1)) {

return -1;

}

clen = strlen(uft8);

last = maxlen;

iconv(ic,&uft8,&clen,&gbk,&maxlen);

last -= maxlen;

gbk[0] = '\0';

iconv_close(ic);

return last;

}

分类: C/C++, Linux, Win32 标签:

使用原子操作实现自旋锁

2013年10月14日 admin 没有评论

原子操作
在windows平台有InterlockedCompareExchange原子操作接口。实现对内存的互斥修改

LONG InterlockedCompareExchange(
    _Inout_ LONG volatile *Destination,
    _In_ LONG Exchange,
    _In_ LONG Comparand
);

LONG InterlockedCompareExchange(

_Inout_ LONG volatile *Destination,

_In_ LONG Exchange,

_In_ LONG Comparand

);

如果对函数的解释有点疑惑，可以看一下该函数的大致实现。

LONG InterlockedCompareExchange(LONG volatile *Destination,LONG Exchange,LONG Comparand)
{
    /*Lock Bus*/
    LONG old = *Destination;
    if (Comparand != Exchage) {
        *Destination = Exchage;
    }
    /*Unlock Bus*/
    return old;
}

LONG InterlockedCompareExchange(LONG volatile *Destination,LONG Exchange,LONG Comparand)

{

/*Lock Bus*/

LONG old = *Destination;

if (Comparand != Exchage) {

*Destination = Exchage;

}

/*Unlock Bus*/

return old;

}

自旋锁
如果我们所1代表“加锁”，0代表“未加锁”。加锁的过程是将内存值0改成1，所以我们可以利用这特性实现加锁操作和解锁操作。

int trylock(LONG * lock)
{
    LONG old;
    old = InterlockedCompareExchange(lock,1,0);
    if (old == 0) { /*lock ok*/
        return 1;
    }
    return 0; /*locked by others*/
}

int unlock(LONG * lock)
{
    *lock=0;
}

int trylock(LONG * lock)

{

LONG old;

old = InterlockedCompareExchange(lock,1,0);

if (old == 0) { /*lock ok*/

return 1;

}

return 0; /*locked by others*/

}

int unlock(LONG * lock)

{

*lock=0;

}

知道trylock只是尝试去将0改成1，如果之前已经是1说明，锁被占用了。所以我们实现了自旋等待锁被释放。

void lock(LONG * lock)
{
    while(trylock(lock));
}

void lock(LONG * lock)

{

while(trylock(lock));

}

更好的实现，用Sleep切换CPU。

void lock(LONG *lock)
{
    while (trylock(lock)) {
        Sleep(0);
    }
}

void lock(LONG *lock)

{

while (trylock(lock)) {

Sleep(0);

}

对于基于linux的gcc也是有相应的“比较修改”接口__sync_bool_compare_and_swap(lock, old, set)，它的参数与windows的接口有两点不一样，参数不一致，返回类型也不一样。它的trylock的实现：

int trylock(LONG * lock)
{
    return __sync_bool_compare_and_swap(lock,0,1);
}

int trylock(LONG * lock)

{

return __sync_bool_compare_and_swap(lock,0,1);

}

example

#ifdef WIN32
#define trylock(x)  (InterlockedCompareExchange((long *)x,1,0)==0)
#else
#define trylock(x)  __sync_bool_compare_and_swap((long *)x,0,1)
#endif
#define initlock(x)  ((*x)=0)
#define lock(x)  while(trylock(x))
#define unlock(x) ((*x)=0)

static int global_var;
static long glock=0;

/*thread 1*/
lock(&glock)
global_var=12;
unlock(&glock)

/*thread 2*/
lock(&glock)
global_var=13;
unlock(&glock)

#ifdef WIN32

#define trylock(x) (InterlockedCompareExchange((long *)x,1,0)==0)

#else

#define trylock(x) __sync_bool_compare_and_swap((long *)x,0,1)

#endif

#define initlock(x) ((*x)=0)

#define lock(x) while(trylock(x))

#define unlock(x) ((*x)=0)

static int global_var;

static long glock=0;

/*thread 1*/

lock(&glock)

global_var=12;

unlock(&glock)

/*thread 2*/

lock(&glock)

global_var=13;

unlock(&glock)

分类: C/C++, Linux, Win32 标签:

VirtualBox从U盘启动方法

2011年12月25日 admin 1 条评论

#进入命令行

cd C:\Program Files\Sun\xVM VirtualBox

1	cd C:\Program Files\Sun\xVM VirtualBox

#获取磁盘信息(这个最关键)

wmic /output:d:\diskdrive.html diskdrive list /format:htable

1	wmic /output:d:\diskdrive.html diskdrive list /format:htable

#打开d:/diskdrive.html ，查看DeviceID栏，获取到你的U盘DeviceID，如\\.\PHYSICALDRIVE1

#为U盘创建启动文件

VBoxManage internalcommands createrawvmdk -filename d:\UsbDisk.vmdk -rawdisk \\.\PHYSICALDRIVE1

1	VBoxManage internalcommands createrawvmdk -filename d:\UsbDisk.vmdk -rawdisk \\.\PHYSICALDRIVE1

# 添加磁盘d:\UsbDisk.vmdk, F12启动虚拟机，选择这个磁盘即可磁盘

分类: C/C++, Linux, Win32, 翻译, 计算机网络, 转载标签:

存档

OBS的插件-画板实现（基于Qt)

Win32选择保存文件路径和打开文件夹的函数

使用librtmp进行H264与AAC直播

1、帧的划分

1.1 H.264帧

1.2 AAC帧

2.视频与音频的编码信息

GBK与UTF-8之间的转化

使用原子操作实现自旋锁

VirtualBox从U盘启动方法

近期文章

分类目录

文章归档

链接表

功能