libavcodec/cljr.c

   1 /*
   2  * Cirrus Logic AccuPak (CLJR) codec
   3  * Copyright (c) 2003 Alex Beregszaszi
   4  *
   5  * This file is part of FFmpeg.
   6  *
   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.
  11  *
  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.
  16  *
  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
  20  */
  21
  22 /**
  23  * @file cljr.c
  24  * Cirrus Logic AccuPak codec.
  25  */
  26
  27 #include "avcodec.h"
  28 #include "mpegvideo.h"
  29
  30 typedef struct CLJRContext{
  31     AVCodecContext *avctx;
  32     AVFrame picture;
  33     int delta[16];
  34     int offset[4];
  35     GetBitContext gb;
  36 } CLJRContext;
  37
  38 static int decode_frame(AVCodecContext *avctx,
  39                         void *data, int *data_size,
  40                         const uint8_t *buf, int buf_size)
  41 {
  42     CLJRContext * const a = avctx->priv_data;
  43     AVFrame *picture = data;
  44     AVFrame * const p= (AVFrame*)&a->picture;
  45     int x, y;
  46
  47     if(p->data[0])
  48         avctx->release_buffer(avctx, p);
  49
  50     p->reference= 0;
  51     if(avctx->get_buffer(avctx, p) < 0){
  52         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
  53         return -1;
  54     }
  55     p->pict_type= I_TYPE;
  56     p->key_frame= 1;
  57
  58     init_get_bits(&a->gb, buf, buf_size);
  59
  60     for(y=0; y<avctx->height; y++){
  61         uint8_t *luma= &a->picture.data[0][ y*a->picture.linesize[0] ];
  62         uint8_t *cb= &a->picture.data[1][ y*a->picture.linesize[1] ];
  63         uint8_t *cr= &a->picture.data[2][ y*a->picture.linesize[2] ];
  64         for(x=0; x<avctx->width; x+=4){
  65                 luma[3] = get_bits(&a->gb, 5) << 3;
  66             luma[2] = get_bits(&a->gb, 5) << 3;
  67             luma[1] = get_bits(&a->gb, 5) << 3;
  68             luma[0] = get_bits(&a->gb, 5) << 3;
  69             luma+= 4;
  70             *(cb++) = get_bits(&a->gb, 6) << 2;
  71             *(cr++) = get_bits(&a->gb, 6) << 2;
  72         }
  73     }
  74
  75     *picture= *(AVFrame*)&a->picture;
  76     *data_size = sizeof(AVPicture);
  77
  78     emms_c();
  79
  80     return buf_size;
  81 }
  82
  83 #if 0
  84 static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
  85     CLJRContext * const a = avctx->priv_data;
  86     AVFrame *pict = data;
  87     AVFrame * const p= (AVFrame*)&a->picture;
  88     int size;
  89     int mb_x, mb_y;
  90
  91     *p = *pict;
  92     p->pict_type= I_TYPE;
  93     p->key_frame= 1;
  94
  95     emms_c();
  96
  97     align_put_bits(&a->pb);
  98     while(get_bit_count(&a->pb)&31)
  99         put_bits(&a->pb, 8, 0);
 100
 101     size= get_bit_count(&a->pb)/32;
 102
 103     return size*4;
 104 }
 105 #endif
 106
 107 static void common_init(AVCodecContext *avctx){
 108     CLJRContext * const a = avctx->priv_data;
 109
 110     avctx->coded_frame= (AVFrame*)&a->picture;
 111     a->avctx= avctx;
 112 }
 113
 114 static int decode_init(AVCodecContext *avctx){
 115
 116     common_init(avctx);
 117
 118     avctx->pix_fmt= PIX_FMT_YUV411P;
 119
 120     return 0;
 121 }
 122
 123 #if 0
 124 static int encode_init(AVCodecContext *avctx){
 125
 126     common_init(avctx);
 127
 128     return 0;
 129 }
 130 #endif
 131
 132 AVCodec cljr_decoder = {
 133     "cljr",
 134     CODEC_TYPE_VIDEO,
 135     CODEC_ID_CLJR,
 136     sizeof(CLJRContext),
 137     decode_init,
 138     NULL,
 139     NULL,
 140     decode_frame,
 141     CODEC_CAP_DR1,
 142 };
 143 #if 0
 144 #ifdef CONFIG_ENCODERS
 145
 146 AVCodec cljr_encoder = {
 147     "cljr",
 148     CODEC_TYPE_VIDEO,
 149     CODEC_ID_cljr,
 150     sizeof(CLJRContext),
 151     encode_init,
 152     encode_frame,
 153     //encode_end,
 154 };
 155
 156 #endif //CONFIG_ENCODERS
 157 #endif