Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * XWD image format
  3.  *
  4.  * Copyright (c) 2012 Paul B Mahol
  5.  *
  6.  * This file is part of FFmpeg.
  7.  *
  8.  * FFmpeg is free software; you can redistribute it and/or
  9.  * modify it under the terms of the GNU Lesser General Public
  10.  * License as published by the Free Software Foundation; either
  11.  * version 2.1 of the License, or (at your option) any later version.
  12.  *
  13.  * FFmpeg is distributed in the hope that it will be useful,
  14.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.  * Lesser General Public License for more details.
  17.  *
  18.  * You should have received a copy of the GNU Lesser General Public
  19.  * License along with FFmpeg; if not, write to the Free Software
  20.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21.  */
  22.  
  23. #include "libavutil/intreadwrite.h"
  24. #include "libavutil/pixdesc.h"
  25. #include "avcodec.h"
  26. #include "bytestream.h"
  27. #include "internal.h"
  28. #include "xwd.h"
  29.  
  30. #define WINDOW_NAME         "lavcxwdenc"
  31. #define WINDOW_NAME_SIZE    11
  32.  
  33. static int xwd_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
  34.                             const AVFrame *pict, int *got_packet)
  35. {
  36.     enum AVPixelFormat pix_fmt = avctx->pix_fmt;
  37.     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
  38.     uint32_t pixdepth, bpp, bpad, ncolors = 0, lsize, vclass, be = 0;
  39.     uint32_t rgb[3] = { 0 }, bitorder = 0;
  40.     uint32_t header_size;
  41.     int i, out_size, ret;
  42.     uint8_t *ptr, *buf;
  43.     AVFrame * const p = (AVFrame *)pict;
  44.  
  45.     pixdepth = av_get_bits_per_pixel(desc);
  46.     if (desc->flags & AV_PIX_FMT_FLAG_BE)
  47.         be = 1;
  48.     switch (pix_fmt) {
  49.     case AV_PIX_FMT_ARGB:
  50.     case AV_PIX_FMT_BGRA:
  51.     case AV_PIX_FMT_RGBA:
  52.     case AV_PIX_FMT_ABGR:
  53.         if (pix_fmt == AV_PIX_FMT_ARGB ||
  54.             pix_fmt == AV_PIX_FMT_ABGR)
  55.             be = 1;
  56.         if (pix_fmt == AV_PIX_FMT_ABGR ||
  57.             pix_fmt == AV_PIX_FMT_RGBA) {
  58.             rgb[0] = 0xFF;
  59.             rgb[1] = 0xFF00;
  60.             rgb[2] = 0xFF0000;
  61.         } else {
  62.             rgb[0] = 0xFF0000;
  63.             rgb[1] = 0xFF00;
  64.             rgb[2] = 0xFF;
  65.         }
  66.         bpp      = 32;
  67.         pixdepth = 24;
  68.         vclass   = XWD_TRUE_COLOR;
  69.         bpad     = 32;
  70.         break;
  71.     case AV_PIX_FMT_BGR24:
  72.     case AV_PIX_FMT_RGB24:
  73.         if (pix_fmt == AV_PIX_FMT_RGB24)
  74.             be = 1;
  75.         bpp      = 24;
  76.         vclass   = XWD_TRUE_COLOR;
  77.         bpad     = 32;
  78.         rgb[0]   = 0xFF0000;
  79.         rgb[1]   = 0xFF00;
  80.         rgb[2]   = 0xFF;
  81.         break;
  82.     case AV_PIX_FMT_RGB565LE:
  83.     case AV_PIX_FMT_RGB565BE:
  84.     case AV_PIX_FMT_BGR565LE:
  85.     case AV_PIX_FMT_BGR565BE:
  86.         if (pix_fmt == AV_PIX_FMT_BGR565LE ||
  87.             pix_fmt == AV_PIX_FMT_BGR565BE) {
  88.             rgb[0] = 0x1F;
  89.             rgb[1] = 0x7E0;
  90.             rgb[2] = 0xF800;
  91.         } else {
  92.             rgb[0] = 0xF800;
  93.             rgb[1] = 0x7E0;
  94.             rgb[2] = 0x1F;
  95.         }
  96.         bpp      = 16;
  97.         vclass   = XWD_TRUE_COLOR;
  98.         bpad     = 16;
  99.         break;
  100.     case AV_PIX_FMT_RGB555LE:
  101.     case AV_PIX_FMT_RGB555BE:
  102.     case AV_PIX_FMT_BGR555LE:
  103.     case AV_PIX_FMT_BGR555BE:
  104.         if (pix_fmt == AV_PIX_FMT_BGR555LE ||
  105.             pix_fmt == AV_PIX_FMT_BGR555BE) {
  106.             rgb[0] = 0x1F;
  107.             rgb[1] = 0x3E0;
  108.             rgb[2] = 0x7C00;
  109.         } else {
  110.             rgb[0] = 0x7C00;
  111.             rgb[1] = 0x3E0;
  112.             rgb[2] = 0x1F;
  113.         }
  114.         bpp      = 16;
  115.         vclass   = XWD_TRUE_COLOR;
  116.         bpad     = 16;
  117.         break;
  118.     case AV_PIX_FMT_RGB8:
  119.     case AV_PIX_FMT_BGR8:
  120.     case AV_PIX_FMT_RGB4_BYTE:
  121.     case AV_PIX_FMT_BGR4_BYTE:
  122.     case AV_PIX_FMT_PAL8:
  123.         bpp      = 8;
  124.         vclass   = XWD_PSEUDO_COLOR;
  125.         bpad     = 8;
  126.         ncolors  = 256;
  127.         break;
  128.     case AV_PIX_FMT_GRAY8:
  129.         bpp      = 8;
  130.         bpad     = 8;
  131.         vclass   = XWD_STATIC_GRAY;
  132.         break;
  133.     case AV_PIX_FMT_MONOWHITE:
  134.         be       = 1;
  135.         bitorder = 1;
  136.         bpp      = 1;
  137.         bpad     = 8;
  138.         vclass   = XWD_STATIC_GRAY;
  139.         break;
  140.     default:
  141.         av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
  142.         return AVERROR(EINVAL);
  143.     }
  144.  
  145.     lsize       = FFALIGN(bpp * avctx->width, bpad) / 8;
  146.     header_size = XWD_HEADER_SIZE + WINDOW_NAME_SIZE;
  147.     out_size    = header_size + ncolors * XWD_CMAP_SIZE + avctx->height * lsize;
  148.  
  149.     if ((ret = ff_alloc_packet2(avctx, pkt, out_size)) < 0)
  150.         return ret;
  151.     buf = pkt->data;
  152.  
  153.     p->key_frame = 1;
  154.     p->pict_type = AV_PICTURE_TYPE_I;
  155.  
  156.     bytestream_put_be32(&buf, header_size);
  157.     bytestream_put_be32(&buf, XWD_VERSION);   // file version
  158.     bytestream_put_be32(&buf, XWD_Z_PIXMAP);  // pixmap format
  159.     bytestream_put_be32(&buf, pixdepth);      // pixmap depth in pixels
  160.     bytestream_put_be32(&buf, avctx->width);  // pixmap width in pixels
  161.     bytestream_put_be32(&buf, avctx->height); // pixmap height in pixels
  162.     bytestream_put_be32(&buf, 0);             // bitmap x offset
  163.     bytestream_put_be32(&buf, be);            // byte order
  164.     bytestream_put_be32(&buf, 32);            // bitmap unit
  165.     bytestream_put_be32(&buf, bitorder);      // bit-order of image data
  166.     bytestream_put_be32(&buf, bpad);          // bitmap scan-line pad in bits
  167.     bytestream_put_be32(&buf, bpp);           // bits per pixel
  168.     bytestream_put_be32(&buf, lsize);         // bytes per scan-line
  169.     bytestream_put_be32(&buf, vclass);        // visual class
  170.     bytestream_put_be32(&buf, rgb[0]);        // red mask
  171.     bytestream_put_be32(&buf, rgb[1]);        // green mask
  172.     bytestream_put_be32(&buf, rgb[2]);        // blue mask
  173.     bytestream_put_be32(&buf, 8);             // size of each bitmask in bits
  174.     bytestream_put_be32(&buf, ncolors);       // number of colors
  175.     bytestream_put_be32(&buf, ncolors);       // number of entries in color map
  176.     bytestream_put_be32(&buf, avctx->width);  // window width
  177.     bytestream_put_be32(&buf, avctx->height); // window height
  178.     bytestream_put_be32(&buf, 0);             // window upper left X coordinate
  179.     bytestream_put_be32(&buf, 0);             // window upper left Y coordinate
  180.     bytestream_put_be32(&buf, 0);             // window border width
  181.     bytestream_put_buffer(&buf, WINDOW_NAME, WINDOW_NAME_SIZE);
  182.  
  183.     for (i = 0; i < ncolors; i++) {
  184.         uint32_t val;
  185.         uint8_t red, green, blue;
  186.  
  187.         val   = AV_RN32A(p->data[1] + i * 4);
  188.         red   = (val >> 16) & 0xFF;
  189.         green = (val >>  8) & 0xFF;
  190.         blue  =  val        & 0xFF;
  191.  
  192.         bytestream_put_be32(&buf, i);         // colormap entry number
  193.         bytestream_put_be16(&buf, red   << 8);
  194.         bytestream_put_be16(&buf, green << 8);
  195.         bytestream_put_be16(&buf, blue  << 8);
  196.         bytestream_put_byte(&buf, 0x7);       // bitmask flag
  197.         bytestream_put_byte(&buf, 0);         // padding
  198.     }
  199.  
  200.     ptr = p->data[0];
  201.     for (i = 0; i < avctx->height; i++) {
  202.         bytestream_put_buffer(&buf, ptr, lsize);
  203.         ptr += p->linesize[0];
  204.     }
  205.  
  206.     pkt->flags |= AV_PKT_FLAG_KEY;
  207.     *got_packet = 1;
  208.     return 0;
  209. }
  210.  
  211. AVCodec ff_xwd_encoder = {
  212.     .name         = "xwd",
  213.     .long_name    = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),
  214.     .type         = AVMEDIA_TYPE_VIDEO,
  215.     .id           = AV_CODEC_ID_XWD,
  216.     .encode2      = xwd_encode_frame,
  217.     .pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGRA,
  218.                                                  AV_PIX_FMT_RGBA,
  219.                                                  AV_PIX_FMT_ARGB,
  220.                                                  AV_PIX_FMT_ABGR,
  221.                                                  AV_PIX_FMT_RGB24,
  222.                                                  AV_PIX_FMT_BGR24,
  223.                                                  AV_PIX_FMT_RGB565BE,
  224.                                                  AV_PIX_FMT_RGB565LE,
  225.                                                  AV_PIX_FMT_BGR565BE,
  226.                                                  AV_PIX_FMT_BGR565LE,
  227.                                                  AV_PIX_FMT_RGB555BE,
  228.                                                  AV_PIX_FMT_RGB555LE,
  229.                                                  AV_PIX_FMT_BGR555BE,
  230.                                                  AV_PIX_FMT_BGR555LE,
  231.                                                  AV_PIX_FMT_RGB8,
  232.                                                  AV_PIX_FMT_BGR8,
  233.                                                  AV_PIX_FMT_RGB4_BYTE,
  234.                                                  AV_PIX_FMT_BGR4_BYTE,
  235.                                                  AV_PIX_FMT_PAL8,
  236.                                                  AV_PIX_FMT_GRAY8,
  237.                                                  AV_PIX_FMT_MONOWHITE,
  238.                                                  AV_PIX_FMT_NONE },
  239. };
  240.