Recherche avancée
Autres articles (100)
-
List of compatible distributions
26 avril 2011, parThe table below is the list of Linux distributions compatible with the automated installation script of MediaSPIP. Distribution nameVersion nameVersion number Debian Squeeze 6.x.x Debian Weezy 7.x.x Debian Jessie 8.x.x Ubuntu The Precise Pangolin 12.04 LTS Ubuntu The Trusty Tahr 14.04
If you want to help us improve this list, you can provide us access to a machine whose distribution is not mentioned above or send the necessary fixes to add (...) -
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 -
Activation de l’inscription des visiteurs
12 avril 2011, parIl est également possible d’activer l’inscription des visiteurs ce qui permettra à tout un chacun d’ouvrir soit même un compte sur le canal en question dans le cadre de projets ouverts par exemple.
Pour ce faire, il suffit d’aller dans l’espace de configuration du site en choisissant le sous menus "Gestion des utilisateurs". Le premier formulaire visible correspond à cette fonctionnalité.
Par défaut, MediaSPIP a créé lors de son initialisation un élément de menu dans le menu du haut de la page menant (...)
Sur d’autres sites (8692)
-
Qt Open Source Product 2 - Vlc Demo [closed]
3 juin 2021, par cool codeⅠ. Preface


The previous work was made by the FFmpeg kernel, and FFmpeg is too powerful for many beginners to understand. There are also a lot of users only need a simple video stream can be played, do not need to be involved in the responsible decoding and transcoding, so VLC came in handy, it directly made FFMPEG deep encapsulation, to provide a friendly interface. There's an MPV that does the same thing, and MPV is even better than VLC in that it's just one library file, and it looks like it's packaged as a static library, unlike VLC, VLC comes with a bunch of dynamic library files and plug-in files.
Of course, the simplicity of VLC is that it only needs a few lines of code to start, so that beginners immediately see the effect is very important, very excited, you can more quickly carry out the next step of coding, experience the fun of coding.


Ⅱ. Code framework


#include "ffmpeg.h"

FFmpegThread::FFmpegThread(QObject *parent) : QThread(parent)
{
 setObjectName("FFmpegThread");
 stopped = false;
 isPlay = false;

 frameFinish = false;
 videoWidth = 0;
 videoHeight = 0;
 oldWidth = 0;
 oldHeight = 0;
 videoStreamIndex = -1;
 audioStreamIndex = -1;

 url = "rtsp://192.168.1.128:554/1";

 buffer = NULL;
 avPacket = NULL;
 avFrame = NULL;
 avFrame2 = NULL;
 avFrame3 = NULL;
 avFormatContext = NULL;
 videoCodec = NULL;
 audioCodec = NULL;
 swsContext = NULL;

 options = NULL;
 videoDecoder = NULL;
 audioDecoder = NULL;

 //Initial registration, only register once in a software
 FFmpegThread::initlib();
}

//Only need to initialize once in a software
void FFmpegThread::initlib()
{
 static QMutex mutex;
 QMutexLocker locker(&mutex);
 static bool isInit = false;
 if (!isInit) {
 //Register all available file formats and decoders in the library
 av_register_all();
 //Register all devices, mainly for local camera playback support
#ifdef ffmpegdevice
 avdevice_register_all();
#endif
 //Initialize the network stream format, which must be executed first when using the network stream
 avformat_network_init();

 isInit = true;
 qDebug() << TIMEMS << "init ffmpeg lib ok" << " version:" << FFMPEG_VERSION;
#if 0
 //Output all supported decoder names
 QStringList listCodeName;
 AVCodec *code = av_codec_next(NULL);
 while (code != NULL) {
 listCodeName << code->name;
 code = code->next;
 }

 qDebug() << TIMEMS << listCodeName;
#endif
 }
}

bool FFmpegThread::init()
{
 //Before opening the code stream, specify various parameters such as: detection time/timeout time/maximum delay, etc.
 //Set the cache size, 1080p can increase the value
 av_dict_set(&options, "buffer_size", "8192000", 0);
 //Open in tcp mode, if open in udp mode, replace tcp with udp
 av_dict_set(&options, "rtsp_transport", "tcp", 0);
 //Set the timeout disconnection time, the unit is microseconds, 3000000 means 3 seconds
 av_dict_set(&options, "stimeout", "3000000", 0);
 //Set the maximum delay, in microseconds, 1000000 means 1 second
 av_dict_set(&options, "max_delay", "1000000", 0);
 //Automatically start the number of threads
 av_dict_set(&options, "threads", "auto", 0);

 //Open video stream
 avFormatContext = avformat_alloc_context();

 int result = avformat_open_input(&avFormatContext, url.toStdString().data(), NULL, &options);
 if (result < 0) {
 qDebug() << TIMEMS << "open input error" << url;
 return false;
 }

 //Release setting parameters
 if (options != NULL) {
 av_dict_free(&options);
 }

 //Get flow information
 result = avformat_find_stream_info(avFormatContext, NULL);
 if (result < 0) {
 qDebug() << TIMEMS << "find stream info error";
 return false;
 }

 //----------At the beginning of the video stream part, make a mark to facilitate the folding of the code----------
 if (1) {
 videoStreamIndex = av_find_best_stream(avFormatContext, AVMEDIA_TYPE_VIDEO, -1, -1, &videoDecoder, 0);
 if (videoStreamIndex < 0) {
 qDebug() << TIMEMS << "find video stream index error";
 return false;
 }

 //Get video stream
 AVStream *videoStream = avFormatContext->streams[videoStreamIndex];

 //Get the video stream decoder, or specify the decoder
 videoCodec = videoStream->codec;
 videoDecoder = avcodec_find_decoder(videoCodec->codec_id);
 //videoDecoder = avcodec_find_decoder_by_name("h264_qsv");
 if (videoDecoder == NULL) {
 qDebug() << TIMEMS << "video decoder not found";
 return false;
 }

 //Set up accelerated decoding
 videoCodec->lowres = videoDecoder->max_lowres;
 videoCodec->flags2 |= AV_CODEC_FLAG2_FAST;

 //Open the video decoder
 result = avcodec_open2(videoCodec, videoDecoder, NULL);
 if (result < 0) {
 qDebug() << TIMEMS << "open video codec error";
 return false;
 }

 //Get the resolution size
 videoWidth = videoStream->codec->width;
 videoHeight = videoStream->codec->height;

 //If the width and height are not obtained, return
 if (videoWidth == 0 || videoHeight == 0) {
 qDebug() << TIMEMS << "find width height error";
 return false;
 }

 QString videoInfo = QString("Video stream info -> index: %1 decode: %2 format: %3 duration: %4 s Resolution: %5*%6")
 .arg(videoStreamIndex).arg(videoDecoder->name).arg(avFormatContext->iformat->name)
 .arg((avFormatContext->duration) / 1000000).arg(videoWidth).arg(videoHeight);
 qDebug() << TIMEMS << videoInfo;
 }
 //----------The video stream part starts----------

 //----------Start the audio stream part, mark it to facilitate the code folding----------
 if (1) {
 //Loop to find audio stream index
 audioStreamIndex = -1;
 for (uint i = 0; i < avFormatContext->nb_streams; i++) {
 if (avFormatContext->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
 audioStreamIndex = i;
 break;
 }
 }

 //Some have no audio stream, so there is no need to return here
 if (audioStreamIndex == -1) {
 qDebug() << TIMEMS << "find audio stream index error";
 } else {
 //Get audio stream
 AVStream *audioStream = avFormatContext->streams[audioStreamIndex];
 audioCodec = audioStream->codec;

 //Get the audio stream decoder, or specify the decoder
 audioDecoder = avcodec_find_decoder(audioCodec->codec_id);
 //audioDecoder = avcodec_find_decoder_by_name("aac");
 if (audioDecoder == NULL) {
 qDebug() << TIMEMS << "audio codec not found";
 return false;
 }

 //Open the audio decoder
 result = avcodec_open2(audioCodec, audioDecoder, NULL);
 if (result < 0) {
 qDebug() << TIMEMS << "open audio codec error";
 return false;
 }

 QString audioInfo = QString("Audio stream information -> index: %1 decode: %2 Bit rate: %3 channel num: %4 sampling: %5")
 .arg(audioStreamIndex).arg(audioDecoder->name).arg(avFormatContext->bit_rate)
 .arg(audioCodec->channels).arg(audioCodec->sample_rate);
 qDebug() << TIMEMS << audioInfo;
 }
 }
 //----------End of audio stream----------

 //Pre-allocated memory
 avPacket = av_packet_alloc();
 avFrame = av_frame_alloc();
 avFrame2 = av_frame_alloc();
 avFrame3 = av_frame_alloc();

 //Compare the width and height of the last file. When changing, you need to reallocate the memory
 if (oldWidth != videoWidth || oldHeight != videoHeight) {
 int byte = avpicture_get_size(AV_PIX_FMT_RGB32, videoWidth, videoHeight);
 buffer = (uint8_t *)av_malloc(byte * sizeof(uint8_t));
 oldWidth = videoWidth;
 oldHeight = videoHeight;
 }

 //Define pixel format
 AVPixelFormat srcFormat = AV_PIX_FMT_YUV420P;
 AVPixelFormat dstFormat = AV_PIX_FMT_RGB32;
 //Get the decoded format through the decoder
 srcFormat = videoCodec->pix_fmt;

 //The SWS_FAST_BILINEAR parameter used by the default fastest decoding may lose part of the picture data, and you can change it to other parameters by yourself
 int flags = SWS_FAST_BILINEAR;

 //Open up a cache to store one frame of data
 //The following two methods are ok, avpicture_fill has been gradually abandoned
 //avpicture_fill((AVPicture *)avFrame3, buffer, dstFormat, videoWidth, videoHeight);
 av_image_fill_arrays(avFrame3->data, avFrame3->linesize, buffer, dstFormat, videoWidth, videoHeight, 1);

 //Image conversion
 swsContext = sws_getContext(videoWidth, videoHeight, srcFormat, videoWidth, videoHeight, dstFormat, flags, NULL, NULL, NULL);

 //Output video information
 //av_dump_format(avFormatContext, 0, url.toStdString().data(), 0);

 //qDebug() << TIMEMS << "init ffmpeg finsh";
 return true;
}

void FFmpegThread::run()
{
 while (!stopped) {
 //Perform initialization based on the flag bit
 if (isPlay) {
 this->init();
 isPlay = false;
 continue;
 }

 if (av_read_frame(avFormatContext, avPacket) >= 0) {
 //Determine whether the current package is video or audio
 int index = avPacket->stream_index;
 if (index == videoStreamIndex) {
 //Decode video stream avcodec_decode_video2 method has been deprecated
#if 0
 avcodec_decode_video2(videoCodec, avFrame2, &frameFinish, avPacket);
#else
 frameFinish = avcodec_send_packet(videoCodec, avPacket);
 if (frameFinish < 0) {
 continue;
 }

 frameFinish = avcodec_receive_frame(videoCodec, avFrame2);
 if (frameFinish < 0) {
 continue;
 }
#endif

 if (frameFinish >= 0) {
 //Turn the data into a picture
 sws_scale(swsContext, (const uint8_t *const *)avFrame2->data, avFrame2->linesize, 0, videoHeight, avFrame3->data, avFrame3->linesize);

 //The following two methods can be used
 //QImage image(avFrame3->data[0], videoWidth, videoHeight, QImage::Format_RGB32);
 QImage image((uchar *)buffer, videoWidth, videoHeight, QImage::Format_RGB32);
 if (!image.isNull()) {
 emit receiveImage(image);
 }

 msleep(1);
 }
 } else if (index == audioStreamIndex) {
 //Decode the audio stream, it will not be processed here, and will be handed over to sdl to play
 }
 }

 av_packet_unref(avPacket);
 av_freep(avPacket);
 msleep(1);
 }

 //Release resources after the thread ends
 free();
 stopped = false;
 isPlay = false;
 qDebug() << TIMEMS << "stop ffmpeg thread";
}

void FFmpegThread::setUrl(const QString &url)
{
 this->url = url;
}

void FFmpegThread::free()
{
 if (swsContext != NULL) {
 sws_freeContext(swsContext);
 swsContext = NULL;
 }

 if (avPacket != NULL) {
 av_packet_unref(avPacket);
 avPacket = NULL;
 }

 if (avFrame != NULL) {
 av_frame_free(&avFrame);
 avFrame = NULL;
 }

 if (avFrame2 != NULL) {
 av_frame_free(&avFrame2);
 avFrame2 = NULL;
 }

 if (avFrame3 != NULL) {
 av_frame_free(&avFrame3);
 avFrame3 = NULL;
 }

 if (videoCodec != NULL) {
 avcodec_close(videoCodec);
 videoCodec = NULL;
 }

 if (audioCodec != NULL) {
 avcodec_close(audioCodec);
 audioCodec = NULL;
 }

 if (avFormatContext != NULL) {
 avformat_close_input(&avFormatContext);
 avFormatContext = NULL;
 }

 av_dict_free(&options);
 //qDebug() << TIMEMS << "close ffmpeg ok";
}

void FFmpegThread::play()
{
 //Let the thread perform initialization through the flag bit
 isPlay = true;
}

void FFmpegThread::pause()
{

}

void FFmpegThread::next()
{

}

void FFmpegThread::stop()
{
 //Stop the thread through the flag
 stopped = true;
}

//Real-time video display form class
FFmpegWidget::FFmpegWidget(QWidget *parent) : QWidget(parent)
{
 thread = new FFmpegThread(this);
 connect(thread, SIGNAL(receiveImage(QImage)), this, SLOT(updateImage(QImage)));
 image = QImage();
}

FFmpegWidget::~FFmpegWidget()
{
 close();
}

void FFmpegWidget::paintEvent(QPaintEvent *)
{
 if (image.isNull()) {
 return;
 }

 //qDebug() << TIMEMS << "paintEvent" << objectName();
 QPainter painter(this);
 painter.drawImage(this->rect(), image);
}

void FFmpegWidget::updateImage(const QImage &image)
{
 //this->image = image.copy();
 this->image = image;
 this->update();
}

void FFmpegWidget::setUrl(const QString &url)
{
 thread->setUrl(url);
}

void FFmpegWidget::open()
{
 //qDebug() << TIMEMS << "open video" << objectName();
 clear();

 thread->play();
 thread->start();
}

void FFmpegWidget::pause()
{
 thread->pause();
}

void FFmpegWidget::next()
{
 thread->next();
}

void FFmpegWidget::close()
{
 //qDebug() << TIMEMS << "close video" << objectName();
 if (thread->isRunning()) {
 thread->stop();
 thread->quit();
 thread->wait(500);
 }

 QTimer::singleShot(1, this, SLOT(clear()));
}

void FFmpegWidget::clear()
{
 image = QImage();
 update();
}



Ⅲ. Renderings




Ⅳ. Open source code download URL


1.download URL for dropbox :


https://www.dropbox.com/sh/n58ucs57pscp25e/AABWBQlg4U3Oz2WF9YOJDrj1a?dl=0


2.download URL for box :


https://app.box.com/s/x48a7ttpk667afqqdk7t1fqok4fmvmyv


-
How to get resolution label from a video in ffmpeg
10 mai 2021, par HnnEMy goal is to get the labels 1080p,720p,480p,360p,.. from the video using ffmpeg. Some videos doesn't have the correct dimension to it. for example : 854x546


For the meantime I do it like this. 'height' + 'p' = 546p (which is wrong).
Should I check if 'height' > 480 then return 720 ?.


-
How do I get VLC to play back two separate input streams (Video and Audio) like MPV-Player with mpv —ytdl-format=FormatCode1+FormatCode2 URL
29 avril 2021, par Gubbelso, I finally found out how to play a 1080p with 60fps smoothly on a Raspberry Py 4b or rather on a Raspberry Py 400.


With the following OS installed :
Raspberry Pi OS with desktop and recommended software


But I need to get from Youtube the avc1 (H.264) video stream and not the av01 (AV1) video stream.


And sadly it only plays smooth, if I use the VLC-Media-Player to play back a completely downloaded file.


The MPV alternative with e.g. :


mpv --ytdl-format=299+140 https://www.youtube.com/watch?v=LXb3EKWsInQ


lags sadly.


So I thought of a method to use a similar option with VLC.


My attempt :


#!/bin/bash

echo 'Enter: videoFormatCode audioFormatCode URL'

read video audio link

videoLink=$(youtube-dl -g -f $video $link)

audioLink=$(youtube-dl -g -f $audio $link)




ffmpeg -i "$videoLink" -i "$audioLink" -f matroska - | vlc -


So, first I will find out the format codes with :


youtube-dl -F https://www.youtube.com/watch?v=LXb3EKWsInQ


which gives me :


format code extension resolution note
249 webm audio only tiny 50k , webm_dash container, opus @ 50k (48000Hz), 1.88MiB
250 webm audio only tiny 67k , webm_dash container, opus @ 67k (48000Hz), 2.51MiB
140 m4a audio only tiny 129k , m4a_dash container, mp4a.40.2@129k (44100Hz), 4.84MiB
251 webm audio only tiny 132k , webm_dash container, opus @132k (48000Hz), 4.96MiB
394 mp4 256x144 144p HDR 63k , mp4_dash container, av01.0.00M.10.0.110.09.16.09.0@ 63k, 30fps, video only, 2.39MiB
160 mp4 256x144 144p 70k , mp4_dash container, avc1.4d400c@ 70k, 30fps, video only, 2.64MiB
278 webm 256x144 144p 82k , webm_dash container, vp9@ 82k, 30fps, video only, 3.07MiB
694 mp4 256x144 144p60 HDR 179k , mp4_dash container, av01.0.00M.10.0.110.09.16.09.0@ 179k, 60fps, video only, 6.73MiB
330 webm 256x144 144p60 HDR 212k , webm_dash container, vp9.2@ 212k, 60fps, video only, 7.96MiB
395 mp4 426x240 240p HDR 111k , mp4_dash container, av01.0.00M.10.0.110.09.16.09.0@ 111k, 30fps, video only, 4.16MiB
133 mp4 426x240 240p 156k , mp4_dash container, avc1.4d4015@ 156k, 30fps, video only, 5.86MiB
242 webm 426x240 240p 160k , webm_dash container, vp9@ 160k, 30fps, video only, 6.00MiB
695 mp4 426x240 240p60 HDR 409k , mp4_dash container, av01.0.01M.10.0.110.09.16.09.0@ 409k, 60fps, video only, 15.32MiB
331 webm 426x240 240p60 HDR 444k , webm_dash container, vp9.2@ 444k, 60fps, video only, 16.63MiB
396 mp4 640x360 360p HDR 220k , mp4_dash container, av01.0.01M.10.0.110.09.16.09.0@ 220k, 30fps, video only, 8.23MiB
134 mp4 640x360 360p 337k , mp4_dash container, avc1.4d401e@ 337k, 30fps, video only, 12.64MiB
243 webm 640x360 360p 343k , webm_dash container, vp9@ 343k, 30fps, video only, 12.84MiB
696 mp4 640x360 360p60 HDR 862k , mp4_dash container, av01.0.04M.10.0.110.09.16.09.0@ 862k, 60fps, video only, 32.28MiB
332 webm 640x360 360p60 HDR 954k , webm_dash container, vp9.2@ 954k, 60fps, video only, 35.70MiB
397 mp4 854x480 480p HDR 406k , mp4_dash container, av01.0.04M.10.0.110.09.16.09.0@ 406k, 30fps, video only, 15.19MiB
135 mp4 854x480 480p 563k , mp4_dash container, avc1.4d401f@ 563k, 30fps, video only, 21.08MiB
244 webm 854x480 480p 619k , webm_dash container, vp9@ 619k, 30fps, video only, 23.18MiB
697 mp4 854x480 480p60 HDR 1652k , mp4_dash container, av01.0.05M.10.0.110.09.16.09.0@1652k, 60fps, video only, 61.81MiB
333 webm 854x480 480p60 HDR 1848k , webm_dash container, vp9.2@1848k, 60fps, video only, 69.13MiB
398 mp4 1280x720 720p60 HDR 1151k , mp4_dash container, av01.0.08M.10.0.110.09.16.09.0@1151k, 60fps, video only, 43.09MiB
247 webm 1280x720 720p 1220k , webm_dash container, vp9@1220k, 30fps, video only, 45.67MiB
136 mp4 1280x720 720p 1540k , mp4_dash container, avc1.4d401f@1540k, 30fps, video only, 57.61MiB
302 webm 1280x720 720p60 1964k , webm_dash container, vp9@1964k, 60fps, video only, 73.48MiB
298 mp4 1280x720 720p60 2475k , mp4_dash container, avc1.4d4020@2475k, 60fps, video only, 92.60MiB
698 mp4 1280x720 720p60 HDR 3829k , mp4_dash container, av01.0.08M.10.0.110.09.16.09.0@3829k, 60fps, video only, 143.25MiB
334 webm 1280x720 720p60 HDR 4337k , webm_dash container, vp9.2@4337k, 60fps, video only, 162.26MiB
399 mp4 1920x1080 1080p60 HDR 2151k , mp4_dash container, av01.0.09M.10.0.110.09.16.09.0@2151k, 60fps, video only, 80.49MiB
303 webm 1920x1080 1080p60 3475k , webm_dash container, vp9@3475k, 60fps, video only, 130.01MiB
299 mp4 1920x1080 1080p60 4376k , mp4_dash container, avc1.64002a@4376k, 60fps, video only, 163.70MiB
699 mp4 1920x1080 1080p60 HDR 6358k , mp4_dash container, av01.0.09M.10.0.110.09.16.09.0@6358k, 60fps, video only, 237.83MiB
335 webm 1920x1080 1080p60 HDR 6738k , webm_dash container, vp9.2@6738k, 60fps, video only, 252.04MiB
400 mp4 2560x1440 1440p60 HDR 5529k , mp4_dash container, av01.0.12M.10.0.110.09.16.09.0@5529k, 60fps, video only, 206.83MiB
308 webm 2560x1440 1440p60 10376k , webm_dash container, vp9@10376k, 60fps, video only, 388.14MiB
700 mp4 2560x1440 1440p60 HDR 15170k , mp4_dash container, av01.0.12M.10.0.110.09.16.09.0@15170k, 60fps, video only, 567.45MiB
336 webm 2560x1440 1440p60 HDR 16231k , webm_dash container, vp9.2@16231k, 60fps, video only, 607.14MiB
401 mp4 3840x2160 2160p60 HDR 11707k , mp4_dash container, av01.0.13M.10.0.110.09.16.09.0@11707k, 60fps, video only, 437.93MiB
315 webm 3840x2160 2160p60 25573k , webm_dash container, vp9@25573k, 60fps, video only, 956.58MiB
701 mp4 3840x2160 2160p60 HDR 28033k , mp4_dash container, av01.0.13M.10.0.110.09.16.09.0@28033k, 60fps, video only, 1.02GiB
337 webm 3840x2160 2160p60 HDR 28869k , webm_dash container, vp9.2@28869k, 60fps, video only, 1.05GiB
18 mp4 640x360 360p 642k , avc1.42001E, 30fps, mp4a.40.2 (44100Hz), 24.03MiB
22 mp4 1280x720 720p 1669k , avc1.64001F, 30fps, mp4a.40.2 (44100Hz) (best)


Then I search for a 1080p60 stream with avc1, which leads to format code 299 in this list and then choose a fitting audio stream, like format code 140.


Through the script youtube-dl catches the links for the respective format code, which get joined with ffmpeg as a matroska file and the send to VLC.


But this method lags ; in my opinion because it seems not to cache the stream, like MPV does. And there is not seeking option ; when I try to seek it pops back to the beginning.


I tried it with adding
-bufsize 6750kto the ffmpeg line, but that did not help either.
I also added the VLC option--sout-mux-caching 30000where I thought VLC would get a bigger cache to buffer the stream, but that did not help, too.

So, how could I play back this as a smooth stream in VLC ?


Also, my solution might not the best to start with, so please don't take this as a reference, it was just an attempt by my side with my sparse knowledge how I would handle the situation.


If there are better alternatives, you can of course post them, too. ;)



I also want to add, that the script, which I posted above, works well, when I use the 134 format code with a far lesser resolution, so somewhere seems to be a bottleneck.



Attachment 1 :


Output with format codes 299+140 :




Attachment 2 :


Output with format codes 134+140 :





Should the pastebin not work, here is an alternative link to the outputs.



I terminated the program after several seconds with Ctrl-C, so the output won't be that big, thought it could help to find an answer on this.



Just for reference :
After pressing Ctrl-C this line appeared :


QObject::~QObject: Timers cannot be stopped from another thread


Syndiquer tout le site
