Recherche avancée
Médias (3)
-
Valkaama DVD Cover Outside
4 octobre 2011, par
Mis à jour : Octobre 2011
Langue : English
Type : Image
-
Valkaama DVD Label
4 octobre 2011, par
Mis à jour : Février 2013
Langue : English
Type : Image
-
Valkaama DVD Cover Inside
4 octobre 2011, par
Mis à jour : Octobre 2011
Langue : English
Type : Image
Autres articles (35)
-
La file d’attente de SPIPmotion
28 novembre 2010, parUne file d’attente stockée dans la base de donnée
Lors de son installation, SPIPmotion crée une nouvelle table dans la base de donnée intitulée spip_spipmotion_attentes.
Cette nouvelle table est constituée des champs suivants : id_spipmotion_attente, l’identifiant numérique unique de la tâche à traiter ; id_document, l’identifiant numérique du document original à encoder ; id_objet l’identifiant unique de l’objet auquel le document encodé devra être attaché automatiquement ; objet, le type d’objet auquel (...) -
Organiser par catégorie
17 mai 2013, parDans MédiaSPIP, une rubrique a 2 noms : catégorie et rubrique.
Les différents documents stockés dans MédiaSPIP peuvent être rangés dans différentes catégories. On peut créer une catégorie en cliquant sur "publier une catégorie" dans le menu publier en haut à droite ( après authentification ). Une catégorie peut être rangée dans une autre catégorie aussi ce qui fait qu’on peut construire une arborescence de catégories.
Lors de la publication prochaine d’un document, la nouvelle catégorie créée sera proposée (...) -
Gestion générale des documents
13 mai 2011, parMédiaSPIP ne modifie jamais le document original mis en ligne.
Pour chaque document mis en ligne il effectue deux opérations successives : la création d’une version supplémentaire qui peut être facilement consultée en ligne tout en laissant l’original téléchargeable dans le cas où le document original ne peut être lu dans un navigateur Internet ; la récupération des métadonnées du document original pour illustrer textuellement le fichier ;
Les tableaux ci-dessous expliquent ce que peut faire MédiaSPIP (...)
Sur d’autres sites (5638)
-
For custom FFmpeg I/O API : incorrect data about write_packet Callback function of avio_alloc_context()
13 avril 2021, par oahoI would like to ask a question about ffmpeg custom I/O api.


Description of the problem : I used the FFmpeg official example - remuxing.c to test a simple conversion package operation. (test1.ts -> test1.mp4). This operation result is normal.
But when I use Custom I/O




avio_alloc_context(buf, 65535, 1, nullptr, nullptr, write_cb, seek) ;




function, the custom I/O output is written to the memory, and then the mp4 file is written from this memory. It is found that the output file data is different from Internal file Protocol write. VLC and MediaInfo can't probe it.


I Use Beyond Compare4 to compare file data :


Beyond Compare 4 Picture Comparasion


In this picture, the left is my customized I/O output, and the right is the official example (according to file URLProtocol to Output)


I tested it many times, and each time the data size, data location, and data content are all in the same place. When I change the data of the few bytes with the difference on the left to the data on the right, VLC can play normally.


Is my operation improper, or is it another problem ?


Source Code :


extern "C"{
#include <libavformat></libavformat>avformat.h>
#include <libavcodec></libavcodec>avcodec.h>
}
#include 
#include <cstdio>
#include 
void process_error(int ret, const char* info)
{
 if( ret < 0)
 {
 fprintf(stderr, info);
 std::exit(-1);
 }
}
int fd;
int write_packet(void *opaque, uint8_t *buf, int buf_size)
 {
 int ret;
 ret = write(fd, buf, buf_size);
 printf("write bytes %d\n", ret);
 return (ret == -1) ? AVERROR(errno) : ret;
 }
 int64_t seek(void *opaque, int64_t offset, int whence)
 {
 return offset;
 }

 int main()
 {

 fd = open("/home/oaho/Desktop/22.mp4", O_CREAT | O_WRONLY, 0777);
 if ( fd < 0)
 {
 return -1;
 }


 AVFormatContext *inputContext = nullptr;
 AVFormatContext *ouputContext = nullptr;

 int ret = avformat_open_input(&inputContext, "/home/oaho/Desktop/test1.ts", nullptr, nullptr);
 process_error(ret, "could'not open input\n");
 ret = avformat_find_stream_info(inputContext, nullptr);
 process_error(ret, "could'not find stream information\n");

 avformat_alloc_output_context2(&ouputContext, nullptr, "mp4", nullptr);
 if( ouputContext == nullptr)
 process_error(-1, "could'not alloc outputContext\n");


 if( ouputContext->oformat==nullptr)
 {
 ouputContext->oformat = av_guess_format("mp4", nullptr, nullptr);
 }

 uint8_t* buf = nullptr;
 buf = (uint8_t*)av_malloc(200 * 1024);
 if( buf == nullptr)
 {
 return -1;
 }
 ouputContext->pb = nullptr;
 ouputContext->pb = avio_alloc_context(buf, 200 * 1024, 1, nullptr, nullptr, write_packet, seek);
 if( ouputContext->pb == nullptr)
 {
 return -1;
 }
 ouputContext->flags = AVFMT_FLAG_CUSTOM_IO;
 //pre the stream avalible
 int *arr = new int[inputContext->nb_streams];
 if( arr == nullptr )
 process_error(-1, "can't alloc array\n");
 int stream_index = 0;
 //get stream : video stream , audio stream , subtitle stream
 for(int i = 0;i < inputContext->nb_streams;i++)
 {
 //get the single stream
 AVStream *stream = inputContext->streams[i];
 AVStream *outStream = nullptr;
 AVCodecParameters *codec = stream->codecpar;
 if( codec -> codec_type != AVMediaType::AVMEDIA_TYPE_VIDEO
 && codec -> codec_type != AVMediaType::AVMEDIA_TYPE_AUDIO
 && codec -> codec_type != AVMediaType::AVMEDIA_TYPE_SUBTITLE)
 {
 arr[i] = -1;
 continue;
 }
 arr[i] = stream_index++;
 outStream = avformat_new_stream(ouputContext, nullptr);
 if(outStream == nullptr)
 goto end;
 int ret = avcodec_parameters_copy(outStream->codecpar, stream->codecpar);
 if( ret < 0)
 goto end;
 //not include additional information
 outStream->codecpar->codec_tag = 0;
 }
 ret = avformat_write_header(ouputContext, nullptr);
 process_error(ret, "can't write header\n");

 while(1)
 {
 AVPacket pkt;
 av_init_packet(&pkt);
 AVStream *in_stream, *out_stream;
 ret = av_read_frame(inputContext, &pkt);
 if( ret < 0)
 break; 
 in_stream = inputContext->streams[pkt.stream_index];
 if (arr[pkt.stream_index] < 0) {
 av_packet_unref(&pkt);
 continue;
 }
 pkt.stream_index = arr[pkt.stream_index];
 out_stream = ouputContext->streams[pkt.stream_index];
 /* copy packet */
 pkt.pts = av_rescale_q(pkt.pts, in_stream->time_base, out_stream->time_base);
 pkt.dts = av_rescale_q(pkt.dts, in_stream->time_base, out_stream->time_base);
 pkt.duration = av_rescale_q(pkt.duration, in_stream->time_base, out_stream->time_base);
 pkt.pos = -1;
 //log_packet(ofmt_ctx, &pkt, "out");
 ret = av_interleaved_write_frame(ouputContext, &pkt);
 if (ret < 0) {
 fprintf(stderr, "Error muxing packet\n");
 break;
 }
 av_packet_unref(&pkt);
 }
 av_write_trailer(ouputContext);
 end:
 close(fd);
 delete [] arr;
 avformat_free_context(inputContext);
 avformat_free_context(ouputContext);
 return 0;
 }
</cstdio>

-
lavfi : generalize colorspace coefficent helpers
9 avril 2022, par Niklas Haaslavfi : generalize colorspace coefficent helpers
These are needed beyond just vf_colorspace, so give them a new home in
colorspace.h.In addition to moving code around, also merge the white point and
primary coefficients into a single struct to slightly increase the
convenience and shrink the size of the new API by avoiding the need
to introduce an extra function just to look up the white point as well.
The only place the distinction matters is in a single enum comparison,
which can just as well be a single memcpy - the difference is
negligible.Signed-off-by : Niklas Haas <git@haasn.dev>
-
FFMPEG re-broadcast/proxy MJPEG stream
10 septembre 2022, par Ollie PughI have an MJPEG stream coming from an RPI on my home network and have an NGINX acting as a proxy on an EC2.


For the camera access the flow of stream to the user is the following


RPi -> mjpeg-proxy (running on EC2) -> NGINX (running on same EC2) -> user


the point of mjpeg-proxy is to reduce the load on the RPi and only have one stream to the Pi and allow the EC2 to distribute that one stream.


Now this work fine-ish from my PC (on same network as Pi) the streams work perfectly. But when it comes to my phone on roaming data, the stream is super choppy and the latency grows massively (this project needs minimal latency, like sub 300ms).


I can't understand why this would happen ? Because even when running of my local PC its going through the Proxy hosted in the cloud, so its not as if its an advantage to it being local ?


the stream is fine on another device, e.g. my laptop, but thats on the same network as the RPi. But like I said, it shouldn't makea difference as its going through a proxy !


I was wondering if using FFMPEG to re-stream the mjpeg stream would be beneficial as node is notoriously slow. But I don't really want to be writing my own mjpeg-proxy in C++ to speed this all up.


I have looked online for answers to FFMPEG MJPEG proxy and have been very unsuccesful


Syndiquer tout le site
