Recherche avancée

Sur d’autres sites (6791)

• TSCC RLE Decoding : Best way to get difference between two frames

  25 janvier 2016, par Dylan Alvaro

  Hello video codec experts,

  I am working with a video codec which is tscc video codec. It uses RLE algorithm.

  I am looking for a way to get the differences between the current decoded frame and the previous frame and store those differences in an array (the best case scenario would be to store those frame differences in an openCV matrice cv::Mat).

  Currently, I am waiting to have 2 frames decoded, I keep in memory those two decoded frames and from the 3rd one, I am comparing the two previous frames to look for any difference between them and then I store the differences in a vector.
  This algorithm could be optimized because I’m using lost of resources and not taking advantage of the compressed frame...

  If anyone could help me find a way to improve the idea I have behind this it would be great :

  The decode function is the following. (It uses two control bytes at the beginning of the compressed RLE frame to analyse whether it is an end of frame, end of line, jump of pixels, etc...) :

  static int decode_rle(CamtasiaContext *c, unsigned int srcsize)
  
  {
  
      unsigned char *src = c->decomp_buf;
  
      unsigned char *output, *output_end;
  
      int p1, p2, line=c->height, pos=0, i;
  
      uint16_t pix16;
  
      uint32_t pix32;
  
  
  
      output = c->pic.data[0] + (c->height - 1) * c->pic.linesize[0];
  
      output_end = c->pic.data[0] + (c->height) * c->pic.linesize[0];
  
      while(src < c->decomp_buf + srcsize) {
  
          p1 = *src++;
  
          //Escape code
  
          if(p1 == 0) 
  
          {
  
              p2 = *src++;
  
              if(p2 == 0) { //End-of-line
  
                  output = c->pic.data[0] + (--line) * c->pic.linesize[0];
  
                  if (line < 0)
  
                      return -1;
  
                  pos = 0;
  
                  continue;
  
              } else if(p2 == 1) { //End-of-picture
  
                  return 0;
  
              } else if(p2 == 2) { //Skip
  
                  p1 = *src++;
  
                  p2 = *src++;
  
                  line -= p2;
  
                  if (line < 0)
  
                      return -1;
  
                  pos += p1;
  
                  output = c->pic.data[0] + line * c->pic.linesize[0] + pos * (c->bpp / 8);
  
                  continue;
  
              }
  
              // Copy data
  
              if (output + p2 * (c->bpp / 8) > output_end) {
  
                  src += p2 * (c->bpp / 8);
  
                  continue;
  
              }
  
              if (c->bpp == 16) 
  
              {
  
                  for(i = 0; i < p2; i++) 
  
                  {
  
                      pix16 = AV_RL16(src);
  
                      src += 2;
  
                      *(uint16_t*)output = pix16;
  
                      output += 2;
  
                  }
  
              }
  
              pos += p2;
  
          } 
  
          else 
  
          { //Run of pixels
  
              int pix[4]; //original pixel
  
              switch(c->bpp){
  
              case  8: pix[0] = *src++;
  
                       break;
  
              case 16: pix16 = AV_RL16(src);
  
                       src += 2;
  
                       *(uint16_t*)pix = pix16;
  
                       break;
  
              case 24: pix[0] = *src++;
  
                       pix[1] = *src++;
  
                       pix[2] = *src++;
  
                       break;
  
              case 32: pix32 = AV_RL32(src);
  
                       src += 4;
  
                       *(uint32_t*)pix = pix32;
  
                       break;
  
              }
  
              if (output + p1 * (c->bpp / 8) > output_end)
  
                  continue;
  
              for(i = 0; i < p1; i++) {
  
                  switch(c->bpp){
  
                  case  8: *output++ = pix[0];
  
                           break;
  
                  case 16: *(uint16_t*)output = pix16;
  
                           output += 2;
  
                           break;
  
                  case 24: *output++ = pix[0];
  
                           *output++ = pix[1];
  
                           *output++ = pix[2];
  
                           break;
  
                  case 32: *(uint32_t*)output = pix32;
  
                           output += 4;
  
                           break;
  
                  }
  
              }
  
              pos += p1;
  
          }
  
      }

  Thank you for your kind help !

• x264/x265 options for fast decoding while preserving quality

  18 août 2024, par user3301993

  I want to encode some videos in H264 and H265, and I would like to ask for help in order to chose the adequate options in x264/x265.

  


  

  • My first priority is video quality. Lossless would be the best quality for example

  


  • My second priority is fast decoding speed (ie : I would like faster decoding without sacrificing quality)

    

    • fast decoding for me means that the decoding machine would use less CPU resources reading the resulting video

    


    • Less RAM consumption would be a plus

    


    • Latency is not important

    


    


  


  • I don't care that much if the output file ends up bigger. Also, encoding speed is not important

  


  


  I'm aware of the option -tune fastdecode in both x264 and x265. But apparently the quality gets a bit worse using it.

  


  For x264 :

  


  -tune fastdecode is equivalent to --no-cabac --no-deblock --no-weightb --weightp 0 (My source is x264 --fullhelp)

  


  Which options preserve quality ?

  


  For x265 :

  


  -tune fastdecode is equivalent to --no-deblock --no-sao --no-weightp --no-weightb --no-b-intra (according to x265 doc)

  


  Again, which options preserve quality ?

  


  I tried to read some documentation on these options, but I'm afraid I'm too stupid to understand if they preserve quality or not.

  


  To explain further what I mean by "preserving quality" :

  


  


  I don't understand what the cabac option does exactly. But let's say for example that it adds some extra lossless compression, resulting in a smaller video file, but the decoding machine would need to do extra work to decompress the file

  


  In that case, the --no-cabac option would skip that extra compression, resulting in no loss of quality, with a bigger file size, and the decoding machine would not need to decompress the extra compression, saving CPU work on the decoding side

  


  In this scenario, I would like to add the --no-cabac option, as it speeds up decoding, while preserving quality.

  


  


  I hope I could get my point across

  


  Can anyone help me pick the right options ?

  


  Thanks in advance

  


• x264/x265 options for fast decoding while preserving quality

  18 août 2024, par user3301993

  I want to encode some videos in H264 and H265, and I would like to ask for help in order to chose the adequate options in x264/x265.

  


  

  • My first priority is video quality. Lossless would be the best quality for example

  


  • My second priority is fast decoding speed (ie : I would like faster decoding without sacrificing quality)

    

    • fast decoding for me means that the decoding machine would use less CPU resources reading the resulting video

    


    • Less RAM consumption would be a plus

    


    • Latency is not important

    


    


  


  • I don't care that much if the output file ends up bigger. Also, encoding speed is not important

  


  


  I'm aware of the option -tune fastdecode in both x264 and x265. But apparently the quality gets a bit worse using it.

  


  For x264 :

  


  -tune fastdecode is equivalent to --no-cabac --no-deblock --no-weightb --weightp 0 (My source is x264 --fullhelp)

  


  Which options preserve quality ?

  


  For x265 :

  


  -tune fastdecode is equivalent to --no-deblock --no-sao --no-weightp --no-weightb --no-b-intra (according to x265 doc)

  


  Again, which options preserve quality ?

  


  I tried to read some documentation on these options, but I'm afraid I'm too stupid to understand if they preserve quality or not.

  


  To explain further what I mean by "preserving quality" :

  


  


  I don't understand what the cabac option does exactly. But let's say for example that it adds some extra lossless compression, resulting in a smaller video file, but the decoding machine would need to do extra work to decompress the file

  


  In that case, the --no-cabac option would skip that extra compression, resulting in no loss of quality, with a bigger file size, and the decoding machine would not need to decompress the extra compression, saving CPU work on the decoding side

  


  In this scenario, I would like to add the --no-cabac option, as it speeds up decoding, while preserving quality.

  


  


  I hope I could get my point across

  


  Can anyone help me pick the right options ?

  


  Thanks in advance