Sur d’autres sites (12051)

• Anomalie #4230 (Nouveau) : Limite à la longueur des paramètres d’un modèle

  17 novembre 2018

  Bonjour,

  C’est pas exactement Texwheel parce que le code concerné est dans le core. Mais ça se manifeste dans le traitement des raccourcis typo.
  Bref.

  J’ai constaté que si un modèle contenait trop de caractères, alors qu’il passait en PHP 5.6, il n’était plus interprété en PHP 7.

  Test ici : https://contrib.spip.net/ecrire/?exec=article&id_article=5055

  Et preuve du problème : https://3v4l.org/lqqIG qui montre qu’en PHP 5.6, la regex fonctionne, mais pas pour 7.0.32 - 7.3.0alpha2 (alors qu’avec un caractère de moins, ça passe partout : https://3v4l.org/k4bgd)
  Code construit à partir de https://core.spip.net/projects/spip/repository/entry/branches/spip-3.2/ecrire/inc/lien.php#L294

  Il semblerait que ce soit une limite de PCRE introduite avec PHP7 et son option jit activée par défaut :https://stackoverflow.com/questions/34849485/regex-not-working-for-long-pattern-pcres-jit-compiler-stack-limit-php7

  En local, je n’ai plus le problème en ayant mis dans mes_options.php :
  ini_set(’pcre.jit’, 0) ;

  https://regex101.com/r/DqmJMs/2 permet de voir que la regex fait énormément de backtrack et donc d’étapes : 19105 étapes.

  J’ai idée que l’usage de conditions serait plus efficace, mais j’ai pas trouvé comment.
  https://www.rexegg.com/regex-conditionals.html#engines

• How can I correctly provide a fake webcam input to Chrome ?

  30 août 2018, par doppelgreener

  I’m trying to run end-to-end testing in Chrome for a product that requires a webcam feed halfway through to operate. From what I understand this means providing a fake webcam video to Chrome using the --use-file-for-fake-video-capture="/path/to/video.y4m" command line argument. It will then use that as a webcam video.

  However, no matter what y4m file I provide, I get the following error from Chrome running under these conditions :

  DOMException: Could not start video source
  
  {
  
    code: 0,
  
    message: "Could not start video source",
  
    name: "NotReadableError"
  
  }

  Notably I can provide an audio file just fine using --use-file-for-fake-audio-capture and Chrome will work with it well. The video has been my sticking point.

  This error comes out of the following straightforward mediaDevices request :

  navigator.mediaDevices.getUserMedia({ video: true, audio: true })
  
    .then(data => {
  
      // do stuff
  
    })
  
    .catch(err => {
  
      // oh no!
  
    });

  (This always hits the “oh no !” branch when a video file is provided.)

  What I’ve tried so far

  I’ve been running Chrome with the following command line arguments (newlines added for readability), and I’m using a Mac hence the open command :

  open -a "Google Chrome" --args
  
    --disable-gpu
  
    --use-fake-device-for-media-stream
  
    --use-file-for-fake-video-capture="~/Documents/mock/webcam.y4m"
  
    --use-file-for-fake-audio-capture="~/Documents/mock/microphone.wav"

  webcam.y4m and microphone.wav were generated from a video file I recorded.

  I first recorded a twenty-second mp4 video using my browser’s MediaRecorder, downloaded the result, and converted it using the following command line commands :

  ffmpeg -y -i original.mp4 -f wav -vn microphone.wav
  
  ffmpeg -y -i original.mp4 webcam.y4m

  When this didn’t work, I tried the same using a twenty-second movie file I recorded in Quicktime :

  ffmpeg -y -i original.mov -f wav -vn microphone.wav
  
  ffmpeg -y -i original.mov webcam.y4m

  When that also failed, I went straight to the Chromium file that explains fake video capture, went to the example y4m file list it provided, and downloaded the grandma file and provided that as a command line argument to Chrome instead :

  open -a "Google Chrome" --args
  
    --disable-gpu
  
    --use-fake-device-for-media-stream
  
    --use-file-for-fake-video-capture="~/Documents/mock/grandma_qcif.y4m"
  
    --use-file-for-fake-audio-capture="~/Documents/mock/microphone.wav"

  Chrome provides me with the exact same error in all of these situations.

  The only time Chrome doesn’t error out with that mediaDevices request is when I omit the video completely :

  open -a "Google Chrome" --args
  
    --disable-gpu
  
    --use-fake-device-for-media-stream
  
    --use-file-for-fake-audio-capture="~/Documents/mock/microphone.wav"

  Accounting for C420mpeg2

  TestRTC suggests Chrome will “crash” if I give it a C420mpeg2 file, and recommends that simply replacing the metadata fixes the issue. Indeed the video file I generate from ffmpeg gives me the following header :

  YUV4MPEG2 W1280 H720 F30:1 Ip A1:1 C420mpeg2 XYSCSS=420MPEG2

  Chrome doesn’t actually crash when run with this file, I just get the error above. If I edit the video file to the following header though per TestRTC’s recommendations I get the same situation :

  YUV4MPEG2 W1280 H720 F30:1 Ip A1:1 C420 XYSCSS=420MPEG2

  The video file still gives me the above error in these conditions.

  What can/should I do ?

  How should I be providing a video file to Chrome for this command line argument ?

  How should I be recording or creating the video file ?

  How should I convert it to y4m ?

• how can I copy file frame by frame to get exactly the same file ? (FFmpeg)

  14 février 2018, par user3360601

  I was using an ffmpeg example from original source remuxing.c to copy file by frames. It works, but the result file has another structure inside.

  From the left is original file. It has "framerate" field. Moreover, the copy file has smaller size. On 18 bytes less.

  Question : how can I copy file frame by frame to get exactly the same file ? Including "framerate" field and total size ?

  Code from the source site.

      /*
  
   * Copyright (c) 2013 Stefano Sabatini
  
   *
  
   * Permission is hereby granted, free of charge, to any person obtaining a copy
  
   * of this software and associated documentation files (the "Software"), to deal
  
   * in the Software without restriction, including without limitation the rights
  
   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  
   * copies of the Software, and to permit persons to whom the Software is
  
   * furnished to do so, subject to the following conditions:
  
   *
  
   * The above copyright notice and this permission notice shall be included in
  
   * all copies or substantial portions of the Software.
  
   *
  
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  
   * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  
   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  
   * THE SOFTWARE.
  
   */
  
  
  
  /**
  
   * @file
  
   * libavformat/libavcodec demuxing and muxing API example.
  
   *
  
   * Remux streams from one container format to another.
  
   * @example remuxing.c
  
   */
  
  
  
  #include <libavutil></libavutil>timestamp.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  
  
  static void log_packet(const AVFormatContext *fmt_ctx, const AVPacket *pkt, const char *tag)
  
  {
  
      AVRational *time_base = &amp;fmt_ctx->streams[pkt->stream_index]->time_base;
  
  
  
      printf("%s: pts:%s pts_time:%s dts:%s dts_time:%s duration:%s duration_time:%s stream_index:%d\n",
  
             tag,
  
             av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, time_base),
  
             av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, time_base),
  
             av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, time_base),
  
             pkt->stream_index);
  
  }
  
  
  
  int main(int argc, char **argv)
  
  {
  
      AVOutputFormat *ofmt = NULL;
  
      AVFormatContext *ifmt_ctx = NULL, *ofmt_ctx = NULL;
  
      AVPacket pkt;
  
      const char *in_filename, *out_filename;
  
      int ret, i;
  
      int stream_index = 0;
  
      int *stream_mapping = NULL;
  
      int stream_mapping_size = 0;
  
  
  
      if (argc &lt; 3) {
  
          printf("usage: %s input output\n"
  
                 "API example program to remux a media file with libavformat and libavcodec.\n"
  
                 "The output format is guessed according to the file extension.\n"
  
                 "\n", argv[0]);
  
          return 1;
  
      }
  
  
  
      in_filename  = argv[1];
  
      out_filename = argv[2];
  
  
  
      av_register_all();
  
  
  
      if ((ret = avformat_open_input(&amp;ifmt_ctx, in_filename, 0, 0)) &lt; 0) {
  
          fprintf(stderr, "Could not open input file '%s'", in_filename);
  
          goto end;
  
      }
  
  
  
      if ((ret = avformat_find_stream_info(ifmt_ctx, 0)) &lt; 0) {
  
          fprintf(stderr, "Failed to retrieve input stream information");
  
          goto end;
  
      }
  
  
  
      av_dump_format(ifmt_ctx, 0, in_filename, 0);
  
  
  
      avformat_alloc_output_context2(&amp;ofmt_ctx, NULL, NULL, out_filename);
  
      if (!ofmt_ctx) {
  
          fprintf(stderr, "Could not create output context\n");
  
          ret = AVERROR_UNKNOWN;
  
          goto end;
  
      }
  
  
  
      stream_mapping_size = ifmt_ctx->nb_streams;
  
      stream_mapping = av_mallocz_array(stream_mapping_size, sizeof(*stream_mapping));
  
      if (!stream_mapping) {
  
          ret = AVERROR(ENOMEM);
  
          goto end;
  
      }
  
  
  
      ofmt = ofmt_ctx->oformat;
  
  
  
      for (i = 0; i &lt; ifmt_ctx->nb_streams; i++) {
  
          AVStream *out_stream;
  
          AVStream *in_stream = ifmt_ctx->streams[i];
  
          AVCodecParameters *in_codecpar = in_stream->codecpar;
  
  
  
          if (in_codecpar->codec_type != AVMEDIA_TYPE_AUDIO &amp;&amp;
  
              in_codecpar->codec_type != AVMEDIA_TYPE_VIDEO &amp;&amp;
  
              in_codecpar->codec_type != AVMEDIA_TYPE_SUBTITLE) {
  
              stream_mapping[i] = -1;
  
              continue;
  
          }
  
  
  
          stream_mapping[i] = stream_index++;
  
  
  
          out_stream = avformat_new_stream(ofmt_ctx, NULL);
  
          if (!out_stream) {
  
              fprintf(stderr, "Failed allocating output stream\n");
  
              ret = AVERROR_UNKNOWN;
  
              goto end;
  
          }
  
  
  
          ret = avcodec_parameters_copy(out_stream->codecpar, in_codecpar);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Failed to copy codec parameters\n");
  
              goto end;
  
          }
  
          out_stream->codecpar->codec_tag = 0;
  
      }
  
      av_dump_format(ofmt_ctx, 0, out_filename, 1);
  
  
  
      if (!(ofmt->flags &amp; AVFMT_NOFILE)) {
  
          ret = avio_open(&amp;ofmt_ctx->pb, out_filename, AVIO_FLAG_WRITE);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Could not open output file '%s'", out_filename);
  
              goto end;
  
          }
  
      }
  
  
  
      ret = avformat_write_header(ofmt_ctx, NULL);
  
      if (ret &lt; 0) {
  
          fprintf(stderr, "Error occurred when opening output file\n");
  
          goto end;
  
      }
  
  
  
      while (1) {
  
          AVStream *in_stream, *out_stream;
  
  
  
          ret = av_read_frame(ifmt_ctx, &amp;pkt);
  
          if (ret &lt; 0)
  
              break;
  
  
  
          in_stream  = ifmt_ctx->streams[pkt.stream_index];
  
          if (pkt.stream_index >= stream_mapping_size ||
  
              stream_mapping[pkt.stream_index] &lt; 0) {
  
              av_packet_unref(&amp;pkt);
  
              continue;
  
          }
  
  
  
          pkt.stream_index = stream_mapping[pkt.stream_index];
  
          out_stream = ofmt_ctx->streams[pkt.stream_index];
  
          log_packet(ifmt_ctx, &amp;pkt, "in");
  
  
  
          /* copy packet */
  
          pkt.pts = av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
  
          pkt.dts = av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base, AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX);
  
          pkt.duration = av_rescale_q(pkt.duration, in_stream->time_base, out_stream->time_base);
  
          pkt.pos = -1;
  
          log_packet(ofmt_ctx, &amp;pkt, "out");
  
  
  
          ret = av_interleaved_write_frame(ofmt_ctx, &amp;pkt);
  
          if (ret &lt; 0) {
  
              fprintf(stderr, "Error muxing packet\n");
  
              break;
  
          }
  
          av_packet_unref(&amp;pkt);
  
      }
  
  
  
      av_write_trailer(ofmt_ctx);
  
  end:
  
  
  
      avformat_close_input(&amp;ifmt_ctx);
  
  
  
      /* close output */
  
      if (ofmt_ctx &amp;&amp; !(ofmt->flags &amp; AVFMT_NOFILE))
  
          avio_closep(&amp;ofmt_ctx->pb);
  
      avformat_free_context(ofmt_ctx);
  
  
  
      av_freep(&amp;stream_mapping);
  
  
  
      if (ret &lt; 0 &amp;&amp; ret != AVERROR_EOF) {
  
          fprintf(stderr, "Error occurred: %s\n", av_err2str(ret));
  
          return 1;
  
      }
  
  
  
      return 0;
  
  }