Recherche avancée
Autres articles (53)
-
Websites made with MediaSPIP
2 mai 2011, parThis page lists some websites based on MediaSPIP.
-
MediaSPIP v0.2
21 juin 2013, parMediaSPIP 0.2 est la première version de MediaSPIP stable.
Sa date de sortie officielle est le 21 juin 2013 et est annoncée ici.
Le fichier zip ici présent contient uniquement les sources de MediaSPIP en version standalone.
Comme pour la version précédente, il est nécessaire d’installer manuellement l’ensemble des dépendances logicielles sur le serveur.
Si vous souhaitez utiliser cette archive pour une installation en mode ferme, il vous faudra également procéder à d’autres modifications (...) -
Creating farms of unique websites
13 avril 2011, parMediaSPIP platforms can be installed as a farm, with a single "core" hosted on a dedicated server and used by multiple websites.
This allows (among other things) : implementation costs to be shared between several different projects / individuals rapid deployment of multiple unique sites creation of groups of like-minded sites, making it possible to browse media in a more controlled and selective environment than the major "open" (...)
Sur d’autres sites (7885)
-
For custom FFmpeg I/O API : incorrect data about write_packet Callback function of avio_alloc_context()
13 avril 2021, par oahoI would like to ask a question about ffmpeg custom I/O api.


Description of the problem : I used the FFmpeg official example - remuxing.c to test a simple conversion package operation. (test1.ts -> test1.mp4). This operation result is normal.
But when I use Custom I/O




avio_alloc_context(buf, 65535, 1, nullptr, nullptr, write_cb, seek) ;




function, the custom I/O output is written to the memory, and then the mp4 file is written from this memory. It is found that the output file data is different from Internal file Protocol write. VLC and MediaInfo can't probe it.


I Use Beyond Compare4 to compare file data :


Beyond Compare 4 Picture Comparasion


In this picture, the left is my customized I/O output, and the right is the official example (according to file URLProtocol to Output)


I tested it many times, and each time the data size, data location, and data content are all in the same place. When I change the data of the few bytes with the difference on the left to the data on the right, VLC can play normally.


Is my operation improper, or is it another problem ?


Source Code :


extern "C"{
#include <libavformat></libavformat>avformat.h>
#include <libavcodec></libavcodec>avcodec.h>
}
#include 
#include <cstdio>
#include 
void process_error(int ret, const char* info)
{
 if( ret < 0)
 {
 fprintf(stderr, info);
 std::exit(-1);
 }
}
int fd;
int write_packet(void *opaque, uint8_t *buf, int buf_size)
 {
 int ret;
 ret = write(fd, buf, buf_size);
 printf("write bytes %d\n", ret);
 return (ret == -1) ? AVERROR(errno) : ret;
 }
 int64_t seek(void *opaque, int64_t offset, int whence)
 {
 return offset;
 }

 int main()
 {

 fd = open("/home/oaho/Desktop/22.mp4", O_CREAT | O_WRONLY, 0777);
 if ( fd < 0)
 {
 return -1;
 }


 AVFormatContext *inputContext = nullptr;
 AVFormatContext *ouputContext = nullptr;

 int ret = avformat_open_input(&inputContext, "/home/oaho/Desktop/test1.ts", nullptr, nullptr);
 process_error(ret, "could'not open input\n");
 ret = avformat_find_stream_info(inputContext, nullptr);
 process_error(ret, "could'not find stream information\n");

 avformat_alloc_output_context2(&ouputContext, nullptr, "mp4", nullptr);
 if( ouputContext == nullptr)
 process_error(-1, "could'not alloc outputContext\n");


 if( ouputContext->oformat==nullptr)
 {
 ouputContext->oformat = av_guess_format("mp4", nullptr, nullptr);
 }

 uint8_t* buf = nullptr;
 buf = (uint8_t*)av_malloc(200 * 1024);
 if( buf == nullptr)
 {
 return -1;
 }
 ouputContext->pb = nullptr;
 ouputContext->pb = avio_alloc_context(buf, 200 * 1024, 1, nullptr, nullptr, write_packet, seek);
 if( ouputContext->pb == nullptr)
 {
 return -1;
 }
 ouputContext->flags = AVFMT_FLAG_CUSTOM_IO;
 //pre the stream avalible
 int *arr = new int[inputContext->nb_streams];
 if( arr == nullptr )
 process_error(-1, "can't alloc array\n");
 int stream_index = 0;
 //get stream : video stream , audio stream , subtitle stream
 for(int i = 0;i < inputContext->nb_streams;i++)
 {
 //get the single stream
 AVStream *stream = inputContext->streams[i];
 AVStream *outStream = nullptr;
 AVCodecParameters *codec = stream->codecpar;
 if( codec -> codec_type != AVMediaType::AVMEDIA_TYPE_VIDEO
 && codec -> codec_type != AVMediaType::AVMEDIA_TYPE_AUDIO
 && codec -> codec_type != AVMediaType::AVMEDIA_TYPE_SUBTITLE)
 {
 arr[i] = -1;
 continue;
 }
 arr[i] = stream_index++;
 outStream = avformat_new_stream(ouputContext, nullptr);
 if(outStream == nullptr)
 goto end;
 int ret = avcodec_parameters_copy(outStream->codecpar, stream->codecpar);
 if( ret < 0)
 goto end;
 //not include additional information
 outStream->codecpar->codec_tag = 0;
 }
 ret = avformat_write_header(ouputContext, nullptr);
 process_error(ret, "can't write header\n");

 while(1)
 {
 AVPacket pkt;
 av_init_packet(&pkt);
 AVStream *in_stream, *out_stream;
 ret = av_read_frame(inputContext, &pkt);
 if( ret < 0)
 break; 
 in_stream = inputContext->streams[pkt.stream_index];
 if (arr[pkt.stream_index] < 0) {
 av_packet_unref(&pkt);
 continue;
 }
 pkt.stream_index = arr[pkt.stream_index];
 out_stream = ouputContext->streams[pkt.stream_index];
 /* copy packet */
 pkt.pts = av_rescale_q(pkt.pts, in_stream->time_base, out_stream->time_base);
 pkt.dts = av_rescale_q(pkt.dts, in_stream->time_base, out_stream->time_base);
 pkt.duration = av_rescale_q(pkt.duration, in_stream->time_base, out_stream->time_base);
 pkt.pos = -1;
 //log_packet(ofmt_ctx, &pkt, "out");
 ret = av_interleaved_write_frame(ouputContext, &pkt);
 if (ret < 0) {
 fprintf(stderr, "Error muxing packet\n");
 break;
 }
 av_packet_unref(&pkt);
 }
 av_write_trailer(ouputContext);
 end:
 close(fd);
 delete [] arr;
 avformat_free_context(inputContext);
 avformat_free_context(ouputContext);
 return 0;
 }
</cstdio>

-
riscv : Tweak names of cpu flags, print flags in libavutil/tests/cpu
14 décembre 2023, par Martin Storsjöriscv : Tweak names of cpu flags, print flags in libavutil/tests/cpu
The names of the cpu flags, when parsed from a string with
av_parse_cpu_caps, are parsed by the libavutil eval functions. These
interpret dashes as subtractions. Therefore, these previous cpu flag
names haven't been possible to set.Use the official names for these extensions, as the previous ad-hoc
names wasn't parseable.libavutil/tests/cpu tests that the cpu flags can be set, and prints
the detected flags.Acked-by : Rémi Denis-Courmont <remi@remlab.net>
Signed-off-by : Martin Storsjö <martin@martin.st> -
Matomo 2 reaches end of life soon (December 2017), update now !
7 décembre 2017, par Matomo Core Team — CommunityIn less than three weeks, Matomo (Piwik) 2 will be no longer supported. This means that no further (security) updates will be released for this version. As per our Long Term Support announcement, Matomo 2.X is supported for 12 months after the initial release of Matomo 3.0.0 which was on December 18th 2016. Therefore, Matomo 2 will no longer receive any updates after December 18th 2017.
It has been almost a year since we released Matomo (Piwik) 3 and we highly recommend updating to Matomo 3 ASAP. The major new release came with a new UI, performance and security improvements. If you are still on Matomo 2, the security improvements alone should be worth updating your Matomo to Matomo 3 now. We cannot recommend this enough.
The update to Matomo (Piwik) 3 should be smooth, but may take a while depending on the amount of data you have.
- If you have any problem with the update, feel free to get in touch with us, or ask in the forums.
- If you are currently using Matomo (Piwik) self-hosted and would like to be upgraded, plus your Matomo managed in the official Cloud-hosted service, contact InnoCraft Cloud and they will migrate your database.
At Matomo (Piwik) and InnoCraft, the company of the makers of Matomo, we have seen many thousands of Matomo installations upgraded over the past year and look forward to an exciting future for Matomo 3 and beyond !
Syndiquer tout le site
