Ticket #1537: 0001-Add-CPiA-video-decoder.patch

doc/general.texi

@@ -177 +177 @@
     @tab Amiga CD video format
 @item Core Audio Format         @tab X @tab X
     @tab Apple Core Audio Format
+@item CPiA Video Format         @tab X @tab
 @item CRC testing format        @tab X @tab
 @item Creative Voice            @tab X @tab X
     @tab Created for the Sound Blaster Pro.

libavcodec/Makefile

@@ -141 +141 @@
 OBJS-$(CONFIG_CLJR_ENCODER)            += cljr.o
 OBJS-$(CONFIG_CLLC_DECODER)            += cllc.o
 OBJS-$(CONFIG_COOK_DECODER)            += cook.o
+OBJS-$(CONFIG_CPIA_DECODER)            += cpia.o
 OBJS-$(CONFIG_CSCD_DECODER)            += cscd.o
 OBJS-$(CONFIG_CYUV_DECODER)            += cyuv.o
 OBJS-$(CONFIG_DCA_DECODER)             += dcadec.o dca.o dcadsp.o      \

libavcodec/allcodecs.c

@@ -97 +97 @@
     REGISTER_DECODER (CINEPAK, cinepak);
     REGISTER_ENCDEC  (CLJR, cljr);
     REGISTER_DECODER (CLLC, cllc);
+    REGISTER_DECODER (CPIA, cpia);
     REGISTER_DECODER (CSCD, cscd);
     REGISTER_DECODER (CYUV, cyuv);
     REGISTER_DECODER (DFA, dfa);

libavcodec/avcodec.h

@@ -277 +277 @@
     AV_CODEC_ID_SANM       = MKBETAG('S','A','N','M'),
     AV_CODEC_ID_PAF_VIDEO  = MKBETAG('P','A','F','V'),
     AV_CODEC_ID_AVRN       = MKBETAG('A','V','R','n'),
+    AV_CODEC_ID_CPIA       = MKBETAG('C','P','I','A'),
 
     /* various PCM "codecs" */
     AV_CODEC_ID_FIRST_AUDIO = 0x10000,     ///< A dummy id pointing at the start of audio codecs

libavcodec/codec_desc.c

@@ -1183 +1183 @@
         .name      = "avrn",
         .long_name = NULL_IF_CONFIG_SMALL("Avid AVI Codec"),
     },
+    {
+        .id        = AV_CODEC_ID_CPIA,
+        .type      = AVMEDIA_TYPE_VIDEO,
+        .name      = "cpia",
+        .long_name = NULL_IF_CONFIG_SMALL("CPiA video format"),
+    },
 
     /* various PCM "codecs" */
     {

new file libavcodec/cpia.c

@@ +1 @@
+/*
+ * CPiA video decoder.
+ * Copyright (c) 2012
+ *
+ * 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
+ */
+
+#include "avcodec.h"
+#include "get_bits.h"
+
+
+#define FRAME_HEADER_SIZE       64
+#define MAGIC_0         0x19
+#define MAGIC_1         0x68
+#define SUBSAMPLE_420   0
+#define SUBSAMPLE_422   1
+#define YUVORDER_YUYV   0
+#define YUVORDER_UYVY   1
+#define NOT_COMPRESSED  0
+#define COMPRESSED              1
+#define NO_DECIMATION   0
+#define DECIMATION_ENAB 1
+#define EOL             0xfd    /* End Of Line */
+#define EOI             0xff    /* End Of Image */
+
+
+typedef struct {
+        // The frame we decode into
+    AVFrame frame;
+} CpiaContext;
+
+
+static int
+cpia_decode_frame(AVCodecContext* avctx,
+                 void* data, int* data_size, AVPacket* avpkt)
+{
+        CpiaContext* const cpia = avctx->priv_data;
+
+        // pointer to header frame data
+        uint8_t* const header = avpkt->data;
+        // pointer to frame data, will later point to the start of current line
+        uint8_t* src;
+        // size of remaining frame, will later be updated on each line
+        int src_size;
+
+        uint16_t linelength;
+        uint8_t skip;
+
+        int i,j;
+        // target data
+        AVFrame* const frame = &cpia->frame;
+        
+        // pointer to keep track where we are writing image dat
+        uint8_t *y, *u, *v;
+
+        // Get buffer filled with previous frame
+    if (avctx->reget_buffer(avctx, frame)) {
+        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed!\n");
+        return -1;
+    }
+
+        // Check header
+        if (    avpkt->size < FRAME_HEADER_SIZE
+                ||      header[0] != MAGIC_0 || header[1] != MAGIC_1
+                ||      (header[17] != SUBSAMPLE_420 && header[17] != SUBSAMPLE_422)
+                ||      (header[18] != YUVORDER_YUYV && header[18] != YUVORDER_UYVY)
+                ||      (header[28] != NOT_COMPRESSED && header[28] != COMPRESSED)
+                ||      (header[29] != NO_DECIMATION && header[29] != DECIMATION_ENAB)
+        ) {
+        av_log(avctx, AV_LOG_ERROR, "Invalid header!\n");
+                return AVERROR_INVALIDDATA;
+        }
+
+        // Check for currently unsupported properties
+        if (header[17] == SUBSAMPLE_422) {
+        av_log(avctx, AV_LOG_ERROR, "Unsupported subsample!\n");
+                return -1;
+        } 
+        if (header[18] == YUVORDER_UYVY) {
+        av_log(avctx, AV_LOG_ERROR, "Unsupported YUV byte order!\n");
+                return -1;
+        }
+        if (header[29] == DECIMATION_ENAB) {
+        av_log(avctx, AV_LOG_ERROR, "Decimation unsupported!\n");
+                return -1;
+        }
+
+        // data starts after header, set proper length
+        src = header + FRAME_HEADER_SIZE;
+        src_size = avpkt->size - FRAME_HEADER_SIZE;
+        
+        if (header[28] == NOT_COMPRESSED) {
+                // uncompressed frames are independent
+                frame->pict_type = AV_PICTURE_TYPE_I;
+                frame->key_frame = 1;
+        } else {
+                // compressed frames depend on previous frame
+                frame->pict_type = AV_PICTURE_TYPE_P;
+                frame->key_frame = 0;
+        }
+
+
+        // Data processing
+        for (   i = 0; 
+                        i < frame->height; 
+                        i++, src += linelength, src_size -= linelength
+        ) {
+                // Read line length, two byte little endian
+                linelength = AV_RL16(src); 
+                src += 2;
+                
+                // Some integrity checking      
+                if (src_size < linelength) {
+                        frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
+                        av_log(avctx, AV_LOG_WARNING, "Frame ended enexpectedly!\n");
+                        break;
+                }
+                if (src[linelength - 1] != EOL) {
+                        frame->decode_error_flags = FF_DECODE_ERROR_INVALID_BITSTREAM;
+                        av_log(avctx, AV_LOG_WARNING, "Wrong line length %d or line not terminated properly (found 0x%02x)!\n", linelength, src[linelength - 1]);
+                        break;
+                }
+
+                /* Update the data pointers. Y data is on every line.
+                 * U and V data on every second line
+                 */
+                y = &frame->data[0][i * frame->linesize[0]];
+                u = &frame->data[1][(i >> 1) * frame->linesize[1]];
+                v = &frame->data[2][(i >> 1) * frame->linesize[2]];
+
+                if ((i & 1) && header[17] == SUBSAMPLE_420) {
+                        /* We are on a odd line and 420 subsample is used.
+                         * On this line only Y values are specified, one per pixel.
+                         */
+                        for (j = 0; j < linelength - 1; j++) {
+                                if (src[j] & 1 && header[28] == COMPRESSED) {
+                                        /* It seems that odd lines are always uncompressed, but
+                                         * we do it according to specification anyways.
+                                         */
+                                        skip = src[j] >> 1;
+                                        y += skip;
+                                } else {
+                                        *(y++) = src[j];
+                                }
+                        }
+                } else if (header[17] == SUBSAMPLE_420) {
+                        /* We are on an even line and 420 subsample is used.
+                         * On this line each pair of pixels is described by four bytes.
+                         */
+                        for (j = 0; j < linelength - 1; ) {
+                                if (src[j] & 1 && header[28] == COMPRESSED) {
+                                        // Skip amount of pixels and move forward one byte
+                                        skip = src[j] >> 1;
+                                        y += skip;
+                                        u += skip / 2;
+                                        v += skip / 2;
+                                        j++;
+                                } else {
+                                        // Set image data as specified and move forward 4 bytes
+                                        *(y++) = src[j];
+                                        *(u++) = src[j+1];
+                                        *(y++) = src[j+2];
+                                        *(v++) = src[j+3];
+                                        j += 4;
+                                }
+                        }
+                }
+        }
+        
+        // Not quite sure how this data_size works
+        *data_size = sizeof(AVFrame);
+        *(AVFrame*) data = *frame;
+
+        return avpkt->size;
+}
+
+static av_cold int cpia_decode_init(AVCodecContext *avctx)
+{
+        /* We don't need to allocate memory for our context here.
+         * It is done by ffmpeg
+         */
+
+        // The pixel format this decoder outputs
+    avctx->pix_fmt = PIX_FMT_YUV420P;
+        
+        /* The default timebase set by the v4l2 demuxer leads to probing which is buggy.
+         * Set some reasonable time_base to skip this.
+         */
+        if (avctx->time_base.num == 1 && avctx->time_base.den == 1000000) {
+                avctx->time_base.num = 1;
+                avctx->time_base.den = 60;
+        }
+
+    return 0;
+}
+
+static av_cold int cpia_decode_end(AVCodecContext *avctx)
+{
+    return 0;
+}
+
+
+AVCodec ff_cpia_decoder = {
+    .name           = "cpia",
+    .type           = AVMEDIA_TYPE_VIDEO,
+    .id             = AV_CODEC_ID_CPIA,
+    .priv_data_size = sizeof(CpiaContext),              // for ffmpeg to know how much to allocate
+    .init           = cpia_decode_init,
+    .decode         = cpia_decode_frame,
+    .close          = cpia_decode_end,
+    .capabilities   = CODEC_CAP_DR1,
+        .long_name      = NULL_IF_CONFIG_SMALL("CPiA video format"),
+};

libavdevice/v4l2.c

@@ -150 +150 @@
     { PIX_FMT_NV12,    AV_CODEC_ID_RAWVIDEO, V4L2_PIX_FMT_NV12    },
     { PIX_FMT_NONE,    AV_CODEC_ID_MJPEG,    V4L2_PIX_FMT_MJPEG   },
     { PIX_FMT_NONE,    AV_CODEC_ID_MJPEG,    V4L2_PIX_FMT_JPEG    },
+    { PIX_FMT_NONE,    AV_CODEC_ID_CPIA,     V4L2_PIX_FMT_CPIA1   },
 };
 
 static int device_open(AVFormatContext *ctx)
@@ -549 +550 @@
         return AVERROR(errno);
     }
     av_assert0(buf.index < s->buffers);
+
+    /* CPIA is a compressed format and we don't know the exact number of bytes
+     * used by a frame, so set it here as the driver announces it.
+     */
+    if (ctx->video_codec_id == AV_CODEC_ID_CPIA)
+        s->frame_size = buf.bytesused;
+
     if (s->frame_size > 0 && buf.bytesused != s->frame_size) {
         av_log(ctx, AV_LOG_ERROR,
                "The v4l2 frame is %d bytes, but %d bytes are expected\n",
@@ -767 +775 @@
     AVStream *st;
     int res = 0;
     uint32_t desired_format;
-    enum AVCodecID codec_id;
+    enum AVCodecID codec_id = AV_CODEC_ID_NONE;
     enum PixelFormat pix_fmt = PIX_FMT_NONE;
 
     st = avformat_new_stream(s1, NULL);
@@ -828 +836 @@
 
     desired_format = device_try_init(s1, pix_fmt, &s->width, &s->height,
                                      &codec_id);
+
+    /* If no pixel_format was specified, the codec_id was not known up
+     * until now. Set video_codec_id in the context, as codec_id will
+     * not be available outside this function
+     */
+    if (codec_id != AV_CODEC_ID_NONE && s1->video_codec_id == AV_CODEC_ID_NONE)
+        s1->video_codec_id = codec_id;
+
     if (desired_format == 0) {
         av_log(s1, AV_LOG_ERROR, "Cannot find a proper format for "
                "codec_id %d, pix_fmt %d.\n", s1->video_codec_id, pix_fmt);