Recherche avancée
Médias (91)
-
Géodiversité
9 septembre 2011, par ,
Mis à jour : Août 2018
Langue : français
Type : Texte
-
USGS Real-time Earthquakes
8 septembre 2011, par
Mis à jour : Septembre 2011
Langue : français
Type : Texte
-
SWFUpload Process
6 septembre 2011, par
Mis à jour : Septembre 2011
Langue : français
Type : Texte
-
La conservation du net art au musée. Les stratégies à l’œuvre
26 mai 2011
Mis à jour : Juillet 2013
Langue : français
Type : Texte
-
Podcasting Legal guide
16 mai 2011, par
Mis à jour : Mai 2011
Langue : English
Type : Texte
-
Creativecommons informational flyer
16 mai 2011, par
Mis à jour : Juillet 2013
Langue : English
Type : Texte
Autres articles (74)
-
Gestion des droits de création et d’édition des objets
8 février 2011, parPar défaut, beaucoup de fonctionnalités sont limitées aux administrateurs mais restent configurables indépendamment pour modifier leur statut minimal d’utilisation notamment : la rédaction de contenus sur le site modifiables dans la gestion des templates de formulaires ; l’ajout de notes aux articles ; l’ajout de légendes et d’annotations sur les images ;
-
Dépôt de média et thèmes par FTP
31 mai 2013, parL’outil MédiaSPIP traite aussi les média transférés par la voie FTP. Si vous préférez déposer par cette voie, récupérez les identifiants d’accès vers votre site MédiaSPIP et utilisez votre client FTP favori.
Vous trouverez dès le départ les dossiers suivants dans votre espace FTP : config/ : dossier de configuration du site IMG/ : dossier des média déjà traités et en ligne sur le site local/ : répertoire cache du site web themes/ : les thèmes ou les feuilles de style personnalisées tmp/ : dossier de travail (...) -
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 (...)
Sur d’autres sites (6657)
-
how spotify and other music players implement cross fading between music
11 janvier 2023, par Arihant JainI was working on a media streaming project and thought of implementing a cross fade between the next and current playing song.


HLS is used for streaming music and .m3u8 file is presigned by cloudfront.


Any help will be appreciated.


-
What should I do to handle audio&video in a radio automation software ?
24 avril 2023, par TheDaChickenI am currently working on a program that can be deemed as a "radio automation software."
Radio automation software focuses on audio. It may split audio frames and crossfade between different audio sources.


I want to continue by adding video support for music videos. This makes it not completely about audio.


There is a problem with this. Having audio porition do it's thing while video can be added along side it is difficult. For example, having access to the previous track to be able to crossfade & preloading the song.


This is what I currently have which is being run in a thread.


int ret;
int tryCounter{0};
int64_t end_pts{AV_NOPTS_VALUE};
int64_t end_duration{AV_NOPTS_VALUE};
while(true) {
 std::shared_ptr<cmessage> message;

 ret = queue.Get(message, MessageQueue::MessageQueueFlags::MSQ_NON_BLOCK);
 if (ret < 0) {
 if(ret == MessageQueue::MessageQueueRET::MSQ_STOPPED)
 break;
 Logger::Log(LOGWARNING, "Playback thread received: {}", ret);
 break;
 }

 if (ret == MessageQueue::MessageQueueRET::MSQ_OK && message) {
 if (message->IsType(CMessage::PLAY_SONG)) {
 /* It was requested for the Player to play a new song */
 std::shared_ptr<cmessageplaysong> songMsg = std::static_pointer_cast<cmessageplaysong>(message);
 // steal session :D
 std::unique_ptr<playersession> playerSession = std::move(songMsg->GetSession());
 if (!playerSession->GetTrack()) {
 Logger::Log(LOGWARNING, "PlaybackThread: Ignoring playback song event due to null track");
 goto SEND_NEXT_SONG;
 }
 if(!playerSession->GetPlaylist())
 playerSession->SetPlaylist(m_player->GetPlaylist());
 if (playerSession->IsPreloaded())
 Logger::Log(LOGDEBUG, "PlaybackThread: Received preloaded track.");

 // load track if not loaded already
 if (!playerSession->Open(playerSession->GetTrack(),
 m_info)) {
 Logger::Log(LOGERROR, "Failed to open input");
 goto SEND_NEXT_SONG;
 }

 preloadRequestSent = false;
 m_nextSession = nullptr;

 std::shared_ptr<track> track = playerSession->GetTrack();
 track->start_sample = m_player->GetMainOutput()->GetWrittenSamples();
 track->played = true;
 // Send current song position to callback thread for the callback function to be run when song starts playing
 m_player->SendSongPosition(playerSession->GetTrack(), playerSession->GetPlaylist(),
 playerSession->GetTrackPosition());

 // Grab the old one
 std::unique_ptr<playersession> oldSession = std::move(m_currentSession);
 // Set current audio instance to this input
 m_currentSession.swap(playerSession);

 // Crossfade :D
 ret = CrossFade(oldSession, m_currentSession);
 if (ret == STREAM_MAX) {
 // when the new song goes brrrrr.
 // this rarely happens anyway SOO
 m_currentSession.swap(oldSession);
 goto SEND_NEXT_SONG;
 }

 end_pts = AV_NOPTS_VALUE;
 end_duration = m_currentSession->GetDuration();
 if(m_currentSession->GetTrack()->info.segue_time != AV_NOPTS_VALUE)
 {
 end_duration = m_currentSession->GetTrack()->info.segue_time;
 // this is end duration for max samples :D
 // this variable is dependent on timebase
 end_pts = av_rescale_q(end_duration, CPPAV_TIME_BASE_Q, m_currentSession->GetTimeBase());
 }
 }
 if (message->IsType(CMessage::NEXT_SONG)) {
 /* request for the thread to play song next */
 std::shared_ptr<cmessagenextsong> messageNextSong = std::static_pointer_cast<cmessagenextsong>(message);
 // steal session :D
 m_nextSession = std::move(messageNextSong->GetSession());
 }
 }

 if (!m_currentSession) {
 /* wait until there is a track that can be played */
 /* during this, portaudio should not be opened */
 m_player->GetMainOutput()->OpenPlayback(false);
 std::this_thread::sleep_for(std::chrono::milliseconds(50));
 continue;
 }
 /* there is input so output should be active */
 if (!m_player->GetMainOutput()->IsActive()) {
 m_player->GetMainOutput()->OpenPlayback(true);
 }

 ret = m_currentSession->Decode(m_frame, end_pts);
 if (ret == STREAM_WAIT) {
 continue;
 } else if (ret == STREAM_EOF || ret == STREAM_MAX) {
 SEND_NEXT_SONG:
 if(m_player->GetCurrentTrack())
 m_player->GetCurrentTrack()->end_sample = m_player->GetMainOutput()->GetWrittenSamples();
 // Wait until the next song is in the queue for playback
 QueueNextSong(false);
 continue;
 }
 else if (ret == STREAM_ERROR) { // check & handle errors
 tryCounter++;
 Logger::Log(LOGERROR, "Decoder replied: Error try counter: {}/{}",
 tryCounter, MAX_ERROR_COUNTER);
 if (tryCounter >= MAX_ERROR_COUNTER) {
 goto SEND_NEXT_SONG;
 }
 continue;
 }
 tryCounter = 0;

 int64_t timestamp = 0;
 if (m_frame->GetPTS() != AV_NOPTS_VALUE) // must convert timestamp to static time base :D makes things easier
 timestamp = av_rescale_q(m_frame->GetPTS(), m_frame->GetTimeBase(), CPPAV_TIME_BASE_Q);

 // Check if track is about to end to preload next track
 // TODO make 3 changeable for preloading :)))
 if (!preloadRequestSent && timestamp >= end_duration - (3 * AV_TIME_BASE)) {
 Logger::Log(LOGDEBUG, "Sending next track to preload thread");
 if (QueueNextSong(true))
 preloadRequestSent = true;
 }

 // Write frame into ringbuffer
 ret = m_player->WriteFrame(m_frame);
 assert(ret != STREAM_EOF);
 // Clean out frame :)
 m_frame->Reset();
 }
</cmessagenextsong></cmessagenextsong></playersession></track></playersession></cmessageplaysong></cmessageplaysong></cmessage>

It seems awkward already. I have a huge amount of code for preparing the song. I have to keep track of the end duration and the next song. I have to keep track of the playlist. I am using PlayerSession to grab audio frames, handle all audio packet decoding, resampling to a constant sample rate. I don't think that is going to be viable to keep.


-
lavu/opencl : replace va_ext.h with standard name
23 novembre 2018, par Ruiling Songlavu/opencl : replace va_ext.h with standard name
Khronos OpenCL header (https://github.com/KhronosGroup/OpenCL-Headers)
uses cl_va_api_media_sharing_intel.h. And Intel's official OpenCL driver
for Intel GPU (https://github.com/intel/compute-runtime) was compiled
against Khronos OpenCL header. So it's better to align with Khronos.Signed-off-by : Ruiling Song <ruiling.song@intel.com>
Syndiquer tout le site
