Correct few "ffmpeg" typos
[ffmpeg.git] / libavcodec / svq1dec.c
1 /*
2  * SVQ1 decoder
3  * ported to MPlayer by Arpi <arpi@thot.banki.hu>
4  * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
5  *
6  * Copyright (c) 2002 The Xine Project
7  * Copyright (c) 2002 The FFmpeg Project
8  *
9  * SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
10  *
11  * This file is part of FFmpeg.
12  *
13  * FFmpeg is free software; you can redistribute it and/or
14  * modify it under the terms of the GNU Lesser General Public
15  * License as published by the Free Software Foundation; either
16  * version 2.1 of the License, or (at your option) any later version.
17  *
18  * FFmpeg is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
21  * Lesser General Public License for more details.
22  *
23  * You should have received a copy of the GNU Lesser General Public
24  * License along with FFmpeg; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
26  */
27
28 /**
29  * @file
30  * Sorenson Vector Quantizer #1 (SVQ1) video codec.
31  * For more information of the SVQ1 algorithm, visit:
32  *   http://www.pcisys.net/~melanson/codecs/
33  */
34
35 #include "avcodec.h"
36 #include "get_bits.h"
37 #include "h263.h"
38 #include "hpeldsp.h"
39 #include "internal.h"
40 #include "mathops.h"
41 #include "svq1.h"
42
43 #undef NDEBUG
44 #include <assert.h>
45
46 static VLC svq1_block_type;
47 static VLC svq1_motion_component;
48 static VLC svq1_intra_multistage[6];
49 static VLC svq1_inter_multistage[6];
50 static VLC svq1_intra_mean;
51 static VLC svq1_inter_mean;
52
53 /* motion vector (prediction) */
54 typedef struct svq1_pmv_s {
55     int x;
56     int y;
57 } svq1_pmv;
58
59 typedef struct SVQ1Context {
60     HpelDSPContext hdsp;
61     GetBitContext gb;
62     AVFrame *prev;
63
64     uint8_t *pkt_swapped;
65     int pkt_swapped_allocated;
66
67     int width;
68     int height;
69     int frame_code;
70     int nonref;         // 1 if the current frame won't be referenced
71 } SVQ1Context;
72
73 static const uint8_t string_table[256] = {
74     0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
75     0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
76     0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
77     0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
78     0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
79     0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
80     0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
81     0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
82     0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
83     0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
84     0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
85     0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
86     0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
87     0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
88     0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
89     0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
90     0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
91     0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
92     0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
93     0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
94     0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
95     0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
96     0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
97     0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
98     0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
99     0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
100     0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
101     0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
102     0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
103     0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
104     0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
105     0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
106 };
107
108 #define SVQ1_PROCESS_VECTOR()                                           \
109     for (; level > 0; i++) {                                            \
110         /* process next depth */                                        \
111         if (i == m) {                                                   \
112             m = n;                                                      \
113             if (--level == 0)                                           \
114                 break;                                                  \
115         }                                                               \
116         /* divide block if next bit set */                              \
117         if (!get_bits1(bitbuf))                                         \
118             break;                                                      \
119         /* add child nodes */                                           \
120         list[n++] = list[i];                                            \
121         list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\
122     }
123
124 #define SVQ1_ADD_CODEBOOK()                                             \
125     /* add codebook entries to vector */                                \
126     for (j = 0; j < stages; j++) {                                      \
127         n3  = codebook[entries[j]] ^ 0x80808080;                        \
128         n1 += (n3 & 0xFF00FF00) >> 8;                                   \
129         n2 +=  n3 & 0x00FF00FF;                                         \
130     }                                                                   \
131                                                                         \
132     /* clip to [0..255] */                                              \
133     if (n1 & 0xFF00FF00) {                                              \
134         n3  = (n1 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
135         n1 += 0x7F007F00;                                               \
136         n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
137         n1 &= n3 & 0x00FF00FF;                                          \
138     }                                                                   \
139                                                                         \
140     if (n2 & 0xFF00FF00) {                                              \
141         n3  = (n2 >> 15  & 0x00010001 | 0x01000100) - 0x00010001;       \
142         n2 += 0x7F007F00;                                               \
143         n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001;       \
144         n2 &= n3 & 0x00FF00FF;                                          \
145     }
146
147 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)                               \
148     codebook = (const uint32_t *)cbook[level];                          \
149     if (stages > 0)                                                     \
150         bit_cache = get_bits(bitbuf, 4 * stages);                       \
151     /* calculate codebook entries for this vector */                    \
152     for (j = 0; j < stages; j++) {                                      \
153         entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) +   \
154                       16 * j) << (level + 1);                           \
155     }                                                                   \
156     mean -= stages * 128;                                               \
157     n4    = (mean << 16) + mean;
158
159 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
160                                    int pitch)
161 {
162     uint32_t bit_cache;
163     uint8_t *list[63];
164     uint32_t *dst;
165     const uint32_t *codebook;
166     int entries[6];
167     int i, j, m, n;
168     int mean, stages;
169     unsigned x, y, width, height, level;
170     uint32_t n1, n2, n3, n4;
171
172     /* initialize list for breadth first processing of vectors */
173     list[0] = pixels;
174
175     /* recursively process vector */
176     for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
177         SVQ1_PROCESS_VECTOR();
178
179         /* destination address and vector size */
180         dst    = (uint32_t *)list[i];
181         width  = 1 << ((4 + level) / 2);
182         height = 1 << ((3 + level) / 2);
183
184         /* get number of stages (-1 skips vector, 0 for mean only) */
185         stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
186
187         if (stages == -1) {
188             for (y = 0; y < height; y++)
189                 memset(&dst[y * (pitch / 4)], 0, width);
190             continue;   /* skip vector */
191         }
192
193         if (stages > 0 && level >= 4) {
194             av_dlog(NULL,
195                     "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",
196                     stages, level);
197             return AVERROR_INVALIDDATA;  /* invalid vector */
198         }
199
200         mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
201
202         if (stages == 0) {
203             for (y = 0; y < height; y++)
204                 memset(&dst[y * (pitch / 4)], mean, width);
205         } else {
206             SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
207
208             for (y = 0; y < height; y++) {
209                 for (x = 0; x < width / 4; x++, codebook++) {
210                     n1 = n4;
211                     n2 = n4;
212                     SVQ1_ADD_CODEBOOK()
213                     /* store result */
214                     dst[x] = n1 << 8 | n2;
215                 }
216                 dst += pitch / 4;
217             }
218         }
219     }
220
221     return 0;
222 }
223
224 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
225                                        int pitch)
226 {
227     uint32_t bit_cache;
228     uint8_t *list[63];
229     uint32_t *dst;
230     const uint32_t *codebook;
231     int entries[6];
232     int i, j, m, n;
233     int mean, stages;
234     int x, y, width, height, level;
235     uint32_t n1, n2, n3, n4;
236
237     /* initialize list for breadth first processing of vectors */
238     list[0] = pixels;
239
240     /* recursively process vector */
241     for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
242         SVQ1_PROCESS_VECTOR();
243
244         /* destination address and vector size */
245         dst    = (uint32_t *)list[i];
246         width  = 1 << ((4 + level) / 2);
247         height = 1 << ((3 + level) / 2);
248
249         /* get number of stages (-1 skips vector, 0 for mean only) */
250         stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
251
252         if (stages == -1)
253             continue;           /* skip vector */
254
255         if ((stages > 0) && (level >= 4)) {
256             av_dlog(NULL,
257                     "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",
258                     stages, level);
259             return AVERROR_INVALIDDATA;  /* invalid vector */
260         }
261
262         mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
263
264         SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);
265
266         for (y = 0; y < height; y++) {
267             for (x = 0; x < width / 4; x++, codebook++) {
268                 n3 = dst[x];
269                 /* add mean value to vector */
270                 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);
271                 n2 = n4 +  (n3 & 0x00FF00FF);
272                 SVQ1_ADD_CODEBOOK()
273                 /* store result */
274                 dst[x] = n1 << 8 | n2;
275             }
276             dst += pitch / 4;
277         }
278     }
279     return 0;
280 }
281
282 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
283                                      svq1_pmv **pmv)
284 {
285     int diff;
286     int i;
287
288     for (i = 0; i < 2; i++) {
289         /* get motion code */
290         diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
291         if (diff < 0)
292             return AVERROR_INVALIDDATA;
293         else if (diff) {
294             if (get_bits1(bitbuf))
295                 diff = -diff;
296         }
297
298         /* add median of motion vector predictors and clip result */
299         if (i == 1)
300             mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);
301         else
302             mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);
303     }
304
305     return 0;
306 }
307
308 static void svq1_skip_block(uint8_t *current, uint8_t *previous,
309                             int pitch, int x, int y)
310 {
311     uint8_t *src;
312     uint8_t *dst;
313     int i;
314
315     src = &previous[x + y * pitch];
316     dst = current;
317
318     for (i = 0; i < 16; i++) {
319         memcpy(dst, src, 16);
320         src += pitch;
321         dst += pitch;
322     }
323 }
324
325 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
326                                    uint8_t *current, uint8_t *previous,
327                                    int pitch, svq1_pmv *motion, int x, int y,
328                                    int width, int height)
329 {
330     uint8_t *src;
331     uint8_t *dst;
332     svq1_pmv mv;
333     svq1_pmv *pmv[3];
334     int result;
335
336     /* predict and decode motion vector */
337     pmv[0] = &motion[0];
338     if (y == 0) {
339         pmv[1] =
340         pmv[2] = pmv[0];
341     } else {
342         pmv[1] = &motion[x / 8 + 2];
343         pmv[2] = &motion[x / 8 + 4];
344     }
345
346     result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
347     if (result)
348         return result;
349
350     motion[0].x         =
351     motion[x / 8 + 2].x =
352     motion[x / 8 + 3].x = mv.x;
353     motion[0].y         =
354     motion[x / 8 + 2].y =
355     motion[x / 8 + 3].y = mv.y;
356
357     mv.x = av_clip(mv.x, -2 * x, 2 * (width  - x - 16));
358     mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));
359
360     src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
361     dst = current;
362
363     hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);
364
365     return 0;
366 }
367
368 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,
369                                       uint8_t *current, uint8_t *previous,
370                                       int pitch, svq1_pmv *motion, int x, int y,
371                                       int width, int height)
372 {
373     uint8_t *src;
374     uint8_t *dst;
375     svq1_pmv mv;
376     svq1_pmv *pmv[4];
377     int i, result;
378
379     /* predict and decode motion vector (0) */
380     pmv[0] = &motion[0];
381     if (y == 0) {
382         pmv[1] =
383         pmv[2] = pmv[0];
384     } else {
385         pmv[1] = &motion[(x / 8) + 2];
386         pmv[2] = &motion[(x / 8) + 4];
387     }
388
389     result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
390     if (result)
391         return result;
392
393     /* predict and decode motion vector (1) */
394     pmv[0] = &mv;
395     if (y == 0) {
396         pmv[1] =
397         pmv[2] = pmv[0];
398     } else {
399         pmv[1] = &motion[(x / 8) + 3];
400     }
401     result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
402     if (result)
403         return result;
404
405     /* predict and decode motion vector (2) */
406     pmv[1] = &motion[0];
407     pmv[2] = &motion[(x / 8) + 1];
408
409     result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
410     if (result)
411         return result;
412
413     /* predict and decode motion vector (3) */
414     pmv[2] = &motion[(x / 8) + 2];
415     pmv[3] = &motion[(x / 8) + 3];
416
417     result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
418     if (result)
419         return result;
420
421     /* form predictions */
422     for (i = 0; i < 4; i++) {
423         int mvx = pmv[i]->x + (i  & 1) * 16;
424         int mvy = pmv[i]->y + (i >> 1) * 16;
425
426         // FIXME: clipping or padding?
427         mvx = av_clip(mvx, -2 * x, 2 * (width  - x - 8));
428         mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));
429
430         src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
431         dst = current;
432
433         hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
434
435         /* select next block */
436         if (i & 1)
437             current += 8 * (pitch - 1);
438         else
439             current += 8;
440     }
441
442     return 0;
443 }
444
445 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,
446                                    GetBitContext *bitbuf,
447                                    uint8_t *current, uint8_t *previous,
448                                    int pitch, svq1_pmv *motion, int x, int y,
449                                    int width, int height)
450 {
451     uint32_t block_type;
452     int result = 0;
453
454     /* get block type */
455     block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
456
457     /* reset motion vectors */
458     if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
459         motion[0].x         =
460         motion[0].y         =
461         motion[x / 8 + 2].x =
462         motion[x / 8 + 2].y =
463         motion[x / 8 + 3].x =
464         motion[x / 8 + 3].y = 0;
465     }
466
467     switch (block_type) {
468     case SVQ1_BLOCK_SKIP:
469         svq1_skip_block(current, previous, pitch, x, y);
470         break;
471
472     case SVQ1_BLOCK_INTER:
473         result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,
474                                          pitch, motion, x, y, width, height);
475
476         if (result != 0) {
477             av_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);
478             break;
479         }
480         result = svq1_decode_block_non_intra(bitbuf, current, pitch);
481         break;
482
483     case SVQ1_BLOCK_INTER_4V:
484         result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,
485                                             pitch, motion, x, y, width, height);
486
487         if (result != 0) {
488             av_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);
489             break;
490         }
491         result = svq1_decode_block_non_intra(bitbuf, current, pitch);
492         break;
493
494     case SVQ1_BLOCK_INTRA:
495         result = svq1_decode_block_intra(bitbuf, current, pitch);
496         break;
497     }
498
499     return result;
500 }
501
502 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t *out)
503 {
504     uint8_t seed;
505     int i;
506
507     out[0] = get_bits(bitbuf, 8);
508     seed   = string_table[out[0]];
509
510     for (i = 1; i <= out[0]; i++) {
511         out[i] = get_bits(bitbuf, 8) ^ seed;
512         seed   = string_table[out[i] ^ seed];
513     }
514 }
515
516 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame)
517 {
518     SVQ1Context *s = avctx->priv_data;
519     GetBitContext *bitbuf = &s->gb;
520     int frame_size_code;
521     int width  = s->width;
522     int height = s->height;
523
524     skip_bits(bitbuf, 8); /* temporal_reference */
525
526     /* frame type */
527     s->nonref = 0;
528     switch (get_bits(bitbuf, 2)) {
529     case 0:
530         frame->pict_type = AV_PICTURE_TYPE_I;
531         break;
532     case 2:
533         s->nonref = 1;
534     case 1:
535         frame->pict_type = AV_PICTURE_TYPE_P;
536         break;
537     default:
538         av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");
539         return AVERROR_INVALIDDATA;
540     }
541
542     if (frame->pict_type == AV_PICTURE_TYPE_I) {
543         /* unknown fields */
544         if (s->frame_code == 0x50 || s->frame_code == 0x60) {
545             int csum = get_bits(bitbuf, 16);
546
547             csum = ff_svq1_packet_checksum(bitbuf->buffer,
548                                            bitbuf->size_in_bits >> 3,
549                                            csum);
550
551             av_dlog(avctx, "%s checksum (%02x) for packet data\n",
552                     (csum == 0) ? "correct" : "incorrect", csum);
553         }
554
555         if ((s->frame_code ^ 0x10) >= 0x50) {
556             uint8_t msg[256];
557
558             svq1_parse_string(bitbuf, msg);
559
560             av_log(avctx, AV_LOG_INFO,
561                    "embedded message:\n%s\n", (char *)msg);
562         }
563
564         skip_bits(bitbuf, 2);
565         skip_bits(bitbuf, 2);
566         skip_bits1(bitbuf);
567
568         /* load frame size */
569         frame_size_code = get_bits(bitbuf, 3);
570
571         if (frame_size_code == 7) {
572             /* load width, height (12 bits each) */
573             width  = get_bits(bitbuf, 12);
574             height = get_bits(bitbuf, 12);
575
576             if (!width || !height)
577                 return AVERROR_INVALIDDATA;
578         } else {
579             /* get width, height from table */
580             width  = ff_svq1_frame_size_table[frame_size_code][0];
581             height = ff_svq1_frame_size_table[frame_size_code][1];
582         }
583     }
584
585     /* unknown fields */
586     if (get_bits1(bitbuf)) {
587         skip_bits1(bitbuf);    /* use packet checksum if (1) */
588         skip_bits1(bitbuf);    /* component checksums after image data if (1) */
589
590         if (get_bits(bitbuf, 2) != 0)
591             return AVERROR_INVALIDDATA;
592     }
593
594     if (get_bits1(bitbuf)) {
595         skip_bits1(bitbuf);
596         skip_bits(bitbuf, 4);
597         skip_bits1(bitbuf);
598         skip_bits(bitbuf, 2);
599
600         if (skip_1stop_8data_bits(bitbuf) < 0)
601             return AVERROR_INVALIDDATA;
602     }
603
604     s->width  = width;
605     s->height = height;
606     return 0;
607 }
608
609 static int svq1_decode_frame(AVCodecContext *avctx, void *data,
610                              int *got_frame, AVPacket *avpkt)
611 {
612     const uint8_t *buf = avpkt->data;
613     int buf_size       = avpkt->size;
614     SVQ1Context     *s = avctx->priv_data;
615     AVFrame       *cur = data;
616     uint8_t *current;
617     int result, i, x, y, width, height;
618     svq1_pmv *pmv;
619
620     /* initialize bit buffer */
621     init_get_bits8(&s->gb, buf, buf_size);
622
623     /* decode frame header */
624     s->frame_code = get_bits(&s->gb, 22);
625
626     if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))
627         return AVERROR_INVALIDDATA;
628
629     /* swap some header bytes (why?) */
630     if (s->frame_code != 0x20) {
631         uint32_t *src;
632
633         if (buf_size < 9 * 4) {
634             av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");
635             return AVERROR_INVALIDDATA;
636         }
637
638         av_fast_padded_malloc(&s->pkt_swapped, &s->pkt_swapped_allocated,
639                        buf_size);
640         if (!s->pkt_swapped)
641             return AVERROR(ENOMEM);
642
643         memcpy(s->pkt_swapped, buf, buf_size);
644         buf = s->pkt_swapped;
645         init_get_bits(&s->gb, buf, buf_size * 8);
646         skip_bits(&s->gb, 22);
647
648         src = (uint32_t *)(s->pkt_swapped + 4);
649
650         if (buf_size < 36)
651             return AVERROR_INVALIDDATA;
652
653         for (i = 0; i < 4; i++)
654             src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
655     }
656
657     result = svq1_decode_frame_header(avctx, cur);
658     if (result != 0) {
659         av_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);
660         return result;
661     }
662
663     result = ff_set_dimensions(avctx, s->width, s->height);
664     if (result < 0)
665         return result;
666
667     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||
668         (avctx->skip_frame >= AVDISCARD_NONKEY &&
669          cur->pict_type != AV_PICTURE_TYPE_I) ||
670         avctx->skip_frame >= AVDISCARD_ALL)
671         return buf_size;
672
673     result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);
674     if (result < 0)
675         return result;
676
677     pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
678     if (!pmv)
679         return AVERROR(ENOMEM);
680
681     /* decode y, u and v components */
682     for (i = 0; i < 3; i++) {
683         int linesize = cur->linesize[i];
684         if (i == 0) {
685             width    = FFALIGN(s->width,  16);
686             height   = FFALIGN(s->height, 16);
687         } else {
688             if (avctx->flags & CODEC_FLAG_GRAY)
689                 break;
690             width    = FFALIGN(s->width  / 4, 16);
691             height   = FFALIGN(s->height / 4, 16);
692         }
693
694         current = cur->data[i];
695
696         if (cur->pict_type == AV_PICTURE_TYPE_I) {
697             /* keyframe */
698             for (y = 0; y < height; y += 16) {
699                 for (x = 0; x < width; x += 16) {
700                     result = svq1_decode_block_intra(&s->gb, &current[x],
701                                                      linesize);
702                     if (result) {
703                         av_log(avctx, AV_LOG_ERROR,
704                                "Error in svq1_decode_block %i (keyframe)\n",
705                                result);
706                         goto err;
707                     }
708                 }
709                 current += 16 * linesize;
710             }
711         } else {
712             /* delta frame */
713             uint8_t *previous = s->prev->data[i];
714             if (!previous ||
715                 s->prev->width != s->width || s->prev->height != s->height) {
716                 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
717                 result = AVERROR_INVALIDDATA;
718                 goto err;
719             }
720
721             memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
722
723             for (y = 0; y < height; y += 16) {
724                 for (x = 0; x < width; x += 16) {
725                     result = svq1_decode_delta_block(avctx, &s->hdsp,
726                                                      &s->gb, &current[x],
727                                                      previous, linesize,
728                                                      pmv, x, y, width, height);
729                     if (result != 0) {
730                         av_dlog(avctx,
731                                 "Error in svq1_decode_delta_block %i\n",
732                                 result);
733                         goto err;
734                     }
735                 }
736
737                 pmv[0].x     =
738                     pmv[0].y = 0;
739
740                 current += 16 * linesize;
741             }
742         }
743     }
744
745     if (!s->nonref) {
746         av_frame_unref(s->prev);
747         result = av_frame_ref(s->prev, cur);
748         if (result < 0)
749             goto err;
750     }
751
752     *got_frame = 1;
753     result     = buf_size;
754
755 err:
756     av_free(pmv);
757     return result;
758 }
759
760 static av_cold int svq1_decode_init(AVCodecContext *avctx)
761 {
762     SVQ1Context *s = avctx->priv_data;
763     int i;
764     int offset = 0;
765
766     s->prev = av_frame_alloc();
767     if (!s->prev)
768         return AVERROR(ENOMEM);
769
770     s->width            = avctx->width  + 3 & ~3;
771     s->height           = avctx->height + 3 & ~3;
772     avctx->pix_fmt      = AV_PIX_FMT_YUV410P;
773
774     ff_hpeldsp_init(&s->hdsp, avctx->flags);
775
776     INIT_VLC_STATIC(&svq1_block_type, 2, 4,
777                     &ff_svq1_block_type_vlc[0][1], 2, 1,
778                     &ff_svq1_block_type_vlc[0][0], 2, 1, 6);
779
780     INIT_VLC_STATIC(&svq1_motion_component, 7, 33,
781                     &ff_mvtab[0][1], 2, 1,
782                     &ff_mvtab[0][0], 2, 1, 176);
783
784     for (i = 0; i < 6; i++) {
785         static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
786                                              { 10, 10, 14, 14, 14, 16 } };
787         static VLC_TYPE table[168][2];
788         svq1_intra_multistage[i].table           = &table[offset];
789         svq1_intra_multistage[i].table_allocated = sizes[0][i];
790         offset                                  += sizes[0][i];
791         init_vlc(&svq1_intra_multistage[i], 3, 8,
792                  &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
793                  &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
794                  INIT_VLC_USE_NEW_STATIC);
795         svq1_inter_multistage[i].table           = &table[offset];
796         svq1_inter_multistage[i].table_allocated = sizes[1][i];
797         offset                                  += sizes[1][i];
798         init_vlc(&svq1_inter_multistage[i], 3, 8,
799                  &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
800                  &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
801                  INIT_VLC_USE_NEW_STATIC);
802     }
803
804     INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
805                     &ff_svq1_intra_mean_vlc[0][1], 4, 2,
806                     &ff_svq1_intra_mean_vlc[0][0], 4, 2, 632);
807
808     INIT_VLC_STATIC(&svq1_inter_mean, 9, 512,
809                     &ff_svq1_inter_mean_vlc[0][1], 4, 2,
810                     &ff_svq1_inter_mean_vlc[0][0], 4, 2, 1434);
811
812     return 0;
813 }
814
815 static av_cold int svq1_decode_end(AVCodecContext *avctx)
816 {
817     SVQ1Context *s = avctx->priv_data;
818
819     av_frame_free(&s->prev);
820     av_freep(&s->pkt_swapped);
821     s->pkt_swapped_allocated = 0;
822
823     return 0;
824 }
825
826 static void svq1_flush(AVCodecContext *avctx)
827 {
828     SVQ1Context *s = avctx->priv_data;
829
830     av_frame_unref(s->prev);
831 }
832
833 AVCodec ff_svq1_decoder = {
834     .name           = "svq1",
835     .long_name      = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
836     .type           = AVMEDIA_TYPE_VIDEO,
837     .id             = AV_CODEC_ID_SVQ1,
838     .priv_data_size = sizeof(SVQ1Context),
839     .init           = svq1_decode_init,
840     .close          = svq1_decode_end,
841     .decode         = svq1_decode_frame,
842     .capabilities   = CODEC_CAP_DR1,
843     .flush          = svq1_flush,
844     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV410P,
845                                                      AV_PIX_FMT_NONE },
846 };