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.
44689 Commits
32 Branches
824MB
Tree: c5714b51aa
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c5714b51aa'
${ noResults }
FFmpeg/libavcodec/xwdenc.c

239 lines
8.6KB
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 int xwd_encode_frame(AVCodecContext *avctx, AVPacket *pkt,

  34.                             const AVFrame *p, 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. 

  44.     pixdepth = av_get_bits_per_pixel(desc);

  45.     if (desc->flags & AV_PIX_FMT_FLAG_BE)

  46.         be = 1;

  47.     switch (pix_fmt) {

  48.     case AV_PIX_FMT_ARGB:

  49.     case AV_PIX_FMT_BGRA:

  50.     case AV_PIX_FMT_RGBA:

  51.     case AV_PIX_FMT_ABGR:

  52.         if (pix_fmt == AV_PIX_FMT_ARGB ||

  53.             pix_fmt == AV_PIX_FMT_ABGR)

  54.             be = 1;

  55.         if (pix_fmt == AV_PIX_FMT_ABGR ||

  56.             pix_fmt == AV_PIX_FMT_RGBA) {

  57.             rgb[0] = 0xFF;

  58.             rgb[1] = 0xFF00;

  59.             rgb[2] = 0xFF0000;

  60.         } else {

  61.             rgb[0] = 0xFF0000;

  62.             rgb[1] = 0xFF00;

  63.             rgb[2] = 0xFF;

  64.         }

  65.         bpp      = 32;

  66.         pixdepth = 24;

  67.         vclass   = XWD_TRUE_COLOR;

  68.         bpad     = 32;

  69.         break;

  70.     case AV_PIX_FMT_BGR24:

  71.     case AV_PIX_FMT_RGB24:

  72.         if (pix_fmt == AV_PIX_FMT_RGB24)

  73.             be = 1;

  74.         bpp      = 24;

  75.         vclass   = XWD_TRUE_COLOR;

  76.         bpad     = 32;

  77.         rgb[0]   = 0xFF0000;

  78.         rgb[1]   = 0xFF00;

  79.         rgb[2]   = 0xFF;

  80.         break;

  81.     case AV_PIX_FMT_RGB565LE:

  82.     case AV_PIX_FMT_RGB565BE:

  83.     case AV_PIX_FMT_BGR565LE:

  84.     case AV_PIX_FMT_BGR565BE:

  85.         if (pix_fmt == AV_PIX_FMT_BGR565LE ||

  86.             pix_fmt == AV_PIX_FMT_BGR565BE) {

  87.             rgb[0] = 0x1F;

  88.             rgb[1] = 0x7E0;

  89.             rgb[2] = 0xF800;

  90.         } else {

  91.             rgb[0] = 0xF800;

  92.             rgb[1] = 0x7E0;

  93.             rgb[2] = 0x1F;

  94.         }

  95.         bpp      = 16;

  96.         vclass   = XWD_TRUE_COLOR;

  97.         bpad     = 16;

  98.         break;

  99.     case AV_PIX_FMT_RGB555LE:

  100.     case AV_PIX_FMT_RGB555BE:

  101.     case AV_PIX_FMT_BGR555LE:

  102.     case AV_PIX_FMT_BGR555BE:

  103.         if (pix_fmt == AV_PIX_FMT_BGR555LE ||

  104.             pix_fmt == AV_PIX_FMT_BGR555BE) {

  105.             rgb[0] = 0x1F;

  106.             rgb[1] = 0x3E0;

  107.             rgb[2] = 0x7C00;

  108.         } else {

  109.             rgb[0] = 0x7C00;

  110.             rgb[1] = 0x3E0;

  111.             rgb[2] = 0x1F;

  112.         }

  113.         bpp      = 16;

  114.         vclass   = XWD_TRUE_COLOR;

  115.         bpad     = 16;

  116.         break;

  117.     case AV_PIX_FMT_RGB8:

  118.     case AV_PIX_FMT_BGR8:

  119.     case AV_PIX_FMT_RGB4_BYTE:

  120.     case AV_PIX_FMT_BGR4_BYTE:

  121.     case AV_PIX_FMT_PAL8:

  122.         bpp      = 8;

  123.         vclass   = XWD_PSEUDO_COLOR;

  124.         bpad     = 8;

  125.         ncolors  = 256;

  126.         break;

  127.     case AV_PIX_FMT_MONOWHITE:

  128.         be       = 1;

  129.         bitorder = 1;

  130.         bpp      = 1;

  131.         bpad     = 8;

  132.         vclass   = XWD_STATIC_GRAY;

  133.         break;

  134.     default:

  135.         av_log(avctx, AV_LOG_INFO, "unsupported pixel format\n");

  136.         return AVERROR(EINVAL);

  137.     }

  138. 

  139.     lsize       = FFALIGN(bpp * avctx->width, bpad) / 8;

  140.     header_size = XWD_HEADER_SIZE + WINDOW_NAME_SIZE;

  141.     out_size    = header_size + ncolors * XWD_CMAP_SIZE + avctx->height * lsize;

  142. 

  143.     if ((ret = ff_alloc_packet(pkt, out_size)) < 0) {

  144.         av_log(avctx, AV_LOG_ERROR, "output buffer too small\n");

  145.         return ret;

  146.     }

  147.     buf = pkt->data;

  148. 

  149. #if FF_API_CODED_FRAME

  150. FF_DISABLE_DEPRECATION_WARNINGS

  151.     avctx->coded_frame->key_frame = 1;

  152.     avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

  153. FF_ENABLE_DEPRECATION_WARNINGS

  154. #endif

  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_MONOWHITE,

  237.                                                  AV_PIX_FMT_NONE },

  238. };