2fdf638b |
/*
* Quicktime Video (RPZA) Video Decoder
* Copyright (C) 2003 the ffmpeg project
* |
b78e7197 |
* This file is part of FFmpeg.
*
* FFmpeg is free software; you can redistribute it and/or |
2fdf638b |
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either |
b78e7197 |
* version 2.1 of the License, or (at your option) any later version. |
2fdf638b |
* |
b78e7197 |
* FFmpeg is distributed in the hope that it will be useful, |
2fdf638b |
* 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 |
b78e7197 |
* License along with FFmpeg; if not, write to the Free Software |
5509bffa |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
2fdf638b |
*/
/** |
ba87f080 |
* @file |
467ec3c1 |
* QT RPZA Video Decoder by Roberto Togni |
2fdf638b |
* For more information about the RPZA format, visit:
* http://www.pcisys.net/~melanson/codecs/
*
* The RPZA decoder outputs RGB555 colorspace data.
*
* Note that this decoder reads big endian RGB555 pixel values from the
* bytestream, arranges them in the host's endian order, and outputs
* them to the final rendered map in the same host endian order. This is |
2f5df0b1 |
* intended behavior as the libavcodec documentation states that RGB555
* pixels shall be stored in native CPU endianness. |
2fdf638b |
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
|
1d9c2dc8 |
#include "libavutil/internal.h" |
6a5d31ac |
#include "libavutil/intreadwrite.h" |
2fdf638b |
#include "avcodec.h"
typedef struct RpzaContext {
AVCodecContext *avctx;
AVFrame frame;
|
f61bf052 |
const unsigned char *buf; |
2fdf638b |
int size;
} RpzaContext;
#define ADVANCE_BLOCK() \
{ \
pixel_ptr += 4; \
if (pixel_ptr >= width) \
{ \
pixel_ptr = 0; \
row_ptr += stride * 4; \
} \
total_blocks--; \
if (total_blocks < 0) \
{ \ |
9b879566 |
av_log(s->avctx, AV_LOG_ERROR, "warning: block counter just went negative (this should not happen)\n"); \ |
2fdf638b |
return; \
} \
}
static void rpza_decode_stream(RpzaContext *s)
{
int width = s->avctx->width;
int stride = s->frame.linesize[0] / 2;
int row_inc = stride - 4;
int stream_ptr = 0;
int chunk_size;
unsigned char opcode;
int n_blocks;
unsigned short colorA = 0, colorB;
unsigned short color4[4];
unsigned char index, idx;
unsigned short ta, tb;
unsigned short *pixels = (unsigned short *)s->frame.data[0];
int row_ptr = 0; |
9d8795e5 |
int pixel_ptr = -4; |
2fdf638b |
int block_ptr;
int pixel_x, pixel_y;
int total_blocks;
/* First byte is always 0xe1. Warn if it's different */
if (s->buf[stream_ptr] != 0xe1) |
bd085459 |
av_log(s->avctx, AV_LOG_ERROR, "First chunk byte is 0x%02x instead of 0xe1\n", |
2fdf638b |
s->buf[stream_ptr]);
/* Get chunk size, ingnoring first byte */ |
fead30d4 |
chunk_size = AV_RB32(&s->buf[stream_ptr]) & 0x00FFFFFF; |
2fdf638b |
stream_ptr += 4;
/* If length mismatch use size from MOV file and try to decode anyway */
if (chunk_size != s->size) |
9b879566 |
av_log(s->avctx, AV_LOG_ERROR, "MOV chunk size != encoded chunk size; using MOV chunk size\n"); |
2fdf638b |
chunk_size = s->size;
/* Number of 4x4 blocks in frame. */ |
8b58ed63 |
total_blocks = ((s->avctx->width + 3) / 4) * ((s->avctx->height + 3) / 4); |
2fdf638b |
/* Process chunk data */
while (stream_ptr < chunk_size) {
opcode = s->buf[stream_ptr++]; /* Get opcode */
n_blocks = (opcode & 0x1f) + 1; /* Extract block counter from opcode */
/* If opcode MSbit is 0, we need more data to decide what to do */
if ((opcode & 0x80) == 0) {
colorA = (opcode << 8) | (s->buf[stream_ptr++]);
opcode = 0;
if ((s->buf[stream_ptr] & 0x80) != 0) { |
115329f1 |
/* Must behave as opcode 110xxxxx, using colorA computed
* above. Use fake opcode 0x20 to enter switch block at |
2fdf638b |
* the right place */
opcode = 0x20;
n_blocks = 1;
}
}
switch (opcode & 0xe0) {
/* Skip blocks */
case 0x80:
while (n_blocks--) { |
e02c251e |
ADVANCE_BLOCK(); |
2fdf638b |
}
break;
/* Fill blocks with one color */
case 0xa0: |
fead30d4 |
colorA = AV_RB16 (&s->buf[stream_ptr]); |
2fdf638b |
stream_ptr += 2;
while (n_blocks--) { |
9d8795e5 |
ADVANCE_BLOCK() |
2fdf638b |
block_ptr = row_ptr + pixel_ptr;
for (pixel_y = 0; pixel_y < 4; pixel_y++) {
for (pixel_x = 0; pixel_x < 4; pixel_x++){
pixels[block_ptr] = colorA;
block_ptr++;
}
block_ptr += row_inc;
}
}
break;
/* Fill blocks with 4 colors */
case 0xc0: |
fead30d4 |
colorA = AV_RB16 (&s->buf[stream_ptr]); |
2fdf638b |
stream_ptr += 2;
case 0x20: |
fead30d4 |
colorB = AV_RB16 (&s->buf[stream_ptr]); |
2fdf638b |
stream_ptr += 2;
/* sort out the colors */
color4[0] = colorB;
color4[1] = 0;
color4[2] = 0;
color4[3] = colorA;
/* red components */
ta = (colorA >> 10) & 0x1F;
tb = (colorB >> 10) & 0x1F;
color4[1] |= ((11 * ta + 21 * tb) >> 5) << 10;
color4[2] |= ((21 * ta + 11 * tb) >> 5) << 10;
/* green components */
ta = (colorA >> 5) & 0x1F;
tb = (colorB >> 5) & 0x1F;
color4[1] |= ((11 * ta + 21 * tb) >> 5) << 5;
color4[2] |= ((21 * ta + 11 * tb) >> 5) << 5;
/* blue components */
ta = colorA & 0x1F;
tb = colorB & 0x1F;
color4[1] |= ((11 * ta + 21 * tb) >> 5);
color4[2] |= ((21 * ta + 11 * tb) >> 5);
|
78e9852a |
if (s->size - stream_ptr < n_blocks * 4)
return; |
2fdf638b |
while (n_blocks--) { |
9d8795e5 |
ADVANCE_BLOCK(); |
2fdf638b |
block_ptr = row_ptr + pixel_ptr;
for (pixel_y = 0; pixel_y < 4; pixel_y++) {
index = s->buf[stream_ptr++];
for (pixel_x = 0; pixel_x < 4; pixel_x++){
idx = (index >> (2 * (3 - pixel_x))) & 0x03;
pixels[block_ptr] = color4[idx];
block_ptr++;
}
block_ptr += row_inc;
}
}
break;
/* Fill block with 16 colors */
case 0x00: |
78e9852a |
if (s->size - stream_ptr < 16)
return; |
9d8795e5 |
ADVANCE_BLOCK(); |
2fdf638b |
block_ptr = row_ptr + pixel_ptr;
for (pixel_y = 0; pixel_y < 4; pixel_y++) {
for (pixel_x = 0; pixel_x < 4; pixel_x++){
/* We already have color of upper left pixel */
if ((pixel_y != 0) || (pixel_x !=0)) { |
fead30d4 |
colorA = AV_RB16 (&s->buf[stream_ptr]); |
2fdf638b |
stream_ptr += 2;
}
pixels[block_ptr] = colorA;
block_ptr++;
}
block_ptr += row_inc;
}
break;
/* Unknown opcode */
default: |
9b879566 |
av_log(s->avctx, AV_LOG_ERROR, "Unknown opcode %d in rpza chunk." |
2fdf638b |
" Skip remaining %d bytes of chunk data.\n", opcode,
chunk_size - stream_ptr);
return;
} /* Opcode switch */
}
}
|
98a6fff9 |
static av_cold int rpza_decode_init(AVCodecContext *avctx) |
2fdf638b |
{ |
e4141433 |
RpzaContext *s = avctx->priv_data; |
2fdf638b |
s->avctx = avctx; |
716d413c |
avctx->pix_fmt = AV_PIX_FMT_RGB555; |
2fdf638b |
|
01042d41 |
avcodec_get_frame_defaults(&s->frame); |
e1c2a5a0 |
s->frame.data[0] = NULL; |
2fdf638b |
return 0;
}
static int rpza_decode_frame(AVCodecContext *avctx, |
df9b9567 |
void *data, int *got_frame, |
7a00bbad |
AVPacket *avpkt) |
2fdf638b |
{ |
7a00bbad |
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; |
e4141433 |
RpzaContext *s = avctx->priv_data; |
e4ca055b |
int ret; |
2fdf638b |
s->buf = buf;
s->size = buf_size;
|
371e1654 |
s->frame.reference = 3; |
155aa417 |
s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE; |
e4ca055b |
if ((ret = avctx->reget_buffer(avctx, &s->frame)) < 0) { |
e1c2a5a0 |
av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); |
e4ca055b |
return ret; |
2fdf638b |
}
rpza_decode_stream(s);
|
df9b9567 |
*got_frame = 1; |
2fdf638b |
*(AVFrame*)data = s->frame;
/* always report that the buffer was completely consumed */
return buf_size;
}
|
98a6fff9 |
static av_cold int rpza_decode_end(AVCodecContext *avctx) |
2fdf638b |
{ |
e4141433 |
RpzaContext *s = avctx->priv_data; |
2fdf638b |
|
e1c2a5a0 |
if (s->frame.data[0])
avctx->release_buffer(avctx, &s->frame); |
2fdf638b |
return 0;
}
|
e7e2df27 |
AVCodec ff_rpza_decoder = { |
ec6402b7 |
.name = "rpza",
.type = AVMEDIA_TYPE_VIDEO, |
36ef5369 |
.id = AV_CODEC_ID_RPZA, |
ec6402b7 |
.priv_data_size = sizeof(RpzaContext),
.init = rpza_decode_init,
.close = rpza_decode_end,
.decode = rpza_decode_frame,
.capabilities = CODEC_CAP_DR1, |
00c3b67b |
.long_name = NULL_IF_CONFIG_SMALL("QuickTime video (RPZA)"), |
2fdf638b |
}; |