Recherche avancée
Médias (91)
-
Richard Stallman et le logiciel libre
19 octobre 2011, par
Mis à jour : Mai 2013
Langue : français
Type : Texte
-
Stereo master soundtrack
17 octobre 2011, par
Mis à jour : Octobre 2011
Langue : English
Type : Audio
-
Elephants Dream - Cover of the soundtrack
17 octobre 2011, par
Mis à jour : Octobre 2011
Langue : English
Type : Image
-
#7 Ambience
16 octobre 2011, par
Mis à jour : Juin 2015
Langue : English
Type : Audio
-
#6 Teaser Music
16 octobre 2011, par
Mis à jour : Février 2013
Langue : English
Type : Audio
-
#5 End Title
16 octobre 2011, par
Mis à jour : Février 2013
Langue : English
Type : Audio
Autres articles (84)
-
Amélioration de la version de base
13 septembre 2013Jolie sélection multiple
Le plugin Chosen permet d’améliorer l’ergonomie des champs de sélection multiple. Voir les deux images suivantes pour comparer.
Il suffit pour cela d’activer le plugin Chosen (Configuration générale du site > Gestion des plugins), puis de configurer le plugin (Les squelettes > Chosen) en activant l’utilisation de Chosen dans le site public et en spécifiant les éléments de formulaires à améliorer, par exemple select[multiple] pour les listes à sélection multiple (...) -
Menus personnalisés
14 novembre 2010, parMediaSPIP utilise le plugin Menus pour gérer plusieurs menus configurables pour la navigation.
Cela permet de laisser aux administrateurs de canaux la possibilité de configurer finement ces menus.
Menus créés à l’initialisation du site
Par défaut trois menus sont créés automatiquement à l’initialisation du site : Le menu principal ; Identifiant : barrenav ; Ce menu s’insère en général en haut de la page après le bloc d’entête, son identifiant le rend compatible avec les squelettes basés sur Zpip ; (...) -
Gestion de la ferme
2 mars 2010, parLa ferme est gérée dans son ensemble par des "super admins".
Certains réglages peuvent être fais afin de réguler les besoins des différents canaux.
Dans un premier temps il utilise le plugin "Gestion de mutualisation"
Sur d’autres sites (8080)
-
Audio Video Mixing - Sync issue in Android with FFMPEG, Media Codec in different devices
24 novembre 2020, par khushbuI have already tried everything for Audio Video mixing and it's not working perfectly as in processing while mixing audio into the recorded video, sometimes the audio is ahead of video and vice-versa.


Using FFMPEG :


This is for add an Audio file to the Video file and generated the final Video where audio is replaced in the video.


val cmd ="-i $inputVideoPath -i ${inputAudio.absolutePath} -map 0:v -map 1:a -c:v copy -shortest ${outputVideo.absolutePath}"


After generating the final video, found some delay based on device performance so added delay in the below two cases :


1)Added delay in Audio if audio is ahead of the video.


val cmd = "-i ${tmpVideo.absolutePath} -itsoffset $hms -i ${tmpVideo.absolutePath} -map 0:v -map 1:a -c copy -preset veryfast ${createdVideo1?.absolutePath}"


2)Added delay in Video if the video is ahead of the audio.


val cmd = "-i ${tmpVideo.absolutePath} -itsoffset $hms -i ${tmpVideo.absolutePath} -map 1:v -map 0:a -c copy -preset veryfast ${createdVideo1?.absolutePath}"


NOTE : Here $hms is delay in 00:00:00.000 formate


but still, it's not working on all the devices like readmi, oneplus etc.


Using Media Codec :


Found some better performance in this solution but still not working on all the devices.


In this process, It's supporting .aac format so first if the user selected .mp3 formate than i have to convert it into .aac format using the below function :


fun Convert_Mp3_to_acc() {

 
 AndroidAudioConverter.load(requireActivity(), object : ILoadCallback {
 override fun onSuccess() {

 val callback: IConvertCallback = object : IConvertCallback {
 override fun onSuccess(convertedFile: File) {
 toggleLoader(false)
 audioLink = convertedFile.absolutePath
 append()
 

 }

 override fun onFailure(error: java.lang.Exception) {
 toggleLoader(false)
 Toast.makeText(requireActivity(), "" + error, Toast.LENGTH_SHORT).show()
 }
 }
 AndroidAudioConverter.with(requireActivity())
 .setFile(File(audioLink))
 .setFormat(AudioFormat.AAC)
 .setCallback(callback)
 .convert()
 }

 override fun onFailure(error: java.lang.Exception) {
 toggleLoader(false)
 }
 })
}


After successful conversion from .mp3 to .aac formate, It's extracting audio track and video track for merge


private fun append(): Boolean {

 val progressDialog = ProgressDialog(requireContext())
 Thread {
 requireActivity().runOnUiThread {
 progressDialog.setMessage("Please wait..")
 progressDialog.show()
 }
 val video_list = ArrayList<string>()
 for (i in videopaths.indices) {
 val file: File = File(videopaths.get(i))
 if (file.exists()) {
 val retriever = MediaMetadataRetriever()
 retriever.setDataSource(requireActivity(), Uri.fromFile(file))
 val hasVideo =
 retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_HAS_VIDEO)
 val isVideo = "yes" == hasVideo
 if (isVideo /*&& file.length() > 1000*/) {
 Log.d("resp", videopaths.get(i))
 video_list.add(videopaths.get(i))
 }
 }
 }
 try {
 val inMovies = arrayOfNulls<movie>(video_list.size)
 for (i in video_list.indices) {
 inMovies[i] = MovieCreator.build(video_list[i])
 }
 val videoTracks: MutableList<track> =
 LinkedList()
 val audioTracks: MutableList<track> =
 LinkedList()
 for (m in inMovies) {
 for (t in m!!.tracks) {
 if (t.handler == "soun") {
 audioTracks.add(t)
 }
 if (t.handler == "vide") {
 videoTracks.add(t)
 }
 }
 }
 val result = Movie()
 if (audioTracks.size > 0) {
 result.addTrack(AppendTrack(*audioTracks.toTypedArray()))
 }
 if (videoTracks.size > 0) {
 result.addTrack(AppendTrack(*videoTracks.toTypedArray()))
 }
 val out = DefaultMp4Builder().build(result)
 var outputFilePath: String? = null
 outputFilePath = Variables.outputfile

 /*if (audio != null) {
 Variables.outputfile
 } else {
 Variables.outputfile2
 }*/

 val fos = FileOutputStream(File(outputFilePath))
 out.writeContainer(fos.channel)
 fos.close()

 requireActivity().runOnUiThread {
 progressDialog.dismiss()

 Merge_withAudio()

 /* if (audio != null) else {
 //Go_To_preview_Activity()
 }*/
 }
 } catch (e: java.lang.Exception) {
 }
 }.start()

 return true
}
</track></track></movie></string>

This will add the selected audio with the recorded video


fun Merge_withAudio() {
 val root = Environment.getExternalStorageDirectory().toString()

 // Uri mediaPath = Uri.parse("android.resource://" + getPackageName() + "/" + R.raw.file_copy);
 //String audio_file =Variables.app_folder+Variables.SelectedAudio_AAC;

 //String filename = "android.resource://" + getPackageName() + "/raw/file_copy.aac";
 val audio_file: String = audioLink!!
 Log.e("Merge ", audio_file)
 val video = "$root/output.mp4"

 val bundle=Bundle()
 bundle.putString("FinalVideo", createdVideo?.absolutePath)

 val merge_video_audio = Merge_Video_Audio(this, bundle, object : AsyncResponse {
 override fun processFinish(output: Bundle?) {

 requireActivity().runOnUiThread {
 finalVideo = bundle.getString("FinalVideo")
 createdVideo = File(finalVideo)

 Log.e("Final Path ", finalVideo)

 createThumb {
 setUpExoPlayer()
 }
 }

 }
 })
 merge_video_audio.doInBackground(audio_file, video, createdVideo?.absolutePath)
}


 public class Merge_Video_Audio extends AsyncTask {

 ProgressDialog progressDialog;
 RecentCompletedVideoFragment context;
 public AsyncResponse delegate = null;


Bundle bundleValue;

String audio,video,output;

public Merge_Video_Audio(RecentCompletedVideoFragment context, Bundle bundle , AsyncResponse delegate ){
 this.context=context;
 this.bundleValue=bundle;
 this.delegate=delegate;
 progressDialog=new ProgressDialog(context.requireContext());
 progressDialog.setMessage("Please Wait...");
}

@Override
protected void onPreExecute() {
 super.onPreExecute();
}

@Override
public String doInBackground(String... strings) {
 try {
 progressDialog.show();
 }catch (Exception e){

 }
 audio=strings[0];
 video=strings[1];
 output=strings[2];

 Log.d("resp",audio+"----"+video+"-----"+output);

 Thread thread = new Thread(runnable);
 thread.start();

 return null;
}


@Override
protected void onPostExecute(String s) {
 super.onPostExecute(s);
 Log.e("On Post Execute ", "True");


}


 public void Go_To_preview_Activity(){

 delegate.processFinish(bundleValue);
 }

 public Track CropAudio(String videopath, Track fullAudio){
 try {

 IsoFile isoFile = new IsoFile(videopath);

 double lengthInSeconds = (double)
 isoFile.getMovieBox().getMovieHeaderBox().getDuration() /
 isoFile.getMovieBox().getMovieHeaderBox().getTimescale();


 Track audioTrack = (Track) fullAudio;


 double startTime1 = 0;
 double endTime1 = lengthInSeconds;


 long currentSample = 0;
 double currentTime = 0;
 double lastTime = -1;
 long startSample1 = -1;
 long endSample1 = -1;


 for (int i = 0; i < audioTrack.getSampleDurations().length; i++) {

 long delta = audioTrack.getSampleDurations()[i];

 if (currentTime > lastTime && currentTime <= startTime1) {
 // current sample is still before the new starttime
 startSample1 = currentSample;
 }
 if (currentTime > lastTime && currentTime <= endTime1) {
 // current sample is after the new start time and still before the new endtime
 endSample1 = currentSample;
 }

 lastTime = currentTime;
 currentTime += (double) delta / (double) audioTrack.getTrackMetaData().getTimescale();
 currentSample++;
 }

 CroppedTrack cropperAacTrack = new CroppedTrack(fullAudio, startSample1, endSample1);

 return cropperAacTrack;

 } catch (IOException e) {
 e.printStackTrace();
 }

 return fullAudio;
}



 public Runnable runnable =new Runnable() {
 @Override
 public void run() {

 try {

 Movie m = MovieCreator.build(video);


 List nuTracks = new ArrayList<>();

 for (Track t : m.getTracks()) {
 if (!"soun".equals(t.getHandler())) {

 Log.e("Track ",t.getName());
 nuTracks.add(t);
 }
 }

 Log.e("Path ",audio.toString());


 try {
 // Track nuAudio = new AACTrackImpl();
 Track nuAudio = new AACTrackImpl(new FileDataSourceImpl(audio));

 Track crop_track = CropAudio(video, nuAudio);

 nuTracks.add(crop_track);

 m.setTracks(nuTracks);

 Container mp4file = new DefaultMp4Builder().build(m);

 FileChannel fc = new FileOutputStream(new File(output)).getChannel();
 mp4file.writeContainer(fc);
 fc.close();

 }catch (FileNotFoundException fnfe){
 fnfe.printStackTrace();
 }catch(IOException ioe){
 ioe.printStackTrace();
 }


 try {

 progressDialog.dismiss();
 }catch (Exception e){
 Log.d("resp",e.toString());

 }finally {
 Go_To_preview_Activity();

 }

 } catch (IOException e) {
 e.printStackTrace();
 Log.d("resp",e.toString());

 }

 }

 };

 }


This solution is also not working in all the devices.


Can anyone suggest where i am going wrong or any solution for it ?


-
Corrupt AVFrame returned by libavcodec
2 janvier 2015, par informer2000As part of a bigger project, I’m trying to decode a number of HD (1920x1080) video streams simultaneously. Each video stream is stored in raw yuv420p format within an AVI container. I have a Decoder class from which I create a number of objects within different threads (one object per thread). The two main methods in Decoder are
decode()andgetNextFrame(), which I provide the implementation for below.When I separate the decoding logic and use it to decode a single stream, everything works fine. However, when I use the multi-threaded code, I get a segmentation fault and the program crashes within the processing code in the decoding loop. After some investigation, I realized that the data array of the
AVFramefilled ingetNextFrame()contains addresses which are out of range (according to gdb).I’m really lost here ! I’m not doing anything that would change the contents of the
AVFramein my code. The only place where I attempt to access the AVFrame is when I callsws_scale()to convert the color format and that’s where the segmentation fault occurs in the second case because of the corruptAVFrame. Any suggestion as to why this is happening is greatly appreciated. Thanks in advance.The
decode()method :void decode() {
QString filename("video.avi");
AVFormatContext* container = 0;
if (avformat_open_input(&container, filename.toStdString().c_str(), NULL, NULL) < 0) {
fprintf(stderr, "Could not open %s\n", filename.toStdString().c_str());
exit(1);
}
if (avformat_find_stream_info(container, NULL) < 0) {
fprintf(stderr, "Could not find file info..\n");
}
// find a video stream
int stream_id = -1;
for (unsigned int i = 0; i < container->nb_streams; i++) {
if (container->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
stream_id = i;
break;
}
}
if (stream_id == -1) {
fprintf(stderr, "Could not find a video stream..\n");
}
av_dump_format(container, stream_id, filename.toStdString().c_str(), false);
// find the appropriate codec and open it
AVCodecContext* codec_context = container->streams[stream_id]->codec; // Get a pointer to the codec context for the video stream
AVCodec* codec = avcodec_find_decoder(codec_context->codec_id); // Find the decoder for the video stream
if (codec == NULL) {
fprintf(stderr, "Could not find a suitable codec..\n");
return -1; // Codec not found
}
// Inform the codec that we can handle truncated bitstreams -- i.e.,
// bitstreams where frame boundaries can fall in the middle of packets
if (codec->capabilities & CODEC_CAP_TRUNCATED)
codec_context->flags |= CODEC_FLAG_TRUNCATED;
fprintf(stderr, "Codec: %s\n", codec->name);
// open the codec
int ret = avcodec_open2(codec_context, codec, NULL);
if (ret < 0) {
fprintf(stderr, "Could not open the needed codec.. Error: %d\n", ret);
return -1;
}
// allocate video frame
AVFrame *frame = avcodec_alloc_frame(); // deprecated, should use av_frame_alloc() instead
if (!frame) {
fprintf(stderr, "Could not allocate video frame..\n");
return -1;
}
int frameNumber = 0;
// as long as there are remaining frames in the stream
while (getNextFrame(container, codec_context, stream_id, frame)) {
// Processing logic here...
// AVFrame data array contains three addresses which are out of range
}
// freeing resources
av_free(frame);
avcodec_close(codec_context);
avformat_close_input(&container);
}The
getNextFrame()method :bool getNextFrame(AVFormatContext *pFormatCtx,
AVCodecContext *pCodecCtx,
int videoStream,
AVFrame *pFrame) {
uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
char buf[1024];
int len;
int got_picture;
AVPacket avpkt;
av_init_packet(&avpkt);
memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
// read data from bit stream and store it in the AVPacket object
while(av_read_frame(pFormatCtx, &avpkt) >= 0) {
// check the stream index of the read packet to make sure it is a video stream
if(avpkt.stream_index == videoStream) {
// decode the packet and store the decoded content in the AVFrame object and set the flag if we have a complete decoded picture
avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, &avpkt);
// if we have completed decoding an entire picture (frame), return true
if(got_picture) {
av_free_packet(&avpkt);
return true;
}
}
// free the AVPacket object that was allocated by av_read_frame
av_free_packet(&avpkt);
}
return false;
}The lock management callback function :
static int lock_call_back(void ** mutex, enum AVLockOp op) {
switch (op) {
case AV_LOCK_CREATE:
*mutex = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t));
pthread_mutex_init((pthread_mutex_t *)(*mutex), NULL);
break;
case AV_LOCK_OBTAIN:
pthread_mutex_lock((pthread_mutex_t *)(*mutex));
break;
case AV_LOCK_RELEASE:
pthread_mutex_unlock((pthread_mutex_t *)(*mutex));
break;
case AV_LOCK_DESTROY:
pthread_mutex_destroy((pthread_mutex_t *)(*mutex));
free(*mutex);
break;
}
return 0;
} -
Wrap audio data of the pcm_alaw type into an MKA audio file using the ffmpeg API
19 septembre 2020, par bbddImagine that in my project, I receive
RTPpackets with the payload type-8, for later saving this load as the Nth part of the audio track. I extract this load from theRTPpacket and save it to a temporary buffer :

...

while ((rtp = receiveRtpPackets()).withoutErrors()) {
 payloadData.push(rtp.getPayloadData());
}

audioGenerator.setPayloadData(payloadData);
audioGenerator.recordToFile();

...


After filling a temporary buffer of a certain size with this payload, I process this buffer, namely, extract the entire payload and encode it using ffmpeg for further saving to an audio file in Matroska format. But I have a problem. Since the payload of the
RTPpacket istype 8, I have to save the raw audio data of the pcm_alaw format tomkaaudio format. But when saving raw datapcm_alawto an audio file, I get these messages from the library :

...

[libopus @ 0x18eff60] Queue input is backward in time
[libopus @ 0x18eff60] Queue input is backward in time
[libopus @ 0x18eff60] Queue input is backward in time
[libopus @ 0x18eff60] Queue input is backward in time

...


When you open an audio file in vlc, nothing is played (the audio track timestamp is missing).


The task of my project is to simply take pcm_alaw data and pack it in a container, in
mkaformat. The best way to determine the codec is to use the av_guess_codec() function, which in turn automatically selects the desired codec ID. But how do I pack the raw data into the container correctly, I do not know.

It is important to note that I can get as raw data any format of this data (audio formats only) defined by the
RTPpacket type (All types ofRTPpacket payload). All I know is that in any case, I have to pack the audio data in anmkacontainer.

I also attach the code (borrowed from this resource) that I use :


audiogenerater.h


extern "C"
{
#include "libavformat/avformat.h"
#include "libavcodec/avcodec.h"
#include "libswresample/swresample.h"
}

class AudioGenerater
{
public:

 AudioGenerater();
 ~AudioGenerater() = default;

 void generateAudioFileWithOptions(
 QString fileName,
 QByteArray pcmData,
 int channel,
 int bitRate,
 int sampleRate,
 AVSampleFormat format);
 
private:

 // init Format
 bool initFormat(QString audioFileName);

private:

 AVCodec *m_AudioCodec = nullptr;
 AVCodecContext *m_AudioCodecContext = nullptr;
 AVFormatContext *m_FormatContext = nullptr;
 AVOutputFormat *m_OutputFormat = nullptr;
};


audiogenerater.cpp


AudioGenerater::AudioGenerater()
{
 av_register_all();
 avcodec_register_all();
}

AudioGenerater::~AudioGenerater()
{
 // ... 
}

bool AudioGenerater::initFormat(QString audioFileName)
{
 // Create an output Format context
 int result = avformat_alloc_output_context2(&m_FormatContext, nullptr, nullptr, audioFileName.toLocal8Bit().data());
 if (result < 0) {
 return false;
 }

 m_OutputFormat = m_FormatContext->oformat;

 // Create an audio stream
 AVStream* audioStream = avformat_new_stream(m_FormatContext, m_AudioCodec);
 if (audioStream == nullptr) {
 avformat_free_context(m_FormatContext);
 return false;
 }

 // Set the parameters in the stream
 audioStream->id = m_FormatContext->nb_streams - 1;
 audioStream->time_base = { 1, 8000 };
 result = avcodec_parameters_from_context(audioStream->codecpar, m_AudioCodecContext);
 if (result < 0) {
 avformat_free_context(m_FormatContext);
 return false;
 }

 // Print FormatContext information
 av_dump_format(m_FormatContext, 0, audioFileName.toLocal8Bit().data(), 1);

 // Open file IO
 if (!(m_OutputFormat->flags & AVFMT_NOFILE)) {
 result = avio_open(&m_FormatContext->pb, audioFileName.toLocal8Bit().data(), AVIO_FLAG_WRITE);
 if (result < 0) {
 avformat_free_context(m_FormatContext);
 return false;
 }
 }

 return true;
}

void AudioGenerater::generateAudioFileWithOptions(
 QString _fileName,
 QByteArray _pcmData,
 int _channel,
 int _bitRate,
 int _sampleRate,
 AVSampleFormat _format)
{
 AVFormatContext* oc;
 if (avformat_alloc_output_context2(
 &oc, nullptr, nullptr, _fileName.toStdString().c_str())
 < 0) {
 qDebug() << "Error in line: " << __LINE__;
 return;
 }
 if (!oc) {
 printf("Could not deduce output format from file extension: using mka.\n");
 avformat_alloc_output_context2(
 &oc, nullptr, "mka", _fileName.toStdString().c_str());
 }
 if (!oc) {
 qDebug() << "Error in line: " << __LINE__;
 return;
 }
 AVOutputFormat* fmt = oc->oformat;
 if (fmt->audio_codec == AV_CODEC_ID_NONE) {
 qDebug() << "Error in line: " << __LINE__;
 return;
 }

 AVCodecID codecID = av_guess_codec(
 fmt, nullptr, _fileName.toStdString().c_str(), nullptr, AVMEDIA_TYPE_AUDIO);
 // Find Codec
 m_AudioCodec = avcodec_find_encoder(codecID);
 if (m_AudioCodec == nullptr) {
 qDebug() << "Error in line: " << __LINE__;
 return;
 }
 // Create an encoder context
 m_AudioCodecContext = avcodec_alloc_context3(m_AudioCodec);
 if (m_AudioCodecContext == nullptr) {
 qDebug() << "Error in line: " << __LINE__;
 return;
 }

 // Setting parameters
 m_AudioCodecContext->bit_rate = _bitRate;
 m_AudioCodecContext->sample_rate = _sampleRate;
 m_AudioCodecContext->sample_fmt = _format;
 m_AudioCodecContext->channels = _channel;

 m_AudioCodecContext->channel_layout = av_get_default_channel_layout(_channel);
 m_AudioCodecContext->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

 // Turn on the encoder
 int result = avcodec_open2(m_AudioCodecContext, m_AudioCodec, nullptr);
 if (result < 0) {
 avcodec_free_context(&m_AudioCodecContext);
 if (m_FormatContext != nullptr)
 avformat_free_context(m_FormatContext);
 return;
 }

 // Create a package
 if (!initFormat(_fileName)) {
 avcodec_free_context(&m_AudioCodecContext);
 if (m_FormatContext != nullptr)
 avformat_free_context(m_FormatContext);
 return;
 }

 // write to the file header
 result = avformat_write_header(m_FormatContext, nullptr);
 if (result < 0) {
 avcodec_free_context(&m_AudioCodecContext);
 if (m_FormatContext != nullptr)
 avformat_free_context(m_FormatContext);
 return;
 }

 // Create Frame
 AVFrame* frame = av_frame_alloc();
 if (frame == nullptr) {
 avcodec_free_context(&m_AudioCodecContext);
 if (m_FormatContext != nullptr)
 avformat_free_context(m_FormatContext);
 return;
 }

 int nb_samples = 0;
 if (m_AudioCodecContext->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE) {
 nb_samples = 10000;
 }
 else {
 nb_samples = m_AudioCodecContext->frame_size;
 }

 // Set the parameters of the Frame
 frame->nb_samples = nb_samples;
 frame->format = m_AudioCodecContext->sample_fmt;
 frame->channel_layout = m_AudioCodecContext->channel_layout;

 // Apply for data memory
 result = av_frame_get_buffer(frame, 0);
 if (result < 0) {
 av_frame_free(&frame);
 {
 avcodec_free_context(&m_AudioCodecContext);
 if (m_FormatContext != nullptr)
 avformat_free_context(m_FormatContext);
 return;
 }
 }

 // Set the Frame to be writable
 result = av_frame_make_writable(frame);
 if (result < 0) {
 av_frame_free(&frame);
 {
 avcodec_free_context(&m_AudioCodecContext);
 if (m_FormatContext != nullptr)
 avformat_free_context(m_FormatContext);
 return;
 }
 }

 int perFrameDataSize = frame->linesize[0];
 int count = _pcmData.size() / perFrameDataSize;
 bool needAddOne = false;
 if (_pcmData.size() % perFrameDataSize != 0) {
 count++;
 needAddOne = true;
 }

 int frameCount = 0;
 for (int i = 0; i < count; ++i) {
 // Create a Packet
 AVPacket* pkt = av_packet_alloc();
 if (pkt == nullptr) {
 avcodec_free_context(&m_AudioCodecContext);
 if (m_FormatContext != nullptr)
 avformat_free_context(m_FormatContext);
 return;
 }
 av_init_packet(pkt);

 if (i == count - 1)
 perFrameDataSize = _pcmData.size() % perFrameDataSize;

 // Synthesize WAV files
 memset(frame->data[0], 0, perFrameDataSize);
 memcpy(frame->data[0], &(_pcmData.data()[perFrameDataSize * i]), perFrameDataSize);

 frame->pts = frameCount++;
 // send Frame
 result = avcodec_send_frame(m_AudioCodecContext, frame);
 if (result < 0)
 continue;

 // Receive the encoded Packet
 result = avcodec_receive_packet(m_AudioCodecContext, pkt);
 if (result < 0) {
 av_packet_free(&pkt);
 continue;
 }

 // write to file
 av_packet_rescale_ts(pkt, m_AudioCodecContext->time_base, m_FormatContext->streams[0]->time_base);
 pkt->stream_index = 0;
 result = av_interleaved_write_frame(m_FormatContext, pkt);
 if (result < 0)
 continue;

 av_packet_free(&pkt);
 }

 // write to the end of the file
 av_write_trailer(m_FormatContext);
 // Close file IO
 avio_closep(&m_FormatContext->pb);
 // Release Frame memory
 av_frame_free(&frame);

 avcodec_free_context(&m_AudioCodecContext);
 if (m_FormatContext != nullptr)
 avformat_free_context(m_FormatContext);
}


main.cpp


int main(int argc, char **argv)
{
 av_log_set_level(AV_LOG_TRACE);

 QFile file("rawDataOfPcmAlawType.bin");
 if (!file.open(QIODevice::ReadOnly)) {
 return EXIT_FAILURE;
 }
 QByteArray rawData(file.readAll());

 AudioGenerater generator;
 generator.generateAudioFileWithOptions(
 "test.mka",
 rawData,
 1, 
 64000, 
 8000,
 AV_SAMPLE_FMT_S16);

 return 0;
}


It is IMPORTANT you help me find the most appropriate way to record
pcm_alawor a different data format in anMKAaudio file.

I ask everyone who knows anything to help (there is too little time left to implement this project)


Syndiquer tout le site
