3
* Copyright (C) 2002 the xine project
4
* Copyright (C) 2002 the ffmpeg project
6
* This library 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 of the License, or (at your option) any later version.
11
* This library 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.
16
* You should have received a copy of the GNU Lesser General Public
17
* License along with this library; if not, write to the Free Software
18
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
* Ported to mplayer by Arpi <arpi@thot.banki.hu>
22
* Ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>
24
* SVQ1 Encoder (c) 2004 Mike Melanson <melanson@pcisys.net>
29
* Sorenson Vector Quantizer #1 (SVQ1) video codec.
30
* For more information of the SVQ1 algorithm, visit:
31
* http://www.pcisys.net/~melanson/codecs/
45
#include "mpegvideo.h"
51
extern const uint8_t mvtab[33][2];
53
static VLC svq1_block_type;
54
static VLC svq1_motion_component;
55
static VLC svq1_intra_multistage[6];
56
static VLC svq1_inter_multistage[6];
57
static VLC svq1_intra_mean;
58
static VLC svq1_inter_mean;
60
#define SVQ1_BLOCK_SKIP 0
61
#define SVQ1_BLOCK_INTER 1
62
#define SVQ1_BLOCK_INTER_4V 2
63
#define SVQ1_BLOCK_INTRA 3
65
typedef struct SVQ1Context {
66
MpegEncContext m; // needed for motion estimation, should not be used for anything else, the idea is to make the motion estimation eventually independant of MpegEncContext, so this will be removed then (FIXME/XXX)
67
AVCodecContext *avctx;
70
AVFrame current_picture;
75
PutBitContext reorder_pb[6]; //why ooh why this sick breadth first order, everything is slower and more complex
80
/* Y plane block dimensions */
84
/* U & V plane (C planes) block dimensions */
90
int16_t (*motion_val8[3])[2];
91
int16_t (*motion_val16[3])[2];
96
/* motion vector (prediction) */
97
typedef struct svq1_pmv_s {
103
#include "svq1_vlc.h"
105
static const uint16_t checksum_table[256] = {
106
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
107
0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
108
0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
109
0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
110
0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
111
0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
112
0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
113
0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
114
0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
115
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
116
0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
117
0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
118
0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
119
0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
120
0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
121
0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
122
0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
123
0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
124
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
125
0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
126
0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
127
0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
128
0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
129
0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
130
0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
131
0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
132
0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
133
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
134
0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
135
0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
136
0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
137
0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
140
static const uint8_t string_table[256] = {
141
0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,
142
0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,
143
0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,
144
0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,
145
0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,
146
0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,
147
0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,
148
0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,
149
0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,
150
0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,
151
0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,
152
0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,
153
0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,
154
0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,
155
0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,
156
0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,
157
0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,
158
0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,
159
0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,
160
0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,
161
0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,
162
0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,
163
0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,
164
0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,
165
0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,
166
0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,
167
0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,
168
0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,
169
0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,
170
0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,
171
0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,
172
0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
175
#define SVQ1_PROCESS_VECTOR()\
176
for (; level > 0; i++) {\
177
/* process next depth */\
183
/* divide block if next bit set */\
184
if (get_bits (bitbuf, 1) == 0)\
186
/* add child nodes */\
187
list[n++] = list[i];\
188
list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\
191
#define SVQ1_ADD_CODEBOOK()\
192
/* add codebook entries to vector */\
193
for (j=0; j < stages; j++) {\
194
n3 = codebook[entries[j]] ^ 0x80808080;\
195
n1 += ((n3 & 0xFF00FF00) >> 8);\
196
n2 += (n3 & 0x00FF00FF);\
199
/* clip to [0..255] */\
200
if (n1 & 0xFF00FF00) {\
201
n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
203
n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
204
n1 &= (n3 & 0x00FF00FF);\
207
if (n2 & 0xFF00FF00) {\
208
n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
210
n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\
211
n2 &= (n3 & 0x00FF00FF);\
214
#define SVQ1_DO_CODEBOOK_INTRA()\
215
for (y=0; y < height; y++) {\
216
for (x=0; x < (width / 4); x++, codebook++) {\
221
dst[x] = (n1 << 8) | n2;\
226
#define SVQ1_DO_CODEBOOK_NONINTRA()\
227
for (y=0; y < height; y++) {\
228
for (x=0; x < (width / 4); x++, codebook++) {\
230
/* add mean value to vector */\
231
n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\
232
n2 = (n3 & 0x00FF00FF) + n4;\
235
dst[x] = (n1 << 8) | n2;\
240
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
241
codebook = (const uint32_t *) cbook[level];\
242
bit_cache = get_bits (bitbuf, 4*stages);\
243
/* calculate codebook entries for this vector */\
244
for (j=0; j < stages; j++) {\
245
entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\
247
mean -= (stages * 128);\
248
n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
250
static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
254
const uint32_t *codebook;
258
unsigned x, y, width, height, level;
259
uint32_t n1, n2, n3, n4;
261
/* initialize list for breadth first processing of vectors */
264
/* recursively process vector */
265
for (i=0, m=1, n=1, level=5; i < n; i++) {
266
SVQ1_PROCESS_VECTOR();
268
/* destination address and vector size */
269
dst = (uint32_t *) list[i];
270
width = 1 << ((4 + level) /2);
271
height = 1 << ((3 + level) /2);
273
/* get number of stages (-1 skips vector, 0 for mean only) */
274
stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
277
for (y=0; y < height; y++) {
278
memset (&dst[y*(pitch / 4)], 0, width);
280
continue; /* skip vector */
283
if ((stages > 0) && (level >= 4)) {
285
av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",stages,level);
287
return -1; /* invalid vector */
290
mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
293
for (y=0; y < height; y++) {
294
memset (&dst[y*(pitch / 4)], mean, width);
297
SVQ1_CALC_CODEBOOK_ENTRIES(svq1_intra_codebooks);
298
SVQ1_DO_CODEBOOK_INTRA()
305
static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) {
309
const uint32_t *codebook;
313
int x, y, width, height, level;
314
uint32_t n1, n2, n3, n4;
316
/* initialize list for breadth first processing of vectors */
319
/* recursively process vector */
320
for (i=0, m=1, n=1, level=5; i < n; i++) {
321
SVQ1_PROCESS_VECTOR();
323
/* destination address and vector size */
324
dst = (uint32_t *) list[i];
325
width = 1 << ((4 + level) /2);
326
height = 1 << ((3 + level) /2);
328
/* get number of stages (-1 skips vector, 0 for mean only) */
329
stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
331
if (stages == -1) continue; /* skip vector */
333
if ((stages > 0) && (level >= 4)) {
335
av_log(s->avctx, AV_LOG_INFO, "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",stages,level);
337
return -1; /* invalid vector */
340
mean = get_vlc2(bitbuf, svq1_inter_mean.table, 9, 3) - 256;
342
SVQ1_CALC_CODEBOOK_ENTRIES(svq1_inter_codebooks);
343
SVQ1_DO_CODEBOOK_NONINTRA()
348
static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv_t *mv, svq1_pmv_t **pmv) {
352
for (i=0; i < 2; i++) {
354
/* get motion code */
355
diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
359
if(get_bits1(bitbuf)) diff= -diff;
362
/* add median of motion vector predictors and clip result */
364
mv->y = ((diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y)) << 26) >> 26;
366
mv->x = ((diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x)) << 26) >> 26;
372
static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
377
src = &previous[x + y*pitch];
380
for (i=0; i < 16; i++) {
381
memcpy (dst, src, 16);
387
static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
388
uint8_t *current, uint8_t *previous, int pitch,
389
svq1_pmv_t *motion, int x, int y) {
396
/* predict and decode motion vector */
403
pmv[1] = &motion[(x / 8) + 2];
404
pmv[2] = &motion[(x / 8) + 4];
407
result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
413
motion[(x / 8) + 2].x =
414
motion[(x / 8) + 3].x = mv.x;
416
motion[(x / 8) + 2].y =
417
motion[(x / 8) + 3].y = mv.y;
419
if(y + (mv.y >> 1)<0)
421
if(x + (mv.x >> 1)<0)
425
int w= (s->width+15)&~15;
426
int h= (s->height+15)&~15;
427
if(x + (mv.x >> 1)<0 || y + (mv.y >> 1)<0 || x + (mv.x >> 1) + 16 > w || y + (mv.y >> 1) + 16> h)
428
av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mv.x >> 1), y + (mv.y >> 1));
431
src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch];
434
s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16);
439
static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
440
uint8_t *current, uint8_t *previous, int pitch,
441
svq1_pmv_t *motion,int x, int y) {
448
/* predict and decode motion vector (0) */
455
pmv[1] = &motion[(x / 8) + 2];
456
pmv[2] = &motion[(x / 8) + 4];
459
result = svq1_decode_motion_vector (bitbuf, &mv, pmv);
464
/* predict and decode motion vector (1) */
471
pmv[1] = &motion[(x / 8) + 3];
473
result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv);
478
/* predict and decode motion vector (2) */
480
pmv[2] = &motion[(x / 8) + 1];
482
result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv);
487
/* predict and decode motion vector (3) */
488
pmv[2] = &motion[(x / 8) + 2];
489
pmv[3] = &motion[(x / 8) + 3];
491
result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv);
496
/* form predictions */
497
for (i=0; i < 4; i++) {
498
int mvx= pmv[i]->x + (i&1)*16;
499
int mvy= pmv[i]->y + (i>>1)*16;
501
///XXX /FIXME cliping or padding?
508
int w= (s->width+15)&~15;
509
int h= (s->height+15)&~15;
510
if(x + (mvx >> 1)<0 || y + (mvy >> 1)<0 || x + (mvx >> 1) + 8 > w || y + (mvy >> 1) + 8> h)
511
av_log(s->avctx, AV_LOG_INFO, "%d %d %d %d\n", x, y, x + (mvx >> 1), y + (mvy >> 1));
513
src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch];
516
s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8);
518
/* select next block */
520
current += 8*(pitch - 1);
529
static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
530
uint8_t *current, uint8_t *previous, int pitch,
531
svq1_pmv_t *motion, int x, int y) {
536
block_type = get_vlc2(bitbuf, svq1_block_type.table, 2, 2);
538
/* reset motion vectors */
539
if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {
542
motion[(x / 8) + 2].x =
543
motion[(x / 8) + 2].y =
544
motion[(x / 8) + 3].x =
545
motion[(x / 8) + 3].y = 0;
548
switch (block_type) {
549
case SVQ1_BLOCK_SKIP:
550
svq1_skip_block (current, previous, pitch, x, y);
553
case SVQ1_BLOCK_INTER:
554
result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y);
559
av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_block %i\n",result);
563
result = svq1_decode_block_non_intra (bitbuf, current, pitch);
566
case SVQ1_BLOCK_INTER_4V:
567
result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y);
572
av_log(s->avctx, AV_LOG_INFO, "Error in svq1_motion_inter_4v_block %i\n",result);
576
result = svq1_decode_block_non_intra (bitbuf, current, pitch);
579
case SVQ1_BLOCK_INTRA:
580
result = svq1_decode_block_intra (bitbuf, current, pitch);
587
/* standard video sizes */
588
static struct { int width; int height; } svq1_frame_size_table[8] = {
589
{ 160, 120 }, { 128, 96 }, { 176, 144 }, { 352, 288 },
590
{ 704, 576 }, { 240, 180 }, { 320, 240 }, { -1, -1 }
593
static uint16_t svq1_packet_checksum (uint8_t *data, int length, int value) {
596
for (i=0; i < length; i++) {
597
value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
603
#if 0 /* unused, remove? */
604
static uint16_t svq1_component_checksum (uint16_t *pixels, int pitch,
605
int width, int height, int value) {
608
for (y=0; y < height; y++) {
609
for (x=0; x < width; x++) {
610
value = checksum_table[pixels[x] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
620
static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
624
out[0] = get_bits (bitbuf, 8);
626
seed = string_table[out[0]];
628
for (i=1; i <= out[0]; i++) {
629
out[i] = get_bits (bitbuf, 8) ^ seed;
630
seed = string_table[out[i] ^ seed];
634
static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
636
int temporal_reference;
638
temporal_reference = get_bits (bitbuf, 8);
641
s->pict_type= get_bits (bitbuf, 2)+1;
645
if (s->pict_type == I_TYPE) {
648
if (s->f_code == 0x50 || s->f_code == 0x60) {
649
int csum = get_bits (bitbuf, 16);
651
csum = svq1_packet_checksum ((uint8_t *)bitbuf->buffer, bitbuf->size_in_bits>>3, csum);
653
// av_log(s->avctx, AV_LOG_INFO, "%s checksum (%02x) for packet data\n",
654
// (csum == 0) ? "correct" : "incorrect", csum);
657
if ((s->f_code ^ 0x10) >= 0x50) {
660
svq1_parse_string (bitbuf, (char *) msg);
662
av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg);
665
skip_bits (bitbuf, 2);
666
skip_bits (bitbuf, 2);
669
/* load frame size */
670
frame_size_code = get_bits (bitbuf, 3);
672
if (frame_size_code == 7) {
673
/* load width, height (12 bits each) */
674
s->width = get_bits (bitbuf, 12);
675
s->height = get_bits (bitbuf, 12);
677
if (!s->width || !s->height)
680
/* get width, height from table */
681
s->width = svq1_frame_size_table[frame_size_code].width;
682
s->height = svq1_frame_size_table[frame_size_code].height;
687
if (get_bits (bitbuf, 1) == 1) {
688
skip_bits1 (bitbuf); /* use packet checksum if (1) */
689
skip_bits1 (bitbuf); /* component checksums after image data if (1) */
691
if (get_bits (bitbuf, 2) != 0)
695
if (get_bits (bitbuf, 1) == 1) {
697
skip_bits (bitbuf, 4);
699
skip_bits (bitbuf, 2);
701
while (get_bits (bitbuf, 1) == 1) {
702
skip_bits (bitbuf, 8);
709
static int svq1_decode_frame(AVCodecContext *avctx,
710
void *data, int *data_size,
711
uint8_t *buf, int buf_size)
713
MpegEncContext *s=avctx->priv_data;
714
uint8_t *current, *previous;
715
int result, i, x, y, width, height;
716
AVFrame *pict = data;
718
/* initialize bit buffer */
719
init_get_bits(&s->gb,buf,buf_size*8);
721
/* decode frame header */
722
s->f_code = get_bits (&s->gb, 22);
724
if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
727
/* swap some header bytes (why?) */
728
if (s->f_code != 0x20) {
729
uint32_t *src = (uint32_t *) (buf + 4);
731
for (i=0; i < 4; i++) {
732
src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
736
result = svq1_decode_frame_header (&s->gb, s);
741
av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_frame_header %i\n",result);
746
//FIXME this avoids some confusion for "B frames" without 2 references
747
//this should be removed after libavcodec can handle more flexible picture types & ordering
748
if(s->pict_type==B_TYPE && s->last_picture_ptr==NULL) return buf_size;
750
if(avctx->hurry_up && s->pict_type==B_TYPE) return buf_size;
751
if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==B_TYPE)
752
||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=I_TYPE)
753
|| avctx->skip_frame >= AVDISCARD_ALL)
756
if(MPV_frame_start(s, avctx) < 0)
759
/* decode y, u and v components */
760
for (i=0; i < 3; i++) {
763
width = (s->width+15)&~15;
764
height = (s->height+15)&~15;
765
linesize= s->linesize;
767
if(s->flags&CODEC_FLAG_GRAY) break;
768
width = (s->width/4+15)&~15;
769
height = (s->height/4+15)&~15;
770
linesize= s->uvlinesize;
773
current = s->current_picture.data[i];
775
if(s->pict_type==B_TYPE){
776
previous = s->next_picture.data[i];
778
previous = s->last_picture.data[i];
781
if (s->pict_type == I_TYPE) {
783
for (y=0; y < height; y+=16) {
784
for (x=0; x < width; x+=16) {
785
result = svq1_decode_block_intra (&s->gb, ¤t[x], linesize);
789
av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result);
794
current += 16*linesize;
797
svq1_pmv_t pmv[width/8+3];
799
memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv_t));
801
for (y=0; y < height; y+=16) {
802
for (x=0; x < width; x+=16) {
803
result = svq1_decode_delta_block (s, &s->gb, ¤t[x], previous,
804
linesize, pmv, x, y);
808
av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_delta_block %i\n",result);
817
current += 16*linesize;
822
*pict = *(AVFrame*)&s->current_picture;
827
*data_size=sizeof(AVFrame);
831
static int svq1_decode_init(AVCodecContext *avctx)
833
MpegEncContext *s = avctx->priv_data;
836
MPV_decode_defaults(s);
839
s->width = (avctx->width+3)&~3;
840
s->height = (avctx->height+3)&~3;
841
s->codec_id= avctx->codec->id;
842
avctx->pix_fmt = PIX_FMT_YUV410P;
843
avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames
844
s->flags= avctx->flags;
845
if (MPV_common_init(s) < 0) return -1;
847
init_vlc(&svq1_block_type, 2, 4,
848
&svq1_block_type_vlc[0][1], 2, 1,
849
&svq1_block_type_vlc[0][0], 2, 1, 1);
851
init_vlc(&svq1_motion_component, 7, 33,
853
&mvtab[0][0], 2, 1, 1);
855
for (i = 0; i < 6; i++) {
856
init_vlc(&svq1_intra_multistage[i], 3, 8,
857
&svq1_intra_multistage_vlc[i][0][1], 2, 1,
858
&svq1_intra_multistage_vlc[i][0][0], 2, 1, 1);
859
init_vlc(&svq1_inter_multistage[i], 3, 8,
860
&svq1_inter_multistage_vlc[i][0][1], 2, 1,
861
&svq1_inter_multistage_vlc[i][0][0], 2, 1, 1);
864
init_vlc(&svq1_intra_mean, 8, 256,
865
&svq1_intra_mean_vlc[0][1], 4, 2,
866
&svq1_intra_mean_vlc[0][0], 4, 2, 1);
868
init_vlc(&svq1_inter_mean, 9, 512,
869
&svq1_inter_mean_vlc[0][1], 4, 2,
870
&svq1_inter_mean_vlc[0][0], 4, 2, 1);
875
static int svq1_decode_end(AVCodecContext *avctx)
877
MpegEncContext *s = avctx->priv_data;
883
static void svq1_write_header(SVQ1Context *s, int frame_type)
888
put_bits(&s->pb, 22, 0x20);
890
/* temporal reference (sure hope this is a "don't care") */
891
put_bits(&s->pb, 8, 0x00);
894
put_bits(&s->pb, 2, frame_type - 1);
896
if (frame_type == I_TYPE) {
898
/* no checksum since frame code is 0x20 */
900
/* no embedded string either */
902
/* output 5 unknown bits (2 + 2 + 1) */
903
put_bits(&s->pb, 5, 0);
905
for (i = 0; i < 7; i++)
907
if ((svq1_frame_size_table[i].width == s->frame_width) &&
908
(svq1_frame_size_table[i].height == s->frame_height))
910
put_bits(&s->pb, 3, i);
917
put_bits(&s->pb, 3, 7);
918
put_bits(&s->pb, 12, s->frame_width);
919
put_bits(&s->pb, 12, s->frame_height);
923
/* no checksum or extra data (next 2 bits get 0) */
924
put_bits(&s->pb, 2, 0);
928
#define QUALITY_THRESHOLD 100
929
#define THRESHOLD_MULTIPLIER 0.6
931
#if defined(HAVE_ALTIVEC)
935
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){
936
int count, y, x, i, j, split, best_mean, best_score, best_count;
938
int block_sum[7]= {0, 0, 0, 0, 0, 0};
939
int w= 2<<((level+2)>>1);
940
int h= 2<<((level+1)>>1);
942
int16_t block[7][256];
943
const int8_t *codebook_sum, *codebook;
944
const uint16_t (*mean_vlc)[2];
945
const uint8_t (*multistage_vlc)[2];
948
//FIXME optimize, this doenst need to be done multiple times
950
codebook_sum= svq1_intra_codebook_sum[level];
951
codebook= svq1_intra_codebooks[level];
952
mean_vlc= svq1_intra_mean_vlc;
953
multistage_vlc= svq1_intra_multistage_vlc[level];
956
int v= src[x + y*stride];
957
block[0][x + w*y]= v;
963
codebook_sum= svq1_inter_codebook_sum[level];
964
codebook= svq1_inter_codebooks[level];
965
mean_vlc= svq1_inter_mean_vlc + 256;
966
multistage_vlc= svq1_inter_multistage_vlc[level];
969
int v= src[x + y*stride] - ref[x + y*stride];
970
block[0][x + w*y]= v;
978
best_score -= ((block_sum[0]*block_sum[0])>>(level+3));
979
best_mean= (block_sum[0] + (size>>1)) >> (level+3);
982
for(count=1; count<7; count++){
983
int best_vector_score= INT_MAX;
984
int best_vector_sum=-999, best_vector_mean=-999;
985
const int stage= count-1;
986
const int8_t *vector;
989
int sum= codebook_sum[stage*16 + i];
991
int diff, mean, score;
993
vector = codebook + stage*size*16 + i*size;
995
for(j=0; j<size; j++){
997
sqr += (v - block[stage][j])*(v - block[stage][j]);
999
diff= block_sum[stage] - sum;
1000
mean= (diff + (size>>1)) >> (level+3);
1001
assert(mean >-300 && mean<300);
1002
if(intra) mean= clip(mean, 0, 255);
1003
else mean= clip(mean, -256, 255);
1004
score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
1005
if(score < best_vector_score){
1006
best_vector_score= score;
1007
best_vector[stage]= i;
1008
best_vector_sum= sum;
1009
best_vector_mean= mean;
1012
assert(best_vector_mean != -999);
1013
vector= codebook + stage*size*16 + best_vector[stage]*size;
1014
for(j=0; j<size; j++){
1015
block[stage+1][j] = block[stage][j] - vector[j];
1017
block_sum[stage+1]= block_sum[stage] - best_vector_sum;
1018
best_vector_score +=
1019
lambda*(+ 1 + 4*count
1020
+ multistage_vlc[1+count][1]
1021
+ mean_vlc[best_vector_mean][1]);
1023
if(best_vector_score < best_score){
1024
best_score= best_vector_score;
1026
best_mean= best_vector_mean;
1032
if(best_score > threshold && level){
1034
int offset= (level&1) ? stride*h/2 : w/2;
1035
PutBitContext backup[6];
1037
for(i=level-1; i>=0; i--){
1038
backup[i]= s->reorder_pb[i];
1040
score += encode_block(s, src , ref , decoded , stride, level-1, threshold>>1, lambda, intra);
1041
score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
1044
if(score < best_score){
1048
for(i=level-1; i>=0; i--){
1049
s->reorder_pb[i]= backup[i];
1054
put_bits(&s->reorder_pb[level], 1, split);
1057
assert((best_mean >= 0 && best_mean<256) || !intra);
1058
assert(best_mean >= -256 && best_mean<256);
1059
assert(best_count >=0 && best_count<7);
1060
assert(level<4 || best_count==0);
1062
/* output the encoding */
1063
put_bits(&s->reorder_pb[level],
1064
multistage_vlc[1 + best_count][1],
1065
multistage_vlc[1 + best_count][0]);
1066
put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
1067
mean_vlc[best_mean][0]);
1069
for (i = 0; i < best_count; i++){
1070
assert(best_vector[i]>=0 && best_vector[i]<16);
1071
put_bits(&s->reorder_pb[level], 4, best_vector[i]);
1076
decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
1084
#ifdef CONFIG_ENCODERS
1086
static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
1087
int width, int height, int src_stride, int stride)
1091
int block_width, block_height;
1094
const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
1096
/* figure out the acceptable level thresholds in advance */
1097
threshold[5] = QUALITY_THRESHOLD;
1098
for (level = 4; level >= 0; level--)
1099
threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;
1101
block_width = (width + 15) / 16;
1102
block_height = (height + 15) / 16;
1104
if(s->picture.pict_type == P_TYPE){
1105
s->m.avctx= s->avctx;
1106
s->m.current_picture_ptr= &s->m.current_picture;
1107
s->m.last_picture_ptr = &s->m.last_picture;
1108
s->m.last_picture.data[0]= ref_plane;
1110
s->m.last_picture.linesize[0]=
1111
s->m.new_picture.linesize[0]=
1112
s->m.current_picture.linesize[0]= stride;
1114
s->m.height= height;
1115
s->m.mb_width= block_width;
1116
s->m.mb_height= block_height;
1117
s->m.mb_stride= s->m.mb_width+1;
1118
s->m.b8_stride= 2*s->m.mb_width+1;
1120
s->m.pict_type= s->picture.pict_type;
1121
s->m.me_method= s->avctx->me_method;
1122
s->m.me.scene_change_score=0;
1123
s->m.flags= s->avctx->flags;
1124
// s->m.out_format = FMT_H263;
1125
// s->m.unrestricted_mv= 1;
1127
s->m.lambda= s->picture.quality;
1128
s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
1129
s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
1131
if(!s->motion_val8[plane]){
1132
s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
1133
s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
1136
s->m.mb_type= s->mb_type;
1138
//dummies, to avoid segfaults
1139
s->m.current_picture.mb_mean= (uint8_t *)s->dummy;
1140
s->m.current_picture.mb_var= (uint16_t*)s->dummy;
1141
s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
1142
s->m.current_picture.mb_type= s->dummy;
1144
s->m.current_picture.motion_val[0]= s->motion_val8[plane] + 2;
1145
s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
1146
s->m.dsp= s->dsp; //move
1149
s->m.me.dia_size= s->avctx->dia_size;
1150
s->m.first_slice_line=1;
1151
for (y = 0; y < block_height; y++) {
1152
uint8_t src[stride*16];
1154
s->m.new_picture.data[0]= src - y*16*stride; //ugly
1157
for(i=0; i<16 && i + 16*y<height; i++){
1158
memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1159
for(x=width; x<16*block_width; x++)
1160
src[i*stride+x]= src[i*stride+x-1];
1162
for(; i<16 && i + 16*y<16*block_height; i++)
1163
memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1165
for (x = 0; x < block_width; x++) {
1167
ff_init_block_index(&s->m);
1168
ff_update_block_index(&s->m);
1170
ff_estimate_p_frame_motion(&s->m, x, y);
1172
s->m.first_slice_line=0;
1175
ff_fix_long_p_mvs(&s->m);
1176
ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
1179
s->m.first_slice_line=1;
1180
for (y = 0; y < block_height; y++) {
1181
uint8_t src[stride*16];
1183
for(i=0; i<16 && i + 16*y<height; i++){
1184
memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
1185
for(x=width; x<16*block_width; x++)
1186
src[i*stride+x]= src[i*stride+x-1];
1188
for(; i<16 && i + 16*y<16*block_height; i++)
1189
memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
1192
for (x = 0; x < block_width; x++) {
1193
uint8_t reorder_buffer[3][6][7*32];
1195
int offset = y * 16 * stride + x * 16;
1196
uint8_t *decoded= decoded_plane + offset;
1197
uint8_t *ref= ref_plane + offset;
1198
int score[4]={0,0,0,0}, best;
1199
uint8_t temp[16*stride];
1201
if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size
1202
av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
1207
ff_init_block_index(&s->m);
1208
ff_update_block_index(&s->m);
1210
if(s->picture.pict_type == I_TYPE || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
1212
init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
1214
if(s->picture.pict_type == P_TYPE){
1215
const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
1216
put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1217
score[0]= vlc[1]*lambda;
1219
score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
1221
count[0][i]= put_bits_count(&s->reorder_pb[i]);
1222
flush_put_bits(&s->reorder_pb[i]);
1229
if(s->picture.pict_type == P_TYPE){
1230
const uint8_t *vlc= svq1_block_type_vlc[SVQ1_BLOCK_INTER];
1231
int mx, my, pred_x, pred_y, dxy;
1232
int16_t *motion_ptr;
1234
motion_ptr= h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
1235
if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
1237
init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
1239
put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
1241
s->m.pb= s->reorder_pb[5];
1244
assert(mx>=-32 && mx<=31);
1245
assert(my>=-32 && my<=31);
1246
assert(pred_x>=-32 && pred_x<=31);
1247
assert(pred_y>=-32 && pred_y<=31);
1248
ff_h263_encode_motion(&s->m, mx - pred_x, 1);
1249
ff_h263_encode_motion(&s->m, my - pred_y, 1);
1250
s->reorder_pb[5]= s->m.pb;
1251
score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
1253
dxy= (mx&1) + 2*(my&1);
1255
s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
1257
score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
1258
best= score[1] <= score[0];
1260
vlc= svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
1261
score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
1262
score[2]+= vlc[1]*lambda;
1263
if(score[2] < score[best] && mx==0 && my==0){
1265
s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
1269
put_bits(&s->pb, vlc[1], vlc[0]);
1275
count[1][i]= put_bits_count(&s->reorder_pb[i]);
1276
flush_put_bits(&s->reorder_pb[i]);
1279
motion_ptr[0 ] = motion_ptr[1 ]=
1280
motion_ptr[2 ] = motion_ptr[3 ]=
1281
motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
1282
motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
1286
s->rd_total += score[best];
1288
for(i=5; i>=0; i--){
1289
ff_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
1292
s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
1295
s->m.first_slice_line=0;
1300
static int svq1_encode_init(AVCodecContext *avctx)
1302
SVQ1Context * const s = avctx->priv_data;
1304
dsputil_init(&s->dsp, avctx);
1305
avctx->coded_frame= (AVFrame*)&s->picture;
1307
s->frame_width = avctx->width;
1308
s->frame_height = avctx->height;
1310
s->y_block_width = (s->frame_width + 15) / 16;
1311
s->y_block_height = (s->frame_height + 15) / 16;
1313
s->c_block_width = (s->frame_width / 4 + 15) / 16;
1314
s->c_block_height = (s->frame_height / 4 + 15) / 16;
1318
s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
1319
s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1320
s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
1321
s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
1322
s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
1323
h263_encode_init(&s->m); //mv_penalty
1328
static int svq1_encode_frame(AVCodecContext *avctx, unsigned char *buf,
1329
int buf_size, void *data)
1331
SVQ1Context * const s = avctx->priv_data;
1332
AVFrame *pict = data;
1333
AVFrame * const p= (AVFrame*)&s->picture;
1337
if(avctx->pix_fmt != PIX_FMT_YUV410P){
1338
av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
1342
if(!s->current_picture.data[0]){
1343
avctx->get_buffer(avctx, &s->current_picture);
1344
avctx->get_buffer(avctx, &s->last_picture);
1347
temp= s->current_picture;
1348
s->current_picture= s->last_picture;
1349
s->last_picture= temp;
1351
init_put_bits(&s->pb, buf, buf_size);
1354
p->pict_type = avctx->frame_number % avctx->gop_size ? P_TYPE : I_TYPE;
1355
p->key_frame = p->pict_type == I_TYPE;
1357
svq1_write_header(s, p->pict_type);
1359
if(svq1_encode_plane(s, i,
1360
s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
1361
s->frame_width / (i?4:1), s->frame_height / (i?4:1),
1362
s->picture.linesize[i], s->current_picture.linesize[i]) < 0)
1366
// align_put_bits(&s->pb);
1367
while(put_bits_count(&s->pb) & 31)
1368
put_bits(&s->pb, 1, 0);
1370
flush_put_bits(&s->pb);
1372
return (put_bits_count(&s->pb) / 8);
1375
static int svq1_encode_end(AVCodecContext *avctx)
1377
SVQ1Context * const s = avctx->priv_data;
1380
av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
1382
av_freep(&s->m.me.scratchpad);
1383
av_freep(&s->m.me.map);
1384
av_freep(&s->m.me.score_map);
1385
av_freep(&s->mb_type);
1386
av_freep(&s->dummy);
1389
av_freep(&s->motion_val8[i]);
1390
av_freep(&s->motion_val16[i]);
1396
#endif //CONFIG_ENCODERS
1398
AVCodec svq1_decoder = {
1402
sizeof(MpegEncContext),
1408
.flush= ff_mpeg_flush,
1409
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1412
#ifdef CONFIG_ENCODERS
1414
AVCodec svq1_encoder = {
1418
sizeof(SVQ1Context),
1422
.pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV410P, -1},
1425
#endif //CONFIG_ENCODERS
added
removed
avidemux/ADM_lavcodec/svq1.c
