Recherche avancée

Sur d’autres sites (1988)

• Révision 22075 : Intégration dans SPIP de la possibilité de gérer des liens entre objets

  8 mai 2015, par marcimat ☺☮☯♫

  avec des rôles.

  On intègre l’API présente actuellement dans le plugin Rôles, en modifiant
  un peu les fonctions d’édition de liens.

  Celles-ci permettent maintenant d’éditer des liens ayant donc des rôles.
  Ces différents rôles et le nom de la colonne SQL qui les reçoit,
  s’ils sont utilisés, doivent être déclarés avec la déclaration
  de l’objet éditorial correspondant.

  Un exemple est donné avec le plugin « Roles auteurs » qui définit
  quelques rôles. Les champs décrivant les rôles : `roles_colonne`, `roles_titres` et `roles_objets`
  doivent être déclarés (via le pipeline declarer_tables_objets_sql).

  ```
  "roles_colonne" => "role",
  "roles_titres" => array(
  ’redacteur’ => ’info_statut_redacteur’,
  ’traducteur’ => ’roles_auteurs:traducteur’,
  ’correcteur’ => ’roles_auteurs:correcteur’,
  ’relecteur’ => ’roles_auteurs:relecteur’,
  ),
  "roles_objets" => array(
  ’articles’ => array(
  ’choix’ => array(’redacteur’, ’traducteur’, ’correcteur’, ’relecteur’),
  ’defaut’ => ’redacteur’
  )
  #’*’ => array()
  )
  ```

  Une fois déclaré, on peut appeler les fonctions d’édition de lien
  en transmettant des valeurs de rôles, tel que :

  ```
  objet_associer(
  array(’auteur’ => 3),
  array(’article’ => 11),
  array(’role’ => ’correcteur’)
  ) ;

  // utilisera le rôle par défaut
  objet_associer(
  array(’auteur’ => 3),
  array(’article’ => 11)
  ) ;
  ```

  Si aucun rôle n’est indiqué, le rôle par défaut est appliqué.

  Dans le cas d’une dissociation également, si aucun rôle n’est indiqué,
  seuls les liaisons avec le rôle par défaut seront supprimés ; pour
  supprimer tous les rôles, il faut à ce moment là indiquer ’*’ :

  ```
  objet_dissocier(
  array(’auteur’ => 3),
  array(’article’ => 11),
  array(’role’ => ’correcteur’)
  ) ;

  // utilisera le rôle par défaut
  objet_dissocier(
  array(’auteur’ => 3),
  array(’article’ => 11)
  ) ;

  // enlèvera tous les rôles
  objet_dissocier(
  array(’auteur’ => 3),
  array(’article’ => 11),
  array(’role’ => ’*’)
  ) ;
  ```

  Le formulaire d’édition de liens n’utilisera pas les mêmes squelettes
  de liaison lorsqu’une colonne de rôle est déclarée.

  Ainsi dans cet exemple, au lieu de `prive/objets/liste/auteurs_lies.html`
  et `auteurs_associer.html`, cela utiliserait `prive/objets/liste/auteurs_roles_lies.html`
  et `auteurs_roles_associer.html`. Il faut donc créer ces squelettes.

  Ces squelettes peuvent poster les valeurs au formulaire pour insérer
  de nouveaux liens, de la forme `qualifier_lien[auteur-3-article-11][role]`
  en postant `redacteur` par exemple.

  Il est possible au passage de poster en plus d’autres valeurs, qui seront
  intégrées dans l’enregistrement du lien.
  Ainsi, poster en même temps `qualifier_lien[auteur-3-article-11][valeur]` = `50`
  enregistrera la valeur 50 dans la colonne `valeur` de la table de lien (qui doit
  exister !).

  D’autres informations sont présentes dans http://contrib.spip.net/Des-roles-sur-des-liens,
  http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles_auteurs ou encore
  http://zone.spip.org/trac/spip-zone/browser/_plugins_/roles

• Connection reset by peer, ffmpeg

  18 août 2016, par Johnnylin

  I have tried several ways and done a lot of search. I just cannot figure out why this happens.

  This is the thread. I did almost the same thing.

  https://ffmpeg.org/pipermail/libav-user/2014-March/006356.html

  When you use ffmpeg command line together with ffserver, it works. But when you use sample code. It just does not work.

  What is missing ?

  EDIT

  Hi all,

  I took the muxing.c example and modified it in order to send a stream
  through a network socket. I only made few modifications :

  main function now looks like :

  int main()
  
  {
  
      AVOutputFormat *fmt;
  
      AVFormatContext *oc;
  
      AVStream *audio_st, *video_st;
  
      AVCodec *audio_codec, *video_codec;
  
      double audio_time, video_time;
  
      int flush, ret;
  
  
  
      /* Initialize libavcodec, and register all codecs and formats. */
  
      av_register_all();
  
      avformat_network_init();
  
  
  
      /* allocate the output media context */
  
      avformat_alloc_output_context2(&oc, NULL, "mpegts", NULL);
  
      if (!oc) {
  
          printf("Could not deduce output format from file extension: using
  
  MPEG.\n");
  
          avformat_alloc_output_context2(&oc, NULL, "mpegts", NULL);
  
      }
  
      if (!oc)
  
          return 1;
  
  
  
      fmt = oc->oformat;
  
      //fmt->video_codec = AV_CODEC_ID_MPEG2VIDEO;
  
      //fmt->audio_codec = AV_CODEC_ID_MP3;
  
  
  
      /* Add the audio and video streams using the default format codecs
  
       * and initialize the codecs. */
  
      video_st = NULL;
  
      audio_st = NULL;
  
  
  
      if (fmt->video_codec != AV_CODEC_ID_NONE)
  
          video_st = add_stream(oc, &video_codec, fmt->video_codec);
  
      if (fmt->audio_codec != AV_CODEC_ID_NONE)
  
          audio_st = add_stream(oc, &audio_codec, fmt->audio_codec);
  
  
  
      /* Now that all the parameters are set, we can open the audio and
  
       * video codecs and allocate the necessary encode buffers. */
  
      if (video_st)
  
          open_video(oc, video_codec, video_st);
  
      if (audio_st)
  
          open_audio(oc, audio_codec, audio_st);
  
  
  
     av_dump_format(oc, 0, "http://localhost:8090/feed1.ffm", 1);
  
  
  
      /* open the output file, if needed */
  
      if (!(fmt->flags & AVFMT_NOFILE)) {
  
          ret = avio_open(&oc->pb, "http://localhost:8090/feed1.ffm",
  
  AVIO_FLAG_WRITE);
  
          if (ret < 0) {
  
              fprintf(stderr, "Could not open '%s': %s\n", "
  
  http://localhost:8090/feed1.ffm",
  
                      av_err2str(ret));
  
              return 1;
  
          }
  
      }
  
  
  
      /* Write the stream header, if any. */
  
      ret = avformat_write_header(oc, NULL);
  
      if (ret < 0) {
  
          fprintf(stderr, "Error occurred when opening output file: %s\n",
  
                  av_err2str(ret));
  
          return 1;
  
      }
  
  
  
      flush = 0;
  
      while ((video_st && !video_is_eof) || (audio_st && !audio_is_eof)) {
  
          /* Compute current audio and video time. */
  
          audio_time = (audio_st && !audio_is_eof) ? audio_st->pts.val *
  
  av_q2d(audio_st->time_base) : INFINITY;
  
          video_time = (video_st && !video_is_eof) ? video_st->pts.val *
  
  av_q2d(video_st->time_base) : INFINITY;
  
  
  
          if (!flush &&
  
              (!audio_st || audio_time >= STREAM_DURATION) &&
  
              (!video_st || video_time >= STREAM_DURATION)) {
  
              flush = 1;
  
          }
  
  
  
          /* write interleaved audio and video frames */
  
          if (audio_st && !audio_is_eof && audio_time <= video_time) {
  
              write_audio_frame(oc, audio_st, flush);
  
          } else if (video_st && !video_is_eof && video_time < audio_time) {
  
              write_video_frame(oc, video_st, flush);
  
          }
  
      }
  
  
  
      /* Write the trailer, if any. The trailer must be written before you
  
       * close the CodecContexts open when you wrote the header; otherwise
  
       * av_write_trailer() may try to use memory that was freed on
  
       * av_codec_close(). */
  
      av_write_trailer(oc);
  
  
  
      /* Close each codec. */
  
      if (video_st)
  
          close_video(oc, video_st);
  
      if (audio_st)
  
          close_audio(oc, audio_st);
  
  
  
      if (!(fmt->flags & AVFMT_NOFILE))
  
          /* Close the output file. */
  
          avio_close(oc->pb);
  
  
  
      /* free the stream */
  
      avformat_free_context(oc);
  
  
  
      return 0;
  
  }  

  and, in order to avoid a warning about channel layout not specified, I
  added :

  c->channel_layout = av_get_default_channel_layout(c->channels);
  
  
  
  in function AVStream *add_stream(AVFormatContext *oc, AVCodec **codec,
  
                          enum AVCodecID codec_id)

  just under the row c->channels = 2 ;

  I also raised a ffserver with the following configuration (showing only
  feed lines) :

  <feed>
  
          File /tmp/feed1.ffm
  
          FileMaxSize 1GB
  
          ACL allow 127.0.0.1
  
          ACL allow 192.168.0.0 192.168.255.255
  
  </feed>

  ffserver is working fine if I feed it with a ffmpeg commandline, e.g :

  ffmpeg -r 25 -i movie.mp4 -acodec libfdk_aac  -ab 128k -vcodec libx264 -fpre libx264-fast.ffpreset http://localhost:8090/feed1.ffm

  But with my example, I can write only few frames and after that may muxing
  modified program ends with :

  Error while writing video frame : Connection reset by peer

  I tried also different codecs (h264) and format (flv), turning out in a
  different number of frames written, but eventually I got the same error
  above.

  ffserver do not reports errors at all, only write:
  
  Tue Mar  4 12:55:10 2014 127.0.0.1 - - [POST] "/feed1.ffm HTTP/1.1" 200 4096
  
  confirming that the communication socket was open

  What am i missing ??

  Thanks

• av_interleaved_write_frame() : Connection reset by peer when streaming to RTMP

  17 mai 2023, par Loc Bui Nhien

  I'm trying to stream to an RTMP server using a Python subprocess with FFmpeg. When I wanted to stream it to localhost, everything worked fine. But when I tried to stream it to my designated RMTP server using nginx, now and then, this error will crash the program :

  


  av_interleaved_write_frame(): Broken pipe    
Error writing trailer of rtmp://.../live: Broken pipe


  


  I checked the connection to the server it was fine. Here are my settings for my RTMP server using nginx :

  


  rtmp {
    server {
        listen 1935;
        chunk_size 4096;

        application live {
            live on;
            record off;
        }
    }
}


  


  And here is my code for FFmpeg code to stream :

  


  command = ['ffmpeg',
           '-y',
           '-f', 'rawvideo',
           '-vcodec', 'rawvideo',
           '-pix_fmt', 'bgr24',
           '-s', "{}x{}".format(width, height),
           '-re',
           '-r', str(fps),
           '-i', 'pipe:',
           '-c:v', 'libx264',
           '-pix_fmt', 'yuv420p',
           '-preset', 'medium',
           '-vsync','vfr',
           '-f', 'flv',
           '-flvflags', 'no_duration_filesize',
           rtmp_url]

p = subprocess.Popen(command, stdin=subprocess.PIPE)


  


  I'm pretty sure that it has something to do with how the RTMP server is setup and its settings, but I provide the ffmpeg code just in case.

  


  Thank you in advance.