libavcodec/xwdenc.c

   1 /*
   2  * XWD image format
   3  *
   4  * Copyright (c) 2012 Paul B Mahol
   5  *
   6  * This file is part of Libav.
   7  *
   8  * Libav 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  * Libav 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 Libav; 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 av_cold int xwd_encode_init(AVCodecContext *avctx)
  34 {
  35     avctx->coded_frame = avcodec_alloc_frame();
  36     if (!avctx->coded_frame)
  37         return AVERROR(ENOMEM);
  38
  39     return 0;
  40 }
  41
  42 static int xwd_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
  43                             const AVFrame *p, int *got_packet)
  44 {
  45     enum AVPixelFormat pix_fmt = avctx->pix_fmt;
  46     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
  47     uint32_t pixdepth, bpp, bpad, ncolors = 0, lsize, vclass, be = 0;
  48     uint32_t rgb[3] = { 0 }, bitorder = 0;
  49     uint32_t header_size;
  50     int i, out_size, ret;
  51     uint8_t *ptr, *buf;
  52
  53     pixdepth = av_get_bits_per_pixel(desc);
  54     if (desc->flags & PIX_FMT_BE)
  55         be = 1;
  56     switch (pix_fmt) {
  57     case AV_PIX_FMT_ARGB:
  58     case AV_PIX_FMT_BGRA:
  59     case AV_PIX_FMT_RGBA:
  60     case AV_PIX_FMT_ABGR:
  61         if (pix_fmt == AV_PIX_FMT_ARGB ||
  62             pix_fmt == AV_PIX_FMT_ABGR)
  63             be = 1;
  64         if (pix_fmt == AV_PIX_FMT_ABGR ||
  65             pix_fmt == AV_PIX_FMT_RGBA) {
  66             rgb[0] = 0xFF;
  67             rgb[1] = 0xFF00;
  68             rgb[2] = 0xFF0000;
  69         } else {
  70             rgb[0] = 0xFF0000;
  71             rgb[1] = 0xFF00;
  72             rgb[2] = 0xFF;
  73         }
  74         bpp      = 32;
  75         pixdepth = 24;
  76         vclass   = XWD_TRUE_COLOR;
  77         bpad     = 32;
  78         break;
  79     case AV_PIX_FMT_BGR24:
  80     case AV_PIX_FMT_RGB24:
  81         if (pix_fmt == AV_PIX_FMT_RGB24)
  82             be = 1;
  83         bpp      = 24;
  84         vclass   = XWD_TRUE_COLOR;
  85         bpad     = 32;
  86         rgb[0]   = 0xFF0000;
  87         rgb[1]   = 0xFF00;
  88         rgb[2]   = 0xFF;
  89         break;
  90     case AV_PIX_FMT_RGB565LE:
  91     case AV_PIX_FMT_RGB565BE:
  92     case AV_PIX_FMT_BGR565LE:
  93     case AV_PIX_FMT_BGR565BE:
  94         if (pix_fmt == AV_PIX_FMT_BGR565LE ||
  95             pix_fmt == AV_PIX_FMT_BGR565BE) {
  96             rgb[0] = 0x1F;
  97             rgb[1] = 0x7E0;
  98             rgb[2] = 0xF800;
  99         } else {
 100             rgb[0] = 0xF800;
 101             rgb[1] = 0x7E0;
 102             rgb[2] = 0x1F;
 103         }
 104         bpp      = 16;
 105         vclass   = XWD_TRUE_COLOR;
 106         bpad     = 16;
 107         break;
 108     case AV_PIX_FMT_RGB555LE:
 109     case AV_PIX_FMT_RGB555BE:
 110     case AV_PIX_FMT_BGR555LE:
 111     case AV_PIX_FMT_BGR555BE:
 112         if (pix_fmt == AV_PIX_FMT_BGR555LE ||
 113             pix_fmt == AV_PIX_FMT_BGR555BE) {
 114             rgb[0] = 0x1F;
 115             rgb[1] = 0x3E0;
 116             rgb[2] = 0x7C00;
 117         } else {
 118             rgb[0] = 0x7C00;
 119             rgb[1] = 0x3E0;
 120             rgb[2] = 0x1F;
 121         }
 122         bpp      = 16;
 123         vclass   = XWD_TRUE_COLOR;
 124         bpad     = 16;
 125         break;
 126     case AV_PIX_FMT_RGB8:
 127     case AV_PIX_FMT_BGR8:
 128     case AV_PIX_FMT_RGB4_BYTE:
 129     case AV_PIX_FMT_BGR4_BYTE:
 130     case AV_PIX_FMT_PAL8:
 131         bpp      = 8;
 132         vclass   = XWD_PSEUDO_COLOR;
 133         bpad     = 8;
 134         ncolors  = 256;
 135         break;
 136     case AV_PIX_FMT_MONOWHITE:
 137         be       = 1;
 138         bitorder = 1;
 139         bpp      = 1;
 140         bpad     = 8;
 141         vclass   = XWD_STATIC_GRAY;
 142         break;
 143     default:
 144         av_log(avctx, AV_LOG_INFO, "unsupported pixel format\n");
 145         return AVERROR(EINVAL);
 146     }
 147
 148     lsize       = FFALIGN(bpp * avctx->width, bpad) / 8;
 149     header_size = XWD_HEADER_SIZE + WINDOW_NAME_SIZE;
 150     out_size    = header_size + ncolors * XWD_CMAP_SIZE + avctx->height * lsize;
 151
 152     if ((ret = ff_alloc_packet(pkt, out_size)) < 0) {
 153         av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");
 154         return ret;
 155     }
 156     buf = pkt->data;
 157
 158     avctx->coded_frame->key_frame = 1;
 159     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 160
 161     bytestream_put_be32(&buf, header_size);
 162     bytestream_put_be32(&buf, XWD_VERSION);   // file version
 163     bytestream_put_be32(&buf, XWD_Z_PIXMAP);  // pixmap format
 164     bytestream_put_be32(&buf, pixdepth);      // pixmap depth in pixels
 165     bytestream_put_be32(&buf, avctx->width);  // pixmap width in pixels
 166     bytestream_put_be32(&buf, avctx->height); // pixmap height in pixels
 167     bytestream_put_be32(&buf, 0);             // bitmap x offset
 168     bytestream_put_be32(&buf, be);            // byte order
 169     bytestream_put_be32(&buf, 32);            // bitmap unit
 170     bytestream_put_be32(&buf, bitorder);      // bit-order of image data
 171     bytestream_put_be32(&buf, bpad);          // bitmap scan-line pad in bits
 172     bytestream_put_be32(&buf, bpp);           // bits per pixel
 173     bytestream_put_be32(&buf, lsize);         // bytes per scan-line
 174     bytestream_put_be32(&buf, vclass);        // visual class
 175     bytestream_put_be32(&buf, rgb[0]);        // red mask
 176     bytestream_put_be32(&buf, rgb[1]);        // green mask
 177     bytestream_put_be32(&buf, rgb[2]);        // blue mask
 178     bytestream_put_be32(&buf, 8);             // size of each bitmask in bits
 179     bytestream_put_be32(&buf, ncolors);       // number of colors
 180     bytestream_put_be32(&buf, ncolors);       // number of entries in color map
 181     bytestream_put_be32(&buf, avctx->width);  // window width
 182     bytestream_put_be32(&buf, avctx->height); // window height
 183     bytestream_put_be32(&buf, 0);             // window upper left X coordinate
 184     bytestream_put_be32(&buf, 0);             // window upper left Y coordinate
 185     bytestream_put_be32(&buf, 0);             // window border width
 186     bytestream_put_buffer(&buf, WINDOW_NAME, WINDOW_NAME_SIZE);
 187
 188     for (i = 0; i < ncolors; i++) {
 189         uint32_t val;
 190         uint8_t red, green, blue;
 191
 192         val   = AV_RN32A(p->data[1] + i * 4);
 193         red   = (val >> 16) & 0xFF;
 194         green = (val >>  8) & 0xFF;
 195         blue  =  val        & 0xFF;
 196
 197         bytestream_put_be32(&buf, i);         // colormap entry number
 198         bytestream_put_be16(&buf, red   << 8);
 199         bytestream_put_be16(&buf, green << 8);
 200         bytestream_put_be16(&buf, blue  << 8);
 201         bytestream_put_byte(&buf, 0x7);       // bitmask flag
 202         bytestream_put_byte(&buf, 0);         // padding
 203     }
 204
 205     ptr = p->data[0];
 206     for (i = 0; i < avctx->height; i++) {
 207         bytestream_put_buffer(&buf, ptr, lsize);
 208         ptr += p->linesize[0];
 209     }
 210
 211     pkt->flags |= AV_PKT_FLAG_KEY;
 212     *got_packet = 1;
 213     return 0;
 214 }
 215
 216 static av_cold int xwd_encode_close(AVCodecContext *avctx)
 217 {
 218     av_freep(&avctx->coded_frame);
 219
 220     return 0;
 221 }
 222
 223 AVCodec ff_xwd_encoder = {
 224     .name         = "xwd",
 225     .type         = AVMEDIA_TYPE_VIDEO,
 226     .id           = AV_CODEC_ID_XWD,
 227     .init         = xwd_encode_init,
 228     .encode2      = xwd_encode_frame,
 229     .close        = xwd_encode_close,
 230     .pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGRA,
 231                                                  AV_PIX_FMT_RGBA,
 232                                                  AV_PIX_FMT_ARGB,
 233                                                  AV_PIX_FMT_ABGR,
 234                                                  AV_PIX_FMT_RGB24,
 235                                                  AV_PIX_FMT_BGR24,
 236                                                  AV_PIX_FMT_RGB565BE,
 237                                                  AV_PIX_FMT_RGB565LE,
 238                                                  AV_PIX_FMT_BGR565BE,
 239                                                  AV_PIX_FMT_BGR565LE,
 240                                                  AV_PIX_FMT_RGB555BE,
 241                                                  AV_PIX_FMT_RGB555LE,
 242                                                  AV_PIX_FMT_BGR555BE,
 243                                                  AV_PIX_FMT_BGR555LE,
 244                                                  AV_PIX_FMT_RGB8,
 245                                                  AV_PIX_FMT_BGR8,
 246                                                  AV_PIX_FMT_RGB4_BYTE,
 247                                                  AV_PIX_FMT_BGR4_BYTE,
 248                                                  AV_PIX_FMT_PAL8,
 249                                                  AV_PIX_FMT_MONOWHITE,
 250                                                  AV_PIX_FMT_NONE },
 251     .long_name    = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),
 252 };