← Back to branch summary

~ubuntu-branches/ubuntu/trusty/gst-libav1.0/trusty-proposed

« back to all changes in this revision

Viewing changes to gst-libs/ext/libav/libavcodec/xwdenc.c

  • Committer: Package Import Robot
  • Author(s): Sebastian Dröge
  • Date: 2013-09-24 17:07:00 UTC
  • mfrom: (1.1.17) (7.1.9 experimental)
  • Revision ID: package-import@ubuntu.com-20130924170700-4dg62s3pwl0pdakz
Tags: 1.2.0-1
* New upstream stable release:
  + debian/control:
    - Build depend on GStreamer and gst-plugins-base >= 1.2.0.

Show diffs side-by-side

added added

removed removed

Lines of Context:
gst-libs/ext/libav/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
};