Recherche avancée

Sur d’autres sites (11259)

• Remuxing mp4 on the fly with FFmpeg API

  25 octobre 2015, par Vadym

  My goal is to stream out mpegts. As input, I take an mp4 file stream. That is, video producer writes mp4 file into a stream that I try to work with. The video may be anywhere from one minute to ten minutes. Because producer writes bytes into stream, the originally written mp4 header is not complete (first 32 bytes prior to ftyp are 0x00 because it doesn’t know yet various offsets... which are written post-recording, I think) :

  This is how the header of typical mp4 looks like :

  00 00 00 18   66 74 79 70   69 73 6f 6d   00 00 00 00   ....ftypisom.... 
  
  69 73 6f 6d   33 67 70 34   00 01 bb 8c   6d 64 61 74   isom3gp4..»Œmdat

  This is how the header of "in progress" mp4 looks like :

  00 00 00 00   66 74 79 70   69 73 6f 6d   00 00 00 00   ....ftypisom.... 
  
  69 73 6f 6d   33 67 70 34   00 00 00 18   3f 3f 3f 3f   isom3gp4....????
  
  6d 64 61 74                                             mdat

  It is my guess but I assume that once the producer completes recording, it updates the header by writing all the necessary offsets.

  I have run into two issues while trying to make this work :

  1. I created a custom AVIO with read function that does not support seeking. In my driver program, I decided to stream in a properly formatted mp4 file. I am able to detect its input format. When I try to open it, I see that my custom read function gets executed within avformat_open_input until the entire file is read in.

  My code sample :

  av_register_all();
  
  
  
  AVFormatContext* pCtx = avformat_alloc_context();
  
  pCtx->pb = avio_alloc_context(
  
      pBuffer,         // internal buffer
  
      iBufSize,        // internal buffer size
  
      0,               // bWriteable (1=true,0=false)
  
      stream,          // user data ; will be passed to our callback functions
  
      read_stream,     // read callback function
  
      NULL,            // write callback function (not used in this example)
  
      NULL             // seek callback function
  
  );
  
  pCtx->pb->seekable = 0;
  
  pCtx->pb->write_flag = 0;
  
  pCtx->iformat = av_find_input_format( "mp4" );
  
  pCtx->flags |= AVFMT_FLAG_CUSTOM_IO;
  
  
  
  avformat_open_input( &pCtx, "", pCtx->iformat, NULL );

  Obviously, this does not work as I need (I expectations were wrong). Once I substitute the file of finite size by a stream of varies length, I cannot have avformat_open_input wait around for the stream to finish before attempting to do further processing.

  As such, I need to find a way to open input without attempt to read it and only read when I execute av_read_frame. Is this at all possible to do by using custom AVIO. That is, prepare/open input -> read initial input data into input buffer -> read frame/packet from input buffer -> write packet to output -> repeat read input data until the end of stream.

  I did scavenge google and only saw two alternatives : providing custom URLProtocol and using AVFMT_NOFILE.

  Custom URLProtocol
  This sounds like a little backwards way for what I’m trying to accomplish. I understand that it is best used when there is a file source available. Whereas I am trying to read from a byte stream. Also, another reason I think it doesn’t fit my needs is that custom URLProtocol needs to be compiled into ffmpeg lib, correct ? Or is there a way to manually register it during runtime ?

  AVFMT NOFILE
  This seems like something that should actually work best for me. The flag itself says that there is no underlying source file and assumes that I will handle all the reading and provisioning of input data. The trouble is that I haven’t seen any online code snippets so far but my assumption is as follows :

  I am really hoping to get some suggestions of food for brain from anyone because I am a newbie to ffmpeg and digital media and my second issue expects that I can stream output while ingesting input.

  1. As I mentioned above, I have a handle on the mp4 file bytestream as it would be written to the hard disk. The format is mp4 (h.264 and aac). I need to remux it to mpegts prior to streaming it out. This shouldn’t be difficult because mp4 and mpegts are simply containers. From what I learned so far, mp4 file looks the following :

     [header info containing format versions]
     mdat
     [stream data, in my case h.264 and aac streams]
     [some trailer separator]
     [trailer data]

  If that is correct, I should be able to get the handle on h.264 and aac interleaved data by simply starting to read the stream after "mdat" identifier, correct ?

  If that is true and I decide to go with AVFMT_NOFILE approach of managing input data, I can just ingest stream data (into AVFormatContext buffer) -> av_read_frame -> process it -> populate AVFormatContext with more data -> av_read_frame -> and so on until the end of stream.

  I know, this is a mouthful and a dump of my thoughts but I would appreciate any discussion, pointers, thoughts !

• Dreamcast Track Sizes

  1er mars 2015, par Multimedia Mike — Sega Dreamcast

  I’ve been playing around with Sega Dreamcast discs lately. Not playing the games on the DC discs, of course, just studying their structure. To review, the Sega Dreamcast game console used special optical discs named GD-ROMs, where the GD stands for “gigadisc”. They are capable of holding about 1 gigabyte of data.

  You know what’s weird about these discs ? Each one manages to actually store a gigabyte of data. Each disc has a CD portion and a GD portion. The CD portion occupies the first 45000 sectors and can be read in any standard CD drive. This area is divided between a brief data track and a brief (usually) audio track.

  The GD region starts at sector 45000. Sometimes, it’s just one humongous data track that consumes the entire GD region. More often, however, the data track is split between the first track and the last track in the region and there are 1 or more audio tracks in between. But the weird thing is, the GD region is always full. I made a study of it (click for a larger, interactive graph) :

  
  
  

  Some discs put special data or audio bonuses in the CD region for players to discover. But every disc manages to fill out the GD region. I checked up on a lot of those audio tracks that divide the GD data and they’re legitimate music tracks. So what’s the motivation ? Why would the data track be split in 2 pieces like that ?

  I eventually realized that I probably answered this question in this blog post from 4 years ago. The read speed from the outside of an optical disc is higher than the inside of the same disc. When I inspect the outer data tracks of some of these discs, sure enough, there seem to be timing-sensitive multimedia FMV files living on the outer stretches.

  One day, I’ll write a utility to take apart the split ISO-9660 filesystem offset from a weird sector.

• Evolution #4346 (En cours) : Extraire la gestion des catégories de SPIP et SVP (action 1)

  11 juin 2019, par Eric Lupinacci

  Le passage sous Composer va à plus ou moins long terme remettre en cause SVP. SVP supporte aujourd’hui plusieurs fonctions distinctes dont :

  1. la "gestion" des catégories
  2. la "gestion" des branches SPIP
  3. la construction du référentiel des plugins et des dépôts.
  4. l’installation des plugins incluant la gestion des dépendances.

  La mise en place de Composer (objectif final avec les plugins) remet en cause complètement la fonction 4-.
  L’idée est donc :

  • action 1 : transférer la fonction 1 dans un plugin à part : c’est déjà fait en grande partie et le plugin s’appelle SVP Typologie.
  • action 2 : transférer la fonction 2 dans SPIP directement (ou ailleurs, à réfléchir). Cela correspond principalement à des globales et une balise.
  • action 3 : transférer la fonction 3 dans un plugin "Référentiel des plugins" qui construit la base des plugins à partir des archives XML. En complément, il serait bien de réfléchir à une autre manière d’intégrer dans le référentiel les plugins Github de façon corriger les liens erronés puis ensuite de rajouter les zips Composer.
  • action 4 : réduire SVP à la fonction 4 en nécessitant le plugin "Référentiel des plugins" pour un certain temps.

  Ce ticket est avant tout dédié à l’action 1.
  Outre le plugin SVP Typologie développé pour l’instant sur Github https://github.com/smellup/svp_typologie il faut aussi faire des modifications sur SVP et le Core.

  Pour le Core, il faut :

  • passer la catégorie en optionnelle, supprimer la liste des valeurs possibles afin de ne pas générer d’erreur. Une fois les nouvelles catégories adoptées, on pourra même supprimer la catégorie des fichiers XML.
  • vérifier que les références à la catégorie dans les fonctions de chargement des XML sont compatibles avec l’absence de catégorie (a priori c’est le cas dans info_plugin).

  Pour SVP, il faut :

  • supprimer les balises, filtres et globales associés aux catégories
  • certains autres filtres (comptage en particulier) ne sont utilisés que dans Plugins SPIP. Il convient de les déplacer dans le plugin idoine (Plugins SPIP ou Contrib à terme)
  • Supprimer le filtre catégorie dans le formulaire de recherche des plugins.