sgienc.c 6.97 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * SGI image encoder
 * Todd Kirby <doubleshot@pacbell.net>
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "avcodec.h"
#include "bytestream.h"
24
#include "internal.h"
25 26 27 28 29 30
#include "sgi.h"
#include "rle.h"

#define SGI_SINGLE_CHAN 2
#define SGI_MULTI_CHAN 3

31 32
static av_cold int encode_init(AVCodecContext *avctx)
{
33
    if (avctx->width > 65535 || avctx->height > 65535) {
34 35
        av_log(avctx, AV_LOG_ERROR,
               "Unsupported resolution %dx%d.\n", avctx->width, avctx->height);
36
        av_log(avctx, AV_LOG_ERROR, "SGI does not support resolutions above 65535x65535\n");
37
        return AVERROR_INVALIDDATA;
38
    }
39

40 41 42
    avctx->coded_frame = av_frame_alloc();
    if (!avctx->coded_frame)
        return AVERROR(ENOMEM);
43

44 45 46
    return 0;
}

47 48
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                        const AVFrame *frame, int *got_packet)
49
{
50
    const AVFrame * const p = frame;
51 52
    uint8_t *offsettab, *lengthtab, *in_buf, *encode_buf, *buf;
    int x, y, z, length, tablesize, ret;
53
    unsigned int width, height, depth, dimension;
54
    unsigned int bytes_per_channel, pixmax, put_be;
55
    unsigned char *end_buf;
56

57 58
    avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;
    avctx->coded_frame->key_frame = 1;
59

60
    width  = avctx->width;
61
    height = avctx->height;
62 63 64
    bytes_per_channel = 1;
    pixmax = 0xFF;
    put_be = HAVE_BIGENDIAN;
65 66

    switch (avctx->pix_fmt) {
67
    case AV_PIX_FMT_GRAY8:
68 69 70
        dimension = SGI_SINGLE_CHAN;
        depth     = SGI_GRAYSCALE;
        break;
71
    case AV_PIX_FMT_RGB24:
72 73 74
        dimension = SGI_MULTI_CHAN;
        depth     = SGI_RGB;
        break;
75
    case AV_PIX_FMT_RGBA:
76 77 78
        dimension = SGI_MULTI_CHAN;
        depth     = SGI_RGBA;
        break;
79
    case AV_PIX_FMT_GRAY16LE:
80
        put_be = !HAVE_BIGENDIAN;
81
    case AV_PIX_FMT_GRAY16BE:
82 83 84 85 86 87
        avctx->coder_type = FF_CODER_TYPE_RAW;
        bytes_per_channel = 2;
        pixmax = 0xFFFF;
        dimension = SGI_SINGLE_CHAN;
        depth     = SGI_GRAYSCALE;
        break;
88
    case AV_PIX_FMT_RGB48LE:
89
        put_be = !HAVE_BIGENDIAN;
90
    case AV_PIX_FMT_RGB48BE:
91 92 93 94 95 96
        avctx->coder_type = FF_CODER_TYPE_RAW;
        bytes_per_channel = 2;
        pixmax = 0xFFFF;
        dimension = SGI_MULTI_CHAN;
        depth     = SGI_RGB;
        break;
97
    case AV_PIX_FMT_RGBA64LE:
98
        put_be = !HAVE_BIGENDIAN;
99
    case AV_PIX_FMT_RGBA64BE:
100 101 102 103 104 105
        avctx->coder_type = FF_CODER_TYPE_RAW;
        bytes_per_channel = 2;
        pixmax = 0xFFFF;
        dimension = SGI_MULTI_CHAN;
        depth     = SGI_RGBA;
        break;
106 107
    default:
        return AVERROR_INVALIDDATA;
108 109 110
    }

    tablesize = depth * height * 4;
111 112 113 114 115 116
    length = SGI_HEADER_SIZE;
    if (avctx->coder_type == FF_CODER_TYPE_RAW)
        length += depth * height * width;
    else // assume ff_rl_encode() produces at most 2x size of input
        length += tablesize * 2 + depth * height * (2 * width + 1);

117
    if ((ret = ff_alloc_packet2(avctx, pkt, bytes_per_channel * length)) < 0)
118 119 120
        return ret;
    buf     = pkt->data;
    end_buf = pkt->data + pkt->size;
121 122 123

    /* Encode header. */
    bytestream_put_be16(&buf, SGI_MAGIC);
124
    bytestream_put_byte(&buf, avctx->coder_type != FF_CODER_TYPE_RAW); /* RLE 1 - VERBATIM 0*/
125
    bytestream_put_byte(&buf, bytes_per_channel);
126 127 128 129 130 131
    bytestream_put_be16(&buf, dimension);
    bytestream_put_be16(&buf, width);
    bytestream_put_be16(&buf, height);
    bytestream_put_be16(&buf, depth);

    bytestream_put_be32(&buf, 0L); /* pixmin */
132
    bytestream_put_be32(&buf, pixmax);
133 134 135 136 137 138
    bytestream_put_be32(&buf, 0L); /* dummy */

    /* name */
    memset(buf, 0, SGI_HEADER_SIZE);
    buf += 80;

139
    /* colormap */
140 141 142 143 144 145
    bytestream_put_be32(&buf, 0L);

    /* The rest of the 512 byte header is unused. */
    buf += 404;
    offsettab = buf;

146
    if (avctx->coder_type != FF_CODER_TYPE_RAW) {
147 148 149
        /* Skip RLE offset table. */
        buf += tablesize;
        lengthtab = buf;
150

151 152
        /* Skip RLE length table. */
        buf += tablesize;
153

154
        /* Make an intermediate consecutive buffer. */
155
        if (!(encode_buf = av_malloc(width)))
156
            return -1;
157

158 159
        for (z = 0; z < depth; z++) {
            in_buf = p->data[0] + p->linesize[0] * (height - 1) + z;
160

161
            for (y = 0; y < height; y++) {
162
                bytestream_put_be32(&offsettab, buf - pkt->data);
163

164 165
                for (x = 0; x < width; x++)
                    encode_buf[x] = in_buf[depth * x];
166

167 168 169 170
                if ((length = ff_rle_encode(buf, end_buf - buf - 1, encode_buf, 1, width, 0, 0, 0x80, 0)) < 1) {
                    av_free(encode_buf);
                    return -1;
                }
171

172 173 174 175 176
                buf += length;
                bytestream_put_byte(&buf, 0);
                bytestream_put_be32(&lengthtab, length + 1);
                in_buf -= p->linesize[0];
            }
177 178
        }

179
        av_free(encode_buf);
180 181
    } else {
        for (z = 0; z < depth; z++) {
182
            in_buf = p->data[0] + p->linesize[0] * (height - 1) + z * bytes_per_channel;
183

184 185
            for (y = 0; y < height; y++) {
                for (x = 0; x < width * depth; x += depth)
186
                    if (bytes_per_channel == 1) {
187
                        bytestream_put_byte(&buf, in_buf[x]);
188 189 190 191 192 193 194
                    } else {
                        if (put_be) {
                            bytestream_put_be16(&buf, ((uint16_t *)in_buf)[x]);
                        } else {
                            bytestream_put_le16(&buf, ((uint16_t *)in_buf)[x]);
                        }
                    }
195

196
                in_buf -= p->linesize[0];
197 198
            }
        }
199
    }
200

201
    /* total length */
202
    pkt->size   = buf - pkt->data;
203 204 205 206
    pkt->flags |= AV_PKT_FLAG_KEY;
    *got_packet = 1;

    return 0;
207 208
}

209 210 211 212 213 214
static av_cold int encode_close(AVCodecContext *avctx)
{
    av_frame_free(&avctx->coded_frame);
    return 0;
}

215
AVCodec ff_sgi_encoder = {
216 217 218 219 220 221 222 223
    .name      = "sgi",
    .long_name = NULL_IF_CONFIG_SMALL("SGI image"),
    .type      = AVMEDIA_TYPE_VIDEO,
    .id        = AV_CODEC_ID_SGI,
    .init      = encode_init,
    .encode2   = encode_frame,
    .close     = encode_close,
    .pix_fmts  = (const enum AVPixelFormat[]) {
224 225 226
        AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,
        AV_PIX_FMT_RGB48LE, AV_PIX_FMT_RGB48BE,
        AV_PIX_FMT_RGBA64LE, AV_PIX_FMT_RGBA64BE,
227 228
        AV_PIX_FMT_GRAY16LE, AV_PIX_FMT_GRAY16BE, AV_PIX_FMT_GRAY8,
        AV_PIX_FMT_NONE
229
    },
230
};