Recherche avancée
Médias (2)
-
GetID3 - Bloc informations de fichiers
9 avril 2013, par
Mis à jour : Mai 2013
Langue : français
Type : Image
-
GetID3 - Boutons supplémentaires
9 avril 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Image
Autres articles (107)
-
MediaSPIP 0.1 Beta version
25 avril 2011, parMediaSPIP 0.1 beta is the first version of MediaSPIP proclaimed as "usable".
The zip file provided here only contains the sources of MediaSPIP in its standalone version.
To get a working installation, you must manually install all-software dependencies on the server.
If you want to use this archive for an installation in "farm mode", you will also need to proceed to other manual (...) -
Multilang : améliorer l’interface pour les blocs multilingues
18 février 2011, parMultilang est un plugin supplémentaire qui n’est pas activé par défaut lors de l’initialisation de MediaSPIP.
Après son activation, une préconfiguration est mise en place automatiquement par MediaSPIP init permettant à la nouvelle fonctionnalité d’être automatiquement opérationnelle. Il n’est donc pas obligatoire de passer par une étape de configuration pour cela. -
Supporting all media types
13 avril 2011, parUnlike most software and media-sharing platforms, MediaSPIP aims to manage as many different media types as possible. The following are just a few examples from an ever-expanding list of supported formats : images : png, gif, jpg, bmp and more audio : MP3, Ogg, Wav and more video : AVI, MP4, OGV, mpg, mov, wmv and more text, code and other data : OpenOffice, Microsoft Office (Word, PowerPoint, Excel), web (html, CSS), LaTeX, Google Earth and (...)
Sur d’autres sites (18106)
-
(FFMPEG) avformat_write_header crashes (MSVC2013) (C++) (Qt)
29 avril 2015, par user3502626I just downloaded FFMPEG and now I’m trying to use it in Qt with MSVC2013 compiler.
To understand how it works, I started reading the documentation and the API.
According to this figure, I was trying to make a little test with libavformat.I did all they said in the demuxing module, then the muxing module. But, my program crashes when I call the avformat_write_header() function.
I would like to know what I did wrong and if you could help me to understand that.
In the main :
av_register_all();
if(!decode())
return;The decode() methode :
bool MainWindow::decode()
{
AVFormatContext *formatContext = NULL;
AVPacket packet;
/**************** muxing varaiables ******************/
AVFormatContext *muxingContext = avformat_alloc_context();
AVOutputFormat *outputFormat = NULL;
AVIOContext *contextIO = NULL;
AVCodec *codecEncode = avcodec_find_encoder(AV_CODEC_ID_WMAV2);
AVStream *avStream = NULL;
AVCodecContext *codecContext = NULL;
/******************* demuxing **************************/
//open a media file
if(avformat_open_input(&formatContext,"h.mp3",NULL,NULL)!=0)
{
qDebug() << "paka ouve fichier";
return false;
}
//function which tries to read and decode a few frames to find missing
information.
if(avformat_find_stream_info(formatContext,NULL)<0)
{
qDebug()<<"paka find stream";
return false;
}
/**************** muxing *************************/
//The oformat field must be set to select the muxer that will be used.
muxingContext->oformat = outputFormat;
//Unless the format is of the AVFMT_NOFILE type, the pb field must be set to
//an opened IO context, either returned from avio_open2() or a custom one.
if(avio_open2(&contextIO,"out.wma",AVIO_FLAG_WRITE,NULL,NULL)<0)
{
qDebug() <<"paka kreye fichier soti";
return false;
}
muxingContext->pb = contextIO;
//Unless the format is of the AVFMT_NOSTREAMS type, at least
//one stream must be created with the avformat_new_stream() function.
avStream = avformat_new_stream(muxingContext,codecEncode);
//The caller should fill the stream codec context information,
//such as the codec type, id and other parameters
//(e.g. width / height, the pixel or sample format, etc.) as known
codecContext = avStream->codec;
codecContext->codec_type = AVMEDIA_TYPE_AUDIO;
codecContext->codec_id = AV_CODEC_ID_WMAV2;
codecContext->sample_fmt = codecEncode->sample_fmts[0];
codecContext->bit_rate = 128000;
codecContext->sample_rate = 44000;
codecContext->channels = 2;
//The stream timebase should be set to the timebase that the caller desires
//to use for this stream (note that the timebase actually used by the muxer
//can be different, as will be described later).
avStream->time_base = formatContext->streams[0]->time_base;
qDebug()<streams[0]->time_base.num <<"/"
<streams[0]->time_base.den;
//When the muxing context is fully set up, the caller must call
//avformat_write_header()
//to initialize the muxer internals and write the file header
qDebug() << "does not crash yet";
if(avformat_write_header(muxingContext,NULL) <0)
{
qDebug()<<"cannot write header";
return false;
}
qDebug() << "OOps you can't see me (John Cena)";
///////////////////// Reading from an opened file //////////////////////////
while(av_read_frame(formatContext,&packet)==0)
{
//The data is then sent to the muxer by repeatedly calling
//av_write_frame() or av_interleaved_write_frame()
if(av_write_frame(muxingContext,&packet)<0)
qDebug()<<"paka write frame";
else
qDebug()<<"writing";
}
//Once all the data has been written, the caller must call
//av_write_trailer() to flush any buffered packets and finalize
//the output file, then close the IO context (if any) and finally
//free the muxing context with avformat_free_context().
if(av_write_trailer(muxingContext)!=0)
{
qDebug()<<"paka ekri trailer";
return false;
}
return true;
}The program shows the message does not crash yet. But not OOps you can’t see me (John Cena)
And there is no error. I used an MP3 file as input and I would like to ouput it in WMA.
-
How to save/encode recorded raw PCM Data as AAC/MP4 format file in Android
28 janvier 2015, par INVISIBLEi want to save recorder pcm data as aac/mp4 format file.
i am using AudioRecord class for recording audio in android. i have success fully saved it as wave file by adding a wave header to raw data. but dont know how to save it as aac/mp4 file, because aac/mp4 format is compressed then wave.
the methods i am using for saving pcm data as wave is pasted below.recorder = new AudioRecord(MediaRecorder.AudioSource.MIC,
SavedSampleRate, RECORDER_CHANNELS, RECORDER_AUDIO_ENCODING,
bufferSize);
recorder.startRecording();
isRecording = true;
isRecording = true;
recordingThread = new Thread(new Runnable() {
@Override
public void run() {
writeAudioDataToFile();
}
}, "AudioRecorder Thread");
recordingThread.start();second
private void writeAudioDataToFile() {
byte data[] = new byte[bufferSize];
// short sData[] = new short[bufferSize];
String filename = getTempFilename();
FileOutputStream os = null;
try {
os = new FileOutputStream(filename);
} catch (Exception e) {
e.printStackTrace();
}
int read = 0;
if (null != os) {
while (isRecording) {
double sum = 0;
read = recorder.read(data, 0, bufferSize);
if (AudioRecord.ERROR_INVALID_OPERATION != read) {
try {
synchronized (this) {
// Necessary in order to convert negative shorts!
final int USHORT_MASK = (1 << 16) - 1;
final ByteBuffer buf = ByteBuffer.wrap(data).order(
ByteOrder.LITTLE_ENDIAN);
final ByteBuffer newBuf = ByteBuffer.allocate(
data.length).order(ByteOrder.LITTLE_ENDIAN);
int sample;
while (buf.hasRemaining()) {
short shortSample = buf.getShort();
sample = (int) shortSample & USHORT_MASK;
sample = sample * db_value_global;
sample = mRmsFilterSetting.filter
.apply((((int) 0) | shortSample)
* db_value_global);
newBuf.putShort((short) sample);
}
data = newBuf.array();
os.write(data);
}
} catch (Exception e) {
e.printStackTrace();
}
}
}
try {
os.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}and finally saving it as
private void copyWaveFile(ArrayList<string> inFilename, String outFilename) {
FileInputStream[] in = null;
FileOutputStream out = null;
long totalAudioLen = 0;
long totalDataLen = totalAudioLen + 36;
long longSampleRate = SavedSampleRate;
int channels = 2;
long byteRate = RECORDER_BPP * SavedSampleRate * channels / 8;
byte[] data = new byte[bufferSize];
try {
out = new FileOutputStream(outFilename);
in = new FileInputStream[inFilename.size()];
for (int i = 0; i < in.length; i++) {
in[i] = new FileInputStream(inFilename.get(i));
totalAudioLen += in[i].getChannel().size();
}
totalDataLen = totalAudioLen + 36;
WriteWaveFileHeader(out, totalAudioLen, totalDataLen,
longSampleRate, channels, byteRate);
for (int i = 0; i < in.length; i++) {
while (in[i].read(data) != -1) {
out.write(data);
}
in[i].close();
}
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
private void WriteWaveFileHeader(FileOutputStream out, long totalAudioLen,
long totalDataLen, long longSampleRate, int channels, long byteRate)
throws IOException {
byte[] header = new byte[44];
header[0] = 'R'; // RIFF/WAVE header
header[1] = 'I';
header[2] = 'F';
header[3] = 'F';
header[4] = (byte) (totalDataLen & 0xff);
header[5] = (byte) ((totalDataLen >> 8) & 0xff);
header[6] = (byte) ((totalDataLen >> 16) & 0xff);
header[7] = (byte) ((totalDataLen >> 24) & 0xff);
header[8] = 'W';
header[9] = 'A';
header[10] = 'V';
header[11] = 'E';
header[12] = 'f'; // 'fmt ' chunk
header[13] = 'm';
header[14] = 't';
header[15] = ' ';
header[16] = 16; // 4 bytes: size of 'fmt ' chunk
header[17] = 0;
header[18] = 0;
header[19] = 0;
header[20] = 1; // format = 1
header[21] = 0;
header[22] = (byte) channels;
header[23] = 0;
header[24] = (byte) (longSampleRate & 0xff);
header[25] = (byte) ((longSampleRate >> 8) & 0xff);
header[26] = (byte) ((longSampleRate >> 16) & 0xff);
header[27] = (byte) ((longSampleRate >> 24) & 0xff);
header[28] = (byte) (byteRate & 0xff);
header[29] = (byte) ((byteRate >> 8) & 0xff);
header[30] = (byte) ((byteRate >> 16) & 0xff);
header[31] = (byte) ((byteRate >> 24) & 0xff);
header[32] = (byte) (2 * 16 / 8); // block align
header[33] = 0;
header[34] = RECORDER_BPP; // bits per sample
header[35] = 0;
header[36] = 'd';
header[37] = 'a';
header[38] = 't';
header[39] = 'a';
header[40] = (byte) (totalAudioLen & 0xff);
header[41] = (byte) ((totalAudioLen >> 8) & 0xff);
header[42] = (byte) ((totalAudioLen >> 16) & 0xff);
header[43] = (byte) ((totalAudioLen >> 24) & 0xff);
out.write(header, 0, 44);
}
</string>in this piece of code i am recording small PCM files with AudioRecord and saving them as wave file by adding wave header.
is there any step by step tutorial for how to save pcm data as mp4/aac file.
thanks in advance.
-
Decoding pcm_s16le with FFMPEG ?
9 juin, par Davide Caresiai have a problem decoding a wav file using ffmpeg. I'm new to it and i'm not quite used to it.


In my application i have to input the audio file and get an array of samples to work on.
I used ffmpeg to create a function that gets in input the path of the file, the position in time where to start to output the samples and the lenght of the chunk to decode in seconds.


When I try to decode the file harp.wav everything runs fine, and I can plot the samples as in the image plot-harp.png


The file is a WAV file encoded as : pcm_u8, 11025 Hz, 1 channels, u8, 88 kb/s


The problems comes when i try to decode the file demo-unprocessed.wav.
It outputs a series of samples that has no sense. It outputs a serie of samples plotted as the image graph1-demo.jpg shows.


The file is a WAV file encoded as : pcm_s16le, 44100 Hz, 1 channels, s16, 705 kb/s


IDK where the problem in my code is, I already checked the code before and after the decoding with FFMPEG, and it works absolutely fine.


Here is the code for the dataReader.cpp :


/* Start by including the necessary */
#include "dataReader.h"
#include <cstdlib>
#include <iostream>
#include <fstream>

#ifdef __cplusplus
extern "C" {
#endif
 #include <libavcodec></libavcodec>avcodec.h> 
 #include <libavformat></libavformat>avformat.h>
 #include <libavutil></libavutil>avutil.h>
#ifdef __cplusplus 
}
#endif

using namespace std;

/* initialization function for audioChunk */
audioChunk::audioChunk(){
 data=NULL;
 size=0;
 bitrate=0;
}

/* function to get back chunk lenght in seconds */
int audioChunk::getTimeLenght(){
 return size/bitrate;
}

/* initialization function for audioChunk_dNorm */
audioChunk_dNorm::audioChunk_dNorm(){
 data=NULL;
 size=0;
 bitrate=0;
}

/* function to get back chunk lenght in seconds */
int audioChunk_dNorm::getTimeLenght(){
 return size/bitrate;
}

/* function to normalize audioChunk into audioChunk_dNorm */
void audioChunk_dNorm::fillAudioChunk(audioChunk* cnk){

 size=cnk->size;
 bitrate=cnk->bitrate;

 double min=cnk->data[0];
 double max=cnk->data[0];

 for(int i=0;isize;i++){
 if(*(cnk->data+i)>max) max=*(cnk->data+i);
 else if(*(cnk->data+i)data+i);
 }

 data=new double[size];

 for(int i=0;i/data[i]=cnk->data[i]+256*data[i+1];
 if(data[i]!=255) data[i]=2*((cnk->data[i])-(max-min)/2)/(max-min);
 else data[i]=0;
 }
 cout<<"bitrate "<* inizialize audioChunk */
 audioChunk output;

 /* Check input times */
 if((start_time<0)||(lenght<0)) {
 cout<<"Input times should be positive";
 return output;
 }

 /* Start FFmpeg */
 av_register_all();

 /* Initialize the frame to read the data and verify memory allocation */
 AVFrame* frame = av_frame_alloc();
 if (!frame)
 {
 cout << "Error allocating the frame" << endl;
 return output;
 }

 /* Initialization of the Context, to open the file */
 AVFormatContext* formatContext = NULL;
 /* Opening the file, and check if it has opened */
 if (avformat_open_input(&formatContext, path_name, NULL, NULL) != 0)
 {
 av_frame_free(&frame);
 cout << "Error opening the file" << endl;
 return output;
 }

 /* Find the stream info, if not found, exit */
 if (avformat_find_stream_info(formatContext, NULL) < 0)
 {
 av_frame_free(&frame);
 avformat_close_input(&formatContext);
 cout << "Error finding the stream info" << endl;
 return output;
 }

 /* Check inputs to verify time input */
 if(start_time>(formatContext->duration/1000000)){
 cout<< "Error, start_time is over file duration"<* Chunk = number of samples to output */
 long long int chunk = ((formatContext->bit_rate)*lenght/8);
 /* Start = address of sample where start to read */
 long long int start = ((formatContext->bit_rate)*start_time/8);
 /* Tot_sampl = number of the samples in the file */
 long long int tot_sampl = (formatContext->bit_rate)*(formatContext->duration)/8000000;

 /* Set the lenght of chunk to avoid segfault and to read all the file */
 if (start+chunk>tot_sampl) {chunk = tot_sampl-start;}
 if (lenght==0) {start = 0; chunk = tot_sampl;}

 /* initialize the array to output */
 output.data = new unsigned char[chunk];
 output.bitrate = formatContext->bit_rate;
 output.size=chunk;

 av_dump_format(formatContext,0,NULL,0);
 cout<* Find the audio Stream, if no audio stream are found, clean and exit */
 AVCodec* cdc = NULL;
 int streamIndex = av_find_best_stream(formatContext, AVMEDIA_TYPE_AUDIO, -1, -1, &cdc, 0);
 if (streamIndex < 0)
 {
 av_frame_free(&frame);
 avformat_close_input(&formatContext);
 cout << "Could not find any audio stream in the file" << endl;
 return output;
 }

 /* Open the audio stream to read data in audioStream */
 AVStream* audioStream = formatContext->streams[streamIndex];

 /* Initialize the codec context */
 AVCodecContext* codecContext = audioStream->codec;
 codecContext->codec = cdc;
 /* Open the codec, and verify if it has opened */
 if (avcodec_open2(codecContext, codecContext->codec, NULL) != 0)
 {
 av_frame_free(&frame);
 avformat_close_input(&formatContext);
 cout << "Couldn't open the context with the decoder" << endl;
 return output;
 }

 /* Initialize buffer to store compressed packets */
 AVPacket readingPacket;
 av_init_packet(&readingPacket);


 int j=0;
 int count = 0; 

 while(av_read_frame(formatContext, &readingPacket)==0){
 if((count+readingPacket.size)>start){
 if(readingPacket.stream_index == audioStream->index){

 AVPacket decodingPacket = readingPacket;

 // Audio packets can have multiple audio frames in a single packet
 while (decodingPacket.size > 0){
 // Try to decode the packet into a frame
 // Some frames rely on multiple packets, so we have to make sure the frame is finished before
 // we can use it
 int gotFrame = 0;
 int result = avcodec_decode_audio4(codecContext, frame, &gotFrame, &decodingPacket);

 count += result;

 if (result >= 0 && gotFrame)
 {
 decodingPacket.size -= result;
 decodingPacket.data += result;
 int a;

 for(int i=0;idata[0][i];

 j++;
 if(j>=chunk) break;
 }

 // We now have a fully decoded audio frame
 }
 else
 {
 decodingPacket.size = 0;
 decodingPacket.data = NULL;
 }
 if(j>=chunk) break;
 }
 } 
 }else count+=readingPacket.size;

 // To prevent memory leak, must free packet.
 av_free_packet(&readingPacket);
 if(j>=chunk) break;
 }

 // Some codecs will cause frames to be buffered up in the decoding process. If the CODEC_CAP_DELAY flag
 // is set, there can be buffered up frames that need to be flushed, so we'll do that
 if (codecContext->codec->capabilities & CODEC_CAP_DELAY)
 {
 av_init_packet(&readingPacket);
 // Decode all the remaining frames in the buffer, until the end is reached
 int gotFrame = 0;
 int a;
 int result=avcodec_decode_audio4(codecContext, frame, &gotFrame, &readingPacket);
 while (result >= 0 && gotFrame)
 {
 // We now have a fully decoded audio frame
 for(int i=0;idata[0][i];

 j++;
 if(j>=chunk) break;
 }
 if(j>=chunk) break;
 }
 }

 // Clean up!
 av_free(frame);
 avcodec_close(codecContext);
 avformat_close_input(&formatContext);

 cout<<"Ended Reading, "<code></fstream></iostream></cstdlib>

Here is the dataReader.h


/* 
 * File: dataReader.h
 * Author: davide
 *
 * Created on 27 luglio 2015, 11.11
 */

#ifndef DATAREADER_H
#define DATAREADER_H

/* function that reads a file and outputs an array of samples
 * @ path_name = the path of the file to read
 * @ start_time = the position where to start the data reading, 0 = start
 * the time is in seconds, it can hold to 10e-6 seconds
 * @ lenght = the lenght of the frame to extract the data, 
 * 0 = read all the file (do not use with big files)
 * if lenght > of file duration, it reads through the end of file.
 * the time is in seconds, it can hold to 10e-6 seconds 
 */

#include 

class audioChunk{
public:
 uint8_t *data;
 unsigned int size;
 int bitrate;
 int getTimeLenght();
 audioChunk();
};

class audioChunk_dNorm{
public:
 double* data;
 unsigned int size;
 int bitrate;
 int getTimeLenght();
 void fillAudioChunk(audioChunk* cnk);
 audioChunk_dNorm();
};

audioChunk readData(const char* path_name, const double start_time, const double lenght);

#endif /* DATAREADER_H */


And finally there is the main.cpp of the application.


/* 
 * File: main.cpp
 * Author: davide
 *
 * Created on 28 luglio 2015, 17.04
 */

#include <cstdlib>
#include "dataReader.h"
#include "transforms.h"
#include "tognuplot.h"
#include <fstream>
#include <iostream>

using namespace std;

/*
 * 
 */
int main(int argc, char** argv) {

 audioChunk *chunk1=new audioChunk;

 audioChunk_dNorm *normChunk1=new audioChunk_dNorm;

 *chunk1=readData("./audio/demo-unprocessed.wav",0,1);

 normChunk1->fillAudioChunk(chunk1);

 ofstream file1;
 file1.open("./file/2wave.txt", std::ofstream::trunc);
 if(file1.is_open()) {
 for(int i=0;isize;i++) {
 int a=chunk1->data[i];
 file1<code></iostream></fstream></cstdlib>

I can't understand why the outputs goes like this. Is it possible that the decoder can't convert the samples (pcm_16le, 16bits) into FFMPEG AVFrame.data, that stores the samples ad uint8_t ? And if it is it is there some way to make FFMPEG work for audio files that stores samples at more than 8 bits ?


The file graph1-demo_good.jpg is how the samples should be, extracted with a working LIBSNDFILE application that I made.


EDIT : Seems like the program can't convert the decoded data, couples of little endian bytes stored in a couple of uint8_t unsigned char, into the destination format (that i set as unsigned char[]), because it stores the bits as little-endian 16 bytes. So the data into audioChunk.data is right, but I have to read it not as an unsigned char, but as a couple of little-endian bytes.


Syndiquer tout le site
