自学教程：C++ AVG_ASSERT函数代码示例

CameraInfo* FWCamera::getCameraInfos(int deviceNumber){#ifdef AVG_ENABLE_1394_2    dc1394_t* pDC1394 = dc1394_new();    if (pDC1394 == 0) {        AVG_ASSERT(false);        return NULL;    }    dc1394camera_list_t * pCameraList;    int err=dc1394_camera_enumerate(pDC1394, &pCameraList);    if (err != DC1394_SUCCESS) {        AVG_ASSERT(false);        return NULL;    }    if (pCameraList->num != 0) {        dc1394camera_id_t id = pCameraList->ids[deviceNumber];        dc1394camera_t * pCamera = dc1394_camera_new_unit(pDC1394, id.guid,                id.unit);        if (pCamera) {            stringstream deviceID;            deviceID << hex << id.guid;//pCamera->guid;            CameraInfo* camInfo = new CameraInfo("Firewire", deviceID.str());            getCameraControls(pCamera, camInfo);            getCameraImageFormats(pCamera, camInfo);            dc1394_camera_free(pCamera);            dc1394_camera_free_list(pCameraList);            dc1394_free(pDC1394);            return camInfo;        }    }#endif    return NULL;}

int TexInfo::getGLInternalFormat() const{    switch (m_pf) {        case I8:            return GL_LUMINANCE;        case A8:            return GL_ALPHA;        case R8G8B8A8:        case R8G8B8X8:            return GL_RGBA;        case B8G8R8A8:        case B8G8R8X8:            AVG_ASSERT(!GLContext::getCurrent()->isGLES());            return GL_RGBA;#ifndef AVG_ENABLE_EGL                    case R8:            return GL_R8;        case R32G32B32A32F:            return GL_RGBA32F_ARB;        case I32F:            return GL_LUMINANCE32F_ARB;#endif        case R8G8B8:        case B5G6R5:            return GL_RGB;        default:            AVG_ASSERT(false);            return 0;    }}

void TestHelper::processTouchStatus(CursorEventPtr pEvent){    map<int, TouchStatusPtr>::iterator it = m_Touches.find(pEvent->getCursorID());    switch (pEvent->getType()) {        case Event::CURSOR_DOWN: {                AVG_ASSERT(it == m_Touches.end());                TouchStatusPtr pTouchStatus(new TouchStatus(pEvent));                m_Touches[pEvent->getCursorID()] = pTouchStatus;            }            break;        case Event::CURSOR_MOTION:        case Event::CURSOR_UP: {                if (it == m_Touches.end()) {                    cerr << "borked: " << pEvent->getCursorID() << ", " <<                             pEvent->typeStr() << endl;                }                AVG_ASSERT(it != m_Touches.end());                TouchStatusPtr pTouchStatus = (*it).second;                pTouchStatus->pushEvent(pEvent);            }            break;        default:            AVG_ASSERT(false);            break;    }}

AVPacket * FFMpegDemuxer::getPacket(int streamIndex){    // Make sure enableStream was called on streamIndex.    AVG_ASSERT(m_PacketLists.size() > 0);    AVG_ASSERT(streamIndex > -1 && streamIndex < 10);    if (m_PacketLists.find(streamIndex) == m_PacketLists.end()) {        cerr << this << ": getPacket: Stream " << streamIndex << " not found." << endl;        dump();        AVG_ASSERT(false);    }    PacketList& curPacketList = m_PacketLists.find(streamIndex)->second;    AVPacket* pPacket;    if (!curPacketList.empty()) {        // The stream has packets queued already.        pPacket = curPacketList.front();        curPacketList.pop_front();    } else {        // No packets queued for this stream -> read and queue packets until we get one        // that is meant for this stream.        do {            pPacket = new AVPacket;            memset(pPacket, 0, sizeof(AVPacket));            int err = av_read_frame(m_pFormatContext, pPacket);            if (err < 0) {                // EOF or error                if (err != int(AVERROR_EOF)) {                    char sz[256];                    av_strerror(err, sz, 256);                    AVG_TRACE(Logger::category::PLAYER, Logger::severity::ERROR,                            "Error decoding video: " << sz);                }                av_free_packet(pPacket);                delete pPacket;                pPacket = 0;                return 0;            }            if (pPacket->stream_index != streamIndex) {                if (m_PacketLists.find(pPacket->stream_index) != m_PacketLists.end()) {                    // Relevant stream, but not ours                    av_dup_packet(pPacket);                    PacketList& otherPacketList =                             m_PacketLists.find(pPacket->stream_index)->second;                    otherPacketList.push_back(pPacket);                } else {                    // Disabled stream                    av_free_packet(pPacket);                    delete pPacket;                    pPacket = 0;                }             } else {                // Our stream                av_dup_packet(pPacket);            }        } while (!pPacket || pPacket->stream_index != streamIndex);    }    return pPacket;}

BitmapPtr CMUCamera::getImage(bool bWait){    if (bWait) {        unsigned rc = WaitForSingleObject(m_pCamera->GetFrameEvent(), INFINITE);        AVG_ASSERT(rc == WAIT_OBJECT_0);    } else {        unsigned rc = WaitForSingleObject(m_pCamera->GetFrameEvent(), 0);        if (rc == WAIT_TIMEOUT) {            // No frame yet            return BitmapPtr();        }        AVG_ASSERT(rc == WAIT_OBJECT_0);    }    int rc2 = m_pCamera->AcquireImageEx(FALSE, NULL);    if (rc2 != CAM_SUCCESS) {        throw Exception(AVG_ERR_CAMERA_NONFATAL,                "CMUCamera: Could not acquire image from camera. " +                CMUErrorToString(rc2));    }    unsigned long captureBufferLength;    unsigned char* pCaptureBuffer = m_pCamera->GetRawData(&captureBufferLength);    BitmapPtr pCamBmp(new Bitmap(getImgSize(), getCamPF(), pCaptureBuffer,             captureBufferLength / getImgSize().y, false, "TempCameraBmp"));    return convertCamFrameToDestPF(pCamBmp);}

void VideoWriterThread::openVideoCodec(){    AVCodec* videoCodec = avcodec_find_encoder(m_pVideoStream->codec->codec_id);    AVG_ASSERT(videoCodec);    int rc = avcodec_open2(m_pVideoStream->codec, videoCodec, 0);    AVG_ASSERT(rc == 0);}

void VideoWriterThread::openVideoCodec(){    AVCodec* videoCodec = avcodec_find_encoder(m_pVideoStream->codec->codec_id);    AVG_ASSERT(videoCodec);#if LIBAVCODEC_VERSION_INT > AV_VERSION_INT(53, 8, 0)    int rc = avcodec_open2(m_pVideoStream->codec, videoCodec, 0);#else    int rc = avcodec_open(m_pVideoStream->codec, videoCodec);#endif    AVG_ASSERT(rc == 0);}

void VideoWriterThread::writeFrame(AVFrame* pFrame){    ScopeTimer timer(ProfilingZoneWriteFrame);    m_FramesWritten++;    AVCodecContext* pCodecContext = m_pVideoStream->codec;    AVPacket packet = { 0 };    int ret;    bool bGotOutput;#if LIBAVCODEC_VERSION_INT > AV_VERSION_INT(54, 0, 0)    av_init_packet(&packet);    int got_output = 0;    ret = avcodec_encode_video2(pCodecContext, &packet, pFrame, &got_output);    AVG_ASSERT(ret >= 0);    if ((pCodecContext->coded_frame->pts) != (long long)AV_NOPTS_VALUE) {        packet.pts = av_rescale_q(pCodecContext->coded_frame->pts,                pCodecContext->time_base, m_pVideoStream->time_base);    }    bGotOutput = (got_output != 0);#else    int out_size = avcodec_encode_video(pCodecContext, m_pVideoBuffer,            VIDEO_BUFFER_SIZE, pFrame);    if (out_size > 0) {        av_init_packet(&packet);        if ((pCodecContext->coded_frame->pts) != (long long)AV_NOPTS_VALUE) {            packet.pts = av_rescale_q(pCodecContext->coded_frame->pts,                    pCodecContext->time_base, m_pVideoStream->time_base);        }        if (pCodecContext->coded_frame->key_frame) {            packet.flags |= AV_PKT_FLAG_KEY;        }        packet.stream_index = m_pVideoStream->index;        packet.data = m_pVideoBuffer;        packet.size = out_size;    }    bGotOutput = (out_size > 0);#endif    if (bGotOutput) {        /* write the compressed frame in the media file */        ret = av_interleaved_write_frame(m_pOutputFormatContext, &packet);        av_free_packet(&packet);        if (ret != 0) {            AVG_TRACE(Logger::category::VIDEO, Logger::severity::ERROR,                    getAVErrorString(ret));        }        AVG_ASSERT(ret == 0);    }}

void VDPAUDecoder::setupDecoder(AVCodecContext* pContext){    VdpStatus status;    // Create new decoder and mixer.    VdpDecoderProfile profile = 0;    switch (pContext->pix_fmt) {        case PIX_FMT_VDPAU_MPEG1:            profile = VDP_DECODER_PROFILE_MPEG1;            break;        case PIX_FMT_VDPAU_MPEG2:            profile = VDP_DECODER_PROFILE_MPEG2_MAIN;            break;        case PIX_FMT_VDPAU_H264:            profile = VDP_DECODER_PROFILE_H264_HIGH;            break;        case PIX_FMT_VDPAU_WMV3:            profile = VDP_DECODER_PROFILE_VC1_SIMPLE;            break;        case PIX_FMT_VDPAU_VC1:            profile = VDP_DECODER_PROFILE_VC1_SIMPLE;            break;        default:            AVG_ASSERT(false);    }    status = vdp_decoder_create(getVDPAUDevice(), profile, m_Size.x, m_Size.y, 16,            &m_VDPDecoder);    AVG_ASSERT(status == VDP_STATUS_OK);    m_PixFmt = pContext->pix_fmt;    VdpVideoMixerFeature features[] = {        VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL,        VDP_VIDEO_MIXER_FEATURE_DEINTERLACE_TEMPORAL_SPATIAL,    };    VdpVideoMixerParameter params[] = {         VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH,        VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT,        VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE,        VDP_VIDEO_MIXER_PARAMETER_LAYERS    };    VdpChromaType chroma = VDP_CHROMA_TYPE_420;    int  numLayers = 0;    void const* paramValues [] = { &m_Size.x, &m_Size.y, &chroma, &numLayers };    status = vdp_video_mixer_create(getVDPAUDevice(), 2, features, 4, params,             paramValues, &m_VDPMixer);    AVG_ASSERT(status == VDP_STATUS_OK);}

void BmpTextureMover::moveBmpToTexture(BitmapPtr pBmp, GLTexture& tex){    AVG_ASSERT(pBmp->getSize() == tex.getSize());    AVG_ASSERT(getSize() == pBmp->getSize());    AVG_ASSERT(pBmp->getPixelFormat() == getPF());    tex.activate();    unsigned char * pStartPos = pBmp->getPixels();    IntPoint size = tex.getSize();    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, size.x, size.y,                    tex.getGLFormat(getPF()), tex.getGLType(getPF()),                    pStartPos);    tex.generateMipmaps();    GLContext::checkError("BmpTextureMover::moveBmpToTexture: glTexSubImage2D()");}

void Contact::sendEventToListeners(CursorEventPtr pCursorEvent){    switch (pCursorEvent->getType()) {        case Event::CURSOR_DOWN:            break;        case Event::CURSOR_MOTION:            notifySubscribers("CURSOR_MOTION", pCursorEvent);            break;        case Event::CURSOR_UP:            notifySubscribers("CURSOR_UP", pCursorEvent);            removeSubscribers();            break;        default:            AVG_ASSERT_MSG(false, pCursorEvent->typeStr().c_str());    }    m_bSendingEvents = true;    AVG_ASSERT(pCursorEvent->getContact() == shared_from_this());    EventPtr pEvent = boost::dynamic_pointer_cast<Event>(pCursorEvent);    m_bCurListenerIsDead = false;    for (map<int, Listener>::iterator it = m_ListenerMap.begin();             it != m_ListenerMap.end();)    {        Listener listener = it->second;        m_CurListenerID = it->first;        m_bCurListenerIsDead = false;        switch (pCursorEvent->getType()) {            case Event::CURSOR_MOTION:                if (listener.m_pMotionCallback != Py_None) {                    py::call<void>(listener.m_pMotionCallback, pEvent);                }                break;            case Event::CURSOR_UP:                if (listener.m_pUpCallback != Py_None) {                    py::call<void>(listener.m_pUpCallback, pEvent);                }                break;            default:                AVG_ASSERT(false);        }        map<int, Listener>::iterator lastIt = it;        ++it;        if (m_bCurListenerIsDead) {            m_ListenerMap.erase(lastIt);            m_bCurListenerIsDead = false;        }    }    m_bSendingEvents = false;}

void AudioMsg::setAudio(AudioBufferPtr pAudioBuffer, float audioTime){    AVG_ASSERT(pAudioBuffer);    setType(AUDIO);    m_pAudioBuffer = pAudioBuffer;    m_AudioTime = audioTime;}

GLfunction getProcAddress(const string& sName){    AVG_ASSERT(glproc::s_hGLLib);#ifdef _WIN32    GLfunction pProc = (GLfunction)wglGetProcAddress(sName.c_str());/*    if (!pProc) {        char szErr[512];        FormatMessage((FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM),                0, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),                szErr, 512, 0);        throw Exception(AVG_ERR_VIDEO_GENERAL,                 string("wglGetProcAddress("+sName+") failed: ") + szErr);    }*/#else    GLfunction pProc = (GLfunction)dlsym(glproc::s_hGLLib, sName.c_str());    if (!pProc) {        // If the name didn't work, try using an underscore :-).        string sName_ = string("_")+sName;        pProc = (GLfunction)dlsym(glproc::s_hGLLib, sName_.c_str());    }#endif    return(pProc);}

void SyncVideoDecoder::readFrame(AVFrame* pFrame){    AVG_ASSERT(getState() == DECODING);    ScopeTimer timer(DecodeProfilingZone);     if (m_bProcessingLastFrames) {        // EOF received, but last frames still need to be decoded.        bool bGotPicture = m_pFrameDecoder->decodeLastFrame(pFrame);        if (!bGotPicture) {            m_bProcessingLastFrames = false;        }    } else {                bool bDone = false;        while (!bDone) {            AVPacket* pPacket = m_pDemuxer->getPacket(getVStreamIndex());            m_bFirstPacket = false;            bool bGotPicture;            if (pPacket) {                bGotPicture = m_pFrameDecoder->decodePacket(pPacket, pFrame,                         m_bVideoSeekDone);            } else {                bGotPicture = m_pFrameDecoder->decodeLastFrame(pFrame);            }            if (bGotPicture && m_pFrameDecoder->isEOF()) {                m_bProcessingLastFrames = true;            }            if (bGotPicture || m_pFrameDecoder->isEOF()) {                bDone = true;            }        }    }}

CameraInfo* CMUCamera::getCameraInfos(int deviceNumber){#ifdef AVG_ENABLE_CMU1394    C1394Camera* pCamera = new C1394Camera();    int err = pCamera->RefreshCameraList();    if (err <= 0) {        return 0;    }    err = pCamera->SelectCamera(deviceNumber);    if (err != CAM_SUCCESS) {        AVG_ASSERT(false);    }    pCamera->InitCamera(true);    long long uniqueID;    pCamera->GetCameraUniqueID((PLARGE_INTEGER)&uniqueID);    stringstream deviceID;    deviceID << uniqueID;    CameraInfo* pCamInfo = new CameraInfo("Firewire", deviceID.str());    getCameraImageFormats(pCamera, pCamInfo);    getCameraControls(pCamera, pCamInfo);    delete pCamera;    return pCamInfo;#endif    return NULL;}

void AudioMsg::setSeekDone(int seqNum, float seekTime){    setType(SEEK_DONE);    AVG_ASSERT(seqNum != -1);    m_SeekSeqNum = seqNum;    m_SeekTime = seekTime;}

void FilterWipeBorder::applyInPlace(BitmapPtr pBmp){    AVG_ASSERT(pBmp->getPixelFormat() == I8);    if (m_NumPixels != 0) {        int stride = pBmp->getStride();        unsigned char * pPixels = pBmp->getPixels();        IntPoint size = pBmp->getSize();        IntPoint activeSize = pBmp->getSize()-IntPoint(2*m_NumPixels, 2*m_NumPixels);        unsigned char * pSrcLine = pPixels+stride*m_NumPixels+m_NumPixels;        for (int y = m_NumPixels-1; y >= 0; --y) {            memcpy(pPixels+stride*y+m_NumPixels, pSrcLine, activeSize.x);        }        pSrcLine = pPixels+stride*(size.y-m_NumPixels-1)+m_NumPixels;        for (int y = size.y-m_NumPixels; y < size.y; ++y) {            memcpy(pPixels+stride*y+m_NumPixels, pSrcLine, activeSize.x);        }        for (int y = 0; y < size.y; ++y) {            unsigned char src = *(pPixels+stride*y+m_NumPixels);            memset(pPixels+stride*y, src, m_NumPixels);            src = *(pPixels+stride*y+size.x-m_NumPixels-1);            memset(pPixels+stride*y+size.x-m_NumPixels, src, m_NumPixels);        }    }}

void BitmapManagerMsg::executeCallback(){    AVG_ASSERT(m_MsgType != NONE);    switch (m_MsgType) {        case BITMAP:            boost::python::call<void>(m_OnLoadedCb.ptr(), m_pBmp);            break;        case ERROR:            boost::python::call<void>(m_OnLoadedCb.ptr(), m_pEx);            break;                default:            AVG_ASSERT(false);    }}

BitmapPtr FilterDilation::apply(BitmapPtr pSrcBmp) {    AVG_ASSERT(pSrcBmp->getPixelFormat() == I8);    IntPoint size = pSrcBmp->getSize();    BitmapPtr pDestBmp = BitmapPtr(new Bitmap(size, I8, pSrcBmp->getName()));    unsigned char * pSrcLine = pSrcBmp->getPixels();    unsigned char * pNextSrcLine;    unsigned char * pDestLine = pDestBmp->getPixels();    for (int y = 0; y < size.y; y++) {        pDestLine = pDestBmp->getPixels()+y*pDestBmp->getStride();        unsigned char * pLastSrcLine = pSrcLine;        pSrcLine = pSrcBmp->getPixels()+y*pSrcBmp->getStride();        if (y < size.y-1) {            pNextSrcLine = pSrcBmp->getPixels()+(y+1)*pSrcBmp->getStride();        } else {            pNextSrcLine = pSrcBmp->getPixels()+y*pSrcBmp->getStride();        }        pDestLine[0] = max(pSrcLine[0], max(pSrcLine[1],                 max(pLastSrcLine[0], pNextSrcLine[0])));        for (int x = 1; x < size.x-1; x++) {             pDestLine[x] = max(pSrcLine[x], max(pSrcLine[x-1], max(pSrcLine[x+1],                     max(pLastSrcLine[x], pNextSrcLine[x]))));        }        pDestLine[size.x-1] = max(pSrcLine[size.x-2], max(pSrcLine[size.x-1],                 max(pLastSrcLine[size.x-1], pNextSrcLine[size.x-1])));    }    return pDestBmp;}

int AppleTrackpadInputDevice::callback(int device, Finger *data, int nFingers,                                       double timestamp, int frame){    AVG_ASSERT(s_pInstance != 0);    s_pInstance->onData(device, data, nFingers, timestamp, frame);    return 0;}

void FWCamera::getCameraImageFormats(dc1394camera_t* pCamera, CameraInfo* camInfo){    dc1394video_modes_t videoModes;    dc1394framerates_t framerates;    dc1394error_t err = dc1394_video_get_supported_modes(pCamera, &videoModes);    if (err != DC1394_SUCCESS) {        AVG_ASSERT(false);        return;    }    for (unsigned i = 0; i < videoModes.num; i++) {        //Covers only libavg supported formats, other capabilities are ignored        if (videoModes.modes[i] >= DC1394_VIDEO_MODE_320x240_YUV422                && videoModes.modes[i] <= DC1394_VIDEO_MODE_1600x1200_MONO16){            PixelFormat pixFormat = getPFFromVideoMode(videoModes.modes[i]);            IntPoint size = getFrameSizeFromVideoMode(videoModes.modes[i]);            FrameratesVector framerateList;            err = dc1394_video_get_supported_framerates(pCamera, videoModes.modes[i],                    &framerates);            if (err != DC1394_SUCCESS) {                AVG_LOG_WARNING("Camera: No framerates. Error was: " << err);            } else {                for (unsigned j = 0; j < framerates.num; j++)                {                    float rate = framerateToFloat(framerates.framerates[j]);                    framerateList.push_back(rate);                }            }            CameraImageFormat format = CameraImageFormat(size,pixFormat,framerateList);            camInfo->addImageFormat(format);        }    }}