Ticket #5923: photocd.diff

Changelog

@@ -49 +49 @@
 - Auravision Aura 1 and 2 decoders
 - Deluxe Paint Animation playback system
 - SIPR decoding for modes 8k5, 6k5 and 5k0
+- Kodak PhotoCD image decoder
 
 
 

libavcodec/allcodecs.c

@@ -144 +144 @@
     REGISTER_ENCDEC  (PCX, pcx);
     REGISTER_ENCDEC  (PGM, pgm);
     REGISTER_ENCDEC  (PGMYUV, pgmyuv);
+    REGISTER_DECODER (PHOTOCD, photocd);
     REGISTER_ENCDEC  (PNG, png);
     REGISTER_ENCDEC  (PPM, ppm);
     REGISTER_DECODER (PTX, ptx);

libavcodec/photocd.c

@@ +1 @@
+/*
+ * Kodak PhotoCD (a.k.a. ImagePac) image decoder
+ *
+ * Copyright (c) 1996-2002 Gerd Knorr
+ * Copyright (c) 2010 Kenneth Vermeirsch
+ *
+ * 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
+ */
+
+/**
+ * @file libavcodec/photocd.c
+ * Kodak PhotoCD (a.k.a. ImagePac) image decoder
+ *
+ * Supports resolutions up to 3072x2048.
+ */
+#include "avcodec.h"
+
+typedef struct
+{
+    AVFrame  picture;
+
+    int      thumbnails;  //* number of thumbnails; 0 for normal image */
+    int      resolution;
+    int      orientation;
+
+    const uint8_t *stream;
+    int      streampos;
+
+    uint8_t *seq [3]; //* huffman tables */
+    uint8_t *bits[3];
+} PhotoCDContext;
+
+static const int   img_start [] = { 0 /*dummy */ , 8192, 47104, 196608 };
+static const short def_width [] = { 0 /*dummy */ , 192, 384, 768, 1536, 3072, 6144 };
+static const short def_height[] = { 0 /*dummy */ , 128, 256, 512, 1024, 2048, 4096 };
+
+#define HTABLE_SIZE 0x10000
+
+#define SETSHIFT       { shiftreg=(((stream[0]<<16) | (stream[1]<<8 ) | \
+                                    (stream[2])) >> (8-bit)) & 0xffff; }
+#define LEFTSHIFT      { shiftreg=((shiftreg<<1) & 0xffff) | \
+    ((stream[2]>>(7-bit++))&1); stream += bit>>3; bit &= 7; }
+
+static av_always_inline void interp_lowres(PhotoCDContext *ctx, AVFrame *picture,
+                                           int width, int height)
+{
+    register uint8_t *dest;
+    uint8_t *ptr, *ptr1, *ptr2;
+    register int x;
+    int y;
+    const uint8_t *const start = ctx->stream + ctx->streampos + img_start[3];
+    const register uint8_t *src = start;
+
+    ptr  = picture->data[0];
+    ptr1 = picture->data[1];
+    ptr2 = picture->data[2];
+
+    for (y = 0; y < height; y += 2) {
+        for (dest = ptr, x = 0; x < width - 1; x++) {
+            *(dest++) =  src[x];
+            *(dest++) = (src[x] + src[x + 1] + 1) >> 1;
+        }
+        *(dest++) = src[x];
+        *(dest++) = src[x];
+
+        src += def_width[3];
+        ptr += picture->linesize[0] << 1;
+
+        for (dest = ptr, x = 0; x < width - 1; x++) {
+            *(dest++) =  src[x];
+            *(dest++) = (src[x] + src[x + 1] + 1) >> 1;
+        }
+        *(dest++) = src[x];
+        *(dest++) = src[x];
+
+        src += def_width[3];
+        ptr += picture->linesize[0] << 1;
+
+        for (dest = ptr1, x = 0; x < (width >> 1) - 1; x++) {
+            *(dest++) =  src[x];
+            *(dest++) = (src[x] + src[x + 1] + 1) >> 1;
+        }
+        *(dest++) = src[x];
+        *(dest++) = src[x];
+
+        src  += def_width[3] >> 1;
+        ptr1 += picture->linesize[1] << 1;
+
+        for (dest = ptr2, x = 0; x < (width >> 1) - 1; x++) {
+            *(dest++) =  src[x];
+            *(dest++) = (src[x] + src[x + 1] + 1) >> 1;
+        }
+        *(dest++) = src[x];
+        *(dest++) = src[x];
+
+        src  += def_width[3] >> 1;
+        ptr2 += picture->linesize[2] << 1;
+    }
+
+    ctx->streampos += src - start;
+}
+
+static void interp_lines(uint8_t *ptr, int linesize, int width, int height)
+{
+    register uint8_t *src1, *src2, *dest;
+    register int x;
+    int y;
+
+    for (y = 0; y < height - 2; y += 2) {
+        src1 = ptr;
+        dest = src1 + linesize;
+        src2 = dest + linesize;
+        for (x = 0; x < width - 2; x += 2) {
+            dest[x]     = (src1[x] + src2[x] + 1) >> 1;
+            dest[x + 1] = (src1[x] + src2[x] + src1[x + 2] + src2[x + 2] + 2) >> 2;
+        }
+        dest[x] = dest[x + 1] = (src1[x] + src2[x] + 1) >> 1;
+
+        ptr += linesize << 1;
+    }
+
+    src1 = ptr;
+    dest = ptr + linesize;
+    for (x = 0; x < width - 2; x += 2) {
+        dest[x]     = src1[x];
+        dest[x + 1] = (src1[x] + src1[x + 2] + 1) >> 1;
+    }
+    dest[x] = dest[x + 1] = src1[x];
+}
+
+static void interp_pixels(uint8_t *ptr, int linesize, int width, int height)
+{
+    register uint8_t *src, *dest;
+    register int x;
+    int y;
+
+    for (y = height - 2; y >= 0; y -= 2) {
+        src  = ptr + (y >> 1) * linesize;
+        dest = ptr +  y       * linesize;
+
+        dest[width - 2] = dest[width - 1] = src[(width >> 1) - 1];
+        for (x = width - 4; x >= 0; x -= 2) {
+            dest[x]     =  src[x >> 1];
+            dest[x + 1] = (src[x >> 1] + src[(x >> 1) + 1] + 1) >> 1;
+        }
+    }
+}
+
+static int read_hufftable(AVCodecContext *avctx, uint8_t ** aseq, uint8_t ** abits)
+{
+    PhotoCDContext *const ctx = avctx->priv_data;
+    const uint8_t *src = ctx->stream + ctx->streampos;
+    const int tablen = *src;
+    int len = tablen, i, j;
+
+    if (!*aseq)
+      *aseq  = av_malloc(HTABLE_SIZE * sizeof (char));
+    if (!*abits)
+      *abits = av_malloc(HTABLE_SIZE * sizeof (char));
+
+    memset(*aseq,  0, HTABLE_SIZE * sizeof (char));
+    memset(*abits, 0, HTABLE_SIZE * sizeof (char));
+
+    for (i = 1; len >= 0; i += 4, len--) {
+        const int bits = src[i] + 1;
+        const int seq  = (int) src[i + 1] << 8 | (int) src[i + 2];
+        const int seq2 = seq + (0x10000 >> bits);
+        for (j = seq; j < seq2; j++) {
+            if ((*abits)[j]) {
+                av_log(avctx, AV_LOG_ERROR, "invalid huffmann code table #%x\n", j);
+                return -1;
+            }
+            (*aseq )[j] = src[i + 3];
+            (*abits)[j] = bits;
+        }
+    }
+
+    ctx->streampos += i << 2;
+    return 0;
+}
+
+static int decode_huff(AVCodecContext *avctx, AVFrame *frame,
+                       int target_res, int curr_res)
+{
+    PhotoCDContext *const ctx = avctx->priv_data;
+    const uint8_t *const start = ctx->stream + ctx->streampos;
+    const uint8_t *stream = start;
+    int y = 0, type, height, y2;
+    register int shiftreg, bit;
+    const int scaling = target_res - curr_res;
+    const uint8_t type2idx[] = { 0, 0xff, 1, 2 };
+
+    height = def_height[curr_res];
+    y2 = avctx->height >> scaling;
+
+    while (y < height) {
+        register uint8_t *data;
+        register int x;
+        uint8_t *seq;
+        uint8_t *bits;
+        int x2, idx;
+
+        bit = 0;
+        for (;;) {
+            stream = memchr(stream, 0xff, 10240);
+            if (stream[1] == 0xff)
+                break;
+            stream++;
+        }
+
+        SETSHIFT;
+        while (shiftreg != 0xfffe)
+            LEFTSHIFT;
+        stream += 2;
+        SETSHIFT;
+        y = (shiftreg >> 1) & 0x1fff;
+        type = (shiftreg >> 14);
+        stream += 2;
+        SETSHIFT;
+
+        assert(type == 0 || type == 2 || type == 3);
+        if (y > height) {
+            av_log(avctx, AV_LOG_ERROR, "row out of range: %d\n", y);
+            return -1;
+        }
+
+        /* decode line */
+        idx  = type2idx[type];
+        seq  = ctx->seq [idx];
+        bits = ctx->bits[idx];
+        data = frame->data[idx] + (y >> !!type) * frame->linesize[idx];
+
+        x2 = avctx->width >> (scaling + !!type);
+        for (x = 0; x < x2; x++) {
+            data[x] = av_clip_uint8((int) data[x] + (signed char) seq[shiftreg]);
+            bit += bits[shiftreg];
+            stream += bit >> 3;
+            bit &= 7;
+            SETSHIFT;
+        }
+    }
+
+    ctx->streampos += (int) (stream - start);
+    ctx->streampos  = (ctx->streampos + 0x6000 + 2047) & ~0x7ff;
+    return 0;
+}
+
+static int photocd_decode_frame(AVCodecContext *avctx, void *data,
+                                int *data_size, AVPacket *avpkt)
+{
+    const uint8_t *const buf = avpkt->data;
+    PhotoCDContext *const ctx = avctx->priv_data;
+    AVFrame *picture = data;
+    AVFrame *const p = (AVFrame *) &ctx->picture;
+    int ptr_incr, size_read, n;
+    uint8_t *ptr, *ptr1, *ptr2;
+
+    if (avpkt->size < 7) {
+        av_log(avctx, AV_LOG_WARNING, "invalid file\n");
+        return -1;
+    }
+
+    if (!strncmp("PCD_OPA", buf, 7)) {
+        ctx->thumbnails = (int) buf[10] << 8 | (int) buf[11];
+        av_log(avctx, AV_LOG_WARNING, "this is a thumbnails file, "
+                                      "reading first thumbnail only\n");
+    } else if (avpkt->size < 786432) {
+        av_log(avctx, AV_LOG_ERROR, "probably not a PhotoCD image: too small\n");
+        return -1;
+    }
+
+    ctx->orientation = ctx->thumbnails ? buf[12] & 3 : buf[0x48] & 3;
+
+    if (ctx->thumbnails)
+        ctx->resolution = 1;
+    else if (avpkt->size == 786432)
+        ctx->resolution = 3;
+    else
+        ctx->resolution = av_clip(5 - avctx->lowres, 1, 5);
+
+    avctx->width  = def_width [ctx->resolution];
+    avctx->height = def_height[ctx->resolution];
+
+    if (p->data[0])
+        avctx->release_buffer(avctx, p);
+    if (avctx->get_buffer(avctx, p) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+        return -1;
+    }
+
+    if (ctx->resolution < 4) {
+        int y;
+        const uint8_t *bufptr;
+
+        ptr  = p->data[0];
+        ptr1 = p->data[1];
+        ptr2 = p->data[2];
+
+        if (ctx->thumbnails) {
+            bufptr = buf + 10240;
+        } else {
+            bufptr = buf + img_start[ctx->resolution];
+        }
+
+        ptr_incr = avctx->width >> 1;
+
+        for (y = 0; y < avctx->height; y += 2) {
+            n = avctx->width;
+
+            memcpy(ptr, bufptr, n);
+            ptr += p->linesize[0];
+            bufptr += ptr_incr + ptr_incr;
+
+            memcpy(ptr, bufptr, n);
+            ptr += p->linesize[0];
+            bufptr += ptr_incr + ptr_incr;
+
+            n >>= 1;
+
+            memcpy(ptr1, bufptr, n);
+            ptr1 += p->linesize[1];
+            bufptr += ptr_incr;
+
+            memcpy(ptr2, bufptr, n);
+            ptr2 += p->linesize[2];
+            bufptr += ptr_incr;
+        }
+        size_read = bufptr - buf;
+    } else {
+        ctx->stream = buf;
+        ctx->streampos = 0;
+        ptr  = p->data[0];
+        ptr1 = p->data[1];
+        ptr2 = p->data[2];
+
+        interp_lowres(ctx, p, def_width[3], def_height[3]);
+
+        interp_lines(ptr1, p->linesize[1], def_width[3], def_height[3]);
+        interp_lines(ptr2, p->linesize[2], def_width[3], def_height[3]);
+
+        if (ctx->resolution == 5) {
+            interp_pixels(ptr1, p->linesize[1], def_width[4], def_height[4]);
+            interp_lines (ptr1, p->linesize[1], def_width[4], def_height[4]);
+            interp_pixels(ptr2, p->linesize[2], def_width[4], def_height[4]);
+            interp_lines (ptr2, p->linesize[2], def_width[4], def_height[4]);
+        }
+
+        interp_lines(ptr, p->linesize[0], def_width[4], def_height[4]);
+
+        ctx->streampos = 0xc2000;
+        if (read_hufftable(avctx, &ctx->seq[0], &ctx->bits[0]) < 0)
+            return -1;
+        ctx->streampos = (ctx->streampos + 2047) & ~0x3ff;
+        if (decode_huff(avctx, p, ctx->resolution, 4) < 0)
+            return -1;
+
+        if (ctx->resolution == 5) {
+            interp_pixels(ptr, p->linesize[0], def_width[5], def_height[5]);
+            interp_lines (ptr, p->linesize[0], def_width[5], def_height[5]);
+
+            for (n = 0; n < 3; n++) {
+              if (read_hufftable(avctx, &ctx->seq[n], &ctx->bits[n]) < 0)
+                  return -1;
+            }
+            ctx->streampos = (ctx->streampos + 2047) & ~0x3ff;
+            if (decode_huff(avctx, p, 5, 5) < 0)
+                return -1;
+        }
+
+        size_read = ctx->streampos;
+    }
+
+    *picture   = *(AVFrame *) &ctx->picture;
+    *data_size = sizeof (AVPicture);
+
+    return size_read;
+}
+
+static av_cold int photocd_decode_init(AVCodecContext *avctx)
+{
+    PhotoCDContext *const ctx = avctx->priv_data;
+
+    memset(ctx, 0, sizeof (PhotoCDContext));
+
+    /* how to get the colorspace right? */
+    //avctx->pix_fmt    = PIX_FMT_YUV420P;
+    //avctx->colorspace = AVCOL_SPC_BT470BG;
+    //avctx->color_trc  = AVCOL_TRC_BT709;
+    //avctx->color_primaries = AVCOL_PRI_BT470BG;
+    //avctx->color_primaries = AVCOL_PRI_BT709;
+
+    avcodec_get_frame_defaults((AVFrame *) &ctx->picture);
+    avctx->coded_frame = (AVFrame *) &ctx->picture;
+
+    return 0;
+}
+
+static av_cold int photocd_decode_close(AVCodecContext *avctx)
+{
+    PhotoCDContext *const ctx = avctx->priv_data;
+
+    if (ctx->picture.data[0])
+        avctx->release_buffer(avctx, &ctx->picture);
+
+    av_free(ctx->seq [0]);
+    av_free(ctx->bits[0]);
+    av_free(ctx->seq [1]);
+    av_free(ctx->bits[1]);
+    av_free(ctx->seq [2]);
+    av_free(ctx->bits[2]);
+
+    return 0;
+}
+
+AVCodec photocd_decoder =
+{
+    .name           = "photocd",
+    .type           = CODEC_TYPE_VIDEO,
+    .id             = CODEC_ID_PHOTOCD,
+    .priv_data_size = sizeof (PhotoCDContext),
+    .init           = photocd_decode_init,
+    .close          = photocd_decode_close,
+    .decode         = photocd_decode_frame,
+    .capabilities   = CODEC_CAP_DR1,
+    .pix_fmts       = (const enum PixelFormat[]) { PIX_FMT_YUV420P, PIX_FMT_NONE },
+    .long_name      = NULL_IF_CONFIG_SMALL("Kodak Photo CD (a.k.a. ImagePac) image"),
+};

libavcodec/avcodec.h

@@ -203 +203 @@
     CODEC_ID_CDGRAPHICS,
     CODEC_ID_R210,
     CODEC_ID_ANM,
+    CODEC_ID_PHOTOCD,
 
     /* various PCM "codecs" */
     CODEC_ID_PCM_S16LE= 0x10000,

libavcodec/Makefile

@@ -224 +224 @@
 OBJS-$(CONFIG_PGMYUV_DECODER)          += pnmdec.o pnm.o
 OBJS-$(CONFIG_PGMYUV_ENCODER)          += pnmenc.o pnm.o
 OBJS-$(CONFIG_PGSSUB_DECODER)          += pgssubdec.o
+OBJS-$(CONFIG_PHOTOCD_DECODER)         += photocd.o
 OBJS-$(CONFIG_PNG_DECODER)             += png.o pngdec.o
 OBJS-$(CONFIG_PNG_ENCODER)             += png.o pngenc.o
 OBJS-$(CONFIG_PPM_DECODER)             += pnmdec.o pnm.o

libavformat/img2.c

@@ -73 +73 @@
     { CODEC_ID_SUNRAST   , "sunras"},
     { CODEC_ID_JPEG2000  , "jp2"},
     { CODEC_ID_DPX       , "dpx"},
+    { CODEC_ID_PHOTOCD   , "pcd"},
     { CODEC_ID_NONE      , NULL}
 };