Recherche avancée

Sur d’autres sites (10801)

• Revision a2e711ce38 : Properly reset the block coding skip flag array in non-RD mode The block coding

  14 mars 2014, par Jingning Han

  Changed Paths :
   Modify /vp9/encoder/vp9_encodeframe.c

  
  
  Properly reset the block coding skip flag array in non-RD mode

  The block coding skip flags are assigned in the normal RD mode
  decision loop. They are then used in the final encoding stage.
  In the non-RD mode decision, the forward transform and quantization
  stages are replaced by modeling based on SSE and variance of
  prediction residues. This commit applies reset to this array in
  the non-RD coding mode.

  Change-Id : I66584669b035e9c8ac23e95047849ff277472742

• Cloaked Archive Wiki

  16 mai 2011, par Multimedia Mike — General

  Google’s Chrome browser has made me phenomenally lazy. I don’t even attempt to type proper, complete URLs into the address bar anymore. I just type something vaguely related to the address and let the search engine take over. I saw something weird when I used this method to visit Archive Team’s site :

  
  
  

  There’s greater detail when you elect to view more results from the site :

  
  
  

  As the administrator of a MediaWiki installation like the one that archiveteam.org runs on, I was a little worried that they might have a spam problem. However, clicking through to any of those out-of-place pages does not indicate anything related to pharmaceuticals. Viewing source also reveals nothing amiss.

  I quickly deduced that this is a textbook example of website cloaking. This is when a website reports different content to a search engine than it reports to normal web browsers (humans, presumably). General pseudocode :

  PLAIN TEXT

  C :

  1. if (web_request.user_agent_string == CRAWLER_USER_AGENT)
  2.  return cloaked_data ;
  3. else
  4.  return real_data ;

  You can verify this for yourself using the wget command line utility :

  <br />
$ wget --quiet --user-agent="<strong>Mozilla/5.0</strong>" \<br />
 http://www.archiveteam.org/index.php?title=Geocities -O - | grep \&lt;title\&gt;<br />
&lt;title&gt;GeoCities - Archiveteam&lt;/title&gt;

  $ wget —quiet —user-agent="Googlebot/2.1"
  http://www.archiveteam.org/index.php?title=Geocities -O - | grep \<title\>
  <title>Cheap xanax | Online Drug Store, Big Discounts</title>
  

  I guess the little web prank worked because the phaux-pharma stuff got indexed. It makes we wonder if there’s a MediaWiki plugin that does this automatically.

  For extra fun, here’s a site called the CloakingDetector which purports to be able to detect whether a page employs cloaking. This is just one humble observer’s opinion, but I don’t think the site works too well :
  
  

  
  
  

• libavformat : calling avformat_open_input 2 times results in decoding white frames

  25 avril 2017, par explodus
  • pre build ffmpeg libs format/util/scale
  • version 57.56.101
  • don’t use any deprecated function
  • use the actual style
    • av_read_frame -> avcodec_send_packet -> avcodec_receive_frame -> sws_scale

  Everything is fine on the first run, but when i wanna load/open another file i only get white frames.

  void video::app::flush_cached_frames() {
  
      if (nullptr == avcontext)
  
          return;
  
      if (nullptr == avpicture)
  
          return;
  
  
  
      // send an empty packet which instructs the codec to start flushing
  
      AVPacket pkt;
  
      av_init_packet(&pkt);
  
      pkt.data = NULL;
  
      pkt.size = 0;
  
      avcodec_send_packet(avcontext, &pkt);
  
  
  
      // drain the codec
  
      while (true) {
  
          int r = avcodec_receive_frame(avcontext, avpicture);
  
          if (r != 0)
  
              break;
  
      }
  
  }
  
  
  
  void video::app::close_avi() {
  
      flush_cached_frames();
  
  
  
      if (avformat && avstream)
  
          seek_to_frame(0);
  
      avstream = nullptr;
  
  
  
      if (avfile)
  
          fclose(avfile);
  
      avfile = nullptr;
  
  
  
      if (avcontext)
  
          avcodec_close(avcontext);
  
      avcontext = nullptr;
  
  
  
      if (avformat)
  
          avformat_free_context(avformat);
  
      avformat = nullptr;
  
  
  
      if (sws_ctx)
  
          sws_freeContext(sws_ctx);
  
      sws_ctx = nullptr;
  
  
  
      if (avparser)
  
          av_parser_close(avparser);
  
      avparser = nullptr;
  
  
  
      if (avinbuf)
  
          av_free(avinbuf);
  
      avinbuf = nullptr;
  
  }

  I think i close anything perfectly. Has anyone an idea ?

  edit1 : init/load

  unsigned video::app::load(const std::string& name) {
  
      _file = name_;
  
  
  
      close_avi();
  
  
  
      av_register_all();
  
      avcodec_register_all();
  
  
  
      av_init_packet(&avpkt);
  
  
  
      AVCodecID codec_id = AV_CODEC_ID_H264;
  
      int64_t duration = 0;
  
      double fps = .0;
  
      int ret = 0;
  
      {
  
          av_log_set_level(1);
  
  
  
          avfile = fopen(name_.c_str(), "rb");
  
  
  
          avformat = avformat_alloc_context();
  
          ret = avformat_open_input(&avformat, name_.c_str(), nullptr, nullptr);
  
          ret = avformat_find_stream_info(avformat, nullptr);
  
          duration = avformat->duration;
  
  
  
          avstream = nullptr;
  
          if (avformat->nb_streams == 1) {
  
              avstream = avformat->streams[0];
  
          } else {
  
              avstream = avformat->streams[av_find_default_stream_index(avformat)];
  
          }
  
  
  
          if (avstream) {
  
              fps = (double(avstream->avg_frame_rate.num) / double(avstream->avg_frame_rate.den));
  
              codec_id = avstream->codecpar->codec_id;
  
              duration = avstream->duration;
  
  
  
              _vid.v_width = avstream->codecpar->width;
  
              _vid.v_height = avstream->codecpar->height;
  
  
  
              _vid.lastframe = duration / fps;
  
              _vid.lastframe = avstream->nb_frames;
  
          }
  
  
  
          avcodec = avcodec_find_decoder(avstream->codecpar->codec_id);
  
          avparser = av_parser_init(avcodec->id);
  
          avcontext = avcodec_alloc_context3(avcodec);
  
  
  
          avcontext->flags |= AVFMT_FLAG_NONBLOCK;
  
          avcontext->flags |= AVFMT_FLAG_FLUSH_PACKETS;
  
          avcontext->flags |= AVFMT_FLAG_DISCARD_CORRUPT;
  
          avcontext->flags |= AVFMT_FLAG_NOBUFFER;
  
  
  
          ret = avcodec_parameters_to_context(avcontext, avstream->codecpar);
  
          ret = avcodec_open2(avcontext, avcodec, nullptr);
  
  
  
  
  
          // Determine required buffer size and allocate buffer
  
          auto numBytes = av_image_get_buffer_size(
  
                AV_PIX_FMT_BGRA
  
              , avcontext->width
  
              , avcontext->height
  
              , 1);
  
          if (avinbuf)
  
              av_free(avinbuf);
  
          avinbuf = nullptr;
  
          avinbuf = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));
  
          ret = av_image_fill_arrays(
  
                avrgb->data
  
              , avrgb->linesize
  
              , avinbuf
  
              , AV_PIX_FMT_BGRA
  
              , avcontext->width
  
              , avcontext->height
  
              , 1);
  
  
  
          sws_ctx = sws_getContext(
  
                  avcontext->width
  
              , avcontext->height
  
              , avcontext->pix_fmt
  
              , avcontext->width
  
              , avcontext->height
  
              , AV_PIX_FMT_BGRA
  
              , SWS_BILINEAR
  
              , nullptr
  
              , nullptr
  
              , nullptr
  
          );
  
      }
  
  
  
      int err = (sws_ctx && avcontext && avformat) ? 0 : 1;
  
      // ...
  
  }

  getting the frame :

  uint8_t * video::app::get_frame(uint32_t frame) {
  
      if (!avcontext)
  
          return nullptr;
  
      if (!avformat)
  
          return nullptr;
  
      if (!avpicture)
  
          return nullptr;
  
      if (!avfile)
  
          return nullptr;
  
  
  
      try {
  
          int ret = 0;
  
  
  
          if (avpicture->data)
  
              av_frame_unref(avpicture);
  
  
  
          while (true) {
  
              if ((ret = av_read_frame(avformat, &avpkt)) < 0)
  
                  break;
  
  
  
              if (avpkt.stream_index == avstream->index) {
  
                  ret = avcodec_send_packet(avcontext, &avpkt);
  
                  if (ret < 0)
  
                      break;
  
  
  
                  while (ret >= 0) {
  
                      ret = avcodec_receive_frame(avcontext, avpicture);
  
                      if (ret == AVERROR_EOF) {
  
                          return nullptr;
  
                      } else if (ret == -11) {
  
                          avpkt.data = nullptr;
  
                          avpkt.size = 0;
  
                          break;
  
                      } else if (ret < 0) {
  
                          return nullptr;
  
                      }
  
  
  
                      if (ret == AVERROR(EAGAIN)) {
  
                          avpkt.data = nullptr;
  
                          avpkt.size = 0;
  
                          break;
  
                      }
  
  
  
                      if (ret >= 0) {
  
                          int linesize[AV_NUM_DATA_POINTERS] = {
  
                                avpicture->linesize[0]
  
                              , avpicture->linesize[1]
  
                              , avpicture->linesize[2]
  
                              , avpicture->linesize[3]
  
                              , avpicture->linesize[4]
  
                              , avpicture->linesize[5]
  
                              , avpicture->linesize[6]
  
                              , avpicture->linesize[7]
  
                          };
  
                          uint8_t * data[AV_NUM_DATA_POINTERS] = {
  
                                avpicture->data[0]
  
                              , avpicture->data[1]
  
                              , avpicture->data[2]
  
                              , avpicture->data[3]
  
                              , avpicture->data[4]
  
                              , avpicture->data[5]
  
                              , avpicture->data[6]
  
                              , avpicture->data[7]
  
                          };
  
  
  
                          {
  
                              // flip the frame, never ever touch this thing again!
  
                              // If the planes in the image are unequal size(e.g.YUV420) you need to adapt the height.
  
                              auto h = avcontext->height;
  
                              for (int i = 0; i < 4; i++) {
  
                                  if (i)
  
                                      data[i] += linesize[i] * ((h >> 1) - 1);
  
                                  else
  
                                      data[i] += linesize[i] * (h - 1);
  
                                  linesize[i] = -linesize[i];
  
                              }
  
                          }
  
  
  
                          ret = sws_scale(
  
                                sws_ctx
  
                              , (uint8_t const * const *)data
  
                              , linesize
  
                              , 0
  
                              , avcontext->height
  
                              , avrgb->data
  
                              , avrgb->linesize);
  
  
  
                          av_packet_unref(&avpkt);
  
  
  
                          currPts = avpkt.dts;
  
                          currPts *= av_q2d(avstream->time_base);
  
  
  
                          usleep(1000000 * (currPts - prevPts));
  
                          prevPts = currPts;
  
  
  
                          return avrgb->data[0];
  
                      }
  
                  }
  
              }
  
              av_packet_unref(&avpkt);
  
          }
  
  
  
      } catch (...) {
  
      }
  
  
  
      return nullptr;
  
  }