indeo2.c
Go to the documentation of this file.
1 /*
2  * Intel Indeo 2 codec
3  * Copyright (c) 2005 Konstantin Shishkov
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
27 #define BITSTREAM_READER_LE
28 #include "libavutil/attributes.h"
29 #include "avcodec.h"
30 #include "get_bits.h"
31 #include "indeo2data.h"
32 #include "mathops.h"
33 
34 typedef struct Ir2Context{
39 } Ir2Context;
40 
41 #define CODE_VLC_BITS 14
42 static VLC ir2_vlc;
43 
44 /* Indeo 2 codes are in range 0x01..0x7F and 0x81..0x90 */
45 static inline int ir2_get_code(GetBitContext *gb)
46 {
47  return get_vlc2(gb, ir2_vlc.table, CODE_VLC_BITS, 1) + 1;
48 }
49 
50 static int ir2_decode_plane(Ir2Context *ctx, int width, int height, uint8_t *dst, int stride,
51  const uint8_t *table)
52 {
53  int i;
54  int j;
55  int out = 0;
56  int c;
57  int t;
58 
59  if(width&1)
60  return -1;
61 
62  /* first line contain absolute values, other lines contain deltas */
63  while (out < width){
64  c = ir2_get_code(&ctx->gb);
65  if(c >= 0x80) { /* we have a run */
66  c -= 0x7F;
67  if(out + c*2 > width)
68  return -1;
69  for (i = 0; i < c * 2; i++)
70  dst[out++] = 0x80;
71  } else { /* copy two values from table */
72  dst[out++] = table[c * 2];
73  dst[out++] = table[(c * 2) + 1];
74  }
75  }
76  dst += stride;
77 
78  for (j = 1; j < height; j++){
79  out = 0;
80  while (out < width){
81  c = ir2_get_code(&ctx->gb);
82  if(c >= 0x80) { /* we have a skip */
83  c -= 0x7F;
84  if(out + c*2 > width)
85  return -1;
86  for (i = 0; i < c * 2; i++) {
87  dst[out] = dst[out - stride];
88  out++;
89  }
90  } else { /* add two deltas from table */
91  t = dst[out - stride] + (table[c * 2] - 128);
92  t= av_clip_uint8(t);
93  dst[out] = t;
94  out++;
95  t = dst[out - stride] + (table[(c * 2) + 1] - 128);
96  t= av_clip_uint8(t);
97  dst[out] = t;
98  out++;
99  }
100  }
101  dst += stride;
102  }
103  return 0;
104 }
105 
106 static int ir2_decode_plane_inter(Ir2Context *ctx, int width, int height, uint8_t *dst, int stride,
107  const uint8_t *table)
108 {
109  int j;
110  int out = 0;
111  int c;
112  int t;
113 
114  if(width&1)
115  return -1;
116 
117  for (j = 0; j < height; j++){
118  out = 0;
119  while (out < width){
120  c = ir2_get_code(&ctx->gb);
121  if(c >= 0x80) { /* we have a skip */
122  c -= 0x7F;
123  out += c * 2;
124  } else { /* add two deltas from table */
125  t = dst[out] + (((table[c * 2] - 128)*3) >> 2);
126  t= av_clip_uint8(t);
127  dst[out] = t;
128  out++;
129  t = dst[out] + (((table[(c * 2) + 1] - 128)*3) >> 2);
130  t= av_clip_uint8(t);
131  dst[out] = t;
132  out++;
133  }
134  }
135  dst += stride;
136  }
137  return 0;
138 }
139 
141  void *data, int *got_frame,
142  AVPacket *avpkt)
143 {
144  const uint8_t *buf = avpkt->data;
145  int buf_size = avpkt->size;
146  Ir2Context * const s = avctx->priv_data;
147  AVFrame *picture = data;
148  AVFrame * const p = &s->picture;
149  int start;
150 
151  if(p->data[0])
152  avctx->release_buffer(avctx, p);
153 
154  p->reference = 1;
156  if (avctx->reget_buffer(avctx, p)) {
157  av_log(s->avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
158  return -1;
159  }
160 
161  start = 48; /* hardcoded for now */
162 
163  if (start >= buf_size) {
164  av_log(s->avctx, AV_LOG_ERROR, "input buffer size too small (%d)\n", buf_size);
165  return AVERROR_INVALIDDATA;
166  }
167 
168  s->decode_delta = buf[18];
169 
170  /* decide whether frame uses deltas or not */
171 #ifndef BITSTREAM_READER_LE
172  for (i = 0; i < buf_size; i++)
173  buf[i] = ff_reverse[buf[i]];
174 #endif
175 
176  init_get_bits(&s->gb, buf + start, (buf_size - start) * 8);
177 
178  if (s->decode_delta) { /* intraframe */
179  ir2_decode_plane(s, avctx->width, avctx->height,
180  s->picture.data[0], s->picture.linesize[0], ir2_luma_table);
181  /* swapped U and V */
182  ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,
183  s->picture.data[2], s->picture.linesize[2], ir2_luma_table);
184  ir2_decode_plane(s, avctx->width >> 2, avctx->height >> 2,
185  s->picture.data[1], s->picture.linesize[1], ir2_luma_table);
186  } else { /* interframe */
187  ir2_decode_plane_inter(s, avctx->width, avctx->height,
188  s->picture.data[0], s->picture.linesize[0], ir2_luma_table);
189  /* swapped U and V */
190  ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,
191  s->picture.data[2], s->picture.linesize[2], ir2_luma_table);
192  ir2_decode_plane_inter(s, avctx->width >> 2, avctx->height >> 2,
193  s->picture.data[1], s->picture.linesize[1], ir2_luma_table);
194  }
195 
196  *picture = s->picture;
197  *got_frame = 1;
198 
199  return buf_size;
200 }
201 
203  Ir2Context * const ic = avctx->priv_data;
204  static VLC_TYPE vlc_tables[1 << CODE_VLC_BITS][2];
205 
206  ic->avctx = avctx;
207 
208  avctx->pix_fmt= AV_PIX_FMT_YUV410P;
209 
210  ir2_vlc.table = vlc_tables;
211  ir2_vlc.table_allocated = 1 << CODE_VLC_BITS;
212 #ifdef BITSTREAM_READER_LE
213  init_vlc(&ir2_vlc, CODE_VLC_BITS, IR2_CODES,
214  &ir2_codes[0][1], 4, 2,
216 #else
217  init_vlc(&ir2_vlc, CODE_VLC_BITS, IR2_CODES,
218  &ir2_codes[0][1], 4, 2,
219  &ir2_codes[0][0], 4, 2, INIT_VLC_USE_NEW_STATIC);
220 #endif
221 
222  return 0;
223 }
224 
226  Ir2Context * const ic = avctx->priv_data;
227  AVFrame *pic = &ic->picture;
228 
229  if (pic->data[0])
230  avctx->release_buffer(avctx, pic);
231 
232  return 0;
233 }
234 
236  .name = "indeo2",
237  .type = AVMEDIA_TYPE_VIDEO,
238  .id = AV_CODEC_ID_INDEO2,
239  .priv_data_size = sizeof(Ir2Context),
243  .capabilities = CODEC_CAP_DR1,
244  .long_name = NULL_IF_CONFIG_SMALL("Intel Indeo 2"),
245 };
static int ir2_get_code(GetBitContext *gb)
Definition: indeo2.c:45
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
int buffer_hints
codec suggestion on buffer type if != 0
Definition: avcodec.h:1253
GetBitContext gb
Definition: indeo2.c:37
void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
Definition: avcodec.h:2259
int decode_delta
Definition: indeo2.c:38
int size
Definition: avcodec.h:916
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1533
#define VLC_TYPE
Definition: get_bits.h:61
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:2960
Macro definitions for various function/variable attributes.
int(* reget_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called at the beginning of a frame to get cr buffer for it.
Definition: avcodec.h:2273
AVCodec ff_indeo2_decoder
Definition: indeo2.c:235
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
uint8_t
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:915
bitstream reader API header.
static av_cold int ir2_decode_init(AVCodecContext *avctx)
Definition: indeo2.c:202
static float t
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
Definition: avcodec.h:1132
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
Definition: get_bits.h:63
struct Ir2Context Ir2Context
static av_cold int ir2_decode_end(AVCodecContext *avctx)
Definition: indeo2.c:225
static AVFrame * picture
int width
picture width / height.
Definition: avcodec.h:1508
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:515
AVFrame picture
Definition: indeo2.c:36
#define INIT_VLC_USE_NEW_STATIC
Definition: get_bits.h:433
int table_allocated
Definition: get_bits.h:66
#define CODE_VLC_BITS
Definition: indeo2.c:41
static int width
Definition: utils.c:156
external API header
static int ir2_decode_plane(Ir2Context *ctx, int width, int height, uint8_t *dst, int stride, const uint8_t *table)
Definition: indeo2.c:50
static int ir2_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: indeo2.c:140
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
main external API structure.
Definition: avcodec.h:1339
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:326
static int ir2_decode_plane_inter(Ir2Context *ctx, int width, int height, uint8_t *dst, int stride, const uint8_t *table)
Definition: indeo2.c:106
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:418
#define INIT_VLC_LE
Definition: get_bits.h:432
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:71
#define IR2_CODES
Definition: indeo2data.h:27
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:372
static VLC_TYPE vlc_tables[VLC_TABLES_SIZE][2]
Definition: imc.c:115
static const uint8_t ir2_luma_table[256]
Definition: indeo2data.h:106
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
int height
Definition: gxfenc.c:72
void * priv_data
Definition: avcodec.h:1382
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
AVCodecContext * avctx
Definition: indeo2.c:35
const uint8_t ff_reverse[256]
Definition: mathtables.c:70
static VLC ir2_vlc
Definition: indeo2.c:42
This structure stores compressed data.
Definition: avcodec.h:898
static const uint16_t ir2_codes[IR2_CODES][2]
Definition: indeo2data.h:28