Recherche avancée
Médias (2)
-
Valkaama DVD Label
4 octobre 2011, par
Mis à jour : Février 2013
Langue : English
Type : Image
-
Podcasting Legal guide
16 mai 2011, par
Mis à jour : Mai 2011
Langue : English
Type : Texte
Autres articles (67)
-
Submit bugs and patches
13 avril 2011Unfortunately a software is never perfect.
If you think you have found a bug, report it using our ticket system. Please to help us to fix it by providing the following information : the browser you are using, including the exact version as precise an explanation as possible of the problem if possible, the steps taken resulting in the problem a link to the site / page in question
If you think you have solved the bug, fill in a ticket and attach to it a corrective patch.
You may also (...) -
Possibilité de déploiement en ferme
12 avril 2011, parMediaSPIP peut être installé comme une ferme, avec un seul "noyau" hébergé sur un serveur dédié et utilisé par une multitude de sites différents.
Cela permet, par exemple : de pouvoir partager les frais de mise en œuvre entre plusieurs projets / individus ; de pouvoir déployer rapidement une multitude de sites uniques ; d’éviter d’avoir à mettre l’ensemble des créations dans un fourre-tout numérique comme c’est le cas pour les grandes plate-formes tout public disséminées sur le (...) -
Ajouter des informations spécifiques aux utilisateurs et autres modifications de comportement liées aux auteurs
12 avril 2011, parLa manière la plus simple d’ajouter des informations aux auteurs est d’installer le plugin Inscription3. Il permet également de modifier certains comportements liés aux utilisateurs (référez-vous à sa documentation pour plus d’informations).
Il est également possible d’ajouter des champs aux auteurs en installant les plugins champs extras 2 et Interface pour champs extras.
Sur d’autres sites (9302)
-
Easily track Events within Matomo Analytics thanks to Matomo Tag Manager
7 juin 2019, par Matomo Core Team — Analytics TipsEasily track Events within Matomo Analytics thanks to Matomo Tag Manager
Introduction
In this article we’ll cover what events in Matomo Analytics are ; and how you can easily set them up thanks to Matomo Tag Manager.
Key concepts within this article
- Events
- Quick definition of the Tag Management System
- Matomo config
- Creating triggers
- Variables
What are events in Matomo Analytics and why are they useful ?
Events allow you to measure interactions on your website which are not defined by default. With them you can measure clicks on some elements of a page, such as, how visitors are interacting with dropdown menus, media players, scrolling behaviours etc. You can also use them to define goals which make them a key feature in Matomo Analytics. Learn more about tracking events in Matomo.
You can easily access the Events report in Matomo Analytics by clicking on the Behaviour category :
And you may read the following message and feel a bit frustrated :
“There is no data for this report” is a nice way to say, “Hey, you are tracking just a tiny part of what Matomo Analytics can do for you.”
Matomo is a great software, but it can’t guess what you want to track.
In order for Matomo to register those event tracking interactions, you’ll need to explain it by adding a line of code similar to this one when the interaction happens :
_paq.push(['trackEvent', 'Here you enter whatever you want', 'Here too', 'and here also']);Let’s imagine you want to track a click on an HTML button, your code will look something similar to this at the moment of the interaction :
As you can imagine, two main challenges will arise for non developers :
- How to access the source code ?
- How to define the interaction ?
Luckily, Matomo Tag Manager makes those steps easy for you. Let’s see how the same tracking is implemented with Matomo Tag Manager.
A quick definition of what Matomo Tag Manager is
Matomo Tag Manager lets you manage all your tracking and marketing tags in one easy-to-access place. Please visit this page to learn more about Matomo Tag Manager. In order to start using it, you’ll need to copy/paste a tracking code, named a “container”, within the section of your pages.
Once the container is on your website, all you need to do is to follow these simple steps :
- Add a Matomo Tag.
- Assign the condition to fire the tag (what we call the trigger).
- Publish your work.
- And enjoy
1 – Add a Matomo Event tracking code
All you have to do here is click on “CREATE NEW TAG”
Once selected, just mention how you’d like this tag to be named (it is for your internal purpose here so always use an explicit tag name) and the Matomo configuration (the default configuration setting will be fine in most of the cases) :
Then Matomo Tag Manager will ask you the type of tracking you’d like to deploy, in this case, this is an event so select “Event” :
Then all you need is to indicate the values you’d like to push through your event :
To put it in perspective, all we did here through Matomo Tag Manager was implement the equivalent of the following line of code :
_paq.push(['trackEvent', 'Element interactions', 'Click button', 'Click Me']);Let’s now see how can we do this on click code part which we call a trigger.
2 – Assign the condition to fire the tag
In order to execute the event we’ll need to define when it will happen. You do this by clicking on Create a new trigger now :
As the interaction we’d like to track is happening when a click occurs, it will be a click trigger, and as our button is not a link, we’ll select All Elements Click :
Once selected you’ll need to be precise on the condition in which the event will be triggered. In this case we do not want to have events pushed every time someone is clicking on something on our website. We only want to track when they click on this specific button. That’s the reason why our trigger is set to fire only when the click occurs on an element which has an id and has the value “cta” :
Once you click on the green button named CREATE NEW TRIGGER, you validate the tag by clicking on CREATE NEW TAG :
Then you can move to the last part.
3 – Publish your work
Tag Managers are very powerful as they allow you to easily execute any JavaScript code, CSS or even text content on your websites.
That’s why when you create your tag it doesn’t go live straight away on your website. In order to do this you need to publish your tag and this is what the “Publish” category is designed for :
After that, click on the second button if you’re confident your tag and trigger are both ready to go live :
4 – Enjoy
Well done. As your tag is now live, every click made on this button will now be pushed to your Matomo Analytics account within :
1. The visitor log report :
2. The events report :
You may now be asking, “That’s great, but can I collect something more exciting than clicks ?”
Of course you can ! This is what the Matomo Tag Manager is all about.
As long as you can express it through a trigger you can really push whatever you want to Matomo Analytics. You can track scrolling patterns, an element visible on the page like an image, an ad or the time spent on the page. The options are now open to you with Tag Manager.
Give them a try ! Change the triggers, start playing around with variables and discover that the possibilities are endless.
Happy analytics,
Matomo team -
Problem with FFMPEG and PHP
10 septembre 2014, par ziritrionI know this isn’t exactly a programming question per se, but rather a settings question, but still :
I’m trying to convert video with FFMPEG with a PHP script, following this tutorial :
http://vexxhost.com/blog/2007/05/20/how-to-convertencode-files-to-flv-using-ffmpeg-php/
FFMPEG works perfectly and I’ve used it from the command line a number of times. PHP also seems to work fine. I’ve also installed ffmpeg-php and it seems to be loading file.
The problem lies when I try to do the following in PHP :
$srcFile = "p1.avi" ;
$ffmpegObj = new ffmpeg_movie($srcFile) ;
No matter what, PHP will return this :
Warning : can’t open movie file p1.avi in /var/www/converter.php on line xx
Obviously, whatever call I do afterwards with $ffmpegObj will throw a fatal error. I’m absolutely stuck and extensive googling hasn’t helped much.
If you must know, I’m using Ubuntu 9.04 with the default LAMP server packages as well as php5-ffmpeg, and I’ve compiled ffmpeg following a tutorial I found on Ubuntuforums (I’d link to it but stackoverflow won’t let me)
Thanks !
-
Problem to write video using FFMPEG from a vector of cv::Mat
30 décembre 2022, par AlexI'm trying create two functions, one to read a video and store the frmes in a vector of cv::Mat, and other to get a vector of cv::Mat and write this vector in a video. The code compile and run without exception, but the video writed doesn't run, there are data inside, but VLC is not able to run the video. What am I doing wrong in function to write video ?


#include <iostream>
#include <string>
#include <vector>

#include <opencv2></opencv2>core/mat.hpp>
#include <opencv2></opencv2>imgcodecs.hpp>


extern "C" {
#include <libavformat></libavformat>avformat.h>
#include <libavutil></libavutil>imgutils.h>
#include <libswscale></libswscale>swscale.h>
#include <libavcodec></libavcodec>avcodec.h>
 #include <libavutil></libavutil>pixdesc.h>
#include <libavutil></libavutil>opt.h>
}

// helper function to check for FFmpeg errors
inline void checkError(int error, const std::string &message) {
 if (error < 0) {
 std::cerr << message << ": " << av_err2str(error) << std::endl;
 exit(EXIT_FAILURE);
 }
}
 

int writeVideo(const std::string& video_path, std::vector& frames, int width, int height, int fps) {
 // initialize FFmpeg
 av_log_set_level(AV_LOG_ERROR);
 avformat_network_init();

 // create the output video context
 AVFormatContext *formatContext = nullptr;
 int error = avformat_alloc_output_context2(&formatContext, nullptr, nullptr, video_path.c_str());
 checkError(error, "Error creating output context");

 // create the video stream
 AVStream *videoStream = avformat_new_stream(formatContext, nullptr);
 if (!videoStream) {
 std::cerr << "Error creating video stream" << std::endl;
 exit(EXIT_FAILURE);
 }

 // create the video codec context
 const AVCodec *videoCodec = avcodec_find_encoder(AV_CODEC_ID_MPEG4);
 AVCodecContext *videoCodecContext = avcodec_alloc_context3(videoCodec);
 if (!videoCodecContext) {
 std::cerr << "Error allocating video codec context" << std::endl;
 exit(EXIT_FAILURE);
 }
 videoCodecContext->bit_rate = 200000;
 videoCodecContext->width = width;
 videoCodecContext->height = height;
 videoCodecContext->time_base = (AVRational){ 1, fps };
 videoCodecContext->framerate = (AVRational){ fps, 1 };
 videoCodecContext->gop_size = 12;
 videoCodecContext->max_b_frames = 0;
 videoCodecContext->pix_fmt = AV_PIX_FMT_YUV420P;
 if (formatContext->oformat->flags & AVFMT_GLOBALHEADER) {
 videoCodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
 }
 error = avcodec_open2(videoCodecContext, videoCodec, nullptr);
 checkError(error, "Error opening");
 error = avcodec_parameters_from_context(videoStream->codecpar, videoCodecContext);
 checkError(error, "Error setting video codec parameters");

 // open the output file
 error = avio_open(&formatContext->pb, video_path.c_str(), AVIO_FLAG_WRITE);
 checkError(error, "Error opening output file");

 // write the video file header
 error = avformat_write_header(formatContext, nullptr);
 checkError(error, "Error writing video file header");


 AVPacket *packet = av_packet_alloc();
 if (!packet) {
 std::cerr << "Error allocating packet" << std::endl;
 exit(EXIT_FAILURE);
 }
 for (const cv::Mat &frame : frames) {
 // convert the cv::Mat to an AVFrame
 AVFrame *avFrame = av_frame_alloc();
 avFrame->format = videoCodecContext->pix_fmt;
 avFrame->width = width;
 avFrame->height = height;
 error = av_frame_get_buffer(avFrame, 0);
 checkError(error, "Error allocating frame buffer");
 struct SwsContext *frameConverter = sws_getContext(width, height, AV_PIX_FMT_BGR24, width, height, videoCodecContext->pix_fmt, SWS_BICUBIC, nullptr, nullptr, nullptr);
 uint8_t *srcData[AV_NUM_DATA_POINTERS] = { frame.data };
 int srcLinesize[AV_NUM_DATA_POINTERS] = { static_cast<int>(frame.step) };
 sws_scale(frameConverter, srcData, srcLinesize, 0, height, avFrame->data, avFrame->linesize);
 sws_freeContext(frameConverter);

 // encode the AVFrame
 avFrame->pts = packet->pts;
 error = avcodec_send_frame(videoCodecContext, avFrame);
 checkError(error, "Error sending frame to video codec");
 while (error >= 0) {
 error = avcodec_receive_packet(videoCodecContext, packet);
 if (error == AVERROR(EAGAIN) || error == AVERROR_EOF) {
 break;
 }
 checkError(error, "Error encoding video frame");

 // write the encoded packet to the output file
 packet->stream_index = videoStream->index;
 error = av_interleaved_write_frame(formatContext, packet);
 checkError(error, "Error writing video packet");
 av_packet_unref(packet);
 }
 av_frame_free(&avFrame);
 }

 // clean up
 av_packet_free(&packet);
 avcodec_free_context(&videoCodecContext);
 avformat_free_context(formatContext);
 avformat_network_deinit();

 return EXIT_SUCCESS;
}

std::vector readVideo(const std::string video_path) {
 // initialize FFmpeg
 av_log_set_level(AV_LOG_ERROR);
 avformat_network_init();

 AVFormatContext* formatContext = nullptr;
 int error = avformat_open_input(&formatContext, video_path.c_str(), nullptr, nullptr);
 checkError(error, "Error opening input file");

 //Read packets of a media file to get stream information.
 
 error = avformat_find_stream_info(formatContext, nullptr);
 checkError(error, "Error avformat find stream info");
 
 // find the video stream
 AVStream* videoStream = nullptr;
 for (unsigned int i = 0; i < formatContext->nb_streams; i++) {
 if (formatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && !videoStream) {
 videoStream = formatContext->streams[i];
 }
 }
 if (!videoStream) {
 std::cerr << "Error: input file does not contain a video stream" << std::endl;
 exit(EXIT_FAILURE);
 }

 // create the video codec context
 const AVCodec* videoCodec = avcodec_find_decoder(videoStream->codecpar->codec_id);
 AVCodecContext* videoCodecContext = avcodec_alloc_context3(videoCodec);
 if (!videoCodecContext) {
 std::cerr << "Error allocating video codec context" << std::endl;
 exit(EXIT_FAILURE);
 }
 
 std::cout << "::informations::\n";
 std::cout << " bit_rate:" << videoCodecContext->bit_rate << "\n";
 std::cout << " width:" << videoCodecContext->width << "\n";
 std::cout << " height:" << videoCodecContext->height << "\n";
 std::cout << " gop_size:" << videoCodecContext->gop_size << "\n";
 std::cout << " max_b_frames:" << videoCodecContext->max_b_frames << "\n";
 std::cout << " pix_fmt:" << videoCodecContext->pix_fmt << "\n";
 
 error = avcodec_parameters_to_context(videoCodecContext, videoStream->codecpar);
 checkError(error, "Error setting video codec context parameters");
 error = avcodec_open2(videoCodecContext, videoCodec, nullptr);
 checkError(error, "Error opening video codec");

 // create the frame scaler
 int width = videoCodecContext->width;
 int height = videoCodecContext->height;
 struct SwsContext* frameScaler = sws_getContext(width, height, videoCodecContext->pix_fmt, width, height, AV_PIX_FMT_BGR24, SWS_BICUBIC, nullptr, nullptr, nullptr);

 // read the packets and decode the video frames
 std::vector videoFrames;
 AVPacket packet;
 while (av_read_frame(formatContext, &packet) == 0) {
 if (packet.stream_index == videoStream->index) {
 // decode the video frame
 AVFrame* frame = av_frame_alloc();
 int gotFrame = 0;
 error = avcodec_send_packet(videoCodecContext, &packet);
 checkError(error, "Error sending packet to video codec");
 error = avcodec_receive_frame(videoCodecContext, frame);

 //There is not enough data for decoding the frame, have to free and get more data
 
 if (error == AVERROR(EAGAIN))
 {
 av_frame_unref(frame);
 av_freep(frame);
 continue;
 }

 if (error == AVERROR_EOF)
 {
 std::cerr << "AVERROR_EOF" << std::endl;
 break;
 }

 checkError(error, "Error receiving frame from video codec");


 if (error == 0) {
 gotFrame = 1;
 }
 if (gotFrame) {
 // scale the frame to the desired format
 AVFrame* scaledFrame = av_frame_alloc();
 av_image_alloc(scaledFrame->data, scaledFrame->linesize, width, height, AV_PIX_FMT_BGR24, 32);
 sws_scale(frameScaler, frame->data, frame->linesize, 0, height, scaledFrame->data, scaledFrame->linesize);

 // copy the frame data to a cv::Mat object
 cv::Mat mat(height, width, CV_8UC3, scaledFrame->data[0], scaledFrame->linesize[0]);

 videoFrames.push_back(mat.clone());

 // clean up
 av_freep(&scaledFrame->data[0]);
 av_frame_free(&scaledFrame);
 }
 av_frame_free(&frame);
 }
 av_packet_unref(&packet);
 }


 // clean up
 sws_freeContext(frameScaler);
 avcodec_free_context(&videoCodecContext);
 avformat_close_input(&formatContext);
 return videoFrames;
}

int main() {
 auto videoFrames = readVideo("input.mp4");
 cv::imwrite("test.png", videoFrames[10]);
 writeVideo("outnow.mp4", videoFrames, 512, 608, 30);
 //writeVideo("outnow.mp4", videoFrames);
 return 0;
}
</int></vector></string></iostream>

Syndiquer tout le site
