Recherche avancée
Médias (2)
-
Rennes Emotion Map 2010-11
19 octobre 2011, par
Mis à jour : Juillet 2013
Langue : français
Type : Texte
-
Carte de Schillerkiez
13 mai 2011, par
Mis à jour : Septembre 2011
Langue : English
Type : Texte
Autres articles (58)
-
Encodage et transformation en formats lisibles sur Internet
10 avril 2011MediaSPIP transforme et ré-encode les documents mis en ligne afin de les rendre lisibles sur Internet et automatiquement utilisables sans intervention du créateur de contenu.
Les vidéos sont automatiquement encodées dans les formats supportés par HTML5 : MP4, Ogv et WebM. La version "MP4" est également utilisée pour le lecteur flash de secours nécessaire aux anciens navigateurs.
Les documents audios sont également ré-encodés dans les deux formats utilisables par HTML5 :MP3 et Ogg. La version "MP3" (...) -
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 -
ANNEXE : Les plugins utilisés spécifiquement pour la ferme
5 mars 2010, parLe site central/maître de la ferme a besoin d’utiliser plusieurs plugins supplémentaires vis à vis des canaux pour son bon fonctionnement. le plugin Gestion de la mutualisation ; le plugin inscription3 pour gérer les inscriptions et les demandes de création d’instance de mutualisation dès l’inscription des utilisateurs ; le plugin verifier qui fournit une API de vérification des champs (utilisé par inscription3) ; le plugin champs extras v2 nécessité par inscription3 (...)
Sur d’autres sites (8831)
-
libavcodec audio decoding is producing garbeld samples
14 novembre 2024, par user28288805I'm trying to write a function that extracts the raw sample data from audio files. But when debugging with a test file I found that the samples in floating point planar format were not in range of -1.0f to 1.0f as specified in the documentation.


Here is the function :


AudioResource::ReturnCode AudioResource::LoadFromFile(std::string FilePath)
{
 std::string FileURL = "file:" + FilePath;
 AVFormatContext* FormatContext = nullptr;
 int Error = avformat_open_input(&FormatContext, FileURL.c_str(), nullptr, nullptr);

 if (Error < 0)
 {
 return ERROR_OPENING_FILE;
 }

 Error = avformat_find_stream_info(FormatContext, nullptr);
 if (Error < 0)
 {
 return ERROR_FINDING_STREAM_INFO;
 }

 int AudioStream = -1;
 AVCodecParameters* CodecParams;
 for (int i = 0; i < FormatContext->nb_streams; i++)
 {
 if (FormatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_AUDIO)
 {
 CodecParams = FormatContext->streams[i]->codecpar;
 AudioStream = i;
 }
 }

 if (AudioStream == -1)
 {
 return ERROR_AUDIO_STREAM_NOT_FOUND;
 }

 SampleRate = FormatContext->streams[AudioStream]->codecpar->sample_rate;
 AVSampleFormat SampleFormat = (AVSampleFormat) FormatContext->streams[AudioStream]->codecpar->format;
 Channels = FormatContext->streams[AudioStream]->codecpar->ch_layout.nb_channels;

 if (Channels > 2)
 {
 return ERROR_UNSUPPORTED_CHANNEL_COUNT;
 }

 switch (SampleFormat)
 {
 case AV_SAMPLE_FMT_NONE:
 return ERROR_UNKWON_SAMPLE_FORMAT;
 break;
 case AV_SAMPLE_FMT_U8:
 BytesPerSample = 1;
 if (Channels == 1)
 {
 SampleType == MONO_8BIT;
 }
 else
 {
 SampleType = STEREO_8BIT;
 }
 break;
 case AV_SAMPLE_FMT_S16:
 BytesPerSample = 2;
 if (Channels == 1)
 {
 SampleType = MONO_16BIT;
 }
 else
 {
 SampleType = STEREO_16BIT;
 }
 break;
 case AV_SAMPLE_FMT_S32:
 BytesPerSample = 2;
 if (Channels == 1)
 {
 SampleType = MONO_16BIT;
 }
 else
 {
 SampleType= STEREO_16BIT;
 }
 break;
 case AV_SAMPLE_FMT_FLT:
 BytesPerSample = 2;
 if (Channels == 1)
 {
 SampleType = MONO_16BIT;
 }
 else
 {
 SampleType = STEREO_16BIT;
 }
 break;
 case AV_SAMPLE_FMT_DBL:
 BytesPerSample = 2;
 if (Channels == 1)
 {
 SampleType = MONO_16BIT;
 }
 else
 {
 SampleType = STEREO_16BIT;
 }
 break;
 case AV_SAMPLE_FMT_U8P:
 BytesPerSample = 1;
 if (Channels == 1)
 {
 SampleType = MONO_8BIT;
 }
 else
 {
 SampleType = STEREO_8BIT;
 }
 break;
 case AV_SAMPLE_FMT_S16P:
 BytesPerSample = 2;
 if (Channels == 1)
 {
 SampleType = MONO_16BIT;
 }
 else
 {
 SampleType = STEREO_16BIT;
 }
 break;
 case AV_SAMPLE_FMT_S32P:
 BytesPerSample = 2;
 if (Channels == 1)
 {
 SampleType = MONO_16BIT;
 }
 else
 {
 SampleType = STEREO_16BIT;
 }
 break;
 case AV_SAMPLE_FMT_FLTP:
 BytesPerSample = 2;
 if (Channels == 1)
 {
 SampleType = MONO_16BIT;
 }
 else
 {
 SampleType = STEREO_16BIT;
 }
 break;
 case AV_SAMPLE_FMT_DBLP:
 BytesPerSample = 2;
 if (Channels == 1)
 {
 SampleType = MONO_16BIT;
 }
 else
 {
 SampleType = STEREO_16BIT;
 }
 break;
 case AV_SAMPLE_FMT_S64:
 BytesPerSample = 2;
 if (Channels == 1)
 {
 SampleType = MONO_16BIT;
 }
 else
 {
 SampleType = STEREO_16BIT;
 }
 break;
 case AV_SAMPLE_FMT_S64P:
 BytesPerSample = 2;
 if (Channels == 1)
 {
 SampleType = MONO_16BIT;
 }
 else
 {
 SampleType = STEREO_16BIT;
 }
 break;
 default:
 return ERROR_UNKWON_SAMPLE_FORMAT;
 break;
 }

 const AVCodec* AudioCodec = avcodec_find_decoder(CodecParams->codec_id);
 AVCodecContext* CodecContext = avcodec_alloc_context3(AudioCodec);
 avcodec_parameters_to_context(CodecContext, CodecParams);
 avcodec_open2(CodecContext, AudioCodec, nullptr);

 AVPacket* CurrentPacket = av_packet_alloc();
 AVFrame* CurrentFrame = av_frame_alloc();

 while (av_read_frame(FormatContext, CurrentPacket) >= 0)
 {
 avcodec_send_packet(CodecContext, CurrentPacket);
 for (;;)
 {
 Error = avcodec_receive_frame(CodecContext, CurrentFrame);
 if ((Error == AVERROR(EAGAIN)) || (Error == AVERROR_EOF))
 {
 break;
 }
 else if (Error == AVERROR(EINVAL))
 {
 return ERROR_RECIVING_FRAME;
 }
 else if (Error != 0)
 {
 return ERROR_UNEXSPECTED;
 }

 if (SampleFormat == AV_SAMPLE_FMT_U8)
 {

 }
 else if (SampleFormat == AV_SAMPLE_FMT_S16)
 {

 }
 else if (SampleFormat == AV_SAMPLE_FMT_S32)
 {

 }
 else if (SampleFormat == AV_SAMPLE_FMT_FLT)
 {

 }
 else if (SampleFormat == AV_SAMPLE_FMT_DBL)
 {

 }
 else if (SampleFormat == AV_SAMPLE_FMT_U8P)
 {

 }
 else if (SampleFormat == AV_SAMPLE_FMT_S16P)
 {

 }
 else if (SampleFormat == AV_SAMPLE_FMT_S32P)
 {

 }
 else if (SampleFormat == AV_SAMPLE_FMT_FLTP) //
 {
 if (Channels == 2)
 {
 for (size_t i = 0; i < CurrentFrame->linesize[0]; i += sizeof(float))
 {
 float CurrentLeftSample = 0.0f;
 float CurrentRightSample = 0.0f;
 memcpy(&CurrentLeftSample, &CurrentFrame->data[0][i], sizeof(float));
 memcpy(&CurrentRightSample, &CurrentFrame->data[1][i], sizeof(float));

 short int QuantizedLeftSample = roundf(CurrentLeftSample * 0x7fff);
 short int QuantizedRightSample = roundf(CurrentRightSample * 0x7fff);

 LoadByteData<short int="int">(QuantizedLeftSample, AudioData);
 LoadByteData<short int="int">(QuantizedRightSample, AudioData);
 }
 }
 else
 {

 }
 }
 else if (SampleFormat == AV_SAMPLE_FMT_DBLP)
 {

 }
 else if (SampleFormat == AV_SAMPLE_FMT_S64)
 {

 }
 else if (SampleFormat == AV_SAMPLE_FMT_S64P)
 {

 }
 else
 {
 return ERROR_UNEXSPECTED;
 }
 }
 }

 av_frame_free(&CurrentFrame);
 av_packet_free(&CurrentPacket);
 avcodec_free_context(&CodecContext);
 avformat_free_context(FormatContext);
 return OK;
}
</short></short>

Here is where I am reading from AVFrame's buffer


for (size_t i = 0; i < CurrentFrame->linesize[0]; i += sizeof(float))
 {
 float CurrentLeftSample = 0.0f;
 float CurrentRightSample = 0.0f;
 memcpy(&CurrentLeftSample, &CurrentFrame->data[0][i], sizeof(float));
 memcpy(&CurrentRightSample, &CurrentFrame->data[1][i], sizeof(float));

 short int QuantizedLeftSample = roundf(CurrentLeftSample * 0x7fff);
 short int QuantizedRightSample = roundf(CurrentRightSample * 0x7fff);

 LoadByteData<short int="int">(QuantizedLeftSample, AudioData);
 LoadByteData<short int="int">(QuantizedRightSample, AudioData);
 }
</short></short>

Ive tried using different parameters like
CurrentFrame->nb_samples,CurrentFrame->buf[0].sizein the for loop with no success it still produces the same results.

Any help would be much appreciated.


-
sws_scale generates malformed video
29 juillet 2024, par GiuTorI have to encode a series of frames from CAIRO_FORMAT_ARGB32 to AV_PIX_FMT_YUV420P with sws_scale. From the ffmpeg docs I came to know the AV equivalent of the source format is AV_PIX_FMT_ARGB so here is my code :


// Set up conversion context
 img->sws_ctx = sws_getCachedContext(
 img->sws_ctx,
 img->video_size[0],
 img->video_size[1],
 AV_PIX_FMT_ARGB,
 img->video_size[0],
 img->video_size[1],
 AV_PIX_FMT_YUV420P,
 SWS_BILINEAR,
 NULL,
 NULL,
 NULL);

 width = cairo_image_surface_get_width( surface );
 height = cairo_image_surface_get_height( surface );
 stride = cairo_image_surface_get_stride( surface );
 pix = cairo_image_surface_get_data( surface );
 const int in_linesize[1] = { stride };
 
 sws_scale( img->sws_ctx, (const uint8_t * const *) &pix, in_linesize, 0,
 img->video_size[1], img->video_frame->data, img->video_frame->linesize);
 img->video_frame->pts++;


Sadly the video doesn't play and VLC shows a bunch of these useless messages :


[h264 @ 0x7f6ce0cbc1c0] mmco: unref short failure
[h264 @ 0x7f6ce0c39a80] co located POCs unavailable
[h264 @ 0x7f6ce0c82800] co located POCs unavailable
[h264 @ 0x7f6ce0c9f400] mmco: unref short failure


The encoding process runs just fine. I also tried with const int in_linesize[1] = 3 * width ; Where am I wrong ?


-
speedhq : fix out-of-bounds write
1er février 2017, par Steinar H. Gundersonspeedhq : fix out-of-bounds write
Certain alpha run lengths (for SHQ1/SHQ3/SHQ5) could be stored in
both long and short versions, and we would only accept the short version,
returning -1 (invalid code) for the others. This could cause an
out-of-bounds write on malicious input, as discovered by
Andreas Cadhalpun during fuzzing.Fix by simply allowing both versions, leaving no invalid codes
in the alpha VLC.Signed-off-by : Andreas Cadhalpun <Andreas.Cadhalpun@googlemail.com>
Syndiquer tout le site
