Recherche avancée

Médias (91)

Autres articles (72)

  • Le profil des utilisateurs

    12 avril 2011, par

    Chaque utilisateur dispose d’une page de profil lui permettant de modifier ses informations personnelle. Dans le menu de haut de page par défaut, un élément de menu est automatiquement créé à l’initialisation de MediaSPIP, visible uniquement si le visiteur est identifié sur le site.
    L’utilisateur a accès à la modification de profil depuis sa page auteur, un lien dans la navigation "Modifier votre profil" est (...)

  • Configurer la prise en compte des langues

    15 novembre 2010, par

    Accéder à la configuration et ajouter des langues prises en compte
    Afin de configurer la prise en compte de nouvelles langues, il est nécessaire de se rendre dans la partie "Administrer" du site.
    De là, dans le menu de navigation, vous pouvez accéder à une partie "Gestion des langues" permettant d’activer la prise en compte de nouvelles langues.
    Chaque nouvelle langue ajoutée reste désactivable tant qu’aucun objet n’est créé dans cette langue. Dans ce cas, elle devient grisée dans la configuration et (...)

  • XMP PHP

    13 mai 2011, par

    Dixit Wikipedia, XMP signifie :
    Extensible Metadata Platform ou XMP est un format de métadonnées basé sur XML utilisé dans les applications PDF, de photographie et de graphisme. Il a été lancé par Adobe Systems en avril 2001 en étant intégré à la version 5.0 d’Adobe Acrobat.
    Étant basé sur XML, il gère un ensemble de tags dynamiques pour l’utilisation dans le cadre du Web sémantique.
    XMP permet d’enregistrer sous forme d’un document XML des informations relatives à un fichier : titre, auteur, historique (...)

Sur d’autres sites (6206)

  • Why do I get a crash only sometimes when closing input file with ffmpeg

    1er mai 2013, par Bradley

    I have a problem where only sometimes when I call avformat_close_input(&pFormatCtx) and it results in malloc check failed and my application crashes.

    I really need to use ffmpeg because I need to grab a thumbnail of a video to show in a list and I cannot find an alternative library.

    Can anybody see something in my code where I am doing something wrong when using this library which may cause this malloc check failed problem ?

    bool MuteCamera::PullFrame(  )
    
{
    

    

    

    
pMJPEGCodec  = avcodec_find_encoder(CODEC_ID_MJPEG );
    

    

    
bool bRet = false;
    
int videoStream   = -1;
    
AVFrame *pFrame=NULL;
    
AVFrame *pFrameRGB=NULL;
    
AVPacket packet;
    
int frameFinished=0;
    

    
//AVDictionary *optionsDict = NULL;
    
AVInputFormat   *pFormat = NULL;
    
const char      formatName[] = "mp4";
    

    
if (!(pFormat = av_find_input_format(formatName))) {
    
    printf("can't find input format %s\n", formatName);
    
    return -1;
    
}
    

    
AVFormatContext *pFormatCtx = NULL;
    
pFormatCtx=avformat_alloc_context();
    

    
if(pFormatCtx == NULL)
    
{
    
    printf("\n NULL CONTEXT \n ");
    
    return -1;
    
}
    
if(avformat_open_input (&pFormatCtx, capturedUrl.data(), pFormat, NULL) == 0 )
    
{
    
    for(int i=0; i<(int)pFormatCtx->nb_streams; i++)
    
    {
    
        if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO)
    
        {
    
            videoStream=i;
    
            break;
    
        }
    
    }
    
    if(videoStream >= 0 )
    
    {
    
        AVCodecContext *pCodecCtx = pFormatCtx->streams[videoStream]->codec;
    
        AVCodec *pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
    
        if(pCodec != NULL)
    
        {
    
            if( avcodec_open2(pCodecCtx, pCodec, NULL) >= 0 )
    
            {
    

    
                pFrame=avcodec_alloc_frame();
    

    
                if(pFrame != NULL)
    
                {
    

    

    
                    frameFinished = 0;
    

    
                    while(av_read_frame(pFormatCtx, &packet)>=0)
    
                    {
    

    

    
                        if(packet.stream_index==videoStream)
    
                        {
    

    
                            avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
    

    
                            if(frameFinished)
    
                            {
    

    
                                printf("\n FRAMEFINISHED \n ");
    
                                QString *uu = new QString(capturedUrl.data());//
    
                                uu->replace(".mp4", "thumbnail.jpg");
    
                                WriteJPEG(pCodecCtx, pFrame, uu->toLatin1().data(), PIX_FMT_YUVJ420P);
    

    
                                if(viewingVideos && viewingFromDifferent)
    
                                {
    
                                    QVariantMap map = QVariantMap();
    
                                    map["title"] = actualFilename;
    

    
                                    map["path"] =  actualFilename.replace(".mp4", "thumbnail.jpg");// QString("asset:///white_photo.png");
    
                                    m_listDataModel << map;
    

    
                                }
    
                                delete uu;
    
                                av_free_packet(&packet);
    
                                break;
    

    

    

    
                            }
    
                            else
    
                            {
    
                                printf("\n FRAMENOTFINISHED \n ");
    
                            }
    
                        }
    
                        av_free_packet(&packet);
    

    
                    }
    

    

    

    

    
                    av_free(pFrameRGB);
    

    
                    av_free(pFrame);
    

    
                    avcodec_close(pCodecCtx);
    
                    //av_free(pCodecCtx);
    
                    cout << "\n before free formatctx \n";
    
                    cout.flush();
    
                    if(pFormatCtx)
    
                        avformat_close_input(&pFormatCtx);
    
                    cout << "\n after free formatctx \n";
    
                    cout.flush();
    

    
                }
    
                else
    
                    bRet = false;
    

    

    

    

    

    
            }
    
            else
    
                bRet = false;
    
        }
    
        else
    
            bRet = false;
    
    }
    
    else
    
        bRet = false;
    

    

    

    

    

    
}
    

    

    
return bRet;
    
}
    

    

    
bool WriteJPEG (AVCodecContext *pCodecCtx, AVFrame *pFrame, char cFileName[], PixelFormat pix)
    
    {
    
int complete = 0;
    
bool bRet = false;
    
int out_buf_size;
    
uint8_t *out_buf;
    

    
AVCodecContext *pMJPEGCtx = avcodec_alloc_context3(pMJPEGCodec);
    
if( pMJPEGCtx )
    
{
    
    pMJPEGCtx->bit_rate = pCodecCtx->bit_rate;
    
    pMJPEGCtx->width = pCodecCtx->width;
    
    pMJPEGCtx->height = pCodecCtx->height;
    
    pMJPEGCtx->pix_fmt = pix;
    
    pMJPEGCtx->codec_id = CODEC_ID_MJPEG;
    
    pMJPEGCtx->codec_type = AVMEDIA_TYPE_VIDEO;
    
    pMJPEGCtx->time_base.num = pCodecCtx->time_base.num;
    
    pMJPEGCtx->time_base.den = pCodecCtx->time_base.den;
    
    pMJPEGCtx->time_base= (AVRational){1,29.7};
    

    

    

    

    
    if( pMJPEGCodec && (avcodec_open2( pMJPEGCtx, pMJPEGCodec, NULL) >= 0) )
    
    {
    

    
         AVFrame *oframe;
    
        oframe = avcodec_alloc_frame();
    

    
        if(oframe == NULL)
    
        {
    
            printf("\n (oframe == NULL");
    
            fflush(stdout);
    
        }
    

    

    
        /* calculate the bytes needed for the output image and create buffer for the output image */
    
        out_buf_size = avpicture_get_size(pMJPEGCtx->pix_fmt,
    
                pMJPEGCtx->width,
    
                pMJPEGCtx->height);
    
        out_buf = (uint8_t *)av_malloc(out_buf_size * sizeof(uint8_t));
    
        if (out_buf == NULL) {
    
            fprintf(stderr, "cannot allocate output data buffer!\n");
    
            //ret = -ENOMEM;
    

    
        }
    

    
        avpicture_alloc((AVPicture *)oframe, pMJPEGCtx->pix_fmt, pMJPEGCtx->width, pMJPEGCtx->height);
    

    
        struct SwsContext *sws;
    
        sws = sws_getContext(pMJPEGCtx->width, pMJPEGCtx->height, pCodecCtx->pix_fmt,
    
                pMJPEGCtx->width, pMJPEGCtx->height, pMJPEGCtx->pix_fmt, SWS_BILINEAR,
    
                NULL, NULL, NULL);
    

    
        sws_scale(sws, (const uint8_t **)pFrame->data, pFrame->linesize,
    
                0, pMJPEGCtx->height, &oframe->data[0], &oframe->linesize[0]);
    
        sws_freeContext(sws);
    

    

    

    

    

    
        AVPacket pp2;
    
        av_init_packet(&pp2);
    
        pp2.data = NULL;
    
        pp2.size = 0;
    
        avcodec_encode_video2(pMJPEGCtx, &pp2,  oframe, &complete);
    
        if(complete)
    
        {
    
            printf("\n packet recieved");
    
            fflush(stdout);
    
        }
    
        else
    
        {
    
            printf("\n packet NOT recieved");
    
            fflush(stdout);
    
        }
    

    
        if( SaveFrameJpeg(pp2.size, pp2.data, cFileName ) )
    
            bRet = true;
    

    
            av_free(oframe);
    

    

    

    
            avcodec_close(pMJPEGCtx);
    

    
        av_free_packet(&pp2);
    
        av_free(out_buf);
    

    
            av_free(pMJPEGCtx);
    

    

    
    }
    
    else
    
    {
    
        printf("\n problem!!");
    
        fflush(stdout);
    
    }
    

    
    return bRet;
    
}
    
}
    

    
bool SaveFrameJpeg(int nszBuffer, uint8_t *buffer, char cOutFileName[])
    
{
    
bool bRet = false;
    
FILE *pFile;
    
if( nszBuffer > 0 )
    
{
    

    
    if(0 == 0 )
    
    {
    
        printf("\n start SaveFrameJpeg=%d",nszBuffer );
    
        fflush(stdout);
    
        pFile= fopen(cOutFileName, "wb");
    
        fwrite(buffer, sizeof(uint8_t), nszBuffer, pFile);
    
        bRet = true;
    
        fclose(pFile);
    
        printf("\n end SaveFrameJpeg=%d",nszBuffer );
    
        fflush(stdout);
    
    }
    
}
    
return bRet;
    
}
    

    

    
bool newPullFrame(const std::string& capturedUrl)
    
{
    

    
AVCodec* pMJPEGCodec  = avcodec_find_encoder(CODEC_ID_MJPEG );
    

    
int videoStream   = -1;
    

    
AVDictionary *optionsDict = NULL;
    
AVInputFormat   *pFormat = NULL;
    
const char      formatName[] = "mp4";
    

    
if (!(pFormat = av_find_input_format(formatName)))
    
{
    
    std::cout << "can't find input format " << formatName << "\n";
    
    return false;
    
}
    

    
AVFormatContextHandle FormatCtx(avformat_alloc_context());
    

    
if(!FormatCtx.is_valid())
    
{
    
    std::cout << "\n NULL CONTEXT \n ";
    
    return false;
    
}
    

    
if(avformat_open_input (&FormatCtx, capturedUrl.c_str(), pFormat, NULL))
    
    return false;
    

    
for(int i=0; i<(int)FormatCtx->nb_streams; i++)
    
{
    
    if(FormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO)
    
    {
    
        videoStream=i;
    
        break;
    
    }
    
}
    
if(videoStream < 0 )
    
    return false;
    

    
CodecContextHandle CodecCtx(FormatCtx->streams[videoStream]->codec, avcodec_close);
    
AVCodec *pCodec = avcodec_find_decoder(CodecCtx->codec_id);
    

    
if(pCodec == NULL)
    
    return false;
    

    
if( avcodec_open2(CodecCtx, pCodec, &optionsDict) < 0 )
    
    return false;
    

    
FrameHandle Frame(avcodec_alloc_frame(), av_free);
    

    
if(!Frame.is_valid())
    
    return false;
    

    
int frameFinished=0;
    
AVPacket packet;
    

    
while(av_read_frame(FormatCtx, &packet)>=0)
    
{
    

    
    if(packet.stream_index==videoStream)
    
    {
    
        avcodec_decode_video2(CodecCtx, Frame, &frameFinished, &packet);
    

    
        if(frameFinished)
    
        {
    

    
            std::string uu (capturedUrl);
    
            size_t pos = capturedUrl.rfind(".mp4");
    
            uu.replace(pos, 4, "thumbnail.jpg");
    
            // save the frame to file
    
            int Bytes = avpicture_get_size(PIX_FMT_YUVJ420P, CodecCtx->width, CodecCtx->height);
    
            BufferHandle buffer((uint8_t*)av_malloc(Bytes*sizeof(uint8_t)), av_free);
    
            CodecContextHandle OutContext(avcodec_alloc_context3(NULL), free_context);
    

    
            OutContext->bit_rate = CodecCtx->bit_rate;
    

    
            OutContext->width = CodecCtx->width;
    
            OutContext->height = CodecCtx->height;
    
            OutContext->pix_fmt = PIX_FMT_YUVJ420P;
    
            OutContext->codec_id = CODEC_ID_MJPEG;
    
            OutContext->codec_type = AVMEDIA_TYPE_VIDEO;
    
            OutContext->time_base.num = CodecCtx->time_base.num;
    
            OutContext->time_base.den = CodecCtx->time_base.den;
    
            OutContext->time_base= (AVRational){1,29.7};
    
            AVCodec *OutCodec = avcodec_find_encoder(OutContext->codec_id);
    
            avcodec_open2(OutContext, OutCodec, NULL);
    
            OutContext->mb_lmin = OutContext->lmin = OutContext->qmin * 118;
    
            OutContext->mb_lmax = OutContext->lmax = OutContext->qmax * 118;
    
            OutContext->flags = 2;
    
            OutContext->global_quality = OutContext->qmin * 118;
    
            Frame->pts = 1;
    

    
            Frame->quality = OutContext->global_quality;
    

    
            int ActualSize = avcodec_encode_video(OutContext, buffer, Bytes, Frame);
    

    
            std::ofstream file(uu.data(), std::ios_base::binary | std::ios_base::out);
    
            file.write((const char*)(uint8_t*)buffer, ActualSize);
    
            file.close();
    
            av_free_packet(&packet);
    
            av_free(Frame);
    
            break;
    
        }
    
        else
    
        {
    
            std::cout << " new pullframe frameNOTfinished\n";
    
                            cout.flush();
    
        }
    
        //if(CodecCtx->refcounted_frames == 1)
    

    
            av_free(Frame);
    

    
    }
    
    av_free_packet(&packet);
    
}
    

    
return true;
    
}

  • sws/output/yuv2gbrp_full_X_c() : silence warning about uninitialized variable

    10 mai 2013, par Michael Niedermayer
    sws/output/yuv2gbrp_full_X_c() : silence warning about uninitialized variable

    clang did not show this one, so i missed it in the last batch
    

    Signed-off-by : Michael Niedermayer <michaelni@gmx.at>
    • [DH] libswscale/output.c

  • Video as live wallpaper [closed]

    11 mai 2013, par user1957355

    I was trying to set this enter link description here compile app on my device, but then i hate test this, show error in application and close. Why ?
    Sorry for my english :L

Navigation