33
32
* http://www.pcisys.net/~melanson/codecs/
47
#include "mpegvideo.h"
53
extern const uint8_t mvtab[33][2];
55
static VLC svq1_block_type;
56
static VLC svq1_motion_component;
57
static VLC svq1_intra_multistage[6];
58
static VLC svq1_inter_multistage[6];
59
static VLC svq1_intra_mean;
60
static VLC svq1_inter_mean;
62
#define SVQ1_BLOCK_SKIP 0
63
#define SVQ1_BLOCK_INTER 1
64
#define SVQ1_BLOCK_INTER_4V 2
65
#define SVQ1_BLOCK_INTRA 3
67
typedef struct SVQ1Context {
68
MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to make the motion estimation eventually independent of MpegEncContext, so this will be removed then (FIXME/XXX)
69
AVCodecContext *avctx;
72
AVFrame current_picture;
77
PutBitContext reorder_pb[6]; //why ooh why this sick breadth first order, everything is slower and more complex
82
/* Y plane block dimensions */
86
/* U & V plane (C planes) block dimensions */
92
int16_t (*motion_val8[3])[2];
93
int16_t (*motion_val16[3])[2];
98
/* motion vector (prediction) */
99
typedef struct svq1_pmv_s {
104
36
#include "svq1_cb.h"
105
37
#include "svq1_vlc.h"
107
static const uint16_t checksum_table[256] = {
108
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
109
0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
110
0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
111
0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
112
0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
113
0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
114
0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
115
0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
116
0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
117
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
118
0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
119
0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
120
0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
121
0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
122
0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
123
0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
124
0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
125
0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
126
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
127
0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
128
0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
129
0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
130
0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
131
0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
132
0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
133
0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
134
0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
135
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
136
0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
137
0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
138
0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
139
0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
142
static const uint8_t string_table[256] = {
143
0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
144
0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
145
0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
146
0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
147
0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
148
0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
149
0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
150
0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
151
0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
152
0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
153
0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
154
0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
155
0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
156
0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
157
0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
158
0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
159
0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
160
0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
161
0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
162
0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
163
0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
164
0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
165
0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
166
0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
167
0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
168
0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
169
0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
170
0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
171
0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
172
0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
173
0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
174
0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
177
#define SVQ1_PROCESS_VECTOR()\
178
for (; level > 0; i++) {\
179
/* process next depth */\
185
/* divide block if next bit set */\
186
if (get_bits (bitbuf, 1) == 0)\
188
/* add child nodes */\
189
list[n++] = list[i];\
190
list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
193
#define SVQ1_ADD_CODEBOOK()\
194
/* add codebook entries to vector */\
195
for (j=0; j < stages; j++) {\
196
n3 = codebook[entries[j]] ^ 0x80808080;\
197
n1 += ((n3 & 0xFF00FF00) >> 8);\
198
n2 += (n3 & 0x00FF00FF);\
201
/* clip to [0..255] */\
202
if (n1 & 0xFF00FF00) {\
203
n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
205
n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
206
n1 &= (n3 & 0x00FF00FF);\
209
if (n2 & 0xFF00FF00) {\
210
n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
212
n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
213
n2 &= (n3 & 0x00FF00FF);\
216
#define SVQ1_DO_CODEBOOK_INTRA()\
217
for (y=0; y < height; y++) {\
218
for (x=0; x < (width / 4); x++, codebook++) {\
223
dst[x] = (n1 << 8) | n2;\
228
#define SVQ1_DO_CODEBOOK_NONINTRA()\
229
for (y=0; y < height; y++) {\
230
for (x=0; x < (width / 4); x++, codebook++) {\
232
/* add mean value to vector */\
233
n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
234
n2 = (n3 & 0x00FF00FF) + n4;\
237
dst[x] = (n1 << 8) | n2;\
242
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
243
codebook = (const uint32_t *) cbook[level];\
244
bit_cache = get_bits (bitbuf, 4*stages);\
245
/* calculate codebook entries for this vector */\
246
for (j=0; j < stages; j++) {\
247
entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
249
mean -= (stages * 128);\
250
n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
252
static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
256
const uint32_t *codebook;
260
unsigned x, y, width, height, level;
261
uint32_t n1, n2, n3, n4;
263
/* initialize list for breadth first processing of vectors */
266
/* recursively process vector */
267
for (i=0, m=1, n=1, level=5; i < n; i++) {
268
SVQ1_PROCESS_VECTOR();
270
/* destination address and vector size */
271
dst = (uint32_t *) list[i];
272
width = 1 << ((4 + level) /2);
273
height = 1 << ((3 + level) /2);
275
/* get number of stages (-1 skips vector, 0 for mean only) */
276
stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
279
for (y=0; y < height; y++) {
280
memset (&dst[y*(pitch / 4)], 0, width);
282
continue; /* skip vector */
285
if ((stages > 0) && (level >= 4)) {
287
av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
289
return -1; /* invalid vector */
292
mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
295
for (y=0; y < height; y++) {
296
memset (&dst[y*(pitch / 4)], mean, width);
299
SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
300
SVQ1_DO_CODEBOOK_INTRA()
307
static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
311
const uint32_t *codebook;
315
int x, y, width, height, level;
316
uint32_t n1, n2, n3, n4;
318
/* initialize list for breadth first processing of vectors */
321
/* recursively process vector */
322
for (i=0, m=1, n=1, level=5; i < n; i++) {
323
SVQ1_PROCESS_VECTOR();
325
/* destination address and vector size */
326
dst = (uint32_t *) list[i];
327
width = 1 << ((4 + level) /2);
328
height = 1 << ((3 + level) /2);
330
/* get number of stages (-1 skips vector, 0 for mean only) */
331
stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
333
if (stages == -1) continue; /* skip vector */
335
if ((stages > 0) && (level >= 4)) {
337
av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
339
return -1; /* invalid vector */
342
mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
344
SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
345
SVQ1_DO_CODEBOOK_NONINTRA()
350
static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
354
for (i=0; i < 2; i++) {
356
/* get motion code */
357
diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
361
if(get_bits1(bitbuf)) diff= -diff;
364
/* add median of motion vector predictors and clip result */
366
mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
368
mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
374
static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
379
src = &previous[x + y*pitch];
382
for (i=0; i < 16; i++) {
383
memcpy (dst, src, 16);
389
static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
390
uint8_t *current, uint8_t *previous, int pitch,
391
svq1_pmv_t *motion, int x, int y) {
398
/* predict and decode motion vector */
405
pmv[1] = &motion[(x / 8) + 2];
406
pmv[2] = &motion[(x / 8) + 4];
409
result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
415
motion[(x / 8) + 2].x =
416
motion[(x / 8) + 3].x = mv.x;
418
motion[(x / 8) + 2].y =
419
motion[(x / 8) + 3].y = mv.y;
421
if(y + (mv.y >> 1)<0)
423
if(x + (mv.x >> 1)<0)
427
int w= (s->width+15)&~15;
428
int h= (s->height+15)&~15;
429
if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
430
av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
433
src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
436
s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
441
static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
442
uint8_t *current, uint8_t *previous, int pitch,
443
svq1_pmv_t *motion,int x, int y) {
450
/* predict and decode motion vector (0) */
457
pmv[1] = &motion[(x / 8) + 2];
458
pmv[2] = &motion[(x / 8) + 4];
461
result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
466
/* predict and decode motion vector (1) */
473
pmv[1] = &motion[(x / 8) + 3];
475
result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
480
/* predict and decode motion vector (2) */
482
pmv[2] = &motion[(x / 8) + 1];
484
result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
489
/* predict and decode motion vector (3) */
490
pmv[2] = &motion[(x / 8) + 2];
491
pmv[3] = &motion[(x / 8) + 3];
493
result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
498
/* form predictions */
499
for (i=0; i < 4; i++) {
500
int mvx= pmv[i]->x + (i&1)*16;
501
int mvy= pmv[i]->y + (i>>1)*16;
503
///XXX /FIXME cliping or padding?
510
int w= (s->width+15)&~15;
511
int h= (s->height+15)&~15;
512
if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
513
av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
515
src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
518
s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
520
/* select next block */
522
current += 8*(pitch - 1);
531
static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
532
uint8_t *current, uint8_t *previous, int pitch,
533
svq1_pmv_t *motion, int x, int y) {
538
block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
540
/* reset motion vectors */
541
if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
544
motion[(x / 8) + 2].x =
545
motion[(x / 8) + 2].y =
546
motion[(x / 8) + 3].x =
547
motion[(x / 8) + 3].y = 0;
550
switch (block_type) {
551
case SVQ1_BLOCK_SKIP:
552
svq1_skip_block (current, previous, pitch, x, y);
555
case SVQ1_BLOCK_INTER:
556
result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
561
av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
565
result = svq1_decode_block_non_intra (bitbuf, current, pitch);
568
case SVQ1_BLOCK_INTER_4V:
569
result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
574
av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
578
result = svq1_decode_block_non_intra (bitbuf, current, pitch);
581
case SVQ1_BLOCK_INTRA:
582
result = svq1_decode_block_intra (bitbuf, current, pitch);
589
39
/* standard video sizes */
590
static struct { int width; int height; } svq1_frame_size_table[8] = {
40
const svq1_frame_size_t ff_svq1_frame_size_table[8] = {
591
41
{ 160, 120 }, { 128, 96 }, { 176, 144 }, { 352, 288 },
592
42
{ 704, 576 }, { 240, 180 }, { 320, 240 }, { -1, -1 }
595
static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
598
for (i=0; i < length; i++) {
599
value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
605
#if 0 /* unused, remove? */
606
static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
607
int width, int height, int value) {
610
for (y=0; y < height; y++) {
611
for (x=0; x < width; x++) {
612
value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
622
#ifdef CONFIG_DECODERS
623
static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
627
out[0] = get_bits (bitbuf, 8);
629
seed = string_table[out[0]];
631
for (i=1; i <= out[0]; i++) {
632
out[i] = get_bits (bitbuf, 8) ^ seed;
633
seed = string_table[out[i] ^ seed];
637
static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
639
int temporal_reference;
641
temporal_reference = get_bits (bitbuf, 8);
644
s->pict_type= get_bits (bitbuf, 2)+1;
648
if (s->pict_type == I_TYPE) {
651
if (s->f_code == 0x50 || s->f_code == 0x60) {
652
int csum = get_bits (bitbuf, 16);
654
csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
656
// av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
657
// (csum == 0) ? "correct" : "incorrect", csum);
660
if ((s->f_code ^ 0x10) >= 0x50) {
663
svq1_parse_string (bitbuf, msg);
665
av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
668
skip_bits (bitbuf, 2);
669
skip_bits (bitbuf, 2);
672
/* load frame size */
673
frame_size_code = get_bits (bitbuf, 3);
675
if (frame_size_code == 7) {
676
/* load width, height (12 bits each) */
677
s->width = get_bits (bitbuf, 12);
678
s->height = get_bits (bitbuf, 12);
680
if (!s->width || !s->height)
683
/* get width, height from table */
684
s->width = svq1_frame_size_table[frame_size_code].width;
685
s->height = svq1_frame_size_table[frame_size_code].height;
690
if (get_bits (bitbuf, 1) == 1) {
691
skip_bits1 (bitbuf); /* use packet checksum if (1) */
692
skip_bits1 (bitbuf); /* component checksums after image data if (1) */
694
if (get_bits (bitbuf, 2) != 0)
698
if (get_bits (bitbuf, 1) == 1) {
700
skip_bits (bitbuf, 4);
702
skip_bits (bitbuf, 2);
704
while (get_bits (bitbuf, 1) == 1) {
705
skip_bits (bitbuf, 8);
712
static int svq1_decode_frame(AVCodecContext *avctx,
713
void *data, int *data_size,
714
uint8_t *buf, int buf_size)
716
MpegEncContext *s=avctx->priv_data;
717
uint8_t *current, *previous;
718
int result, i, x, y, width, height;
719
AVFrame *pict = data;
721
/* initialize bit buffer */
722
init_get_bits(&s->gb,buf,buf_size*8);
724
/* decode frame header */
725
s->f_code = get_bits (&s->gb, 22);
727
if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
730
/* swap some header bytes (why?) */
731
if (s->f_code != 0x20) {
732
uint32_t *src = (uint32_t *) (buf + 4);
734
for (i=0; i < 4; i++) {
735
src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
739
result = svq1_decode_frame_header (&s->gb, s);
744
av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
749
//FIXME this avoids some confusion for "B frames" without 2 references
750
//this should be removed after libavcodec can handle more flexible picture types & ordering
751
if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
753
if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
754
if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
755
||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
756
|| avctx->skip_frame >= AVDISCARD_ALL)
759
if(MPV_frame_start(s, avctx) < 0)
762
/* decode y, u and v components */
763
for (i=0; i < 3; i++) {
766
width = (s->width+15)&~15;
767
height = (s->height+15)&~15;
768
linesize= s->linesize;
770
if(s->flags&CODEC_FLAG_GRAY) break;
771
width = (s->width/4+15)&~15;
772
height = (s->height/4+15)&~15;
773
linesize= s->uvlinesize;
776
current = s->current_picture.data[i];
778
if(s->pict_type==B_TYPE){
779
previous = s->next_picture.data[i];
781
previous = s->last_picture.data[i];
784
if (s->pict_type == I_TYPE) {
786
for (y=0; y < height; y+=16) {
787
for (x=0; x < width; x+=16) {
788
result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
792
av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
797
current += 16*linesize;
800
svq1_pmv_t pmv[width/8+3];
802
memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
804
for (y=0; y < height; y+=16) {
805
for (x=0; x < width; x+=16) {
806
result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
807
linesize, pmv, x, y);
811
av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
820
current += 16*linesize;
825
*pict = *(AVFrame*)&s->current_picture;
830
*data_size=sizeof(AVFrame);
834
static int svq1_decode_init(AVCodecContext *avctx)
836
MpegEncContext *s = avctx->priv_data;
839
MPV_decode_defaults(s);
842
s->width = (avctx->width+3)&~3;
843
s->height = (avctx->height+3)&~3;
844
s->codec_id= avctx->codec->id;
845
avctx->pix_fmt = PIX_FMT_YUV410P;
846
avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
847
s->flags= avctx->flags;
848
if (MPV_common_init(s) < 0) return -1;
850
init_vlc(&svq1_block_type, 2, 4,
851
&svq1_block_type_vlc[0][1], 2, 1,
852
&svq1_block_type_vlc[0][0], 2, 1, 1);
854
init_vlc(&svq1_motion_component, 7, 33,
856
&mvtab[0][0], 2, 1, 1);
858
for (i = 0; i < 6; i++) {
859
init_vlc(&svq1_intra_multistage[i], 3, 8,
860
&svq1_intra_multistage_vlc[i][0][1], 2, 1,
861
&svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
862
init_vlc(&svq1_inter_multistage[i], 3, 8,
863
&svq1_inter_multistage_vlc[i][0][1], 2, 1,
864
&svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
867
init_vlc(&svq1_intra_mean, 8, 256,
868
&svq1_intra_mean_vlc[0][1], 4, 2,
869
&svq1_intra_mean_vlc[0][0], 4, 2, 1);
871
init_vlc(&svq1_inter_mean, 9, 512,
872
&svq1_inter_mean_vlc[0][1], 4, 2,
873
&svq1_inter_mean_vlc[0][0], 4, 2, 1);
878
static int svq1_decode_end(AVCodecContext *avctx)
880
MpegEncContext *s = avctx->priv_data;
885
#endif /* CONFIG_DECODERS */
887
#ifdef CONFIG_ENCODERS
888
static void svq1_write_header(SVQ1Context *s, int frame_type)
893
put_bits(&s->pb, 22, 0x20);
895
/* temporal reference (sure hope this is a "don't care") */
896
put_bits(&s->pb, 8, 0x00);
899
put_bits(&s->pb, 2, frame_type - 1);
901
if (frame_type == I_TYPE) {
903
/* no checksum since frame code is 0x20 */
905
/* no embedded string either */
907
/* output 5 unknown bits (2 + 2 + 1) */
908
put_bits(&s->pb, 5, 2); /* 2 needed by quicktime decoder */
910
for (i = 0; i < 7; i++)
912
if ((svq1_frame_size_table[i].width == s->frame_width) &&
913
(svq1_frame_size_table[i].height == s->frame_height))
915
put_bits(&s->pb, 3, i);
922
put_bits(&s->pb, 3, 7);
923
put_bits(&s->pb, 12, s->frame_width);
924
put_bits(&s->pb, 12, s->frame_height);
928
/* no checksum or extra data (next 2 bits get 0) */
929
put_bits(&s->pb, 2, 0);
933
#define QUALITY_THRESHOLD 100
934
#define THRESHOLD_MULTIPLIER 0.6
936
#if defined(HAVE_ALTIVEC)
940
static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *decoded, int stride, int level, int threshold, int lambda, int intra){
941
int count, y, x, i, j, split, best_mean, best_score, best_count;
943
int block_sum[7]= {0, 0, 0, 0, 0, 0};
944
int w= 2<<((level+2)>>1);
945
int h= 2<<((level+1)>>1);
947
int16_t block[7][256];
948
const int8_t *codebook_sum, *codebook;
949
const uint16_t (*mean_vlc)[2];
950
const uint8_t (*multistage_vlc)[2];
953
//FIXME optimize, this doenst need to be done multiple times
955
codebook_sum= svq1_intra_codebook_sum[level];
956
codebook= svq1_intra_codebooks[level];
957
mean_vlc= svq1_intra_mean_vlc;
958
multistage_vlc= svq1_intra_multistage_vlc[level];
961
int v= src[x + y*stride];
962
block[0][x + w*y]= v;
968
codebook_sum= svq1_inter_codebook_sum[level];
969
codebook= svq1_inter_codebooks[level];
970
mean_vlc= svq1_inter_mean_vlc + 256;
971
multistage_vlc= svq1_inter_multistage_vlc[level];
974
int v= src[x + y*stride] - ref[x + y*stride];
975
block[0][x + w*y]= v;
983
best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
984
best_mean= (block_sum[0] + (size>>1)) >> (level+3);
987
for(count=1; count<7; count++){
988
int best_vector_score= INT_MAX;
989
int best_vector_sum=-999, best_vector_mean=-999;
990
const int stage= count-1;
991
const int8_t *vector;
994
int sum= codebook_sum[stage*16 + i];
996
int diff, mean, score;
998
vector = codebook + stage*size*16 + i*size;
1000
for(j=0; j<size; j++){
1002
sqr += (v - block[stage][j])*(v - block[stage][j]);
1004
diff= block_sum[stage] - sum;
1005
mean= (diff + (size>>1)) >> (level+3);
1006
assert(mean >-300 && mean<300);
1007
if(intra) mean= av_clip(mean, 0, 255);
1008
else mean= av_clip(mean, -256, 255);
1009
score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
1010
if(score < best_vector_score){
1011
best_vector_score= score;
1012
best_vector[stage]= i;
1013
best_vector_sum= sum;
1014
best_vector_mean= mean;
1017
assert(best_vector_mean != -999);
1018
vector= codebook + stage*size*16 + best_vector[stage]*size;
1019
for(j=0; j<size; j++){
1020
block[stage+1][j] = block[stage][j] - vector[j];
1022
block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1023
best_vector_score +=
1024
lambda*(+ 1 + 4*count
1025
+ multistage_vlc[1+count][1]
1026
+ mean_vlc[best_vector_mean][1]);
1028
if(best_vector_score < best_score){
1029
best_score= best_vector_score;
1031
best_mean= best_vector_mean;
1037
if(best_score > threshold && level){
1039
int offset= (level&1) ? stride*h/2 : w/2;
1040
PutBitContext backup[6];
1042
for(i=level-1; i>=0; i--){
1043
backup[i]= s->reorder_pb[i];
1045
score += encode_block(s, src , ref , decoded , stride, level-1, threshold>>1, lambda, intra);
1046
score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
1049
if(score < best_score){
1053
for(i=level-1; i>=0; i--){
1054
s->reorder_pb[i]= backup[i];
1059
put_bits(&s->reorder_pb[level], 1, split);
1062
assert((best_mean >= 0 && best_mean<256) || !intra);
1063
assert(best_mean >= -256 && best_mean<256);
1064
assert(best_count >=0 && best_count<7);
1065
assert(level<4 || best_count==0);
1067
/* output the encoding */
1068
put_bits(&s->reorder_pb[level],
1069
multistage_vlc[1 + best_count][1],
1070
multistage_vlc[1 + best_count][0]);
1071
put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1072
mean_vlc[best_mean][0]);
1074
for (i = 0; i < best_count; i++){
1075
assert(best_vector[i]>=0 && best_vector[i]<16);
1076
put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1081
decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1090
static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
1091
int width, int height, int src_stride, int stride)
1095
int block_width, block_height;
1098
const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
1100
/* figure out the acceptable level thresholds in advance */
1101
threshold[5] = QUALITY_THRESHOLD;
1102
for (level = 4; level >= 0; level--)
1103
threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1105
block_width = (width + 15) / 16;
1106
block_height = (height + 15) / 16;
1108
if(s->picture.pict_type == P_TYPE){
1109
s->m.avctx= s->avctx;
1110
s->m.current_picture_ptr= &s->m.current_picture;
1111
s->m.last_picture_ptr = &s->m.last_picture;
1112
s->m.last_picture.data[0]= ref_plane;
1114
s->m.last_picture.linesize[0]=
1115
s->m.new_picture.linesize[0]=
1116
s->m.current_picture.linesize[0]= stride;
1118
s->m.height= height;
1119
s->m.mb_width= block_width;
1120
s->m.mb_height= block_height;
1121
s->m.mb_stride= s->m.mb_width+1;
1122
s->m.b8_stride= 2*s->m.mb_width+1;
1124
s->m.pict_type= s->picture.pict_type;
1125
s->m.me_method= s->avctx->me_method;
1126
s->m.me.scene_change_score=0;
1127
s->m.flags= s->avctx->flags;
1128
// s->m.out_format = FMT_H263;
1129
// s->m.unrestricted_mv= 1;
1131
s->m.lambda= s->picture.quality;
1132
s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
1133
s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
1135
if(!s->motion_val8[plane]){
1136
s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
1137
s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
1140
s->m.mb_type= s->mb_type;
1142
//dummies, to avoid segfaults
1143
s->m.current_picture.mb_mean= (uint8_t *)s->dummy;
1144
s->m.current_picture.mb_var= (uint16_t*)s->dummy;
1145
s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
1146
s->m.current_picture.mb_type= s->dummy;
1148
s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2;
1149
s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
1150
s->m.dsp= s->dsp; //move
1153
s->m.me.dia_size= s->avctx->dia_size;
1154
s->m.first_slice_line=1;
1155
for (y = 0; y < block_height; y++) {
1156
uint8_t src[stride*16];
1158
s->m.new_picture.data[0]= src - y*16*stride; //ugly
1161
for(i=0; i<16 && i + 16*y<height; i++){
1162
memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1163
for(x=width; x<16*block_width; x++)
1164
src[i*stride+x]= src[i*stride+x-1];
1166
for(; i<16 && i + 16*y<16*block_height; i++)
1167
memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1169
for (x = 0; x < block_width; x++) {
1171
ff_init_block_index(&s->m);
1172
ff_update_block_index(&s->m);
1174
ff_estimate_p_frame_motion(&s->m, x, y);
1176
s->m.first_slice_line=0;
1179
ff_fix_long_p_mvs(&s->m);
1180
ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
1183
s->m.first_slice_line=1;
1184
for (y = 0; y < block_height; y++) {
1185
uint8_t src[stride*16];
1187
for(i=0; i<16 && i + 16*y<height; i++){
1188
memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1189
for(x=width; x<16*block_width; x++)
1190
src[i*stride+x]= src[i*stride+x-1];
1192
for(; i<16 && i + 16*y<16*block_height; i++)
1193
memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1196
for (x = 0; x < block_width; x++) {
1197
uint8_t reorder_buffer[3][6][7*32];
1199
int offset = y * 16 * stride + x * 16;
1200
uint8_t *decoded= decoded_plane + offset;
1201
uint8_t *ref= ref_plane + offset;
1202
int score[4]={0,0,0,0}, best;
1203
uint8_t temp[16*stride];
1205
if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size
1206
av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1211
ff_init_block_index(&s->m);
1212
ff_update_block_index(&s->m);
1214
if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
1216
init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1218
if(s->picture.pict_type == P_TYPE){
1219
const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1220
put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1221
score[0]= vlc[1]*lambda;
1223
score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
1225
count[0][i]= put_bits_count(&s->reorder_pb[i]);
1226
flush_put_bits(&s->reorder_pb[i]);
1233
if(s->picture.pict_type == P_TYPE){
1234
const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
1235
int mx, my, pred_x, pred_y, dxy;
1236
int16_t *motion_ptr;
1238
motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
1239
if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
1241
init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1243
put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1245
s->m.pb= s->reorder_pb[5];
1248
assert(mx>=-32 && mx<=31);
1249
assert(my>=-32 && my<=31);
1250
assert(pred_x>=-32 && pred_x<=31);
1251
assert(pred_y>=-32 && pred_y<=31);
1252
ff_h263_encode_motion(&s->m, mx - pred_x, 1);
1253
ff_h263_encode_motion(&s->m, my - pred_y, 1);
1254
s->reorder_pb[5]= s->m.pb;
1255
score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
1257
dxy= (mx&1) + 2*(my&1);
1259
s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
1261
score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
1262
best= score[1] <= score[0];
1264
vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
1265
score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
1266
score[2]+= vlc[1]*lambda;
1267
if(score[2] < score[best] && mx==0 && my==0){
1269
s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
1273
put_bits(&s->pb, vlc[1], vlc[0]);
1279
count[1][i]= put_bits_count(&s->reorder_pb[i]);
1280
flush_put_bits(&s->reorder_pb[i]);
1283
motion_ptr[0 ] = motion_ptr[1 ]=
1284
motion_ptr[2 ] = motion_ptr[3 ]=
1285
motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
1286
motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
1290
s->rd_total += score[best];
1292
for(i=5; i>=0; i--){
1293
ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1296
s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
1299
s->m.first_slice_line=0;
1304
static int svq1_encode_init(AVCodecContext *avctx)
1306
SVQ1Context * const s = avctx->priv_data;
1308
dsputil_init(&s->dsp, avctx);
1309
avctx->coded_frame= (AVFrame*)&s->picture;
1311
s->frame_width = avctx->width;
1312
s->frame_height = avctx->height;
1314
s->y_block_width = (s->frame_width + 15) / 16;
1315
s->y_block_height = (s->frame_height + 15) / 16;
1317
s->c_block_width = (s->frame_width / 4 + 15) / 16;
1318
s->c_block_height = (s->frame_height / 4 + 15) / 16;
1322
s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
1323
s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1324
s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1325
s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
1326
s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
1327
h263_encode_init(&s->m); //mv_penalty
1332
static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf,
1333
int buf_size, void *data)
1335
SVQ1Context * const s = avctx->priv_data;
1336
AVFrame *pict = data;
1337
AVFrame * const p= (AVFrame*)&s->picture;
1341
if(avctx->pix_fmt != PIX_FMT_YUV410P){
1342
av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1346
if(!s->current_picture.data[0]){
1347
avctx->get_buffer(avctx, &s->current_picture);
1348
avctx->get_buffer(avctx, &s->last_picture);
1351
temp= s->current_picture;
1352
s->current_picture= s->last_picture;
1353
s->last_picture= temp;
1355
init_put_bits(&s->pb, buf, buf_size);
1358
p->pict_type = avctx->gop_size && avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
1359
p->key_frame = p->pict_type == I_TYPE;
1361
svq1_write_header(s, p->pict_type);
1363
if(svq1_encode_plane(s, i,
1364
s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1365
s->frame_width / (i?4:1), s->frame_height / (i?4:1),
1366
s->picture.linesize[i], s->current_picture.linesize[i]) < 0)
1370
// align_put_bits(&s->pb);
1371
while(put_bits_count(&s->pb) & 31)
1372
put_bits(&s->pb, 1, 0);
1374
flush_put_bits(&s->pb);
1376
return (put_bits_count(&s->pb) / 8);
1379
static int svq1_encode_end(AVCodecContext *avctx)
1381
SVQ1Context * const s = avctx->priv_data;
1384
av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1386
av_freep(&s->m.me.scratchpad);
1387
av_freep(&s->m.me.map);
1388
av_freep(&s->m.me.score_map);
1389
av_freep(&s->mb_type);
1390
av_freep(&s->dummy);
1393
av_freep(&s->motion_val8[i]);
1394
av_freep(&s->motion_val16[i]);
1400
#endif //CONFIG_ENCODERS
1402
#ifdef CONFIG_DECODERS
1403
AVCodec svq1_decoder = {
1407
sizeof(MpegEncContext),
1413
.flush= ff_mpeg_flush,
1414
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1418
#ifdef CONFIG_ENCODERS
1420
AVCodec svq1_encoder = {
1424
sizeof(SVQ1Context),
1428
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1431
#endif //CONFIG_ENCODERS
added
removed
ffmpeg/libavcodec/svq1.c
