Recherche avancée
Médias (91)
-
Head down (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
Echoplex (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
Discipline (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
Letting you (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
1 000 000 (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
-
999 999 (wav version)
26 septembre 2011, par
Mis à jour : Avril 2013
Langue : English
Type : Audio
Autres articles (40)
-
Keeping control of your media in your hands
13 avril 2011, parThe vocabulary used on this site and around MediaSPIP in general, aims to avoid reference to Web 2.0 and the companies that profit from media-sharing.
While using MediaSPIP, you are invited to avoid using words like "Brand", "Cloud" and "Market".
MediaSPIP is designed to facilitate the sharing of creative media online, while allowing authors to retain complete control of their work.
MediaSPIP aims to be accessible to as many people as possible and development is based on expanding the (...) -
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 -
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 ; (...)
Sur d’autres sites (6340)
-
avdevice/decklink : remove pthread dependency
15 avril 2017, par Aaron Levinsonavdevice/decklink : remove pthread dependency
Purpose : avdevice/decklink : Removed pthread dependency by replacing
semaphore used in code appropriately. Doing so makes it easier to
build ffmpeg using Visual C++ on Windows. This is a contination of
Kyle Schwarz's "avdevice/decklink : Remove pthread dependency" patch
that is available at https://patchwork.ffmpeg.org/patch/2654/ . This
patch wasn't accepted, and as far as I can tell, there was no
follow-up after it was rejected.Notes : Used Visual Studio 2015 (with update 3) for this.
Comments :
— configure : Eliminated pthreads dependency for decklink_indev_deps
and decklink_outdev_deps and replaced with threads dependency— libavdevice/decklink_common.cpp / .h :
a) Eliminated semaphore and replaced with a combination of a mutex,
condition variable, and a counter (frames_buffer_available_spots).
b) Removed include of pthread.h and semaphore.h and now using
libavutil/thread.h instead.— libavdevice/decklink_dec.cpp : Eliminated include of pthread.h and
semaphore.h.— libavdevice/decklink_enc.cpp :
a) Eliminated include of pthread.h and semaphore.h.
b) Replaced use of semaphore with the equivalent using a combination
of a mutex, condition variable, and a counter
(frames_buffer_available_spots). In theory, libavutil/thread.h and
the associated code could have been modified instead to add
cross-platform implementations of the sem_ functions, but an
inspection of the ffmpeg source base indicates that there are only
two cases in which semaphores are used (including this one that was
replaced), so it was deemed to not be worth the effort.Signed-off-by : Marton Balint <cus@passwd.hu>
-
C++ Qt FFMPEG RTMP : getting 0 fps
7 juin 2021, par Jinwoo LimI've been programming on Qt and developing an RTMP server.


I almost finished it, but the server says the sent RTMP video has 0 fps.


I think the data are being sent correctly - the server says video in-bytes and audio in-bytes are above 0.


Also, whenever I play RTMP video from the server with VLC, it only shows the exact frame that is supposed to be shown at the time VLC connected to the server.


My conclusion was that my program sends the frame correctly, but the set fps of RTMP server is 0 so VLC refused to play the RTMP video.


Where did I get wrong ?


#include "threadcam_rtmp.h"
#include "global.h"
#include "rtmpstream.h"

#include <vector>

#include <opencv2></opencv2>highgui.hpp>
#include <opencv2></opencv2>video.hpp>

extern "C" {
#include "libavformat/avformat.h"
#include "libavcodec/avcodec.h"
#include "libavutil/avutil.h"
#include "libavutil/audio_fifo.h"
#include "libavutil/time.h"
#include "libswscale/swscale.h"
#include "libavdevice/avdevice.h"
}

#include <qapplication>
#include <qdebug>
#include <qpixmap>

ThreadCam_RTMP::ThreadCam_RTMP(int selectedCam, QMutex &mutex_img):
 mutex(mutex_img)
{
 cam_index = selectedCam;
 show_on = true;
}

void ThreadCam_RTMP::run()
{
 //Settings for opencv cam
 cam_index = start_cam_index;
 if (!cam.open(cam_index)) cam_on = false;
 cam.set(CV_CAP_PROP_FRAME_WIDTH, img_width);
 cam.set(CV_CAP_PROP_FRAME_HEIGHT, img_height);

 //Settings for RTMP streaming
 output = server.c_str();

 av_register_all();
 avdevice_register_all();
 avformat_network_init();

 ifmt = av_find_input_format("dshow");

 AVDictionary *device_param = 0;

 //Set audio device
 if (avformat_open_input(&ifmt_ctx_a, device_name_a, ifmt, &device_param) != 0)
 qDebug("Couldn't open audio stream.");

 //Audio input initialize
 if (avformat_find_stream_info(ifmt_ctx_a, NULL) < 0)
 qDebug("Couldn't find audio stream information.");

 audioindex = -1;
 for (int i = 0; i < ifmt_ctx_a->nb_streams; i++)
 {
 if(ifmt_ctx_a->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO)
 {
 audioindex = i;
 break;
 }
 }
 if (audioindex == -1) qDebug("Couldn't find an audio stream");
 if (avcodec_open2(ifmt_ctx_a->streams[audioindex]->codec, avcodec_find_decoder(ifmt_ctx_a->streams[audioindex]->codec->codec_id), NULL) < 0)
 qDebug("Couldn't open audio codec");

 //Output audio initialize
 out_codec_a = avcodec_find_encoder(AV_CODEC_ID_AAC);
 if(!out_codec_a)
 qDebug("Couldn't find output audio encoder.");
 out_codec_ctx_a = avcodec_alloc_context3(out_codec_a);
 out_codec_ctx_a->channels = 2;
 out_codec_ctx_a->channel_layout = av_get_default_channel_layout(2);
 out_codec_ctx_a->sample_rate = ifmt_ctx_a->streams[audioindex]->codec->sample_rate;
 out_codec_ctx_a->sample_fmt = out_codec_a->sample_fmts[0];
 out_codec_ctx_a->bit_rate = bitrate;
 out_codec_ctx_a->time_base.num = 1;
 out_codec_ctx_a->time_base.den = out_codec_ctx_a->sample_rate;
 out_codec_ctx_a->strict_std_compliance = FF_COMPLIANCE_EXPERIMENTAL;
 if (avcodec_open2(out_codec_ctx_a, out_codec_a, NULL) < 0) qDebug("Couldn't open output audio encoder");

 //Output initialize
 initialize_avformat_context(ofmt_ctx, "flv");
 initialize_io_context(ofmt_ctx, output);

 out_codec = avcodec_find_encoder(AV_CODEC_ID_FLV1);
 if(!out_codec)
 qDebug("Couldn't find output video encoder.");
 out_stream = avformat_new_stream(ofmt_ctx, out_codec);
 out_codec_ctx = avcodec_alloc_context3(out_codec);

 set_codec_params(ofmt_ctx, out_codec_ctx, img_width, img_height, fps, bitrate);
 initialize_codec_stream(out_stream, out_codec_ctx, out_codec, codec_profile);

 out_stream->codecpar->extradata = out_codec_ctx->extradata;
 out_stream->codecpar->extradata_size = out_codec_ctx->extradata_size;

 //Add a new stream to output for muxing
 out_stream_a = avformat_new_stream(ofmt_ctx, out_codec_a);
 out_stream_a->time_base.num = 1;
 out_stream_a->time_base.den = out_codec_ctx_a->sample_rate;
 out_stream_a->codec = out_codec_ctx_a;

 av_dump_format(ofmt_ctx, 0, output, 1);

 int ret = avformat_write_header(ofmt_ctx, nullptr);
 if (ret < 0)
 {
 qDebug("Could not write header!");
 QApplication::quit();
 }

 aud_convert_ctx = swr_alloc_set_opts(NULL,
 av_get_default_channel_layout(out_codec_ctx_a->channels),
 out_codec_ctx_a->sample_fmt,
 out_codec_ctx_a->sample_rate,
 av_get_default_channel_layout(ifmt_ctx_a->streams[audioindex]->codec->channels),
 ifmt_ctx_a->streams[audioindex]->codec->sample_fmt,
 ifmt_ctx_a->streams[audioindex]->codec->sample_rate,
 0, NULL);

 swr_init(aud_convert_ctx);

 AVRational r_framerate1 = {fps, 1};
 int64_t calc_duration = (double)(AV_TIME_BASE)*(1 / av_q2d(r_framerate1));
 int64_t start_time = av_gettime();

 AVAudioFifo *fifo = NULL;
 fifo = av_audio_fifo_alloc(out_codec_ctx_a->sample_fmt, out_codec_ctx_a->channels, 1);

 uint8_t **converted_input_samples = NULL;
 if (!(converted_input_samples = (uint8_t**)calloc(out_codec_ctx_a->channels, sizeof(**converted_input_samples))))
 qDebug("Could not allocate converted input sample pointers");

 int dec_got_frame_a, enc_got_frame_a; 

 auto *frame = allocate_frame_buffer(out_codec_ctx, img_width, img_height);
 auto *swsctx = initialize_sample_scaler(out_codec_ctx, img_width, img_height);

 int64_t vid_pts = 0;

 ofmt_ctx->streams[0]->r_frame_rate = out_codec_ctx->framerate;
 ofmt_ctx->streams[0]->codec->time_base = out_codec_ctx->time_base;

 while(cam_on)
 {
 cv::Mat temp; // image captured from opencv cam
 show_on = keep_sending;

 //capture image from webcam
 if (cam.isOpened())
 {
 cam.read(temp);
 //convert BGR to RGB to show them
 cv::cvtColor(temp, temp, cv::COLOR_BGR2RGB);
 }

 if(show_on)
 {
 //resize and save read img to global variable cap_img
 mutex.lock();
 temp.copyTo(cap_img);
 QImage qimg = QImage(cap_img.data, img_width, img_height, img_width * img_channels, QImage::Format_RGB888);
 mutex.unlock();
 emit ThreadCam_RTMP::setImage(qimg);

 }

 //rtmp streaming
 if (encode_video || encode_audio)
 {
 if (encode_video && (!encode_audio || av_compare_ts(vid_next_pts, time_base_q, aud_next_pts, time_base_q) <= 0))
 {
 mutex.lock();
 AVPacket pkt = {0};
 av_init_packet(&pkt);

 frame = av_frame_alloc();

 std::vector framebuf(av_image_get_buffer_size(out_codec_ctx->pix_fmt, img_width, img_height, 1));
 av_image_fill_arrays(frame->data, frame->linesize, framebuf.data(), out_codec_ctx->pix_fmt,img_width, img_height, 1);
 frame->width = img_width;
 frame->height = img_height;
 frame->format = static_cast<int>(out_codec_ctx->pix_fmt);

 const int stride[] = {static_cast<int>(temp.step[0])};
 sws_scale(swsctx, &temp.data, stride, 0, temp.rows, frame->data, frame->linesize);
 frame->pts = vid_pts + av_rescale_q(1, out_codec_ctx->time_base, out_stream->time_base);
 vid_pts = frame->pts;
 pkt.pts = frame->pts;
 qDebug() << frame->pts;

 int ret = avcodec_send_frame(out_codec_ctx, frame);
 if (ret < 0)
 {
 qDebug("Error sending frame to codec context!");
 av_log_set_callback(printerror);
 }

 ret = avcodec_receive_packet(out_codec_ctx, &pkt);
 if (ret < 0)
 {
 qDebug("Error receiving packet from codec context!");
 }

 av_interleaved_write_frame(ofmt_ctx, &pkt);
 av_packet_unref(&pkt);

 qDebug() << av_q2d(ofmt_ctx->streams[0]->codec->time_base);

 mutex.unlock();
 framecnt++;
 vid_next_pts = framecnt * calc_duration;
 }
 else
 {
 //audio trancoding here
 const int output_frame_size = out_codec_ctx_a->frame_size;

 /**
 * Make sure that there is one frame worth of samples in the FIFO
 * buffer so that the encoder can do its work.
 * Since the decoder's and the encoder's frame size may differ, we
 * need to FIFO buffer to store as many frames worth of input samples
 * that they make up at least one frame worth of output samples.
 */
 while (av_audio_fifo_size(fifo) < output_frame_size)
 {
 /**
 * Decode one frame worth of audio samples, convert it to the
 * output sample format and put it into the FIFO buffer.
 */
 AVFrame *input_frame = av_frame_alloc();
 if (!input_frame) ret = AVERROR(ENOMEM);

 /** Decode one frame worth of audio samples. */
 /** Packet used for temporary storage. */
 AVPacket input_packet;
 av_init_packet(&input_packet);
 input_packet.data = NULL;
 input_packet.size = 0;

 /** Read one audio frame from the input file into a temporary packet. */
 if ((ret = av_read_frame(ifmt_ctx_a, &input_packet)) < 0)
 {
 /** If we are at the end of the file, flush the decoder below. */
 if (ret == AVERROR_EOF) encode_audio = 0;
 else qDebug("Could not read audio frame");
 }

 /**
 * Decode the audio frame stored in the temporary packet.
 * The input audio stream decoder is used to do this.
 * If we are at the end of the file, pass an empty packet to the decoder
 * to flush it.
 */
 if ((ret = avcodec_decode_audio4(ifmt_ctx_a->streams[audioindex]->codec, input_frame, &dec_got_frame_a, &input_packet)) < 0)
 qDebug("Could not decode audio frame");

 av_packet_unref(&input_packet);
 /** If there is decoded data, convert and store it */
 if (dec_got_frame_a)
 {
 /**
 * Allocate memory for the samples of all channels in one consecutive
 * block for convenience.
 */
 if ((ret = av_samples_alloc(converted_input_samples, NULL, out_codec_ctx_a->channels,
 input_frame->nb_samples, out_codec_ctx_a->sample_fmt, 0)) < 0)
 {
 qDebug("Could not allocate converted input samples");
 av_freep(&(*converted_input_samples)[0]);
 free(*converted_input_samples);
 }

 /**
 * Convert the input samples to the desired output sample format.
 * This requires a temporary storage provided by converted_input_samples.
 */
 /** Convert the samples using the resampler. */
 if ((ret = swr_convert(aud_convert_ctx, converted_input_samples, input_frame->nb_samples,
 (const uint8_t**)input_frame->extended_data, input_frame->nb_samples)) < 0) {
 qDebug("Could not convert input samples"); qDebug() << ret;
 }

 /** Add the converted input samples to the FIFO buffer for later processing. */
 /**
 * Make the FIFO as large as it needs to be to hold both,
 * the old and the new samples.
 */
 if ((ret = av_audio_fifo_realloc(fifo, av_audio_fifo_size(fifo) + input_frame->nb_samples)) < 0)
 qDebug("Could not reallocate FIFO");

 /** Store the new samples in the FIFO buffer. */
 if (av_audio_fifo_write(fifo, (void **)converted_input_samples,
 input_frame->nb_samples) < input_frame->nb_samples)
 qDebug("Could not write data to FIFO");
 }
 }

 /**
 * If we have enough samples for the encoder, we encode them.
 * At the end of the file, we pass the remaining samples to
 * the encoder.
 */
 if (av_audio_fifo_size(fifo) >= output_frame_size)
 /**
 * Take one frame worth of audio samples from the FIFO buffer,
 * encode it and write it to the output file.
 */
 {
 /** Temporary storage of the output samples of the frame written to the file. */
 AVFrame *output_frame = av_frame_alloc();
 if (!output_frame) ret = AVERROR(ENOMEM);
 /**
 * Use the maximum number of possible samples per frame.
 * If there is less than the maximum possible frame size in the FIFO
 * buffer use this number. Otherwise, use the maximum possible frame size
 */
 const int frame_size = FFMIN(av_audio_fifo_size(fifo), out_codec_ctx_a->frame_size);

 /** Initialize temporary storage for one output frame. */
 /**
 * Set the frame's parameters, especially its size and format.
 * av_frame_get_buffer needs this to allocate memory for the
 * audio samples of the frame.
 * Default channel layouts based on the number of channels
 * are assumed for simplicity.
 */
 output_frame->nb_samples = frame_size;
 output_frame->channel_layout = out_codec_ctx_a->channel_layout;
 output_frame->format = out_codec_ctx_a->sample_fmt;
 output_frame->sample_rate = out_codec_ctx_a->sample_rate;

 /**
 * Allocate the samples of the created frame. This call will make
 * sure that the audio frame can hold as many samples as specified.
 */
 if ((ret = av_frame_get_buffer(output_frame, 0)) < 0)
 {
 qDebug("Could not allocate output frame samples");
 av_frame_free(&output_frame);
 }

 /**
 * Read as many samples from the FIFO buffer as required to fill the frame.
 * The samples are stored in the frame temporarily.
 */
 if (av_audio_fifo_read(fifo, (void **)output_frame->data, frame_size) < frame_size)
 qDebug("Could not read data from FIFO");

 /** Encode one frame worth of audio samples. */
 /** Packet used for temporary storage. */
 AVPacket output_packet;
 av_init_packet(&output_packet);
 output_packet.data = NULL;
 output_packet.size = 0;

 /** Set a timestamp based on the sample rate for the container. */
 if (output_frame) nb_samples += output_frame->nb_samples;

 /**
 * Encode the audio frame and store it in the temporary packet.
 * The output audio stream encoder is used to do this.
 */
 if ((ret = avcodec_encode_audio2(out_codec_ctx_a, &output_packet, output_frame, &enc_got_frame_a)) < 0)
 {
 qDebug("Could not encode frame");
 av_packet_unref(&output_packet);
 }

 /** Write one audio frame from the temporary packet to the output file. */
 if (enc_got_frame_a)
 {
 output_packet.stream_index = 1;

 AVRational time_base = ofmt_ctx->streams[1]->time_base;
 AVRational r_framerate1 = { ifmt_ctx_a->streams[audioindex]->codec->sample_rate, 1 };// { 44100, 1};
 int64_t calc_duration = (double)(AV_TIME_BASE)*(1 / av_q2d(r_framerate1));

 output_packet.pts = av_rescale_q(nb_samples*calc_duration, time_base_q, time_base);
 output_packet.dts = output_packet.pts;
 output_packet.duration = output_frame->nb_samples;

 //qDebug("audio pts : %d\n", output_packet.pts);
 aud_next_pts = nb_samples*calc_duration;

 int64_t pts_time = av_rescale_q(output_packet.pts, time_base, time_base_q);
 int64_t now_time = av_gettime() - start_time;
 if ((pts_time > now_time) && ((aud_next_pts + pts_time - now_time)/cleanup
 if (out_stream_a) avcodec_close(out_stream_a->codec);
 if (fifo) av_audio_fifo_free(fifo);
 avio_close(ofmt_ctx->pb);
 avformat_free_context(ifmt_ctx_a);
 avformat_free_context(ofmt_ctx);
}
</int></int></qpixmap></qdebug></qapplication></vector>


#include "rtmpstream.h"
#include "global.h"

extern "C" {
#include "libavformat/avformat.h"
#include "libavcodec/avcodec.h"
#include "libavutil/avutil.h"
#include "libswscale/swscale.h"
}

#include <qmessagebox>
#include <qapplication>
#include <qdebug>

void initialize_avformat_context(AVFormatContext *&fctx, const char *format_name)
{
 int ret = avformat_alloc_output_context2(&fctx, nullptr, format_name, nullptr);
 if (ret != 0)
 {
 qDebug("Could not allocate output format context!");
 QApplication::quit();
 }
}

void initialize_io_context(AVFormatContext *&fctx, const char *output)
{
 if (!(fctx->oformat->flags & AVFMT_NOFILE))
 {
 int ret = avio_open2(&fctx->pb, output, AVIO_FLAG_WRITE, nullptr, nullptr);
 if (ret < 0)
 {
 qDebug("Could not open output IO context!");
 QApplication::quit();
 }
 }
}

void set_codec_params(AVFormatContext *fctx, AVCodecContext *codec_ctx, double width, double height, int fps, int bitrate)
{
 const AVRational dst_fps = {fps, 1};
 codec_ctx->codec_tag = 0;
 codec_ctx->codec_id = AV_CODEC_ID_FLV1;
 codec_ctx->codec_type = AVMEDIA_TYPE_VIDEO;
 codec_ctx->width = width;
 codec_ctx->height = height;
 codec_ctx->gop_size = 12;
 codec_ctx->pix_fmt = AV_PIX_FMT_YUV420P;
 codec_ctx->framerate = dst_fps;
 codec_ctx->time_base = av_inv_q(dst_fps);
 codec_ctx->bit_rate = bitrate;
 codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
}

void initialize_codec_stream(AVStream *stream, AVCodecContext *codec_ctx, AVCodec *codec, std::string codec_profile)
{
 int ret = avcodec_parameters_from_context(stream->codecpar, codec_ctx);
 if (ret < 0)
 {
 qDebug("Could not initialize stream codec parameters!");
 QApplication::quit();
 }

 // open video encoder
 ret = avcodec_open2(codec_ctx, codec, 0);
 if (ret < 0)
 {
 qDebug("Could not open video encoder!");
 QApplication::quit();
 }
}


SwsContext *initialize_sample_scaler(AVCodecContext *codec_ctx, double width, double height)
{
 SwsContext *swsctx = sws_getContext(width, height, AV_PIX_FMT_BGR24, width, height, codec_ctx->pix_fmt, SWS_BICUBIC, nullptr, nullptr, nullptr);
 if (!swsctx)
 {
 qDebug("Could not initialize sample scaler!");
 QApplication::quit();
 }

 return swsctx;
}

AVFrame *allocate_frame_buffer(AVCodecContext *codec_ctx, double width, double height)
{
 AVFrame *frame = av_frame_alloc();

 std::vector framebuf(av_image_get_buffer_size(codec_ctx->pix_fmt, width, height, 1));
 av_image_fill_arrays(frame->data, frame->linesize, framebuf.data(), codec_ctx->pix_fmt, width, height, 1);
 frame->width = width;
 frame->height = height;
 frame->format = static_cast<int>(codec_ctx->pix_fmt);

 return frame;
}

void write_frame(AVCodecContext *codec_ctx, AVFormatContext *fmt_ctx, AVStream *st, AVFrame *frame)
{
 AVPacket pkt = {0};
 av_init_packet(&pkt);

 int ret = avcodec_send_frame(codec_ctx, frame);
 if (ret < 0)
 {
 qDebug("Error sending frame to codec context!");
 QApplication::quit();
 }

 ret = avcodec_receive_packet(codec_ctx, &pkt);
 if (ret < 0)
 {
 qDebug("Error receiving packet from codec context!");
 QApplication::quit();
 }

 /* rescale output packet timestamp values from codec to stream timebase */
 av_packet_rescale_ts(&pkt, codec_ctx->time_base, st->time_base);
 pkt.stream_index = st->index;

 av_interleaved_write_frame(fmt_ctx, &pkt);
 av_packet_unref(&pkt);
}

int flush_encoder_a(AVFormatContext *ifmt_ctx_a, AVFormatContext *ofmt_ctx, unsigned int stream_index, int nb_samples)
{
 int ret;
 int got_frame;
 AVPacket enc_pkt;
 if (!(ofmt_ctx->streams[stream_index]->codec->codec->capabilities & AV_CODEC_CAP_DELAY)) return 0;
 while (1)
 {
 enc_pkt.data = NULL;
 enc_pkt.size = 0;
 av_init_packet(&enc_pkt);
 ret = avcodec_encode_audio2(ofmt_ctx->streams[stream_index]->codec, &enc_pkt, NULL, &got_frame);
 av_frame_free(NULL);

 if (ret < 0) break;
 if (!got_frame)
 {
 ret = 0;
 break;
 }

 qDebug("Flush Encoder: Succeed to encode 1 frame!\tsize:%5d\n", enc_pkt.size);
 nb_samples+=1024;

 //Write PTS
 AVRational time_base = ofmt_ctx->streams[stream_index]->time_base;//{ 1, 1000 };
 AVRational r_framerate1 = { ifmt_ctx_a->streams[0]->codec->sample_rate, 1 };
 AVRational time_base_q = { 1, AV_TIME_BASE };

 //Duration between 2 frames (us)
 int64_t calc_duration = (double)(AV_TIME_BASE)*(1 / av_q2d(r_framerate1));

 //Parameters
 enc_pkt.pts = av_rescale_q(nb_samples*calc_duration, time_base_q, time_base);
 enc_pkt.dts = enc_pkt.pts;
 enc_pkt.duration = 1024;

 /* copy packet*/
 //Convert PTS/DTS
 enc_pkt.pos = -1;

 //ofmt_ctx->duration = enc_pkt.duration * nb_samples;

 /* mux encoded frame */
 ret = av_interleaved_write_frame(ofmt_ctx, &enc_pkt);
 if (ret < 0) break;
 }
 return ret;
}
</int></qdebug></qapplication></qmessagebox>

-
Merge commit ’12004a9a7f20e44f4da2ee6c372d5e1794c8d6c5’
20 mars 2017, par Clément BœschMerge commit ’12004a9a7f20e44f4da2ee6c372d5e1794c8d6c5’
* commit ’12004a9a7f20e44f4da2ee6c372d5e1794c8d6c5’ :
audiodsp/x86 : yasmify vector_clipf_sse
audiodsp : reorder arguments for vector_clipfMerged the version from Libav after a discussion with James Almer on
IRC :19:22 <ubitux> jamrial : opinion on 12004a9a7f20e44f4da2ee6c372d5e1794c8d6c5 ?
19:23 <ubitux> it was apparently yasmified differently
19:23 <ubitux> (it depends on the previous commit arg shuffle)
19:24 <ubitux> i don’t see the magic movsxdifnidn in your port btw
19:24 <ubitux> it’s a port from 1d36defe94c7d7ebf995d4dbb4f878d06272f9c6
19:25 <jamrial> seems better thanks to said arg shuffle
19:25 <jamrial> the loop is the same, but init is simpler
19:25 <jamrial> probably worth merging
19:25 <ubitux> OK
19:25 <ubitux> thanks
19:26 <jamrial> curious they didn’t make len ptrdiff_t after the previous bunch of commits, heh
19:26 <ubitux> yeah indeedBoth commits are merged at the same time to prevent a conflict with our
existing yasmified ff_vector_clipf_sse.Merged-by : Clément Bœsch <u@pkh.me>
Syndiquer tout le site
