Statistics
| Branch: | Revision:

ffmpeg / libavcodec / 8bps.c @ 2912e87a

History | View | Annotate | Download (7.64 KB)

1
/*
2
 * Quicktime Planar RGB (8BPS) Video Decoder
3
 * Copyright (C) 2003 Roberto Togni
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * Libav is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with Libav; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
/**
23
 * @file
24
 * QT 8BPS Video Decoder by Roberto Togni
25
 * For more information about the 8BPS format, visit:
26
 *   http://www.pcisys.net/~melanson/codecs/
27
 *
28
 * Supports: PAL8 (RGB 8bpp, paletted)
29
 *         : BGR24 (RGB 24bpp) (can also output it as RGB32)
30
 *         : RGB32 (RGB 32bpp, 4th plane is probably alpha and it's ignored)
31
 *
32
 */
33

    
34
#include <stdio.h>
35
#include <stdlib.h>
36

    
37
#include "libavutil/intreadwrite.h"
38
#include "avcodec.h"
39

    
40

    
41
static const enum PixelFormat pixfmt_rgb24[] = {PIX_FMT_BGR24, PIX_FMT_RGB32, PIX_FMT_NONE};
42

    
43
/*
44
 * Decoder context
45
 */
46
typedef struct EightBpsContext {
47

    
48
        AVCodecContext *avctx;
49
        AVFrame pic;
50

    
51
        unsigned char planes;
52
        unsigned char planemap[4];
53
} EightBpsContext;
54

    
55

    
56
/*
57
 *
58
 * Decode a frame
59
 *
60
 */
61
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt)
62
{
63
        const uint8_t *buf = avpkt->data;
64
        int buf_size = avpkt->size;
65
        EightBpsContext * const c = avctx->priv_data;
66
        const unsigned char *encoded = buf;
67
        unsigned char *pixptr, *pixptr_end;
68
        unsigned int height = avctx->height; // Real image height
69
        unsigned int dlen, p, row;
70
        const unsigned char *lp, *dp;
71
        unsigned char count;
72
        unsigned int px_inc;
73
        unsigned int planes = c->planes;
74
        unsigned char *planemap = c->planemap;
75

    
76
        if(c->pic.data[0])
77
                avctx->release_buffer(avctx, &c->pic);
78

    
79
        c->pic.reference = 0;
80
        c->pic.buffer_hints = FF_BUFFER_HINTS_VALID;
81
        if(avctx->get_buffer(avctx, &c->pic) < 0){
82
                av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
83
                return -1;
84
        }
85

    
86
        /* Set data pointer after line lengths */
87
        dp = encoded + planes * (height << 1);
88

    
89
        /* Ignore alpha plane, don't know what to do with it */
90
        if (planes == 4)
91
                planes--;
92

    
93
        px_inc = planes + (avctx->pix_fmt == PIX_FMT_RGB32);
94

    
95
        for (p = 0; p < planes; p++) {
96
                /* Lines length pointer for this plane */
97
                lp = encoded + p * (height << 1);
98

    
99
                /* Decode a plane */
100
                for(row = 0; row < height; row++) {
101
                        pixptr = c->pic.data[0] + row * c->pic.linesize[0] + planemap[p];
102
                        pixptr_end = pixptr + c->pic.linesize[0];
103
                        dlen = av_be2ne16(*(const unsigned short *)(lp+row*2));
104
                        /* Decode a row of this plane */
105
                        while(dlen > 0) {
106
                                if(dp + 1 >= buf+buf_size) return -1;
107
                                if ((count = *dp++) <= 127) {
108
                                        count++;
109
                                        dlen -= count + 1;
110
                                        if (pixptr + count * px_inc > pixptr_end)
111
                                            break;
112
                                        if(dp + count > buf+buf_size) return -1;
113
                                        while(count--) {
114
                                                *pixptr = *dp++;
115
                                                pixptr += px_inc;
116
                                        }
117
                                } else {
118
                                        count = 257 - count;
119
                                        if (pixptr + count * px_inc > pixptr_end)
120
                                            break;
121
                                        while(count--) {
122
                                                *pixptr = *dp;
123
                                                pixptr += px_inc;
124
                                        }
125
                                        dp++;
126
                                        dlen -= 2;
127
                                }
128
                        }
129
                }
130
        }
131

    
132
        if (avctx->palctrl) {
133
                memcpy (c->pic.data[1], avctx->palctrl->palette, AVPALETTE_SIZE);
134
                if (avctx->palctrl->palette_changed) {
135
                        c->pic.palette_has_changed = 1;
136
                        avctx->palctrl->palette_changed = 0;
137
                } else
138
                        c->pic.palette_has_changed = 0;
139
        }
140

    
141
        *data_size = sizeof(AVFrame);
142
        *(AVFrame*)data = c->pic;
143

    
144
        /* always report that the buffer was completely consumed */
145
        return buf_size;
146
}
147

    
148

    
149
/*
150
 *
151
 * Init 8BPS decoder
152
 *
153
 */
154
static av_cold int decode_init(AVCodecContext *avctx)
155
{
156
        EightBpsContext * const c = avctx->priv_data;
157

    
158
        c->avctx = avctx;
159

    
160
        c->pic.data[0] = NULL;
161

    
162
        switch (avctx->bits_per_coded_sample) {
163
                case 8:
164
                        avctx->pix_fmt = PIX_FMT_PAL8;
165
                        c->planes = 1;
166
                        c->planemap[0] = 0; // 1st plane is palette indexes
167
                        if (avctx->palctrl == NULL) {
168
                                av_log(avctx, AV_LOG_ERROR, "Error: PAL8 format but no palette from demuxer.\n");
169
                                return -1;
170
                        }
171
                        break;
172
                case 24:
173
                        avctx->pix_fmt = avctx->get_format(avctx, pixfmt_rgb24);
174
                        c->planes = 3;
175
                        c->planemap[0] = 2; // 1st plane is red
176
                        c->planemap[1] = 1; // 2nd plane is green
177
                        c->planemap[2] = 0; // 3rd plane is blue
178
                        break;
179
                case 32:
180
                        avctx->pix_fmt = PIX_FMT_RGB32;
181
                        c->planes = 4;
182
#if HAVE_BIGENDIAN
183
                        c->planemap[0] = 1; // 1st plane is red
184
                        c->planemap[1] = 2; // 2nd plane is green
185
                        c->planemap[2] = 3; // 3rd plane is blue
186
                        c->planemap[3] = 0; // 4th plane is alpha???
187
#else
188
                        c->planemap[0] = 2; // 1st plane is red
189
                        c->planemap[1] = 1; // 2nd plane is green
190
                        c->planemap[2] = 0; // 3rd plane is blue
191
                        c->planemap[3] = 3; // 4th plane is alpha???
192
#endif
193
                        break;
194
                default:
195
                        av_log(avctx, AV_LOG_ERROR, "Error: Unsupported color depth: %u.\n", avctx->bits_per_coded_sample);
196
                        return -1;
197
        }
198

    
199
  return 0;
200
}
201

    
202

    
203

    
204

    
205
/*
206
 *
207
 * Uninit 8BPS decoder
208
 *
209
 */
210
static av_cold int decode_end(AVCodecContext *avctx)
211
{
212
        EightBpsContext * const c = avctx->priv_data;
213

    
214
        if (c->pic.data[0])
215
                avctx->release_buffer(avctx, &c->pic);
216

    
217
        return 0;
218
}
219

    
220

    
221

    
222
AVCodec ff_eightbps_decoder = {
223
        "8bps",
224
        AVMEDIA_TYPE_VIDEO,
225
        CODEC_ID_8BPS,
226
        sizeof(EightBpsContext),
227
        decode_init,
228
        NULL,
229
        decode_end,
230
        decode_frame,
231
        CODEC_CAP_DR1,
232
        .long_name = NULL_IF_CONFIG_SMALL("QuickTime 8BPS video"),
233
};