2 * Quicktime Video (RPZA) Video Decoder
3 * Copyright (C) 2003 the ffmpeg project
5 * This file is part of FFmpeg.
7 * FFmpeg 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.
12 * FFmpeg 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.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * QT RPZA Video Decoder by Roberto Togni <rtogni@bresciaonline.it>
25 * For more information about the RPZA format, visit:
26 * http://www.pcisys.net/~melanson/codecs/
28 * The RPZA decoder outputs RGB555 colorspace data.
30 * Note that this decoder reads big endian RGB555 pixel values from the
31 * bytestream, arranges them in the host's endian order, and outputs
32 * them to the final rendered map in the same host endian order. This is
33 * intended behavior as the ffmpeg documentation states that RGB555 pixels
34 * shall be stored in native CPU endianness.
45 typedef struct RpzaContext
{
47 AVCodecContext
*avctx
;
56 #define ADVANCE_BLOCK() \
59 if (pixel_ptr >= width) \
62 row_ptr += stride * 4; \
65 if (total_blocks < 0) \
67 av_log(s->avctx, AV_LOG_ERROR, "warning: block counter just went negative (this should not happen)\n"); \
72 static void rpza_decode_stream(RpzaContext
*s
)
74 int width
= s
->avctx
->width
;
75 int stride
= s
->frame
.linesize
[0] / 2;
76 int row_inc
= stride
- 4;
81 unsigned short colorA
= 0, colorB
;
82 unsigned short color4
[4];
83 unsigned char index
, idx
;
84 unsigned short ta
, tb
;
85 unsigned short *pixels
= (unsigned short *)s
->frame
.data
[0];
93 /* First byte is always 0xe1. Warn if it's different */
94 if (s
->buf
[stream_ptr
] != 0xe1)
95 av_log(s
->avctx
, AV_LOG_ERROR
, "First chunk byte is 0x%02x instead of 0xe1\n",
98 /* Get chunk size, ingnoring first byte */
99 chunk_size
= AV_RB32(&s
->buf
[stream_ptr
]) & 0x00FFFFFF;
102 /* If length mismatch use size from MOV file and try to decode anyway */
103 if (chunk_size
!= s
->size
)
104 av_log(s
->avctx
, AV_LOG_ERROR
, "MOV chunk size != encoded chunk size; using MOV chunk size\n");
106 chunk_size
= s
->size
;
108 /* Number of 4x4 blocks in frame. */
109 total_blocks
= ((s
->avctx
->width
+ 3) / 4) * ((s
->avctx
->height
+ 3) / 4);
111 /* Process chunk data */
112 while (stream_ptr
< chunk_size
) {
113 opcode
= s
->buf
[stream_ptr
++]; /* Get opcode */
115 n_blocks
= (opcode
& 0x1f) + 1; /* Extract block counter from opcode */
117 /* If opcode MSbit is 0, we need more data to decide what to do */
118 if ((opcode
& 0x80) == 0) {
119 colorA
= (opcode
<< 8) | (s
->buf
[stream_ptr
++]);
121 if ((s
->buf
[stream_ptr
] & 0x80) != 0) {
122 /* Must behave as opcode 110xxxxx, using colorA computed
123 * above. Use fake opcode 0x20 to enter switch block at
130 switch (opcode
& 0xe0) {
139 /* Fill blocks with one color */
141 colorA
= AV_RB16 (&s
->buf
[stream_ptr
]);
144 block_ptr
= row_ptr
+ pixel_ptr
;
145 for (pixel_y
= 0; pixel_y
< 4; pixel_y
++) {
146 for (pixel_x
= 0; pixel_x
< 4; pixel_x
++){
147 pixels
[block_ptr
] = colorA
;
150 block_ptr
+= row_inc
;
156 /* Fill blocks with 4 colors */
158 colorA
= AV_RB16 (&s
->buf
[stream_ptr
]);
161 colorB
= AV_RB16 (&s
->buf
[stream_ptr
]);
164 /* sort out the colors */
171 ta
= (colorA
>> 10) & 0x1F;
172 tb
= (colorB
>> 10) & 0x1F;
173 color4
[1] |= ((11 * ta
+ 21 * tb
) >> 5) << 10;
174 color4
[2] |= ((21 * ta
+ 11 * tb
) >> 5) << 10;
176 /* green components */
177 ta
= (colorA
>> 5) & 0x1F;
178 tb
= (colorB
>> 5) & 0x1F;
179 color4
[1] |= ((11 * ta
+ 21 * tb
) >> 5) << 5;
180 color4
[2] |= ((21 * ta
+ 11 * tb
) >> 5) << 5;
182 /* blue components */
185 color4
[1] |= ((11 * ta
+ 21 * tb
) >> 5);
186 color4
[2] |= ((21 * ta
+ 11 * tb
) >> 5);
189 block_ptr
= row_ptr
+ pixel_ptr
;
190 for (pixel_y
= 0; pixel_y
< 4; pixel_y
++) {
191 index
= s
->buf
[stream_ptr
++];
192 for (pixel_x
= 0; pixel_x
< 4; pixel_x
++){
193 idx
= (index
>> (2 * (3 - pixel_x
))) & 0x03;
194 pixels
[block_ptr
] = color4
[idx
];
197 block_ptr
+= row_inc
;
203 /* Fill block with 16 colors */
205 block_ptr
= row_ptr
+ pixel_ptr
;
206 for (pixel_y
= 0; pixel_y
< 4; pixel_y
++) {
207 for (pixel_x
= 0; pixel_x
< 4; pixel_x
++){
208 /* We already have color of upper left pixel */
209 if ((pixel_y
!= 0) || (pixel_x
!=0)) {
210 colorA
= AV_RB16 (&s
->buf
[stream_ptr
]);
213 pixels
[block_ptr
] = colorA
;
216 block_ptr
+= row_inc
;
223 av_log(s
->avctx
, AV_LOG_ERROR
, "Unknown opcode %d in rpza chunk."
224 " Skip remaining %d bytes of chunk data.\n", opcode
,
225 chunk_size
- stream_ptr
);
227 } /* Opcode switch */
231 static int rpza_decode_init(AVCodecContext
*avctx
)
233 RpzaContext
*s
= avctx
->priv_data
;
236 avctx
->pix_fmt
= PIX_FMT_RGB555
;
237 dsputil_init(&s
->dsp
, avctx
);
239 s
->frame
.data
[0] = NULL
;
244 static int rpza_decode_frame(AVCodecContext
*avctx
,
245 void *data
, int *data_size
,
246 uint8_t *buf
, int buf_size
)
248 RpzaContext
*s
= avctx
->priv_data
;
253 s
->frame
.reference
= 1;
254 s
->frame
.buffer_hints
= FF_BUFFER_HINTS_VALID
| FF_BUFFER_HINTS_PRESERVE
| FF_BUFFER_HINTS_REUSABLE
;
255 if (avctx
->reget_buffer(avctx
, &s
->frame
)) {
256 av_log(avctx
, AV_LOG_ERROR
, "reget_buffer() failed\n");
260 rpza_decode_stream(s
);
262 *data_size
= sizeof(AVFrame
);
263 *(AVFrame
*)data
= s
->frame
;
265 /* always report that the buffer was completely consumed */
269 static int rpza_decode_end(AVCodecContext
*avctx
)
271 RpzaContext
*s
= avctx
->priv_data
;
273 if (s
->frame
.data
[0])
274 avctx
->release_buffer(avctx
, &s
->frame
);
279 AVCodec rpza_decoder
= {