
Recherche avancée
Médias (1)
-
Bug de détection d’ogg
22 mars 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Video
Autres articles (74)
-
Le profil des utilisateurs
12 avril 2011, parChaque 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, parAccé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 (...) -
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
Sur d’autres sites (12580)
-
Why do I get a EXC_BAD_ACCESS error while running a simple sws_scale function ? [closed]
3 décembre 2022, par VishAll I'm trying to do is decode a video using ffmpeg, and change format from YUV to RGBA using sws_scale. The code is as follows :


`


#include "video_reader.hpp"
#include 
#include <iostream>

using namespace std;

// av_err2str returns a temporary array. This doesn't work in gcc.
// This function can be used as a replacement for av_err2str.
static const char* av_make_error(int errnum) {
 static char str[AV_ERROR_MAX_STRING_SIZE];
 memset(str, 0, sizeof(str));
 return av_make_error_string(str, AV_ERROR_MAX_STRING_SIZE, errnum);
}

static AVPixelFormat correct_for_deprecated_pixel_format(AVPixelFormat pix_fmt) {
 // Fix swscaler deprecated pixel format warning
 // (YUVJ has been deprecated, change pixel format to regular YUV)
 switch (pix_fmt) {
 case AV_PIX_FMT_YUVJ420P: return AV_PIX_FMT_YUV420P;
 case AV_PIX_FMT_YUVJ422P: return AV_PIX_FMT_YUV422P;
 case AV_PIX_FMT_YUVJ444P: return AV_PIX_FMT_YUV444P;
 case AV_PIX_FMT_YUVJ440P: return AV_PIX_FMT_YUV440P;
 default: return pix_fmt;
 }
}

bool video_reader_open(VideoReaderState* state, const char* filename) {

 // Unpack members of state
 auto& width = state->width;
 auto& height = state->height;
 auto& time_base = state->time_base;
 auto& av_format_ctx = state->av_format_ctx;
 auto& av_codec_ctx = state->av_codec_ctx;
 auto& video_stream_index = state->video_stream_index;
 auto& av_frame = state->av_frame;
 auto& av_packet = state->av_packet;

 // Open the file using libavformat
 av_format_ctx = avformat_alloc_context();
 if (!av_format_ctx) {
 printf("Couldn't created AVFormatContext\n");
 return false;
 }

 if (avformat_open_input(&av_format_ctx, filename, NULL, NULL) != 0) {
 printf("Couldn't open video file\n");
 return false;
 }

 // Find the first valid video stream inside the file
 video_stream_index = -1;
 AVCodecParameters* av_codec_params;
 AVCodec* av_codec;
 for (int i = 0; i < av_format_ctx->nb_streams; ++i) {
 av_codec_params = av_format_ctx->streams[i]->codecpar;
 if (!avcodec_find_decoder(av_codec_params->codec_id)) {
 continue;
 }
 if (av_codec_params->codec_type == AVMEDIA_TYPE_VIDEO) {
 video_stream_index = i;
 width = av_codec_params->width;
 height = av_codec_params->height;
 time_base = av_format_ctx->streams[i]->time_base;
 break;
 }
 }
 if (video_stream_index == -1) {
 printf("Couldn't find valid video stream inside file\n");
 return false;
 }

 // Set up a codec context for the decoder
 av_codec_ctx = avcodec_alloc_context3(avcodec_find_decoder(av_codec_params->codec_id));
 if (!av_codec_ctx) {
 printf("Couldn't create AVCodecContext\n");
 return false;
 }
 if (avcodec_parameters_to_context(av_codec_ctx, av_codec_params) < 0) {
 printf("Couldn't initialize AVCodecContext\n");
 return false;
 }
 if (avcodec_open2(av_codec_ctx, avcodec_find_decoder(av_codec_params->codec_id), NULL) < 0) {
 printf("Couldn't open codec\n");
 return false;
 }

 av_frame = av_frame_alloc();
 if (!av_frame) {
 printf("Couldn't allocate AVFrame\n");
 return false;
 }
 av_packet = av_packet_alloc();
 if (!av_packet) {
 printf("Couldn't allocate AVPacket\n");
 return false;
 }

 return true;
}

bool video_reader_read_frame(VideoReaderState* state, uint8_t* frame_buffer, int64_t* pts) {

 // Unpack members of state
 auto& width = state->width;
 auto& height = state->height;
 auto& av_format_ctx = state->av_format_ctx;
 auto& av_codec_ctx = state->av_codec_ctx;
 auto& video_stream_index = state->video_stream_index;
 auto& av_frame = state->av_frame;
 auto& av_packet = state->av_packet;
 auto& sws_scaler_ctx = state->sws_scaler_ctx;

 // Decode one frame
 int response;
 while (av_read_frame(av_format_ctx, av_packet) >= 0) {
 if (av_packet->stream_index != video_stream_index) {
 av_packet_unref(av_packet);
 continue;
 }

 response = avcodec_send_packet(av_codec_ctx, av_packet);
 if (response < 0) {
 printf("Failed to decode packet: %s\n", av_make_error(response));
 return false;
 }

 response = avcodec_receive_frame(av_codec_ctx, av_frame);
 if (response == AVERROR(EAGAIN) || response == AVERROR_EOF) {
 av_packet_unref(av_packet);
 continue;
 } else if (response < 0) {
 printf("Failed to decode packet: %s\n", av_make_error(response));
 return false;
 }

 av_packet_unref(av_packet);
 break;
 }

 *pts = av_frame->pts;
 

 // Set up sws scaler
 if (!sws_scaler_ctx) {
 auto source_pix_fmt = correct_for_deprecated_pixel_format(av_codec_ctx->pix_fmt);
 sws_scaler_ctx = sws_getContext(width, height, AV_PIX_FMT_YUV420P,
 width, height, AV_PIX_FMT_RGB0,
 SWS_FAST_BILINEAR, NULL, NULL, NULL);
 }
 if (!sws_scaler_ctx) {
 printf("Couldn't initialize sw scaler\n");
 return false;
 }

 cout << av_codec_ctx->pix_fmt << endl;
 uint8_t* dest[4] = { frame_buffer, NULL, NULL, NULL };
 int dest_linesize[4] = { width * 4, 0, 0, 0 };
 sws_scale(sws_scaler_ctx, av_frame->data, av_frame->linesize, 0, av_frame->height, dest, dest_linesize);

 return true;
}

bool video_reader_seek_frame(VideoReaderState* state, int64_t ts) {
 
 // Unpack members of state
 auto& av_format_ctx = state->av_format_ctx;
 auto& av_codec_ctx = state->av_codec_ctx;
 auto& video_stream_index = state->video_stream_index;
 auto& av_packet = state->av_packet;
 auto& av_frame = state->av_frame;
 
 av_seek_frame(av_format_ctx, video_stream_index, ts, AVSEEK_FLAG_BACKWARD);

 // av_seek_frame takes effect after one frame, so I'm decoding one here
 // so that the next call to video_reader_read_frame() will give the correct
 // frame
 int response;
 while (av_read_frame(av_format_ctx, av_packet) >= 0) {
 if (av_packet->stream_index != video_stream_index) {
 av_packet_unref(av_packet);
 continue;
 }

 response = avcodec_send_packet(av_codec_ctx, av_packet);
 if (response < 0) {
 printf("Failed to decode packet: %s\n", av_make_error(response));
 return false;
 }

 response = avcodec_receive_frame(av_codec_ctx, av_frame);
 if (response == AVERROR(EAGAIN) || response == AVERROR_EOF) {
 av_packet_unref(av_packet);
 continue;
 } else if (response < 0) {
 printf("Failed to decode packet: %s\n", av_make_error(response));
 return false;
 }

 av_packet_unref(av_packet);
 break;
 }

 return true;
}

void video_reader_close(VideoReaderState* state) {
 sws_freeContext(state->sws_scaler_ctx);
 avformat_close_input(&state->av_format_ctx);
 avformat_free_context(state->av_format_ctx);
 av_frame_free(&state->av_frame);
 av_packet_free(&state->av_packet);
 avcodec_free_context(&state->av_codec_ctx);
}

</iostream>


`
This gives me the following error at the sws_scale step, during debugging. Could you please let me know what it is I could be doing wrong ?


EXC_BAD_ACCESS (code=1, address=0x910043e491224463)


I was expecting to get the RGBA array as shown in various tutorials.


-
avcodec/avcodec : Deprecate AV_INPUT_BUFFER_MIN_SIZE
17 février 2024, par Andreas Rheinhardtavcodec/avcodec : Deprecate AV_INPUT_BUFFER_MIN_SIZE
It used to be used with preallocated packet buffers with
the old encode API, but said API is no more and therefore
there is no reason for this to be public any more.
So deprecate it and use an internal replacement
for the encoders using it as an upper bound for the
size of their headers.Signed-off-by : Andreas Rheinhardt <andreas.rheinhardt@outlook.com>
- [DH] doc/APIchanges
- [DH] libavcodec/asvenc.c
- [DH] libavcodec/avcodec.h
- [DH] libavcodec/encode.h
- [DH] libavcodec/ffv1enc.c
- [DH] libavcodec/flashsv2enc.c
- [DH] libavcodec/gif.c
- [DH] libavcodec/huffyuvenc.c
- [DH] libavcodec/j2kenc.c
- [DH] libavcodec/jpeglsenc.c
- [DH] libavcodec/libxvid.c
- [DH] libavcodec/ljpegenc.c
- [DH] libavcodec/msrleenc.c
- [DH] libavcodec/msvideo1enc.c
- [DH] libavcodec/pngenc.c
- [DH] libavcodec/proresenc_anatoliy.c
- [DH] libavcodec/proresenc_kostya.c
- [DH] libavcodec/snowenc.c
- [DH] libavcodec/svq1enc.c
- [DH] libavcodec/tiffenc.c
- [DH] libavcodec/version.h
- [DH] libavcodec/version_major.h
-
Anomalie #3517 (Nouveau) : Supporter _AUTO_BR dans les listes à puces
28 juillet 2015, par kent1 -Je ressors une discussion d’il y a quelques temps sur IRC au sujet des sauts de lignes dans les puces qui ne sont pas interprétés actuellement.
Pour ce faire, il suffit dans
plugins-dist/textwheel/spip/spip-listes.php
de remplacer la ligne 97$t = $ajout . str_replace("\n", _AUTOBR."\n",$t[3]);
par$t = $ajout . $t[3];
En gros cela permettrait de traiter les sauts de lignes dans un item de liste comme
<br />
La discussion sur IRC :
18:56:59 kent1: vous voyez un inconvénient d'ajouter le support de _AUTO_BR dans les listes à puces?
19:01:49 _fil_: tu penses à uqoi ?
19:03:35 denisb_mbp: ne pas avoir à utiliser le _ dans le raccourci _fil_
19:03:44 denisb_mbp: pour "aller à la ligne"
19:04:24 denisb_mbp: sauf que faudra quand même l'utiliser pour un double saut de ligne
19:04:29 denisb_mbp: ...
19:04:44 denisb_mbp: sinon y'aura confusion avec la fin de la liste
19:04:50 denisb_mbp: hum...
19:07:40 _fil_: et ça marche pas déjà ?
19:17:48 kent1: ligne 98 de wheels/spip/spip-listes.php
19:17:54 kent1: changer par $t = $ajout . str_replace("\n", _AUTOBR."\n",$t[3]);
19:18:24 kent1: $t[3] étant le texte du contenu après la puce
19:30:16 kent1: comme c'est fait dans paragrapher
19:30:18 kent1: en fait
19:33:53 kent1: "sauf que faudra quand même l'utiliser pour un double saut de ligne" denisb…
19:34:05 kent1: pour fermer une liste on saute une ligne non?
19:34:12 denisb_mbp: ouaip
19:34:24 kent1: donc c'est bon ça devrait pas casser le truc
19:34:32 kent1: puisque la découpe est faite en amont
19:34:55 kent1: la découpe des -* texte etc etc...
19:35:16 kent1: là on ne touche que à "texte etc etc avec des \n dedans"
19:35:31 kent1: *vient de tester et ça marche pas mal*
19:36:29 denisb_mbp: voui...
19:36:48 denisb_mbp: mais \n\n sera traduit par fin de liste et pas par <p>
19:37:23 denisb_mbp: donc pour avoir un </p><p> dans une liste faudra jongler entre \n (autobr) et _ (non marque de fin de fin de liste)
19:37:35 denisb_mbp: mais bon...
19:38:29 kent1: _ ne fera pas de p comme "-* blahbla….\n\n" non plus" à ce que je pense là… \n\n coupe une liste avec un </p><p> entre deux </p><ul> non?
19:38:33 kent1: actuellement
19:55:08 denisb_mbp: ce que je veux dire kent1 c'est que actuellement pour "passer une ligne" dans une liste il me semble bien qu'il faut utiliser un _ non ?
19:55:20 denisb_mbp: pour forcer un retour ligne
19:56:13 denisb_mbp: et pour forcer une ligne blanche il faut donc un double _
19:56:19 kent1: oui c'est ça
19:56:23 kent1: ah ok
19:56:28 kent1: oui effectivement
19:56:34 denisb_mbp: avec autobr, il va y avoir mélange
19:56:45 kent1: oui possible
19:57:00 kent1: en tout cas
19:57:03 kent1: ça marche bien
19:57:04 denisb_mbp: un simple clic sur enter pour aller à la ligne (un \n) mais toujours la nécessité d'un double _ pour sauter une ligne
19:57:13 kent1: yop
19:57:29 denisb_mbp: bref c'est pas ce qu'il y a de plus grave non plus hein !
19:58:02 kent1: le truc c'est que maintenant les users ont l'habitude du \n => <br />
19:58:15 kent1: enfin bref
19:58:20 denisb_mbp: oué
</ul>