2 * Quicktime Video (RPZA) Video Decoder
3 * Copyright (C) 2003 the ffmpeg project
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * QT RPZA Video Decoder by Roberto Togni <rtogni@bresciaonline.it>
24 * For more information about the RPZA format, visit:
25 * http://www.pcisys.net/~melanson/codecs/
27 * The RPZA decoder outputs RGB555 colorspace data.
29 * Note that this decoder reads big endian RGB555 pixel values from the
30 * bytestream, arranges them in the host's endian order, and outputs
31 * them to the final rendered map in the same host endian order. This is
32 * intended behavior as the ffmpeg documentation states that RGB555 pixels
33 * 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
= BE_32(&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
= BE_16 (&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
= BE_16 (&s
->buf
[stream_ptr
]);
161 colorB
= BE_16 (&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
= BE_16 (&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
= (RpzaContext
*)avctx
->priv_data
;
236 avctx
->pix_fmt
= PIX_FMT_RGB555
;
237 avctx
->has_b_frames
= 0;
238 dsputil_init(&s
->dsp
, avctx
);
240 s
->frame
.data
[0] = NULL
;
245 static int rpza_decode_frame(AVCodecContext
*avctx
,
246 void *data
, int *data_size
,
247 uint8_t *buf
, int buf_size
)
249 RpzaContext
*s
= (RpzaContext
*)avctx
->priv_data
;
254 s
->frame
.reference
= 1;
255 s
->frame
.buffer_hints
= FF_BUFFER_HINTS_VALID
| FF_BUFFER_HINTS_PRESERVE
| FF_BUFFER_HINTS_REUSABLE
;
256 if (avctx
->reget_buffer(avctx
, &s
->frame
)) {
257 av_log(avctx
, AV_LOG_ERROR
, "reget_buffer() failed\n");
261 rpza_decode_stream(s
);
263 *data_size
= sizeof(AVFrame
);
264 *(AVFrame
*)data
= s
->frame
;
266 /* always report that the buffer was completely consumed */
270 static int rpza_decode_end(AVCodecContext
*avctx
)
272 RpzaContext
*s
= (RpzaContext
*)avctx
->priv_data
;
274 if (s
->frame
.data
[0])
275 avctx
->release_buffer(avctx
, &s
->frame
);
280 AVCodec rpza_decoder
= {