Recherche avancée
Médias (1)
-
The pirate bay depuis la Belgique
1er avril 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Image
Autres articles (107)
-
Les autorisations surchargées par les plugins
27 avril 2010, parMediaspip core
autoriser_auteur_modifier() afin que les visiteurs soient capables de modifier leurs informations sur la page d’auteurs -
(Dés)Activation de fonctionnalités (plugins)
18 février 2011, parPour gérer l’ajout et la suppression de fonctionnalités supplémentaires (ou plugins), MediaSPIP utilise à partir de la version 0.2 SVP.
SVP permet l’activation facile de plugins depuis l’espace de configuration de MediaSPIP.
Pour y accéder, il suffit de se rendre dans l’espace de configuration puis de se rendre sur la page "Gestion des plugins".
MediaSPIP est fourni par défaut avec l’ensemble des plugins dits "compatibles", ils ont été testés et intégrés afin de fonctionner parfaitement avec chaque (...) -
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
Sur d’autres sites (21364)
-
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
