falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
39979 Commits
32 Branches
283MB
Tree: 593886b5dd
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '593886b5dd'
${ noResults }
FFmpeg/libavcodec/xwdenc.c

253 lines
8.9KB
Raw Blame History 

  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 = av_frame_alloc();

  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 & AV_PIX_FMT_FLAG_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.     .long_name    = NULL_IF_CONFIG_SMALL("XWD (X Window Dump) image"),

  226.     .type         = AVMEDIA_TYPE_VIDEO,

  227.     .id           = AV_CODEC_ID_XWD,

  228.     .init         = xwd_encode_init,

  229.     .encode2      = xwd_encode_frame,

  230.     .close        = xwd_encode_close,

  231.     .pix_fmts     = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGRA,

  232.                                                  AV_PIX_FMT_RGBA,

  233.                                                  AV_PIX_FMT_ARGB,

  234.                                                  AV_PIX_FMT_ABGR,

  235.                                                  AV_PIX_FMT_RGB24,

  236.                                                  AV_PIX_FMT_BGR24,

  237.                                                  AV_PIX_FMT_RGB565BE,

  238.                                                  AV_PIX_FMT_RGB565LE,

  239.                                                  AV_PIX_FMT_BGR565BE,

  240.                                                  AV_PIX_FMT_BGR565LE,

  241.                                                  AV_PIX_FMT_RGB555BE,

  242.                                                  AV_PIX_FMT_RGB555LE,

  243.                                                  AV_PIX_FMT_BGR555BE,

  244.                                                  AV_PIX_FMT_BGR555LE,

  245.                                                  AV_PIX_FMT_RGB8,

  246.                                                  AV_PIX_FMT_BGR8,

  247.                                                  AV_PIX_FMT_RGB4_BYTE,

  248.                                                  AV_PIX_FMT_BGR4_BYTE,

  249.                                                  AV_PIX_FMT_PAL8,

  250.                                                  AV_PIX_FMT_MONOWHITE,

  251.                                                  AV_PIX_FMT_NONE },

  252. };