Recherche avancée
Autres articles (97)
-
Publier sur MédiaSpip
13 juin 2013Puis-je poster des contenus à partir d’une tablette Ipad ?
Oui, si votre Médiaspip installé est à la version 0.2 ou supérieure. Contacter au besoin l’administrateur de votre MédiaSpip pour le savoir -
HTML5 audio and video support
13 avril 2011, parMediaSPIP uses HTML5 video and audio tags to play multimedia files, taking advantage of the latest W3C innovations supported by modern browsers.
The MediaSPIP player used has been created specifically for MediaSPIP and can be easily adapted to fit in with a specific theme.
For older browsers the Flowplayer flash fallback is used.
MediaSPIP allows for media playback on major mobile platforms with the above (...) -
Emballe médias : à quoi cela sert ?
4 février 2011, parCe plugin vise à gérer des sites de mise en ligne de documents de tous types.
Il crée des "médias", à savoir : un "média" est un article au sens SPIP créé automatiquement lors du téléversement d’un document qu’il soit audio, vidéo, image ou textuel ; un seul document ne peut être lié à un article dit "média" ;
Sur d’autres sites (9807)
-
FFMPEG pushed RTMP stream not working on Android & iPhone
1er décembre 2015, par BlackDivineI have to make a semi-live-stream. I used Nginx-rtmp module and then pushed content to it via ffmpeg using :
ffmpeg -re -i content.mp4 -r 25 -f fvl "rtmp://rtmp.server.here"The stream runs fine when I open it in VLC from "rtmp ://rtmp.server.here"
But I also have to make iPhone and Android apps that play these streams. And that’s the problem, the stream doesn’t work on Android and iPhone.
If I use Wowza streaming cloud and stream to Wowza cloud instead of my own nginx-rtmp server then the same app written for Android & iPhone can playback the stream just fine.
Now either nginx-rtmp is not working right, or what else ? I’ve also tried crtmpserver and the same thing happens.
What I want to acheive :
I have to develop a system where we can upstream a TV-Channel (have rights for it) to a server and then make a website, android app & iPhone app so consumers can watch the live channel.The uploading part I have a clue of, probably a TV tuner card and Open Broadcast Software to stream it to server. But the Live playback is new to me.
UPDATE : I also used ffprobe and here’s the output. (See the last line)
munir@munir-HP-ProBook-450-G2:~$ ffprobe rtmp://rtmp.server.here
ffprobe version 2.6.2 Copyright (c) 2007-2015 the FFmpeg developers
built with gcc 4.8 (Ubuntu 4.8.2-19ubuntu1)
configuration: --extra-libs=-ldl --prefix=/opt/ffmpeg --enable-avresample --disable-debug --enable-nonfree --enable-gpl --enable-version3 --enable-libopencore-amrnb --enable-libopencore-amrwb --disable-decoder=amrnb --disable-decoder=amrwb --enable-libpulse --enable-libx264 --enable-libx265 --enable-libfdk-aac --enable-libvorbis --enable-libmp3lame --enable-libopus --enable-libvpx --enable-libspeex --enable-libass --enable-avisynth --enable-libsoxr --enable-libxvid --enable-libvo-aacenc --enable-libvidstab
libavutil 54. 20.100 / 54. 20.100
libavcodec 56. 26.100 / 56. 26.100
libavformat 56. 25.101 / 56. 25.101
libavdevice 56. 4.100 / 56. 4.100
libavfilter 5. 11.102 / 5. 11.102
libavresample 2. 1. 0 / 2. 1. 0
libswscale 3. 1.101 / 3. 1.101
libswresample 1. 1.100 / 1. 1.100
libpostproc 53. 3.100 / 53. 3.100
[flv @ 0x267cc60] Stream discovered after head already parsed
Last message repeated 1 times
Input #0, flv, from 'rtmp://stage.funworldpk.com/live':
Metadata:
Server : NGINX RTMP (github.com/arut/nginx-rtmp-module)
displayWidth : 320
displayHeight : 240
fps : 20
profile :
level :
Duration: 00:00:00.00, start: 288.763000, bitrate: N/A
Stream #0:0: Video: h264 (High), yuv420p, 320x240 [SAR 1:1 DAR 4:3], 20 fps, 20 tbr, 1k tbn, 40 tbc
Stream #0:1: Data: none
Stream #0:2: Audio: aac (LC), 22050 Hz, stereo, fltp
Unsupported codec with id 0 for input stream 1Update 2 :
I got my stream working by using Licensed copy of Wowza streaming server. Everything works now. But obviously this will not be an option for everyone that’s why I am not posting it as an answer. -
C++ ffmpeg lib version 7.0 - runtime error
1er septembre 2024, par Chris PI want to make a C++ lib named cppdub which will mimic the python module pydub.


One main function is to export the AudioSegment to a file with a specific format (example : mp3).


The code is :


void check_av_error(int error_code, const std::string& msg) {
 if (error_code < 0) {
 char errbuf[AV_ERROR_MAX_STRING_SIZE];
 av_strerror(error_code, errbuf, sizeof(errbuf));
 throw std::runtime_error(msg + ": " + errbuf);
 }
}

std::string av_err2str_(int errnum) {
 char buf[AV_ERROR_MAX_STRING_SIZE];
 av_strerror(errnum, buf, sizeof(buf));
 return std::string(buf);
}

void log_error(const std::string& msg) {
 std::cerr << "Error: " << msg << std::endl;
}

std::ofstream cppdub::AudioSegment::export_segment(
 std::string& out_f,
 const std::string& format,
 const std::string& codec,
 const std::string& bitrate,
 const std::vector& parameters,
 const std::map& tags,
 const std::string& id3v2_version,
 const std::string& cover) {

 av_log_set_level(AV_LOG_DEBUG);
 avformat_network_init();

 AVFormatContext* format_ctx = nullptr;
 int ret = avformat_alloc_output_context2(&format_ctx, nullptr, format.c_str(), out_f.c_str());
 check_av_error(ret, "Could not allocate format context");

 if (!(format_ctx->oformat->flags & AVFMT_NOFILE)) {
 ret = avio_open(&format_ctx->pb, out_f.c_str(), AVIO_FLAG_WRITE);
 check_av_error(ret, "Could not open output file");
 }

 AVStream* stream = avformat_new_stream(format_ctx, nullptr);
 if (!stream) {
 avformat_free_context(format_ctx);
 throw std::runtime_error("Could not allocate stream");
 }

 const AVCodec* codec_obj = avcodec_find_encoder_by_name(codec.c_str());
 if (!codec_obj) {
 avformat_free_context(format_ctx);
 throw std::runtime_error("Codec not found");
 }

 AVCodecContext* codec_ctx = avcodec_alloc_context3(codec_obj);
 if (!codec_ctx) {
 avformat_free_context(format_ctx);
 throw std::runtime_error("Could not allocate codec context");
 }

 codec_ctx->sample_rate = this->get_frame_rate();
 AVChannelLayout ch_layout_1;
 av_channel_layout_uninit(&ch_layout_1);
 av_channel_layout_default(&ch_layout_1, 2);
 codec_ctx->ch_layout = ch_layout_1; // Adjust based on your needs
 codec_ctx->bit_rate = std::stoi(bitrate);
 codec_ctx->sample_fmt = codec_obj->sample_fmts[0];

 if (format_ctx->oformat->flags & AVFMT_GLOBALHEADER) {
 codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
 }

 ret = avcodec_open2(codec_ctx, codec_obj, nullptr);
 check_av_error(ret, "Could not open codec");

 stream->time_base = { 1, codec_ctx->sample_rate };
 ret = avcodec_parameters_from_context(stream->codecpar, codec_ctx);
 check_av_error(ret, "Could not set codec parameters");

 ret = avformat_write_header(format_ctx, nullptr);
 check_av_error(ret, "Error occurred when writing header");

 AVPacket pkt;
 av_init_packet(&pkt);
 pkt.data = nullptr;
 pkt.size = 0;

 int frame_size = av_samples_get_buffer_size(nullptr, codec_ctx->ch_layout.nb_channels,
 codec_ctx->frame_size, codec_ctx->sample_fmt, 0);
 check_av_error(frame_size, "Could not calculate frame size");

 AVFrame* frame = av_frame_alloc();
 if (!frame) {
 avcodec_free_context(&codec_ctx);
 avformat_free_context(format_ctx);
 throw std::runtime_error("Error allocating frame");
 }

 frame->format = codec_ctx->sample_fmt;
 frame->ch_layout = codec_ctx->ch_layout;
 frame->sample_rate = codec_ctx->sample_rate;
 frame->nb_samples = codec_ctx->frame_size;

 ret = av_frame_get_buffer(frame, 0);
 if (ret < 0) {
 av_frame_free(&frame);
 avcodec_free_context(&codec_ctx);
 avformat_free_context(format_ctx);
 throw std::runtime_error("Error allocating frame buffer: " + av_err2str_(ret));
 }

 size_t data_offset = 0;

 while (data_offset < this->raw_data().size()) {
 int samples_to_process = std::min(frame_size, static_cast<int>(this->raw_data().size()) - static_cast<int>(data_offset));

 // Fill the frame with audio data
 ret = avcodec_fill_audio_frame(frame, codec_ctx->ch_layout.nb_channels, codec_ctx->sample_fmt,
 reinterpret_cast<const>(this->raw_data().data()) + data_offset,
 samples_to_process, 0);
 if (ret < 0) {
 log_error("Error filling audio frame: " + av_err2str_(ret));
 av_frame_free(&frame);
 avcodec_free_context(&codec_ctx);
 avformat_free_context(format_ctx);
 throw std::runtime_error("Error filling audio frame: " + av_err2str_(ret));
 }

 data_offset += samples_to_process;

 ret = avcodec_send_frame(codec_ctx, frame);
 if (ret < 0) {
 log_error("Error sending frame for encoding: " + av_err2str_(ret));
 av_frame_free(&frame);
 avcodec_free_context(&codec_ctx);
 avformat_free_context(format_ctx);
 throw std::runtime_error("Error sending frame for encoding: " + av_err2str_(ret));
 }

 while (ret >= 0) {
 ret = avcodec_receive_packet(codec_ctx, &pkt);
 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF) {
 break;
 }
 check_av_error(ret, "Error receiving packet");

 pkt.stream_index = stream->index;

 ret = av_interleaved_write_frame(format_ctx, &pkt);
 check_av_error(ret, "Error writing encoded frame to output file");

 av_packet_unref(&pkt);
 }
 }

 // Flush the encoder
 avcodec_send_frame(codec_ctx, nullptr);
 while (avcodec_receive_packet(codec_ctx, &pkt) == 0) {
 pkt.stream_index = stream->index;
 av_interleaved_write_frame(format_ctx, &pkt);
 av_packet_unref(&pkt);
 }

 av_write_trailer(format_ctx);

 av_frame_free(&frame);
 avcodec_free_context(&codec_ctx);
 avformat_free_context(format_ctx);

 return std::ofstream(out_f, std::ios::binary);
}
</const></int></int>

The runtime error is :


Exception thrown at 0x00007FF945137C9B (avcodec-61.dll) in cppdub_test.exe : 0xC0000005 : Access violation reading location 0x0000024CBCD25080.


for line :


ret = avcodec_send_frame(codec_ctx, frame);


Call stack :


avcodec-61.dll!00007ff945137c9b() Unknown
 avcodec-61.dll!00007ff9451381bb() Unknown
 avcodec-61.dll!00007ff945139679() Unknown
 avcodec-61.dll!00007ff94371521d() Unknown
 avcodec-61.dll!00007ff9434a80c2() Unknown
 avcodec-61.dll!00007ff9434a84a6() Unknown
 avcodec-61.dll!00007ff9434a8749() Unknown
> cppdub_test.exe!cppdub::AudioSegment::export_segment(std::string & out_f, const std::string & format, const std::string & codec, const std::string & bitrate, const std::vector> & parameters, const std::map,std::allocator>> & tags, const std::string & id3v2_version, const std::string & cover) Line 572 C++
 cppdub_test.exe!main() Line 33 C++
 [External Code] 



Autos :


+ this 0x000000d3a08ff690 {data_="\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0... ...} cppdub::AudioSegment *
+ bitrate "128000" const std::string &
+ ch_layout_1 {order=AV_CHANNEL_ORDER_NATIVE (1) nb_channels=2 u={mask=3 map=0x0000000000000003 {id=??? name=... opaque=...} } ...} AVChannelLayout
+ codec "libmp3lame" const std::string &
+ codec_ctx 0x0000024cbc78c240 {av_class=avcodec-61.dll!0x00007ff94789c760 {class_name=0x00007ff94789c740 "AVCodecContext" ...} ...} AVCodecContext *
+ codec_obj avcodec-61.dll!0x00007ff9477fa4c0 (load symbols for additional information) {name=0x00007ff9477fa47c "libmp3lame" ...} const AVCodec *
+ cover "" const std::string &
 data_offset 9216 unsigned __int64
+ format "mp3" const std::string &
+ format_ctx 0x0000024cbc788a40 {av_class=avformat-61.dll!0x00007ff99eb09fe0 {class_name=0x00007ff99eb09fc0 "AVFormatContext" ...} ...} AVFormatContext *
+ frame 0x0000024cbc787380 {data=0x0000024cbc787380 {0x0000024cbcd25080 <error reading="reading" characters="characters" of="of">, ...} ...} AVFrame *
 frame_size 9216 int
+ id3v2_version "4" const std::string &
+ out_f "ha-ha-ha.mp3" std::string &
+ parameters { size=0 } const std::vector> &
+ pkt {buf=0x0000000000000000 <null> pts=-9223372036854775808 dts=-9223372036854775808 ...} AVPacket
 ret 9216 int
 samples_to_process 9216 int
+ stream 0x0000024cbc789bc0 {av_class=avformat-61.dll!0x00007ff99eb09840 {class_name=0x00007ff99eb09820 "AVStream" ...} ...} AVStream *
+ tags { size=0 } const std::map,std::allocator>> &
</null></error>

-
Custom Segmentation Guide : How it Works & Segments to Test
13 novembre 2023, par Erin — Analytics Tips, UncategorizedStruggling to get the insights you’re looking for with premade reports and audience segments in your analytics ?
Custom segmentation can help you better understand your customers, app users or website visitors, but only if you know what you’re doing.
You can derive false insights with the wrong segments, leading your marketing campaigns or product development in the wrong direction.
In this article, we’ll break down what custom segmentation is, useful custom segments to consider, how new privacy laws affect segmentation options and how to create these segments in an analytics platform.
What is custom segmentation ?
Custom segmentation is when you divide your audience (customers, users, website visitors) into bespoke segments of your own design, not premade segments designed by the analytics or marketing platform provider.
To do this, you single out “custom segment input” — data points you will use to pinpoint certain users. For example, it could be everyone who has visited a certain page on your site.
Segmentation isn’t just useful for targeting marketing campaigns and also for analysing your customer data. Creating segments is a great way to dive deeper into your data beyond surface-level insights.
You can explore how various factors impact engagement, conversion rates, and customer lifetime value. These insights can help guide your higher-level strategy, not just campaigns.
How custom segments can help your business
As the global business world clamours to become more “data-driven,” even smaller companies collect all sorts of data on visitors, users, and customers.
However, inexperienced organisations often become “data hoarders” without meaningful insights. They have in-house servers full of data or gigabytes stored by Google Analytics and other third-party providers.
One way to leverage this data is with standard customer segmentation models. This can help you get insights into your most valuable customer groups and other standard segments.
Custom segments, in turn, can help you dive deeper. They help you unlock insights into the “why” of certain behaviours. They can help you segment customers and your audience to figure out :
- Why and how someone became a loyal customer
- How high-order-value customers interact with your site before purchases
- Which behaviours indicate audience members are likely to convert
- Which traffic sources drive the most valuable customers
This specific insight’s power led Gartner to predict that 70% of companies will shift focus from “big data” to “small and wide” by 2025. The lateral detail is what helps inform your marketing strategy.
You don’t need the same volume of data if you’re analysing and segmenting it effectively.
Custom segment inputs : 6 data points you can use to create valuable custom segments
To help you get started, here are six useful data points you can use as a basis to create segments — AKA customer segment inputs :
Visits to certain pages
A basic data point that’s great for custom segments is visits to certain pages. Create segments for popular middle-of-funnel pages and compare their engagement and conversion rates.
For example, if a user visits a case study page, you can compare their likelihood to convert vs. other visitors.
This is a type of behavioural segmentation, but it is the easiest custom segment to set up in terms of analysis and marketing efforts.
Visitors who perform certain actions
The other important type of behavioural segment is visitors or users who take certain actions. Think of things like downloading a file, clicking a link, playing a video or scrolling a certain amount.
For instance, you can create a segment of all visitors who have downloaded a white paper. This can help you explore, for example, what drives someone to download a white paper. You can look at the typical user journey and make it easier for them to access the white paper — especially if your sales reps indicate many inbound leads mention it as a key driver of their interest.
User devices
Device-based segmentation lets you compare engagement and conversion rates on mobile, desktop and tablets. You can also get insights into their usage patterns and potential issues with certain mobile elements.
This is one aspect of technographic segmentation, where you segment based on users’ hardware or software. You can also create segments based on browser software or even specific versions.
Loyal or high-value customers
The best way to get more loyal or high-value customers is to explore their journey in more detail. These types of segments can help you better understand your ideal customers and how they act on your site.
You can then use this insight to alter your campaigns or how you communicate with your target audience.
For example, you might notice that high-value customers tend to come from a certain source. You can then focus your marketing efforts on this source to reach more of your ideal customers.
Visitor or customer source
You need to track the results if you’re investing in marketing (like an influencer campaign or a sponsored post) outside platforms with their own analytics.
Before you can create a reliable segment, you need to make sure that you use campaign tracking parameters to reliably track the source. You can use our free campaign tracking URL builder for that.
Demographic segments — location (country, state) and more
Web analytics tools, such as Matomo, use visitors’ IP addresses to pinpoint their location more accurately by cross-referencing with a database of known and estimated IP locations. In addition, these tools can detect a visitor’s location through the language settings in their browser.
This can help create segments based on location or language. By exploring these trends, you can identify patterns in behaviour, tailor your content to specific audiences, and adapt your overall strategy to better meet the preferences and needs of your diverse visitor base.
How new privacy laws affect segmentation options
Over the past few years, new legislation regarding privacy and customer data has been passed globally. The most notable privacy laws are the GDPR in the EU, the CCPA in California and the VCDPA in Virginia.
For most companies, it can save a lot of work and future headaches to choose a GDPR-compliant web analytics solution not only streamlines operations, saving considerable effort and preventing future headaches, but also ensures peace of mind by guaranteeing the collection of compliant and accurate data. This approach allows companies to maintain compliance with privacy regulations while remaining firmly committed to a data-driven strategy.
Create your very own custom segments in Matomo (while ensuring compliance and data accuracy)
Crafting precise marketing messages and optimising ROI is crucial, but it becomes challenging without the right tools, especially when it comes to maintaining accurate data.
That’s where Matomo comes in. Our privacy-friendly web analytics platform is GDPR-compliant and ensures accurate data, empowering you to effortlessly create and analyse precise custom segments.
If you want to improve your marketing campaigns while remaining GDPR-compliant, start your 21-day free trial of Matomo. No credit card required.
Syndiquer tout le site
