Recherche avancée

Sur d’autres sites (7583)

• Merge commit ’e0046bc9c96150fa06146ace9093f06857dd7b23’

  23 mars 2015, par Michael Niedermayer

  Merge commit ’e0046bc9c96150fa06146ace9093f06857dd7b23’
  * commit ’e0046bc9c96150fa06146ace9093f06857dd7b23’ :
  
    movenc : Write the make and model metadata keys for mov style files
  Conflicts :
  
  	libavformat/movenc.c
  Merged-by : Michael Niedermayer <michaelni@gmx.at>
  

  • [DH] libavformat/movenc.c

• ffmpeg library performance for decoding h.264 for embedded device

  2 avril 2015, par pasifus

  I have some confuse when tried to compile and run decode h.264 on ARM and MIPS architecture.

  I have two embedded devices. I tired to run simple code that read h264 format from file and decode it to h264 in loop in maximum speed (without sleep between frames)

  I found that it too slow in there devices.
  I tested HD video (720p/25fps)

  1. MIPS32® 1004K (700MHz) it was 4 fps average.
  2. Raspberry Pi Model B (700MHz) it also was 4 fps average. (i know that raspberry have GPU to decoding/encoding)

  A also check it on my virtual machine on ubuntu i686 (1300MHz) and it was 200 fps average.

  The question : why it so different preference ? Somebody know how to increase decoding preference on MIPS32® 1004K architecture ?

  #include 
  
  #include 
  
  #include 
  
  #include 
  
  
  
  #include <sys></sys>time.h>
  
  #include 
  
  
  
  #include "libavcodec/avcodec.h"
  
  #include "libavutil/mathematics.h"
  
  
  
  #define INBUF_SIZE 80000
  
  
  
  
  
  static long get_time_diff(struct timeval time_now) {
  
     struct timeval time_now2;
  
     gettimeofday(&amp;time_now2,0);
  
     return time_now2.tv_sec*1.e6 - time_now.tv_sec*1.e6 + time_now2.tv_usec - time_now.tv_usec;
  
  }
  
  
  
  int main(int argc, char **argv)
  
  {
  
      AVCodec *codec;
  
      AVCodecContext *c= NULL;
  
      AVCodecParserContext *parser = NULL;
  
      int frame, got_picture, len2, len;
  
      const char *filename;
  
      FILE *f;
  
      AVFrame *picture;
  
      char *arghwtf = malloc(INBUF_SIZE);
  
      uint64_t in_len;
  
      int pts, dts;
  
      struct timeval t,t2;
  
      float inv_fps = 1e6/23.98;
  
      AVPacket avpkt;
  
  
  
      // register all the codecs
  
      avcodec_register_all();
  
  
  
      // log level
  
      av_log_set_level(AV_LOG_PANIC|AV_LOG_FATAL|AV_LOG_ERROR|AV_LOG_WARNING);
  
  
  
      filename = argv[1];
  
  
  
      av_init_packet(&amp;avpkt);
  
  
  
      printf("Decoding file %s...\n", filename);
  
  
  
      // find the H.264 video decoder
  
      codec = avcodec_find_decoder(CODEC_ID_H264);
  
      if (!codec)
  
      {
  
          fprintf(stderr, "codec not found\n");
  
          exit(1);
  
      }
  
  
  
      c = avcodec_alloc_context3(codec);
  
      picture = avcodec_alloc_frame();
  
  
  
      // skiploopfilter=all
  
      c->skip_loop_filter = 48;
  
  
  
      AVDictionary* dictionary = NULL;
  
      if (avcodec_open2(c, codec, &amp;dictionary) &lt; 0)
  
      {
  
          fprintf(stderr, "could not open codec\n");
  
          exit(1);
  
      }
  
  
  
      // the codec gives us the frame size, in samples
  
      parser = av_parser_init(c->codec_id);
  
      parser->flags |= PARSER_FLAG_ONCE;
  
  
  
      f = fopen(filename, "rb");
  
      if (!f)
  
      {
  
          fprintf(stderr, "could not open %s\n", filename);
  
          exit(1);
  
      }
  
  
  
      frame = 0;
  
      gettimeofday(&amp;t, 0);
  
      if(fread(arghwtf, 1, INBUF_SIZE, f) == 0)
  
      {
  
          exit(1);
  
      }
  
  
  
      in_len = 80000;
  
      gettimeofday(&amp;t2, 0);
  
      while (in_len > 0 &amp;&amp; !feof(f))
  
      {
  
          len = av_parser_parse2(parser, c, &amp;avpkt.data, &amp;avpkt.size, arghwtf, in_len, pts, dts, AV_NOPTS_VALUE);
  
  
  
          len2 = avcodec_decode_video2(c, picture, &amp;got_picture, &amp;avpkt);
  
          if (len2 &lt; 0) {
  
              fprintf(stderr, "Error while decoding frame %d\n", frame);
  
              exit(1);
  
          }
  
  
  
          if (got_picture)
  
          {
  
              fprintf(stderr, "\rDisplaying %c %dx%d :frame %3d (%02d:%03d)...", av_get_picture_type_char(picture->pict_type), c->width, c->height, frame, (int)(get_time_diff(t)/1000000), (int)((get_time_diff(t)/1000)%1000));
  
              fflush(stderr);
  
  
  
              frame++;
  
          }
  
  
  
          memcpy(arghwtf, arghwtf + len, 80000-len);
  
          fread(arghwtf + 80000 - len, 1, len, f);
  
      }
  
  
  
      fclose(f);
  
      avcodec_close(c);
  
      av_free(c);
  
      av_free(picture);
  
      printf("\n");
  
      printf("Avarage fps: %d\n", (int)(((double)frame)/(double)(get_time_diff(t)/1000)*1000));
  
  
  
      return 0;
  
  }

• Revision bfc27bb614 : tx-skip experiment : improve entropy coding of coeff tokens This patch allows th

  31 mars 2015, par hui su

  Changed Paths :
   Modify /vp9/common/vp9_entropy.c

  
   Modify /vp9/common/vp9_entropy.h

  
   Modify /vp9/common/vp9_onyxc_int.h

  
   Modify /vp9/common/vp9_quant_common.c

  
   Modify /vp9/decoder/vp9_detokenize.c

  
   Modify /vp9/encoder/vp9_encodemb.c

  
   Modify /vp9/encoder/vp9_rdopt.c

  
   Modify /vp9/encoder/vp9_tokenize.c

  
  
  tx-skip experiment : improve entropy coding of coeff tokens

  This patch allows the prediction residues of tx-skipped blocks
  to use probs that are different from regular transfrom
  coefficients for token entropy coding. Prediction residues are
  assumed as in band 6.

  The initial value of probs is obtained with stats from limited
  tests. The statistic model for constrained token nodes has not
  been optimized. The probs for token extra bits have not been
  optimized. These can be future work.

  Certain coding improvment is observed :
  derflr with all experiments : +6.26% (+0.10%)
  screen_content with palette : +22.48% (+1.28%)

  Change-Id : I1c0d78178ee9f3655febb6f30cdaef8ee9f8e3cc