?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add Speex support to the Ogg muxer.
[FFMpeg-mirror/lagarith.git] / libavcodec / svq3.c
blob9598a14db41dd63944b5af7fb0fbc279d3a5d282
1 /*
2 * Copyright (c) 2003 The FFmpeg Project
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /*
22 * How to use this decoder:
23 * SVQ3 data is transported within Apple Quicktime files. Quicktime files
24 * have stsd atoms to describe media trak properties. A stsd atom for a
25 * video trak contains 1 or more ImageDescription atoms. These atoms begin
26 * with the 4-byte length of the atom followed by the codec fourcc. Some
27 * decoders need information in this atom to operate correctly. Such
28 * is the case with SVQ3. In order to get the best use out of this decoder,
29 * the calling app must make the SVQ3 ImageDescription atom available
30 * via the AVCodecContext's extradata[_size] field:
31 *
32 * AVCodecContext.extradata = pointer to ImageDescription, first characters
33 * are expected to be 'S', 'V', 'Q', and '3', NOT the 4-byte atom length
34 * AVCodecContext.extradata_size = size of ImageDescription atom memory
35 * buffer (which will be the same as the ImageDescription atom size field
36 * from the QT file, minus 4 bytes since the length is missing)
37 *
38 * You will know you have these parameters passed correctly when the decoder
39 * correctly decodes this file:
40 * http://samples.mplayerhq.hu/V-codecs/SVQ3/Vertical400kbit.sorenson3.mov
41 */
42
43 #if CONFIG_ZLIB
44 #include <zlib.h>
45 #endif
46
47 #include "svq1.h"
48
49 /**
50 * @file libavcodec/svq3.c
51 * svq3 decoder.
52 */
53
54 #define FULLPEL_MODE 1
55 #define HALFPEL_MODE 2
56 #define THIRDPEL_MODE 3
57 #define PREDICT_MODE 4
58
59 /* dual scan (from some older h264 draft)
60 o-->o-->o o
61 | /|
62 o o o / o
63 | / | |/ |
64 o o o o
65 /
66 o-->o-->o-->o
67 */
68 static const uint8_t svq3_scan[16] = {
69 0+0*4, 1+0*4, 2+0*4, 2+1*4,
70 2+2*4, 3+0*4, 3+1*4, 3+2*4,
71 0+1*4, 0+2*4, 1+1*4, 1+2*4,
72 0+3*4, 1+3*4, 2+3*4, 3+3*4,
73 };
74
75 static const uint8_t svq3_pred_0[25][2] = {
76 { 0, 0 },
77 { 1, 0 }, { 0, 1 },
78 { 0, 2 }, { 1, 1 }, { 2, 0 },
79 { 3, 0 }, { 2, 1 }, { 1, 2 }, { 0, 3 },
80 { 0, 4 }, { 1, 3 }, { 2, 2 }, { 3, 1 }, { 4, 0 },
81 { 4, 1 }, { 3, 2 }, { 2, 3 }, { 1, 4 },
82 { 2, 4 }, { 3, 3 }, { 4, 2 },
83 { 4, 3 }, { 3, 4 },
84 { 4, 4 }
85 };
86
87 static const int8_t svq3_pred_1[6][6][5] = {
88 { { 2,-1,-1,-1,-1 }, { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 },
89 { 2, 1,-1,-1,-1 }, { 1, 2,-1,-1,-1 }, { 1, 2,-1,-1,-1 } },
90 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 4, 3 }, { 0, 1, 2, 4, 3 },
91 { 0, 2, 1, 4, 3 }, { 2, 0, 1, 3, 4 }, { 0, 4, 2, 1, 3 } },
92 { { 2, 0,-1,-1,-1 }, { 2, 1, 0, 4, 3 }, { 1, 2, 4, 0, 3 },
93 { 2, 1, 0, 4, 3 }, { 2, 1, 4, 3, 0 }, { 1, 2, 4, 0, 3 } },
94 { { 2, 0,-1,-1,-1 }, { 2, 0, 1, 4, 3 }, { 1, 2, 0, 4, 3 },
95 { 2, 1, 0, 4, 3 }, { 2, 1, 3, 4, 0 }, { 2, 4, 1, 0, 3 } },
96 { { 0, 2,-1,-1,-1 }, { 0, 2, 1, 3, 4 }, { 1, 2, 3, 0, 4 },
97 { 2, 0, 1, 3, 4 }, { 2, 1, 3, 0, 4 }, { 2, 0, 4, 3, 1 } },
98 { { 0, 2,-1,-1,-1 }, { 0, 2, 4, 1, 3 }, { 1, 4, 2, 0, 3 },
99 { 4, 2, 0, 1, 3 }, { 2, 0, 1, 4, 3 }, { 4, 2, 1, 0, 3 } },
100 };
101
102 static const struct { uint8_t run; uint8_t level; } svq3_dct_tables[2][16] = {
103 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 2, 1 }, { 0, 2 }, { 3, 1 }, { 4, 1 }, { 5, 1 },
104 { 0, 3 }, { 1, 2 }, { 2, 2 }, { 6, 1 }, { 7, 1 }, { 8, 1 }, { 9, 1 }, { 0, 4 } },
105 { { 0, 0 }, { 0, 1 }, { 1, 1 }, { 0, 2 }, { 2, 1 }, { 0, 3 }, { 0, 4 }, { 0, 5 },
106 { 3, 1 }, { 4, 1 }, { 1, 2 }, { 1, 3 }, { 0, 6 }, { 0, 7 }, { 0, 8 }, { 0, 9 } }
107 };
108
109 static const uint32_t svq3_dequant_coeff[32] = {
110 3881, 4351, 4890, 5481, 6154, 6914, 7761, 8718,
111 9781, 10987, 12339, 13828, 15523, 17435, 19561, 21873,
112 24552, 27656, 30847, 34870, 38807, 43747, 49103, 54683,
113 61694, 68745, 77615, 89113,100253,109366,126635,141533
114 };
115
116
117 static void svq3_luma_dc_dequant_idct_c(DCTELEM *block, int qp)
118 {
119 const int qmul = svq3_dequant_coeff[qp];
120 #define stride 16
121 int i;
122 int temp[16];
123 static const int x_offset[4] = {0, 1*stride, 4* stride, 5*stride};
124 static const int y_offset[4] = {0, 2*stride, 8* stride, 10*stride};
125
126 for (i = 0; i < 4; i++){
127 const int offset = y_offset[i];
128 const int z0 = 13*(block[offset+stride*0] + block[offset+stride*4]);
129 const int z1 = 13*(block[offset+stride*0] - block[offset+stride*4]);
130 const int z2 = 7* block[offset+stride*1] - 17*block[offset+stride*5];
131 const int z3 = 17* block[offset+stride*1] + 7*block[offset+stride*5];
132
133 temp[4*i+0] = z0+z3;
134 temp[4*i+1] = z1+z2;
135 temp[4*i+2] = z1-z2;
136 temp[4*i+3] = z0-z3;
137 }
138
139 for (i = 0; i < 4; i++){
140 const int offset = x_offset[i];
141 const int z0 = 13*(temp[4*0+i] + temp[4*2+i]);
142 const int z1 = 13*(temp[4*0+i] - temp[4*2+i]);
143 const int z2 = 7* temp[4*1+i] - 17*temp[4*3+i];
144 const int z3 = 17* temp[4*1+i] + 7*temp[4*3+i];
145
146 block[stride*0 +offset] = ((z0 + z3)*qmul + 0x80000) >> 20;
147 block[stride*2 +offset] = ((z1 + z2)*qmul + 0x80000) >> 20;
148 block[stride*8 +offset] = ((z1 - z2)*qmul + 0x80000) >> 20;
149 block[stride*10+offset] = ((z0 - z3)*qmul + 0x80000) >> 20;
150 }
151 }
152 #undef stride
153
154 static void svq3_add_idct_c(uint8_t *dst, DCTELEM *block, int stride, int qp,
155 int dc)
156 {
157 const int qmul = svq3_dequant_coeff[qp];
158 int i;
159 uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
160
161 if (dc) {
162 dc = 13*13*((dc == 1) ? 1538*block[0] : ((qmul*(block[0] >> 3)) / 2));
163 block[0] = 0;
164 }
165
166 for (i = 0; i < 4; i++) {
167 const int z0 = 13*(block[0 + 4*i] + block[2 + 4*i]);
168 const int z1 = 13*(block[0 + 4*i] - block[2 + 4*i]);
169 const int z2 = 7* block[1 + 4*i] - 17*block[3 + 4*i];
170 const int z3 = 17* block[1 + 4*i] + 7*block[3 + 4*i];
171
172 block[0 + 4*i] = z0 + z3;
173 block[1 + 4*i] = z1 + z2;
174 block[2 + 4*i] = z1 - z2;
175 block[3 + 4*i] = z0 - z3;
176 }
177
178 for (i = 0; i < 4; i++) {
179 const int z0 = 13*(block[i + 4*0] + block[i + 4*2]);
180 const int z1 = 13*(block[i + 4*0] - block[i + 4*2]);
181 const int z2 = 7* block[i + 4*1] - 17*block[i + 4*3];
182 const int z3 = 17* block[i + 4*1] + 7*block[i + 4*3];
183 const int rr = (dc + 0x80000);
184
185 dst[i + stride*0] = cm[ dst[i + stride*0] + (((z0 + z3)*qmul + rr) >> 20) ];
186 dst[i + stride*1] = cm[ dst[i + stride*1] + (((z1 + z2)*qmul + rr) >> 20) ];
187 dst[i + stride*2] = cm[ dst[i + stride*2] + (((z1 - z2)*qmul + rr) >> 20) ];
188 dst[i + stride*3] = cm[ dst[i + stride*3] + (((z0 - z3)*qmul + rr) >> 20) ];
189 }
190 }
191
192 static inline int svq3_decode_block(GetBitContext *gb, DCTELEM *block,
193 int index, const int type)
194 {
195 static const uint8_t *const scan_patterns[4] =
196 { luma_dc_zigzag_scan, zigzag_scan, svq3_scan, chroma_dc_scan };
197
198 int run, level, sign, vlc, limit;
199 const int intra = (3 * type) >> 2;
200 const uint8_t *const scan = scan_patterns[type];
201
202 for (limit = (16 >> intra); index < 16; index = limit, limit += 8) {
203 for (; (vlc = svq3_get_ue_golomb(gb)) != 0; index++) {
204
205 if (vlc == INVALID_VLC)
206 return -1;
207
208 sign = (vlc & 0x1) - 1;
209 vlc = (vlc + 1) >> 1;
210
211 if (type == 3) {
212 if (vlc < 3) {
213 run = 0;
214 level = vlc;
215 } else if (vlc < 4) {
216 run = 1;
217 level = 1;
218 } else {
219 run = (vlc & 0x3);
220 level = ((vlc + 9) >> 2) - run;
221 }
222 } else {
223 if (vlc < 16) {
224 run = svq3_dct_tables[intra][vlc].run;
225 level = svq3_dct_tables[intra][vlc].level;
226 } else if (intra) {
227 run = (vlc & 0x7);
228 level = (vlc >> 3) + ((run == 0) ? 8 : ((run < 2) ? 2 : ((run < 5) ? 0 : -1)));
229 } else {
230 run = (vlc & 0xF);
231 level = (vlc >> 4) + ((run == 0) ? 4 : ((run < 3) ? 2 : ((run < 10) ? 1 : 0)));
232 }
233 }
234
235 if ((index += run) >= limit)
236 return -1;
237
238 block[scan[index]] = (level ^ sign) - sign;
239 }
240
241 if (type != 2) {
242 break;
243 }
244 }
245
246 return 0;
247 }
248
249 static inline void svq3_mc_dir_part(MpegEncContext *s,
250 int x, int y, int width, int height,
251 int mx, int my, int dxy,
252 int thirdpel, int dir, int avg)
253 {
254 const Picture *pic = (dir == 0) ? &s->last_picture : &s->next_picture;
255 uint8_t *src, *dest;
256 int i, emu = 0;
257 int blocksize = 2 - (width>>3); //16->0, 8->1, 4->2
258
259 mx += x;
260 my += y;
261
262 if (mx < 0 || mx >= (s->h_edge_pos - width - 1) ||
263 my < 0 || my >= (s->v_edge_pos - height - 1)) {
264
265 if ((s->flags & CODEC_FLAG_EMU_EDGE)) {
266 emu = 1;
267 }
268
269 mx = av_clip (mx, -16, (s->h_edge_pos - width + 15));
270 my = av_clip (my, -16, (s->v_edge_pos - height + 15));
271 }
272
273 /* form component predictions */
274 dest = s->current_picture.data[0] + x + y*s->linesize;
275 src = pic->data[0] + mx + my*s->linesize;
276
277 if (emu) {
278 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, (width + 1), (height + 1),
279 mx, my, s->h_edge_pos, s->v_edge_pos);
280 src = s->edge_emu_buffer;
281 }
282 if (thirdpel)
283 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->linesize, width, height);
284 else
285 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->linesize, height);
286
287 if (!(s->flags & CODEC_FLAG_GRAY)) {
288 mx = (mx + (mx < (int) x)) >> 1;
289 my = (my + (my < (int) y)) >> 1;
290 width = (width >> 1);
291 height = (height >> 1);
292 blocksize++;
293
294 for (i = 1; i < 3; i++) {
295 dest = s->current_picture.data[i] + (x >> 1) + (y >> 1)*s->uvlinesize;
296 src = pic->data[i] + mx + my*s->uvlinesize;
297
298 if (emu) {
299 ff_emulated_edge_mc(s->edge_emu_buffer, src, s->uvlinesize, (width + 1), (height + 1),
300 mx, my, (s->h_edge_pos >> 1), (s->v_edge_pos >> 1));
301 src = s->edge_emu_buffer;
302 }
303 if (thirdpel)
304 (avg ? s->dsp.avg_tpel_pixels_tab : s->dsp.put_tpel_pixels_tab)[dxy](dest, src, s->uvlinesize, width, height);
305 else
306 (avg ? s->dsp.avg_pixels_tab : s->dsp.put_pixels_tab)[blocksize][dxy](dest, src, s->uvlinesize, height);
307 }
308 }
309 }
310
311 static inline int svq3_mc_dir(H264Context *h, int size, int mode, int dir,
312 int avg)
313 {
314 int i, j, k, mx, my, dx, dy, x, y;
315 MpegEncContext *const s = (MpegEncContext *) h;
316 const int part_width = ((size & 5) == 4) ? 4 : 16 >> (size & 1);
317 const int part_height = 16 >> ((unsigned) (size + 1) / 3);
318 const int extra_width = (mode == PREDICT_MODE) ? -16*6 : 0;
319 const int h_edge_pos = 6*(s->h_edge_pos - part_width ) - extra_width;
320 const int v_edge_pos = 6*(s->v_edge_pos - part_height) - extra_width;
321
322 for (i = 0; i < 16; i += part_height) {
323 for (j = 0; j < 16; j += part_width) {
324 const int b_xy = (4*s->mb_x + (j >> 2)) + (4*s->mb_y + (i >> 2))*h->b_stride;
325 int dxy;
326 x = 16*s->mb_x + j;
327 y = 16*s->mb_y + i;
328 k = ((j >> 2) & 1) + ((i >> 1) & 2) + ((j >> 1) & 4) + (i & 8);
329
330 if (mode != PREDICT_MODE) {
331 pred_motion(h, k, (part_width >> 2), dir, 1, &mx, &my);
332 } else {
333 mx = s->next_picture.motion_val[0][b_xy][0]<<1;
334 my = s->next_picture.motion_val[0][b_xy][1]<<1;
335
336 if (dir == 0) {
337 mx = ((mx * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
338 my = ((my * h->frame_num_offset) / h->prev_frame_num_offset + 1) >> 1;
339 } else {
340 mx = ((mx * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
341 my = ((my * (h->frame_num_offset - h->prev_frame_num_offset)) / h->prev_frame_num_offset + 1) >> 1;
342 }
343 }
344
345 /* clip motion vector prediction to frame border */
346 mx = av_clip(mx, extra_width - 6*x, h_edge_pos - 6*x);
347 my = av_clip(my, extra_width - 6*y, v_edge_pos - 6*y);
348
349 /* get (optional) motion vector differential */
350 if (mode == PREDICT_MODE) {
351 dx = dy = 0;
352 } else {
353 dy = svq3_get_se_golomb(&s->gb);
354 dx = svq3_get_se_golomb(&s->gb);
355
356 if (dx == INVALID_VLC || dy == INVALID_VLC) {
357 av_log(h->s.avctx, AV_LOG_ERROR, "invalid MV vlc\n");
358 return -1;
359 }
360 }
361
362 /* compute motion vector */
363 if (mode == THIRDPEL_MODE) {
364 int fx, fy;
365 mx = ((mx + 1)>>1) + dx;
366 my = ((my + 1)>>1) + dy;
367 fx = ((unsigned)(mx + 0x3000))/3 - 0x1000;
368 fy = ((unsigned)(my + 0x3000))/3 - 0x1000;
369 dxy = (mx - 3*fx) + 4*(my - 3*fy);
370
371 svq3_mc_dir_part(s, x, y, part_width, part_height, fx, fy, dxy, 1, dir, avg);
372 mx += mx;
373 my += my;
374 } else if (mode == HALFPEL_MODE || mode == PREDICT_MODE) {
375 mx = ((unsigned)(mx + 1 + 0x3000))/3 + dx - 0x1000;
376 my = ((unsigned)(my + 1 + 0x3000))/3 + dy - 0x1000;
377 dxy = (mx&1) + 2*(my&1);
378
379 svq3_mc_dir_part(s, x, y, part_width, part_height, mx>>1, my>>1, dxy, 0, dir, avg);
380 mx *= 3;
381 my *= 3;
382 } else {
383 mx = ((unsigned)(mx + 3 + 0x6000))/6 + dx - 0x1000;
384 my = ((unsigned)(my + 3 + 0x6000))/6 + dy - 0x1000;
385
386 svq3_mc_dir_part(s, x, y, part_width, part_height, mx, my, 0, 0, dir, avg);
387 mx *= 6;
388 my *= 6;
389 }
390
391 /* update mv_cache */
392 if (mode != PREDICT_MODE) {
393 int32_t mv = pack16to32(mx,my);
394
395 if (part_height == 8 && i < 8) {
396 *(int32_t *) h->mv_cache[dir][scan8[k] + 1*8] = mv;
397
398 if (part_width == 8 && j < 8) {
399 *(int32_t *) h->mv_cache[dir][scan8[k] + 1 + 1*8] = mv;
400 }
401 }
402 if (part_width == 8 && j < 8) {
403 *(int32_t *) h->mv_cache[dir][scan8[k] + 1] = mv;
404 }
405 if (part_width == 4 || part_height == 4) {
406 *(int32_t *) h->mv_cache[dir][scan8[k]] = mv;
407 }
408 }
409
410 /* write back motion vectors */
411 fill_rectangle(s->current_picture.motion_val[dir][b_xy], part_width>>2, part_height>>2, h->b_stride, pack16to32(mx,my), 4);
412 }
413 }
414
415 return 0;
416 }
417
418 static int svq3_decode_mb(H264Context *h, unsigned int mb_type)
419 {
420 int i, j, k, m, dir, mode;
421 int cbp = 0;
422 uint32_t vlc;
423 int8_t *top, *left;
424 MpegEncContext *const s = (MpegEncContext *) h;
425 const int mb_xy = h->mb_xy;
426 const int b_xy = 4*s->mb_x + 4*s->mb_y*h->b_stride;
427
428 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
429 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
430 h->topright_samples_available = 0xFFFF;
431
432 if (mb_type == 0) { /* SKIP */
433 if (s->pict_type == FF_P_TYPE || s->next_picture.mb_type[mb_xy] == -1) {
434 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 0, 0);
435
436 if (s->pict_type == FF_B_TYPE) {
437 svq3_mc_dir_part(s, 16*s->mb_x, 16*s->mb_y, 16, 16, 0, 0, 0, 0, 1, 1);
438 }
439
440 mb_type = MB_TYPE_SKIP;
441 } else {
442 mb_type = FFMIN(s->next_picture.mb_type[mb_xy], 6);
443 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 0, 0) < 0)
444 return -1;
445 if (svq3_mc_dir(h, mb_type, PREDICT_MODE, 1, 1) < 0)
446 return -1;
447
448 mb_type = MB_TYPE_16x16;
449 }
450 } else if (mb_type < 8) { /* INTER */
451 if (h->thirdpel_flag && h->halfpel_flag == !get_bits1 (&s->gb)) {
452 mode = THIRDPEL_MODE;
453 } else if (h->halfpel_flag && h->thirdpel_flag == !get_bits1 (&s->gb)) {
454 mode = HALFPEL_MODE;
455 } else {
456 mode = FULLPEL_MODE;
457 }
458
459 /* fill caches */
460 /* note ref_cache should contain here:
461 ????????
462 ???11111
463 N??11111
464 N??11111
465 N??11111
466 */
467
468 for (m = 0; m < 2; m++) {
469 if (s->mb_x > 0 && h->intra4x4_pred_mode[mb_xy - 1][0] != -1) {
470 for (i = 0; i < 4; i++) {
471 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - 1 + i*h->b_stride];
472 }
473 } else {
474 for (i = 0; i < 4; i++) {
475 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 + i*8] = 0;
476 }
477 }
478 if (s->mb_y > 0) {
479 memcpy(h->mv_cache[m][scan8[0] - 1*8], s->current_picture.motion_val[m][b_xy - h->b_stride], 4*2*sizeof(int16_t));
480 memset(&h->ref_cache[m][scan8[0] - 1*8], (h->intra4x4_pred_mode[mb_xy - s->mb_stride][4] == -1) ? PART_NOT_AVAILABLE : 1, 4);
481
482 if (s->mb_x < (s->mb_width - 1)) {
483 *(uint32_t *) h->mv_cache[m][scan8[0] + 4 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride + 4];
484 h->ref_cache[m][scan8[0] + 4 - 1*8] =
485 (h->intra4x4_pred_mode[mb_xy - s->mb_stride + 1][0] == -1 ||
486 h->intra4x4_pred_mode[mb_xy - s->mb_stride ][4] == -1) ? PART_NOT_AVAILABLE : 1;
487 }else
488 h->ref_cache[m][scan8[0] + 4 - 1*8] = PART_NOT_AVAILABLE;
489 if (s->mb_x > 0) {
490 *(uint32_t *) h->mv_cache[m][scan8[0] - 1 - 1*8] = *(uint32_t *) s->current_picture.motion_val[m][b_xy - h->b_stride - 1];
491 h->ref_cache[m][scan8[0] - 1 - 1*8] = (h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] == -1) ? PART_NOT_AVAILABLE : 1;
492 }else
493 h->ref_cache[m][scan8[0] - 1 - 1*8] = PART_NOT_AVAILABLE;
494 }else
495 memset(&h->ref_cache[m][scan8[0] - 1*8 - 1], PART_NOT_AVAILABLE, 8);
496
497 if (s->pict_type != FF_B_TYPE)
498 break;
499 }
500
501 /* decode motion vector(s) and form prediction(s) */
502 if (s->pict_type == FF_P_TYPE) {
503 if (svq3_mc_dir(h, (mb_type - 1), mode, 0, 0) < 0)
504 return -1;
505 } else { /* FF_B_TYPE */
506 if (mb_type != 2) {
507 if (svq3_mc_dir(h, 0, mode, 0, 0) < 0)
508 return -1;
509 } else {
510 for (i = 0; i < 4; i++) {
511 memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
512 }
513 }
514 if (mb_type != 1) {
515 if (svq3_mc_dir(h, 0, mode, 1, (mb_type == 3)) < 0)
516 return -1;
517 } else {
518 for (i = 0; i < 4; i++) {
519 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
520 }
521 }
522 }
523
524 mb_type = MB_TYPE_16x16;
525 } else if (mb_type == 8 || mb_type == 33) { /* INTRA4x4 */
526 memset(h->intra4x4_pred_mode_cache, -1, 8*5*sizeof(int8_t));
527
528 if (mb_type == 8) {
529 if (s->mb_x > 0) {
530 for (i = 0; i < 4; i++) {
531 h->intra4x4_pred_mode_cache[scan8[0] - 1 + i*8] = h->intra4x4_pred_mode[mb_xy - 1][i];
532 }
533 if (h->intra4x4_pred_mode_cache[scan8[0] - 1] == -1) {
534 h->left_samples_available = 0x5F5F;
535 }
536 }
537 if (s->mb_y > 0) {
538 h->intra4x4_pred_mode_cache[4+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][4];
539 h->intra4x4_pred_mode_cache[5+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][5];
540 h->intra4x4_pred_mode_cache[6+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][6];
541 h->intra4x4_pred_mode_cache[7+8*0] = h->intra4x4_pred_mode[mb_xy - s->mb_stride][3];
542
543 if (h->intra4x4_pred_mode_cache[4+8*0] == -1) {
544 h->top_samples_available = 0x33FF;
545 }
546 }
547
548 /* decode prediction codes for luma blocks */
549 for (i = 0; i < 16; i+=2) {
550 vlc = svq3_get_ue_golomb(&s->gb);
551
552 if (vlc >= 25){
553 av_log(h->s.avctx, AV_LOG_ERROR, "luma prediction:%d\n", vlc);
554 return -1;
555 }
556
557 left = &h->intra4x4_pred_mode_cache[scan8[i] - 1];
558 top = &h->intra4x4_pred_mode_cache[scan8[i] - 8];
559
560 left[1] = svq3_pred_1[top[0] + 1][left[0] + 1][svq3_pred_0[vlc][0]];
561 left[2] = svq3_pred_1[top[1] + 1][left[1] + 1][svq3_pred_0[vlc][1]];
562
563 if (left[1] == -1 || left[2] == -1){
564 av_log(h->s.avctx, AV_LOG_ERROR, "weird prediction\n");
565 return -1;
566 }
567 }
568 } else { /* mb_type == 33, DC_128_PRED block type */
569 for (i = 0; i < 4; i++) {
570 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_PRED, 4);
571 }
572 }
573
574 write_back_intra_pred_mode(h);
575
576 if (mb_type == 8) {
577 check_intra4x4_pred_mode(h);
578
579 h->top_samples_available = (s->mb_y == 0) ? 0x33FF : 0xFFFF;
580 h->left_samples_available = (s->mb_x == 0) ? 0x5F5F : 0xFFFF;
581 } else {
582 for (i = 0; i < 4; i++) {
583 memset(&h->intra4x4_pred_mode_cache[scan8[0] + 8*i], DC_128_PRED, 4);
584 }
585
586 h->top_samples_available = 0x33FF;
587 h->left_samples_available = 0x5F5F;
588 }
589
590 mb_type = MB_TYPE_INTRA4x4;
591 } else { /* INTRA16x16 */
592 dir = i_mb_type_info[mb_type - 8].pred_mode;
593 dir = (dir >> 1) ^ 3*(dir & 1) ^ 1;
594
595 if ((h->intra16x16_pred_mode = check_intra_pred_mode(h, dir)) == -1){
596 av_log(h->s.avctx, AV_LOG_ERROR, "check_intra_pred_mode = -1\n");
597 return -1;
598 }
599
600 cbp = i_mb_type_info[mb_type - 8].cbp;
601 mb_type = MB_TYPE_INTRA16x16;
602 }
603
604 if (!IS_INTER(mb_type) && s->pict_type != FF_I_TYPE) {
605 for (i = 0; i < 4; i++) {
606 memset(s->current_picture.motion_val[0][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
607 }
608 if (s->pict_type == FF_B_TYPE) {
609 for (i = 0; i < 4; i++) {
610 memset(s->current_picture.motion_val[1][b_xy + i*h->b_stride], 0, 4*2*sizeof(int16_t));
611 }
612 }
613 }
614 if (!IS_INTRA4x4(mb_type)) {
615 memset(h->intra4x4_pred_mode[mb_xy], DC_PRED, 8);
616 }
617 if (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE) {
618 memset(h->non_zero_count_cache + 8, 0, 4*9*sizeof(uint8_t));
619 s->dsp.clear_blocks(h->mb);
620 }
621
622 if (!IS_INTRA16x16(mb_type) && (!IS_SKIP(mb_type) || s->pict_type == FF_B_TYPE)) {
623 if ((vlc = svq3_get_ue_golomb(&s->gb)) >= 48){
624 av_log(h->s.avctx, AV_LOG_ERROR, "cbp_vlc=%d\n", vlc);
625 return -1;
626 }
627
628 cbp = IS_INTRA(mb_type) ? golomb_to_intra4x4_cbp[vlc] : golomb_to_inter_cbp[vlc];
629 }
630 if (IS_INTRA16x16(mb_type) || (s->pict_type != FF_I_TYPE && s->adaptive_quant && cbp)) {
631 s->qscale += svq3_get_se_golomb(&s->gb);
632
633 if (s->qscale > 31){
634 av_log(h->s.avctx, AV_LOG_ERROR, "qscale:%d\n", s->qscale);
635 return -1;
636 }
637 }
638 if (IS_INTRA16x16(mb_type)) {
639 if (svq3_decode_block(&s->gb, h->mb, 0, 0)){
640 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding intra luma dc\n");
641 return -1;
642 }
643 }
644
645 if (cbp) {
646 const int index = IS_INTRA16x16(mb_type) ? 1 : 0;
647 const int type = ((s->qscale < 24 && IS_INTRA4x4(mb_type)) ? 2 : 1);
648
649 for (i = 0; i < 4; i++) {
650 if ((cbp & (1 << i))) {
651 for (j = 0; j < 4; j++) {
652 k = index ? ((j&1) + 2*(i&1) + 2*(j&2) + 4*(i&2)) : (4*i + j);
653 h->non_zero_count_cache[ scan8[k] ] = 1;
654
655 if (svq3_decode_block(&s->gb, &h->mb[16*k], index, type)){
656 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding block\n");
657 return -1;
658 }
659 }
660 }
661 }
662
663 if ((cbp & 0x30)) {
664 for (i = 0; i < 2; ++i) {
665 if (svq3_decode_block(&s->gb, &h->mb[16*(16 + 4*i)], 0, 3)){
666 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma dc block\n");
667 return -1;
668 }
669 }
670
671 if ((cbp & 0x20)) {
672 for (i = 0; i < 8; i++) {
673 h->non_zero_count_cache[ scan8[16+i] ] = 1;
674
675 if (svq3_decode_block(&s->gb, &h->mb[16*(16 + i)], 1, 1)){
676 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding chroma ac block\n");
677 return -1;
678 }
679 }
680 }
681 }
682 }
683
684 h->cbp= cbp;
685 s->current_picture.mb_type[mb_xy] = mb_type;
686
687 if (IS_INTRA(mb_type)) {
688 h->chroma_pred_mode = check_intra_pred_mode(h, DC_PRED8x8);
689 }
690
691 return 0;
692 }
693
694 static int svq3_decode_slice_header(H264Context *h)
695 {
696 MpegEncContext *const s = (MpegEncContext *) h;
697 const int mb_xy = h->mb_xy;
698 int i, header;
699
700 header = get_bits(&s->gb, 8);
701
702 if (((header & 0x9F) != 1 && (header & 0x9F) != 2) || (header & 0x60) == 0) {
703 /* TODO: what? */
704 av_log(h->s.avctx, AV_LOG_ERROR, "unsupported slice header (%02X)\n", header);
705 return -1;
706 } else {
707 int length = (header >> 5) & 3;
708
709 h->next_slice_index = get_bits_count(&s->gb) + 8*show_bits(&s->gb, 8*length) + 8*length;
710
711 if (h->next_slice_index > s->gb.size_in_bits) {
712 av_log(h->s.avctx, AV_LOG_ERROR, "slice after bitstream end\n");
713 return -1;
714 }
715
716 s->gb.size_in_bits = h->next_slice_index - 8*(length - 1);
717 skip_bits(&s->gb, 8);
718
719 if (h->svq3_watermark_key) {
720 uint32_t header = AV_RL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1]);
721 AV_WL32(&s->gb.buffer[(get_bits_count(&s->gb)>>3)+1], header ^ h->svq3_watermark_key);
722 }
723 if (length > 0) {
724 memcpy((uint8_t *) &s->gb.buffer[get_bits_count(&s->gb) >> 3],
725 &s->gb.buffer[s->gb.size_in_bits >> 3], (length - 1));
726 }
727 skip_bits_long(&s->gb, 0);
728 }
729
730 if ((i = svq3_get_ue_golomb(&s->gb)) == INVALID_VLC || i >= 3){
731 av_log(h->s.avctx, AV_LOG_ERROR, "illegal slice type %d \n", i);
732 return -1;
733 }
734
735 h->slice_type = golomb_to_pict_type[i];
736
737 if ((header & 0x9F) == 2) {
738 i = (s->mb_num < 64) ? 6 : (1 + av_log2 (s->mb_num - 1));
739 s->mb_skip_run = get_bits(&s->gb, i) - (s->mb_x + (s->mb_y * s->mb_width));
740 } else {
741 skip_bits1(&s->gb);
742 s->mb_skip_run = 0;
743 }
744
745 h->slice_num = get_bits(&s->gb, 8);
746 s->qscale = get_bits(&s->gb, 5);
747 s->adaptive_quant = get_bits1(&s->gb);
748
749 /* unknown fields */
750 skip_bits1(&s->gb);
751
752 if (h->unknown_svq3_flag) {
753 skip_bits1(&s->gb);
754 }
755
756 skip_bits1(&s->gb);
757 skip_bits(&s->gb, 2);
758
759 while (get_bits1(&s->gb)) {
760 skip_bits(&s->gb, 8);
761 }
762
763 /* reset intra predictors and invalidate motion vector references */
764 if (s->mb_x > 0) {
765 memset(h->intra4x4_pred_mode[mb_xy - 1], -1, 4*sizeof(int8_t));
766 memset(h->intra4x4_pred_mode[mb_xy - s->mb_x], -1, 8*sizeof(int8_t)*s->mb_x);
767 }
768 if (s->mb_y > 0) {
769 memset(h->intra4x4_pred_mode[mb_xy - s->mb_stride], -1, 8*sizeof(int8_t)*(s->mb_width - s->mb_x));
770
771 if (s->mb_x > 0) {
772 h->intra4x4_pred_mode[mb_xy - s->mb_stride - 1][3] = -1;
773 }
774 }
775
776 return 0;
777 }
778
779 static av_cold int svq3_decode_init(AVCodecContext *avctx)
780 {
781 MpegEncContext *const s = avctx->priv_data;
782 H264Context *const h = avctx->priv_data;
783 int m;
784 unsigned char *extradata;
785 unsigned int size;
786
787 if(avctx->thread_count > 1){
788 av_log(avctx, AV_LOG_ERROR, "SVQ3 does not support multithreaded decoding, patch welcome! (check latest SVN too)\n");
789 return -1;
790 }
791
792 if (decode_init(avctx) < 0)
793 return -1;
794
795 s->flags = avctx->flags;
796 s->flags2 = avctx->flags2;
797 s->unrestricted_mv = 1;
798 h->is_complex=1;
799
800 if (!s->context_initialized) {
801 s->width = avctx->width;
802 s->height = avctx->height;
803 h->halfpel_flag = 1;
804 h->thirdpel_flag = 1;
805 h->unknown_svq3_flag = 0;
806 h->chroma_qp[0] = h->chroma_qp[1] = 4;
807
808 if (MPV_common_init(s) < 0)
809 return -1;
810
811 h->b_stride = 4*s->mb_width;
812
813 alloc_tables(h);
814
815 /* prowl for the "SEQH" marker in the extradata */
816 extradata = (unsigned char *)avctx->extradata;
817 for (m = 0; m < avctx->extradata_size; m++) {
818 if (!memcmp(extradata, "SEQH", 4))
819 break;
820 extradata++;
821 }
822
823 /* if a match was found, parse the extra data */
824 if (extradata && !memcmp(extradata, "SEQH", 4)) {
825
826 GetBitContext gb;
827 int frame_size_code;
828
829 size = AV_RB32(&extradata[4]);
830 init_get_bits(&gb, extradata + 8, size*8);
831
832 /* 'frame size code' and optional 'width, height' */
833 frame_size_code = get_bits(&gb, 3);
834 switch (frame_size_code) {
835 case 0: avctx->width = 160; avctx->height = 120; break;
836 case 1: avctx->width = 128; avctx->height = 96; break;
837 case 2: avctx->width = 176; avctx->height = 144; break;
838 case 3: avctx->width = 352; avctx->height = 288; break;
839 case 4: avctx->width = 704; avctx->height = 576; break;
840 case 5: avctx->width = 240; avctx->height = 180; break;
841 case 6: avctx->width = 320; avctx->height = 240; break;
842 case 7:
843 avctx->width = get_bits(&gb, 12);
844 avctx->height = get_bits(&gb, 12);
845 break;
846 }
847
848 h->halfpel_flag = get_bits1(&gb);
849 h->thirdpel_flag = get_bits1(&gb);
850
851 /* unknown fields */
852 skip_bits1(&gb);
853 skip_bits1(&gb);
854 skip_bits1(&gb);
855 skip_bits1(&gb);
856
857 s->low_delay = get_bits1(&gb);
858
859 /* unknown field */
860 skip_bits1(&gb);
861
862 while (get_bits1(&gb)) {
863 skip_bits(&gb, 8);
864 }
865
866 h->unknown_svq3_flag = get_bits1(&gb);
867 avctx->has_b_frames = !s->low_delay;
868 if (h->unknown_svq3_flag) {
869 #if CONFIG_ZLIB
870 unsigned watermark_width = svq3_get_ue_golomb(&gb);
871 unsigned watermark_height = svq3_get_ue_golomb(&gb);
872 int u1 = svq3_get_ue_golomb(&gb);
873 int u2 = get_bits(&gb, 8);
874 int u3 = get_bits(&gb, 2);
875 int u4 = svq3_get_ue_golomb(&gb);
876 unsigned buf_len = watermark_width*watermark_height*4;
877 int offset = (get_bits_count(&gb)+7)>>3;
878 uint8_t *buf;
879
880 if ((uint64_t)watermark_width*4 > UINT_MAX/watermark_height)
881 return -1;
882
883 buf = av_malloc(buf_len);
884 av_log(avctx, AV_LOG_DEBUG, "watermark size: %dx%d\n", watermark_width, watermark_height);
885 av_log(avctx, AV_LOG_DEBUG, "u1: %x u2: %x u3: %x compressed data size: %d offset: %d\n", u1, u2, u3, u4, offset);
886 if (uncompress(buf, (uLong*)&buf_len, extradata + 8 + offset, size - offset) != Z_OK) {
887 av_log(avctx, AV_LOG_ERROR, "could not uncompress watermark logo\n");
888 av_free(buf);
889 return -1;
890 }
891 h->svq3_watermark_key = ff_svq1_packet_checksum(buf, buf_len, 0);
892 h->svq3_watermark_key = h->svq3_watermark_key << 16 | h->svq3_watermark_key;
893 av_log(avctx, AV_LOG_DEBUG, "watermark key %#x\n", h->svq3_watermark_key);
894 av_free(buf);
895 #else
896 av_log(avctx, AV_LOG_ERROR, "this svq3 file contains watermark which need zlib support compiled in\n");
897 return -1;
898 #endif
899 }
900 }
901 }
902
903 return 0;
904 }
905
906 static int svq3_decode_frame(AVCodecContext *avctx,
907 void *data, int *data_size,
908 AVPacket *avpkt)
909 {
910 const uint8_t *buf = avpkt->data;
911 int buf_size = avpkt->size;
912 MpegEncContext *const s = avctx->priv_data;
913 H264Context *const h = avctx->priv_data;
914 int m, mb_type;
915
916 /* special case for last picture */
917 if (buf_size == 0) {
918 if (s->next_picture_ptr && !s->low_delay) {
919 *(AVFrame *) data = *(AVFrame *) &s->next_picture;
920 s->next_picture_ptr = NULL;
921 *data_size = sizeof(AVFrame);
922 }
923 return 0;
924 }
925
926 init_get_bits (&s->gb, buf, 8*buf_size);
927
928 s->mb_x = s->mb_y = h->mb_xy = 0;
929
930 if (svq3_decode_slice_header(h))
931 return -1;
932
933 s->pict_type = h->slice_type;
934 s->picture_number = h->slice_num;
935
936 if (avctx->debug&FF_DEBUG_PICT_INFO){
937 av_log(h->s.avctx, AV_LOG_DEBUG, "%c hpel:%d, tpel:%d aqp:%d qp:%d, slice_num:%02X\n",
938 av_get_pict_type_char(s->pict_type), h->halfpel_flag, h->thirdpel_flag,
939 s->adaptive_quant, s->qscale, h->slice_num);
940 }
941
942 /* for hurry_up == 5 */
943 s->current_picture.pict_type = s->pict_type;
944 s->current_picture.key_frame = (s->pict_type == FF_I_TYPE);
945
946 /* Skip B-frames if we do not have reference frames. */
947 if (s->last_picture_ptr == NULL && s->pict_type == FF_B_TYPE)
948 return 0;
949 /* Skip B-frames if we are in a hurry. */
950 if (avctx->hurry_up && s->pict_type == FF_B_TYPE)
951 return 0;
952 /* Skip everything if we are in a hurry >= 5. */
953 if (avctx->hurry_up >= 5)
954 return 0;
955 if ( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
956 ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
957 || avctx->skip_frame >= AVDISCARD_ALL)
958 return 0;
959
960 if (s->next_p_frame_damaged) {
961 if (s->pict_type == FF_B_TYPE)
962 return 0;
963 else
964 s->next_p_frame_damaged = 0;
965 }
966
967 if (frame_start(h) < 0)
968 return -1;
969
970 if (s->pict_type == FF_B_TYPE) {
971 h->frame_num_offset = (h->slice_num - h->prev_frame_num);
972
973 if (h->frame_num_offset < 0) {
974 h->frame_num_offset += 256;
975 }
976 if (h->frame_num_offset == 0 || h->frame_num_offset >= h->prev_frame_num_offset) {
977 av_log(h->s.avctx, AV_LOG_ERROR, "error in B-frame picture id\n");
978 return -1;
979 }
980 } else {
981 h->prev_frame_num = h->frame_num;
982 h->frame_num = h->slice_num;
983 h->prev_frame_num_offset = (h->frame_num - h->prev_frame_num);
984
985 if (h->prev_frame_num_offset < 0) {
986 h->prev_frame_num_offset += 256;
987 }
988 }
989
990 for (m = 0; m < 2; m++){
991 int i;
992 for (i = 0; i < 4; i++){
993 int j;
994 for (j = -1; j < 4; j++)
995 h->ref_cache[m][scan8[0] + 8*i + j]= 1;
996 if (i < 3)
997 h->ref_cache[m][scan8[0] + 8*i + j]= PART_NOT_AVAILABLE;
998 }
999 }
1000
1001 for (s->mb_y = 0; s->mb_y < s->mb_height; s->mb_y++) {
1002 for (s->mb_x = 0; s->mb_x < s->mb_width; s->mb_x++) {
1003 h->mb_xy = s->mb_x + s->mb_y*s->mb_stride;
1004
1005 if ( (get_bits_count(&s->gb) + 7) >= s->gb.size_in_bits &&
1006 ((get_bits_count(&s->gb) & 7) == 0 || show_bits(&s->gb, (-get_bits_count(&s->gb) & 7)) == 0)) {
1007
1008 skip_bits(&s->gb, h->next_slice_index - get_bits_count(&s->gb));
1009 s->gb.size_in_bits = 8*buf_size;
1010
1011 if (svq3_decode_slice_header(h))
1012 return -1;
1013
1014 /* TODO: support s->mb_skip_run */
1015 }
1016
1017 mb_type = svq3_get_ue_golomb(&s->gb);
1018
1019 if (s->pict_type == FF_I_TYPE) {
1020 mb_type += 8;
1021 } else if (s->pict_type == FF_B_TYPE && mb_type >= 4) {
1022 mb_type += 4;
1023 }
1024 if (mb_type > 33 || svq3_decode_mb(h, mb_type)) {
1025 av_log(h->s.avctx, AV_LOG_ERROR, "error while decoding MB %d %d\n", s->mb_x, s->mb_y);
1026 return -1;
1027 }
1028
1029 if (mb_type != 0) {
1030 hl_decode_mb (h);
1031 }
1032
1033 if (s->pict_type != FF_B_TYPE && !s->low_delay) {
1034 s->current_picture.mb_type[s->mb_x + s->mb_y*s->mb_stride] =
1035 (s->pict_type == FF_P_TYPE && mb_type < 8) ? (mb_type - 1) : -1;
1036 }
1037 }
1038
1039 ff_draw_horiz_band(s, 16*s->mb_y, 16);
1040 }
1041
1042 MPV_frame_end(s);
1043
1044 if (s->pict_type == FF_B_TYPE || s->low_delay) {
1045 *(AVFrame *) data = *(AVFrame *) &s->current_picture;
1046 } else {
1047 *(AVFrame *) data = *(AVFrame *) &s->last_picture;
1048 }
1049
1050 /* Do not output the last pic after seeking. */
1051 if (s->last_picture_ptr || s->low_delay) {
1052 *data_size = sizeof(AVFrame);
1053 }
1054
1055 return buf_size;
1056 }
1057
1058
1059 AVCodec svq3_decoder = {
1060 "svq3",
1061 CODEC_TYPE_VIDEO,
1062 CODEC_ID_SVQ3,
1063 sizeof(H264Context),
1064 svq3_decode_init,
1065 NULL,
1066 decode_end,
1067 svq3_decode_frame,
1068 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1 | CODEC_CAP_DELAY,
1069 .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 3"),
1070 .pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_NONE},
1071 };
ffmpeg Lagarith lossless decoder