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

/**    /fn openGlBenchmark    /brief constructor*/openGlBenchmark::openGlBenchmark(  ADM_coreVideoFilter *in,CONFcouple *setup) : ADM_coreVideoFilterQtGl(in,setup){UNUSED_ARG(setup);        widget->makeCurrent();        fboY->bind();        printf("Compiling shader /n");        glProgramY = new QGLShaderProgram(context);        ADM_assert(glProgramY);        if ( !glProgramY->addShaderFromSourceCode(QGLShader::Fragment, myShaderY))        {                ADM_error("[GL Render] Fragment log: %s/n", glProgramY->log().toUtf8().constData());                ADM_assert(0);        }        if ( !glProgramY->link())        {            ADM_error("[GL Render] Link log: %s/n", glProgramY->log().toUtf8().constData());            ADM_assert(0);        }        if ( !glProgramY->bind())        {                ADM_error("[GL Render] Binding FAILED/n");                ADM_assert(0);        }        fboY->release();        widget->doneCurrent();}

/**    /fn resetVdpau*/bool vdpauVideoFilterDeint::setupVdpau(void){    scaler=NULL;    secondField=false;    nextFrame=0;    if(!admVdpau::isOperationnal())    {        ADM_warning("Vdpau not operationnal/n");        return false;    }       if(VDP_STATUS_OK!=admVdpau::outputSurfaceCreate(VDP_RGBA_FORMAT_B8G8R8A8,                        info.width,info.height,&outputSurface))     {        ADM_error("Cannot create outputSurface0/n");        return false;    }    for(int i=0;i<ADM_NB_SURFACES;i++) surfacePool[i]=VDP_INVALID_HANDLE;    for(int i=0;i<ADM_NB_SURFACES;i++)    {        if(VDP_STATUS_OK!=admVdpau::surfaceCreate(   previousFilter->getInfo()->width,                                                    previousFilter->getInfo()->height,                                                    &(surfacePool[i])))         {            ADM_error("Cannot create input Surface %d/n",i);            goto badInit;        }        aprintf("Created surface %d/n",(int)surfacePool[i]);    }    // allocate our (dummy) images    for(int i=0;i<3;i++)        xslots[i].image=new ADMImageDefault( previousFilter->getInfo()->width,                                             previousFilter->getInfo()->height);                                                if(VDP_STATUS_OK!=admVdpau::mixerCreate(previousFilter->getInfo()->width,                                            previousFilter->getInfo()->height,&mixer,true))     {        ADM_error("Cannot create mixer/n");        goto badInit;    }     tempBuffer=new uint8_t[info.width*info.height*4];    scaler=new ADMColorScalerSimple( info.width,info.height, ADM_COLOR_BGR32A,ADM_COLOR_YV12);    freeSurface.clear();    for(int i=0;i<ADM_NB_SURFACES;i++)              freeSurface.push_back(surfacePool[i]);        ADM_info("VDPAU setup ok/n");    if(initGl()==false)    {        ADM_error("Cannot setup openGL/n");        goto badInit;    }    ADM_info("VDPAU setup ok/n");    return true;badInit:    cleanupVdpau();    passThrough=true;    return false;}

/**    /fn samePicture    /brief returns the last already decoded picture*/bool        ADM_Composer::samePicture(ADMImage *image){      _SEGMENT *seg=_segments.getSegment(_currentSegment);      _VIDEOS  *ref=_segments.getRefVideo(seg->_reference);        // Do Pts->ref PTsuint64_t refPts;uint64_t segTime;uint32_t segNo;    if(false==_segments.convertLinearTimeToSeg(_currentPts,&segNo,&segTime))    {          ADM_error("Cannot convert time in samePicture/n");                   return false;    }      ADM_assert(_currentSegment==segNo);      refPts=segTime+seg->_refStartTimeUs;      ADMImage *last=ref->_videoCache->getByPts(refPts);      if(last)      {            image->duplicate(last);            updateImageTiming(seg,image);            return true;      }      ADM_error("Cannot find same image in cache/n");       ADM_info("Looking for PTS=%"PRIu64" ms/n",refPts/1000);      ref->_videoCache->dump();      return false;}

/**    /fn ADM_copyFile*/uint8_t ADM_copyFile(const char *source, const char *target){    FILE *fin=ADM_fopen(source,"rb");    if(!fin)    {        ADM_error("Cannot open %s for reading/n",source);        return false;    }    FILE *fout=ADM_fopen(target,"wb");    if(!fout)    {        fclose(fin);        ADM_error("Cannot open %s for writting/n",target);        return false;    }    uint8_t buffer[1024];    while(!feof(fin))    {        int r=fread(buffer,1,1024,fin);        fwrite(buffer,1,r,fout);        if(r!=1024) break;    }    fclose(fin);    fclose(fout);    return true;}

/**    /fn init*/bool vdpauRender::init( GUI_WindowInfo *window, uint32_t w, uint32_t h, float zoom){    if(!w || !h)    {        ADM_info("[VDPAU] Not trying to initialize with zero size dimensions/n");        return false;    }    ADM_info("[Vdpau]Init/n");    info=*window;    if(admVdpau::isOperationnal()==false)    {        ADM_warning("[Vdpau] Not operationnal/n");    }    baseInit(w,h,zoom);    // Create couple of outputSurface    surface[0]=surface[1]=VDP_INVALID_HANDLE;    currentSurface=0;        //    int widthToUse=admVdpau::dimensionRoundUp(w);    int heightToUse=admVdpau::dimensionRoundUp(h);        ADM_info("[VDpau] Allocating surfaces %d x%d , %d x %d, %d x x%d/n",w,h,widthToUse,heightToUse,displayWidth,displayHeight);        if(!reallocOutputSurface(displayWidth,displayHeight))    {        goto badInit;    }    if(VDP_STATUS_OK!=admVdpau::surfaceCreate(widthToUse,heightToUse,&input))     {        ADM_error("Cannot create input Surface/n");        goto badInit;    }    if(VDP_STATUS_OK!=admVdpau::presentationQueueCreate(&queue))     {        ADM_error("Cannot create queue/n");        goto badInit;    }     if(VDP_STATUS_OK!=admVdpau::mixerCreate(widthToUse,heightToUse,&mixer))     {        ADM_error("Cannot create mixer/n");        goto badInit;    }     return true;badInit:        return false;}

void ADM_initBaseDir(int argc, char *argv[]){    char *home = NULL;    // Get the base directory    const char* homeEnv = getenv("HOME");    if (!homeEnv)    {        printf("Oops: can't determine $HOME.");        return;    }    // Try to open the .avidemux directory    strcpy(ADM_basedir, homeEnv);    AddSeparator(ADM_basedir);    const char *ADM_DIR_NAME = ".avidemux6";    strcat(ADM_basedir, ADM_DIR_NAME);    strcat(ADM_basedir, ADM_SEPARATOR);    if (ADM_mkdir(ADM_basedir))    {        printf("Using %s as base directory for prefs, jobs, etc./n", ADM_basedir);    }    else    {        ADM_error("Oops: cannot create the .avidemux directoryi (%s)/n", ADM_basedir);    }}

bool ADM_Composer::setContainer(const char *cont, CONFcouple *c){	int idx = ADM_MuxerIndexFromName(cont);	if (idx == -1)	{		ADM_error("Cannot find muxer for format=%s/n",cont);		return false;	}	ADM_info("setting container as index %d/n",idx);	UI_SetCurrentFormat(idx);	idx = ADM_MuxerIndexFromName(cont);	bool r = false;	if(idx != -1)	{		r = ADM_mx_setExtraConf(idx, c);	}	if (c)		delete c;	return r;}

/**    /fn TimeToFrame    /brief return the frameno whose PTS==time*/static bool TimeToFrame(_VIDEOS *v,uint64_t time,uint32_t *frame,uint32_t *oflags){    vidHeader *demuxer=v->_aviheader;    bool warn=false;    int nb=demuxer->getMainHeader()->dwTotalFrames;    for(int i=0;i<nb;i++)    {        uint64_t pts,dts;        uint32_t flags;            demuxer->getPtsDts(i,&pts,&dts);            demuxer->getFlags(i,&flags);            if(pts==time)            {                *frame=i;                *oflags=flags;                return true;            }            if(dts!=ADM_NO_PTS && warn==false)            {                if(dts>time)                {                    ADM_error("We reached frame %d with a PTS of %"PRIu64" when looking for PTS %"PRIu64"/n",                                            i,dts,time);                    warn=true;                }            }    }    return false;}

uint8_t asfHeader::open(const char *name){  _fd=ADM_fopen(name,"rb");  if(!_fd)  {    GUI_Error_HIG("File Error.","Cannot open file/n");    return 0;   }  myName=ADM_strdup(name);  if(!getHeaders())  {    return 0;   }  ADM_info("Stream Video: index=%d, sid=%d/n",(int)_videoIndex,(int)_videoStreamId);  for(int i=0;i<_nbAudioTrack;i++)    ADM_info("Stream Audio: index=%d, sid=%d/n",                (int)_allAudioTracks[i].streamIndex,(int)_allAudioTracks[i].streamIndex);  buildIndex();  fseeko(_fd,_dataStartOffset,SEEK_SET);  _packet=new asfPacket(_fd,_nbPackets,_packetSize,&readQueue,&storageQueue,_dataStartOffset);  curSeq=1;  for(int i=0;i<_nbAudioTrack;i++)  {        _audioAccess[i]=new asfAudioAccess(this,i);        _audioStreams[i]=ADM_audioCreateStream(&(_allAudioTracks[i].wavHeader), _audioAccess[i]);  }  if(!nbImage)    {        ADM_error("No image found /n");        return 0;    }  return 1;}

/** * /fn printError * @param s : banner * @param er : error code */void AUDMEncoder_Lavcodec::printError(const char *s,int er){    char strer[256]={0};                av_strerror(er, strer, sizeof(strer));                ADM_error("[Lavcodec] %s,err : %d %s!/n",s,er,strer);                }

/**    /fn shiftAudioVideoBy    /brief shift audio and video so that they start close to zero*/bool asfHeader::shiftAudioVideoBy(uint64_t s){    int n=_index.size();    ADM_info("Shifting by %s/n",ADM_us2plain(s));    for(int i=0;i<n;i++)    {        if(_index[i].pts!=ADM_NO_PTS)        {            if(_index[i].pts<s)            {                ADM_error("Shifting too big for frame %d PTS: %s/n",i,ADM_us2plain(_index[i].pts));            }else                _index[i].pts-=s;        }        _index[i].dts=ADM_NO_PTS;/*        if(_index[i].dts!=ADM_NO_PTS)        {            if(_index[i].dts<s)            {                ADM_error("Shifting too big for frame %d DTS: %s/n",i,ADM_us2plain(_index[i].dts));                _index[i].dts=ADM_NO_PTS;            }else                _index[i].dts-=s;        }*/    }    _shiftUs=s;    return true;}

ADM_AudiocodecAC3::ADM_AudiocodecAC3( uint32_t fourcc, WAVHeader *info,uint32_t extraLength,uint8_t *extraData)		:   ADM_Audiocodec(fourcc,*info){    int flags=0;        ADM_assert(fourcc==WAV_AC3);    ac3_handle=NULL;    ac3_sample=NULL;#ifdef ADM_CPU_X86#define CHK(x,y) if(CpuCaps::has##x()) flags|=MM_ACCEL_X86_##y;    CHK(MMX,MMX);    CHK(3DNOW,3DNOW);    CHK(MMXEXT,MMXEXT);#endif    ac3_handle=(void *)a52_init(flags);    if(!ac3_handle)    {        ADM_error("Cannot init a52/n");        ADM_assert(0);    }    ac3_sample=(sample_t *)a52_samples(AC3_HANDLE);    if(!ac3_sample)    {        ADM_warning("Cannot init a52 sample/n");        ADM_assert(0);    }      }

/**    /fn stop    /brief stop*/uint8_t audioDeviceThreaded::stop(){ uint32_t maxWait=3*1000; // Should be enough to drain    ADM_info("[audioDevice]Stopping device...");    if(stopRequest==AUDIO_DEVICE_STARTED)    {        CHANGE_STATE(AUDIO_DEVICE_STOP_REQ);        while(stopRequest==AUDIO_DEVICE_STOP_REQ && maxWait)        {            ADM_usleep(1000);            maxWait--;        }    }    if(!maxWait)    {        ADM_error("Audio device did not stop cleanly/n");    }    localStop();    if(audioBuffer)    {        delete [] audioBuffer;        audioBuffer=NULL;    }    if(silence) delete [] silence;    silence=NULL;    CHANGE_STATE(AUDIO_DEVICE_STOPPED);    return 1;}

muxerMp4v2::~muxerMp4v2(){    ADM_info("[Mp4v2Muxer] Destroying/n");    close();    if(handle)        ADM_error("MP4V2: File still opened/n");    currentMuxer=NULL;}

bool  denoise3dhq_jdeserialize(const char *file, const ADM_paramList *tmpl,denoise3dhq *key){admJsonToCouple json;CONFcouple *c=json.readFromFile(file);if(!c) {ADM_error("Cannot read json file");return false;}bool r= ADM_paramLoadPartial(c,tmpl,key);delete c;return r;};

/**    /fn reallocOutputSurface*/bool vdpauRender::reallocOutputSurface(uint32_t tgtWidth, uint32_t tgtHeight){    if(surface[0]!=VDP_INVALID_HANDLE)  admVdpau::outputSurfaceDestroy(surface[0]);    if(surface[1]!=VDP_INVALID_HANDLE)  admVdpau::outputSurfaceDestroy(surface[1]);    surface[0]=surface[1]=VDP_INVALID_HANDLE;    if(VDP_STATUS_OK!=admVdpau::outputSurfaceCreate(VDP_RGBA_FORMAT_B8G8R8A8,tgtWidth,tgtHeight,&surface[0]))     {        ADM_error("Cannot create outputSurface0/n");        return false;    }    if(VDP_STATUS_OK!=admVdpau::outputSurfaceCreate(VDP_RGBA_FORMAT_B8G8R8A8,tgtWidth,tgtHeight,&surface[1]))     {        ADM_error("Cannot create outputSurface1/n");        return false;    }    return true;}

/** * 	/fn tryLoadingVideoFilterPlugin *  /brief try to load the plugin given as argument.. */static uint8_t tryLoadingVideoFilterPlugin(const char *file){	ADM_vf_plugin *plugin = new ADM_vf_plugin(file);    admVideoFilterInfo          *info=NULL;	if (!plugin->isAvailable())	{		printf("[ADM_vf_plugin] Unable to load %s/n", ADM_GetFileName(file));		goto Err_ad;	}	// Check API version	if (plugin->getApiVersion() != VF_API_VERSION)	{		printf("[ADM_vf_plugin] File %s has API version too old (%d vs %d)/n",			ADM_GetFileName(file), plugin->getApiVersion(), VF_API_VERSION);		goto Err_ad;	}    if(!(plugin->supportedUI() & UI_GetCurrentUI()))    {  // FIXME        ADM_info("==> wrong UI/n");        goto Err_ad;    }	// Get infos	uint32_t major, minor, patch;	plugin->getFilterVersion(&major, &minor, &patch);	plugin->nameOfLibrary = ADM_strdup(ADM_GetFileName(file));    info=&(plugin->info);    info->internalName=plugin->getInternalName();    info->desc=plugin->getDesc();    info->displayName=plugin->getDisplayName();    info->category=plugin->getCategory();	printf("[ADM_vf_plugin] Plugin loaded version %d.%d.%d, name %s/%s/n",		major, minor, patch, info->internalName, info->displayName);    if(info->category>=VF_MAX)    {        ADM_error("This filter has an unknown caregory!/n");        goto Err_ad;    }else    {        plugin->tag=ADM_videoFilterPluginsList[info->category].size()+info->category*100;        ADM_videoFilterPluginsList[info->category].append(plugin);    }	return 1;Err_ad:	delete plugin;	return 0;}

/**    /fn openGlResize    /brief constructor*/openGlResize::openGlResize(  ADM_coreVideoFilter *in,CONFcouple *setup) : ADM_coreVideoFilterQtGl(in,setup){	if (widget == NULL)	{		original = NULL;		return;	}UNUSED_ARG(setup);        if(!setup || !ADM_paramLoad(setup,gl_resize_param,&configuration))        {            // Default value            configuration.width=info.width;            configuration.height=info.height;        }        original=new ADMImageDefault(in->getInfo()->width,in->getInfo()->height);        info.width=configuration.width;        info.height=configuration.height;        resizeFBO(info.width,info.height);        widget->makeCurrent();        fboY->bind();        printf("Compiling shader /n");        glProgramY = new QGLShaderProgram(context);        ADM_assert(glProgramY);        if ( !glProgramY->addShaderFromSourceCode(QGLShader::Fragment, myShaderY))        {                ADM_error("[GL Render] Fragment log: %s/n", glProgramY->log().toUtf8().constData());                ADM_assert(0);        }        if ( !glProgramY->link())        {            ADM_error("[GL Render] Link log: %s/n", glProgramY->log().toUtf8().constData());            ADM_assert(0);        }        if ( !glProgramY->bind())        {                ADM_error("[GL Render] Binding FAILED/n");                ADM_assert(0);        }        fboY->release();        widget->doneCurrent();}

boolFileSystem::rename( string from, string to ){    if(!ADM_renameFile(from.c_str(),to.c_str()))    {        ADM_error("Cannot rename %s to %s/n",from.c_str(),to.c_str());        return true;    }    return false;}

/**    /fn processError*/static bool processError(const char *e){    int x=glGetError();    if(x!=GL_NO_ERROR)    {        ADM_error("%s: Error : %d %s/n",e,x,gluErrorString(x));        return false;    }    return true;}

/**    /fn rotateGl    /brief constructor*/rotateGl::rotateGl(  ADM_coreVideoFilter *in,CONFcouple *setup) : ADM_coreVideoFilterQtGl(in,setup){	if (widget == NULL)	{		original = NULL;		return;	}UNUSED_ARG(setup);        original=new ADMImageDefault(in->getInfo()->width,in->getInfo()->height);        if(!setup || !ADM_paramLoad(setup,gl_rotate_param,&params))        {            // Default value            params.angle=0;        }        widget->makeCurrent();        fboY->bind();        printf("Compiling shader /n");        glProgramY = new QGLShaderProgram(context);        ADM_assert(glProgramY);        if ( !glProgramY->addShaderFromSourceCode(QGLShader::Fragment, myShaderY))        {                ADM_error("[GL Render] Fragment log: %s/n", glProgramY->log().toUtf8().constData());                ADM_assert(0);        }        if ( !glProgramY->link())        {            ADM_error("[GL Render] Link log: %s/n", glProgramY->log().toUtf8().constData());            ADM_assert(0);        }        if ( !glProgramY->bind())        {                ADM_error("[GL Render] Binding FAILED/n");                ADM_assert(0);        }        glList=glGenLists(1);        genQuad();        fboY->release();        widget->doneCurrent();}

/**    /fn ctor*/glRGB::glRGB(ADM_coreVideoFilter *previous,CONFcouple *conf)             :  ADM_coreVideoFilterQtGl(previous,conf){        widget->makeCurrent();        fboY->bind();        ADM_info("Compiling shader /n");        glProgramY = new QGLShaderProgram(context);        ADM_assert(glShaderRgb);        if ( !glProgramY->addShaderFromSourceCode(QGLShader::Fragment, glShaderRgb))        {                ADM_error("[GL Render] Fragment log: %s/n", glProgramY->log().toUtf8().constData());                ADM_assert(0);        }        if ( !glProgramY->link())        {            ADM_error("[GL Render] Link log: %s/n", glProgramY->log().toUtf8().constData());            ADM_assert(0);        }        if ( !glProgramY->bind())        {                ADM_error("[GL Render] Binding FAILED/n");                ADM_assert(0);        }        fboY->release();        widget->doneCurrent();        //        memset(realMatrix,0,sizeof(realMatrix));        realMatrix[0]=0.299;        realMatrix[1]=0.587;        realMatrix[2]=0.114;        realMatrix[4]=-0.14713;        realMatrix[5]=-0.28886;        realMatrix[6]=+0.436;        realMatrix[8]=+0.615;        realMatrix[9]=-0.51499;        realMatrix[10]=-0.10001;}

/** * /fn ADM_getIndexForIso639 * @param iso * @return  */int                 ADM_getIndexForIso639(const char *iso){    int n=ADM_getLanguageListSize();    for(int i=0;i<n;i++)    {        if(!strcmp(languages[i].iso639_2,iso)) return i;    }    ADM_error("Language %s not found in list/n",iso);    return -1;    }

/** *  * @param p */void call_slave(char *p){    uint32_t i;    sscanf(p,"%" PRIu32,&i);    ADM_info("Slave on port  %" PRIu32"/n",i);    if(!ADM_slaveConnect(i))    {            ADM_error("Cannot connect to master/n");            exit(-1);    }}

bool admJsonToCouple::scan( void *xnode,string name){    JSONNODE *node=(JSONNODE *)xnode;   if (!node){        ADM_error("Invalid JSON Node/n");        return false;    }     JSONNODE_ITERATOR i = json_begin(node);    while (i != json_end(node)){        if (*i == NULL){            ADM_error("Invalid JSON Node/n");            return false;        }        json_char *node_name = json_name(*i);        //printf("Node :%s/n",node_name);        // recursively call ourselves to dig deeper into the tree        if (json_type(*i) == JSON_ARRAY || json_type(*i) == JSON_NODE)        {            if(name=="")                 scan(*i,string(node_name));            else                scan(*i,name+string(".")+string(node_name));        }        else        {            keyVal k;            json_char *node_value = json_as_string(*i);            if(name=="")                 k.key=string(node_name);            else                 k.key=string(name)+string(".")+string(node_name);            k.value=string(node_value);            readItems.push_back(k);            json_free(node_value);        }        json_free(node_name);        ++i;    }    return true;}

/**    /fn openGlVertex    /brief constructor*/openGlVertex::openGlVertex(  ADM_coreVideoFilter *in,CONFcouple *setup) : ADM_coreVideoFilterQtGl(in,setup){UNUSED_ARG(setup);        widget->makeCurrent();        fboY->bind();        printf("Compiling shader /n");        // vertex shader                // frag shader        glProgramY = new QGLShaderProgram(context);        ADM_assert(glProgramY);#if 1        if ( !glProgramY->addShaderFromSourceCode(QGLShader::Vertex, myVertex))        {                ADM_error("[GL Render] Vertex log: %s/n", glProgramY->log().toUtf8().constData());                ADM_assert(0);        }#endif        if ( !glProgramY->addShaderFromSourceCode(QGLShader::Fragment, myShaderY))        {                ADM_error("[GL Render] Fragment log: %s/n", glProgramY->log().toUtf8().constData());                ADM_assert(0);        }        if ( !glProgramY->link())        {            ADM_error("[GL Render] Link log: %s/n", glProgramY->log().toUtf8().constData());            ADM_assert(0);        }        if ( !glProgramY->bind())        {                ADM_error("[GL Render] Binding FAILED/n");                ADM_assert(0);        }        glList=glGenLists(1);        buildVertex();        fboY->release();        widget->doneCurrent();}

/**    /fn glYadif    /brief constructor*/glYadif::glYadif(  ADM_coreVideoFilter *in,CONFcouple *setup) : ADM_coreVideoFilterQtGl(in,setup){UNUSED_ARG(setup);        widget->makeCurrent();        fboY->bind();        printf("Compiling shader /n");        glProgramY = new QGLShaderProgram(context);        ADM_assert(glProgramY);        if ( !glProgramY->addShaderFromSourceCode(QGLShader::Fragment, myShaderY))        {                ADM_error("[GL Render] Fragment log: %s/n", glProgramY->log().toUtf8().constData());                ADM_assert(0);        }        if ( !glProgramY->link())        {            ADM_error("[GL Render] Link log: %s/n", glProgramY->log().toUtf8().constData());            ADM_assert(0);        }        if ( !glProgramY->bind())        {                ADM_error("[GL Render] Binding FAILED/n");                ADM_assert(0);        }        fboY->release();        widget->doneCurrent();        original=new ADMImageDefault(in->getInfo()->width,in->getInfo()->height);        if(!setup || !ADM_paramLoad(setup,yadif_param,&configuration))        {            // Default value            configuration.mode=0;            configuration.order=1;        }        vidCache = new VideoCache (10, in);        updateInfo();        myName="yadif";}

/**    /fn setIdentityCSC    /brief set the RGB/YUV matrix to identity so that data are still YUV at the end            Should not work, but it does.*/bool vdpauVideoFilterDeint::setIdentityCSC(void){    ADM_info("Setting custom CSC/n");    const VdpCSCMatrix   matrix={{1.,0,0,0},{0,1.,0,0},{0,0,1.,0}};        VdpVideoMixerAttribute attributes_key[]={VDP_VIDEO_MIXER_ATTRIBUTE_CSC_MATRIX};    const void * attribute_values[] = {&matrix};        VdpStatus st = admVdpau::mixerSetAttributesValue(mixer, 1,attributes_key, (void * const *)attribute_values);    if(st!=VDP_STATUS_OK)        ADM_error("Cannot set custom matrix (CSC)/n");    return true;}