falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

svq1: K&R formatting cosmetics

tags/n1.1
Diego Biurrun 13 years ago
parent
4b895cb294
commit
ada12f8366
7 changed files with 1109 additions and 1075 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +2
    -2
      libavcodec/svq1.c
  2. +4
    -4
      libavcodec/svq1.h
  3. +39
    -38
      libavcodec/svq13.c
  4. +108
    -123
      libavcodec/svq1_vlc.h
  5. +586
    -567
      libavcodec/svq1dec.c
  6. +322
    -283
      libavcodec/svq1enc.c
  7. +48
    -58
      libavcodec/svq1enc_cb.h

+ 2
- 2
libavcodec/svq1.c View File

@@ -38,6 +38,6 @@


/* standard video sizes */ /* standard video sizes */
const struct svq1_frame_size ff_svq1_frame_size_table[7] = { const struct svq1_frame_size ff_svq1_frame_size_table[7] = {
{ 160, 120 }, { 128, 96 }, { 176, 144 }, { 352, 288 },
{ 704, 576 }, { 240, 180 }, { 320, 240 }
{ 160, 120 }, { 128, 96 }, { 176, 144 }, { 352, 288 },
{ 704, 576 }, { 240, 180 }, { 320, 240 }
}; };

+ 4
- 4
libavcodec/svq1.h View File

@@ -47,11 +47,11 @@ struct svq1_frame_size {
uint16_t height; uint16_t height;
}; };


uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length,
int value);
uint16_t ff_svq1_packet_checksum(const uint8_t *data,
const int length, int value);


extern const int8_t* const ff_svq1_inter_codebooks[6];
extern const int8_t* const ff_svq1_intra_codebooks[6];
extern const int8_t *const ff_svq1_inter_codebooks[6];
extern const int8_t *const ff_svq1_intra_codebooks[6];


extern const uint8_t ff_svq1_block_type_vlc[4][2]; extern const uint8_t ff_svq1_block_type_vlc[4][2];
extern const uint8_t ff_svq1_intra_multistage_vlc[6][8][2]; extern const uint8_t ff_svq1_intra_multistage_vlc[6][8][2];


+ 39
- 38
libavcodec/svq13.c View File

@@ -23,46 +23,47 @@
#include "svq1.h" #include "svq1.h"


static const uint16_t checksum_table[256] = { static const uint16_t checksum_table[256] = {
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
}; };


uint16_t ff_svq1_packet_checksum (const uint8_t *data, const int length, int value) {
int i;
uint16_t ff_svq1_packet_checksum (const uint8_t *data,
const int length, int value)
{
int i;


for (i=0; i < length; i++) {
value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
}
for (i = 0; i < length; i++)
value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);


return value;
return value;
} }

+ 108
- 123
libavcodec/svq1_vlc.h View File

@@ -25,131 +25,116 @@


/* values in this table range from 0..3; adjust retrieved value by +0 */ /* values in this table range from 0..3; adjust retrieved value by +0 */
const uint8_t ff_svq1_block_type_vlc[4][2] = { const uint8_t ff_svq1_block_type_vlc[4][2] = {
/* { code, length } */
/* { code, length } */
{ 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 }, { 0x0, 3 } { 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 }, { 0x0, 3 }

}; };


/* values in this table range from -1..6; adjust retrieved value by -1 */ /* values in this table range from -1..6; adjust retrieved value by -1 */
const uint8_t ff_svq1_intra_multistage_vlc[6][8][2] = { const uint8_t ff_svq1_intra_multistage_vlc[6][8][2] = {
/* { code, length } */
{
{ 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 },
{ 0x3, 4 }, { 0x2, 4 }, { 0x0, 5 }, { 0x1, 4 }
},{
{ 0x1, 4 }, { 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 },
{ 0x3, 3 }, { 0x2, 3 }, { 0x0, 4 }, { 0x1, 3 }
},{
{ 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x0, 5 },
{ 0x3, 4 }, { 0x2, 3 }, { 0x2, 4 }, { 0x1, 4 }
},{
{ 0x1, 6 }, { 0x1, 1 }, { 0x1, 2 }, { 0x0, 6 },
{ 0x3, 4 }, { 0x2, 4 }, { 0x1, 5 }, { 0x1, 4 }
},{
{ 0x1, 6 }, { 0x1, 1 }, { 0x1, 2 }, { 0x3, 5 },
{ 0x2, 5 }, { 0x0, 6 }, { 0x1, 5 }, { 0x1, 3 }
},{
{ 0x1, 7 }, { 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 },
{ 0x1, 4 }, { 0x1, 6 }, { 0x0, 7 }, { 0x1, 5 }
}
/* { code, length } */
{ { 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 },
{ 0x3, 4 }, { 0x2, 4 }, { 0x0, 5 }, { 0x1, 4 } },
{ { 0x1, 4 }, { 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 },
{ 0x3, 3 }, { 0x2, 3 }, { 0x0, 4 }, { 0x1, 3 } },
{ { 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x0, 5 },
{ 0x3, 4 }, { 0x2, 3 }, { 0x2, 4 }, { 0x1, 4 } },
{ { 0x1, 6 }, { 0x1, 1 }, { 0x1, 2 }, { 0x0, 6 },
{ 0x3, 4 }, { 0x2, 4 }, { 0x1, 5 }, { 0x1, 4 } },
{ { 0x1, 6 }, { 0x1, 1 }, { 0x1, 2 }, { 0x3, 5 },
{ 0x2, 5 }, { 0x0, 6 }, { 0x1, 5 }, { 0x1, 3 } },
{ { 0x1, 7 }, { 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 },
{ 0x1, 4 }, { 0x1, 6 }, { 0x0, 7 }, { 0x1, 5 } }
}; };


/* values in this table range from -1..6; adjust retrieved value by -1 */ /* values in this table range from -1..6; adjust retrieved value by -1 */
const uint8_t ff_svq1_inter_multistage_vlc[6][8][2] = { const uint8_t ff_svq1_inter_multistage_vlc[6][8][2] = {
/* { code, length } */
{
{ 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 },
{ 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 }
},{
{ 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 },
{ 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 }
},{
{ 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 }
},{
{ 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 }
},{
{ 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 }
},{
{ 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 }, { 0x3, 5 },
{ 0x2, 5 }, { 0x1, 5 }, { 0x1, 6 }, { 0x0, 6 }
}
/* { code, length } */
{ { 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 },
{ 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 } },
{ { 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 },
{ 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 } },
{ { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 } },
{ { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 } },
{ { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 } },
{ { 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 }, { 0x3, 5 },
{ 0x2, 5 }, { 0x1, 5 }, { 0x1, 6 }, { 0x0, 6 } }
}; };


/* values in this table range from 0..255; adjust retrieved value by +0 */ /* values in this table range from 0..255; adjust retrieved value by +0 */
const uint16_t ff_svq1_intra_mean_vlc[256][2] = { const uint16_t ff_svq1_intra_mean_vlc[256][2] = {
/* { code, length } */
{ 0x37, 6 }, { 0x56, 7 }, { 0x1, 17 }, { 0x1, 20 },
{ 0x2, 20 }, { 0x3, 20 }, { 0x0, 20 }, { 0x4, 20 },
{ 0x5, 20 }, { 0x3, 19 }, { 0x15, 11 }, { 0x42, 9 },
{ 0x14, 11 }, { 0x3, 14 }, { 0x2, 14 }, { 0x1, 15 },
{ 0x1, 16 }, { 0x1, 12 }, { 0x2B, 10 }, { 0x18, 11 },
{ 0xC, 11 }, { 0x41, 9 }, { 0x78, 8 }, { 0x6C, 8 },
{ 0x55, 7 }, { 0xF, 4 }, { 0xE, 4 }, { 0x34, 6 },
{ 0x51, 7 }, { 0x72, 8 }, { 0x6E, 8 }, { 0x40, 9 },
{ 0x3F, 9 }, { 0x3E, 9 }, { 0x3D, 9 }, { 0x3C, 9 },
{ 0x3B, 9 }, { 0x3A, 9 }, { 0x39, 9 }, { 0x38, 9 },
{ 0x37, 9 }, { 0x43, 9 }, { 0x46, 9 }, { 0x47, 9 },
{ 0x45, 9 }, { 0x44, 9 }, { 0x49, 9 }, { 0x48, 9 },
{ 0x4A, 8 }, { 0x79, 8 }, { 0x76, 8 }, { 0x77, 8 },
{ 0x71, 8 }, { 0x75, 8 }, { 0x74, 8 }, { 0x73, 8 },
{ 0x6A, 8 }, { 0x55, 8 }, { 0x70, 8 }, { 0x6F, 8 },
{ 0x52, 8 }, { 0x6D, 8 }, { 0x4C, 8 }, { 0x6B, 8 },
{ 0x40, 7 }, { 0x69, 8 }, { 0x68, 8 }, { 0x67, 8 },
{ 0x66, 8 }, { 0x65, 8 }, { 0x64, 8 }, { 0x63, 8 },
{ 0x62, 8 }, { 0x61, 8 }, { 0x60, 8 }, { 0x5F, 8 },
{ 0x5E, 8 }, { 0x5D, 8 }, { 0x5C, 8 }, { 0x5B, 8 },
{ 0x5A, 8 }, { 0x59, 8 }, { 0x58, 8 }, { 0x57, 8 },
{ 0x56, 8 }, { 0x3D, 7 }, { 0x54, 8 }, { 0x53, 8 },
{ 0x3F, 7 }, { 0x51, 8 }, { 0x50, 8 }, { 0x4F, 8 },
{ 0x4E, 8 }, { 0x4D, 8 }, { 0x41, 7 }, { 0x4B, 8 },
{ 0x53, 7 }, { 0x3E, 7 }, { 0x48, 8 }, { 0x4F, 7 },
{ 0x52, 7 }, { 0x45, 8 }, { 0x50, 7 }, { 0x43, 8 },
{ 0x42, 8 }, { 0x41, 8 }, { 0x42, 7 }, { 0x43, 7 },
{ 0x3E, 8 }, { 0x44, 7 }, { 0x3C, 8 }, { 0x45, 7 },
{ 0x46, 7 }, { 0x47, 7 }, { 0x48, 7 }, { 0x49, 7 },
{ 0x4A, 7 }, { 0x4B, 7 }, { 0x4C, 7 }, { 0x4D, 7 },
{ 0x4E, 7 }, { 0x58, 7 }, { 0x59, 7 }, { 0x5A, 7 },
{ 0x5B, 7 }, { 0x5C, 7 }, { 0x5D, 7 }, { 0x44, 8 },
{ 0x49, 8 }, { 0x29, 8 }, { 0x3F, 8 }, { 0x3D, 8 },
{ 0x3B, 8 }, { 0x2C, 8 }, { 0x28, 8 }, { 0x25, 8 },
{ 0x26, 8 }, { 0x5E, 7 }, { 0x57, 7 }, { 0x54, 7 },
{ 0x5F, 7 }, { 0x62, 7 }, { 0x63, 7 }, { 0x64, 7 },
{ 0x61, 7 }, { 0x65, 7 }, { 0x67, 7 }, { 0x66, 7 },
{ 0x35, 6 }, { 0x36, 6 }, { 0x60, 7 }, { 0x39, 8 },
{ 0x3A, 8 }, { 0x38, 8 }, { 0x37, 8 }, { 0x36, 8 },
{ 0x35, 8 }, { 0x34, 8 }, { 0x33, 8 }, { 0x32, 8 },
{ 0x31, 8 }, { 0x30, 8 }, { 0x2D, 8 }, { 0x2B, 8 },
{ 0x2A, 8 }, { 0x27, 8 }, { 0x40, 8 }, { 0x46, 8 },
{ 0x47, 8 }, { 0x26, 9 }, { 0x25, 9 }, { 0x24, 9 },
{ 0x23, 9 }, { 0x22, 9 }, { 0x2E, 8 }, { 0x2F, 8 },
{ 0x1F, 9 }, { 0x36, 9 }, { 0x1D, 9 }, { 0x21, 9 },
{ 0x1B, 9 }, { 0x1C, 9 }, { 0x19, 9 }, { 0x1A, 9 },
{ 0x18, 9 }, { 0x17, 9 }, { 0x16, 9 }, { 0x1E, 9 },
{ 0x20, 9 }, { 0x27, 9 }, { 0x28, 9 }, { 0x29, 9 },
{ 0x2A, 9 }, { 0x2B, 9 }, { 0x2C, 9 }, { 0x2D, 9 },
{ 0x2E, 9 }, { 0x2F, 9 }, { 0x30, 9 }, { 0x35, 9 },
{ 0x31, 9 }, { 0x32, 9 }, { 0x33, 9 }, { 0x34, 9 },
/* { code, length } */
{ 0x37, 6 }, { 0x56, 7 }, { 0x01, 17 }, { 0x01, 20 },
{ 0x02, 20 }, { 0x03, 20 }, { 0x00, 20 }, { 0x04, 20 },
{ 0x05, 20 }, { 0x03, 19 }, { 0x15, 11 }, { 0x42, 9 },
{ 0x14, 11 }, { 0x03, 14 }, { 0x02, 14 }, { 0x01, 15 },
{ 0x01, 16 }, { 0x01, 12 }, { 0x2B, 10 }, { 0x18, 11 },
{ 0x0C, 11 }, { 0x41, 9 }, { 0x78, 8 }, { 0x6C, 8 },
{ 0x55, 7 }, { 0x0F, 4 }, { 0x0E, 4 }, { 0x34, 6 },
{ 0x51, 7 }, { 0x72, 8 }, { 0x6E, 8 }, { 0x40, 9 },
{ 0x3F, 9 }, { 0x3E, 9 }, { 0x3D, 9 }, { 0x3C, 9 },
{ 0x3B, 9 }, { 0x3A, 9 }, { 0x39, 9 }, { 0x38, 9 },
{ 0x37, 9 }, { 0x43, 9 }, { 0x46, 9 }, { 0x47, 9 },
{ 0x45, 9 }, { 0x44, 9 }, { 0x49, 9 }, { 0x48, 9 },
{ 0x4A, 8 }, { 0x79, 8 }, { 0x76, 8 }, { 0x77, 8 },
{ 0x71, 8 }, { 0x75, 8 }, { 0x74, 8 }, { 0x73, 8 },
{ 0x6A, 8 }, { 0x55, 8 }, { 0x70, 8 }, { 0x6F, 8 },
{ 0x52, 8 }, { 0x6D, 8 }, { 0x4C, 8 }, { 0x6B, 8 },
{ 0x40, 7 }, { 0x69, 8 }, { 0x68, 8 }, { 0x67, 8 },
{ 0x66, 8 }, { 0x65, 8 }, { 0x64, 8 }, { 0x63, 8 },
{ 0x62, 8 }, { 0x61, 8 }, { 0x60, 8 }, { 0x5F, 8 },
{ 0x5E, 8 }, { 0x5D, 8 }, { 0x5C, 8 }, { 0x5B, 8 },
{ 0x5A, 8 }, { 0x59, 8 }, { 0x58, 8 }, { 0x57, 8 },
{ 0x56, 8 }, { 0x3D, 7 }, { 0x54, 8 }, { 0x53, 8 },
{ 0x3F, 7 }, { 0x51, 8 }, { 0x50, 8 }, { 0x4F, 8 },
{ 0x4E, 8 }, { 0x4D, 8 }, { 0x41, 7 }, { 0x4B, 8 },
{ 0x53, 7 }, { 0x3E, 7 }, { 0x48, 8 }, { 0x4F, 7 },
{ 0x52, 7 }, { 0x45, 8 }, { 0x50, 7 }, { 0x43, 8 },
{ 0x42, 8 }, { 0x41, 8 }, { 0x42, 7 }, { 0x43, 7 },
{ 0x3E, 8 }, { 0x44, 7 }, { 0x3C, 8 }, { 0x45, 7 },
{ 0x46, 7 }, { 0x47, 7 }, { 0x48, 7 }, { 0x49, 7 },
{ 0x4A, 7 }, { 0x4B, 7 }, { 0x4C, 7 }, { 0x4D, 7 },
{ 0x4E, 7 }, { 0x58, 7 }, { 0x59, 7 }, { 0x5A, 7 },
{ 0x5B, 7 }, { 0x5C, 7 }, { 0x5D, 7 }, { 0x44, 8 },
{ 0x49, 8 }, { 0x29, 8 }, { 0x3F, 8 }, { 0x3D, 8 },
{ 0x3B, 8 }, { 0x2C, 8 }, { 0x28, 8 }, { 0x25, 8 },
{ 0x26, 8 }, { 0x5E, 7 }, { 0x57, 7 }, { 0x54, 7 },
{ 0x5F, 7 }, { 0x62, 7 }, { 0x63, 7 }, { 0x64, 7 },
{ 0x61, 7 }, { 0x65, 7 }, { 0x67, 7 }, { 0x66, 7 },
{ 0x35, 6 }, { 0x36, 6 }, { 0x60, 7 }, { 0x39, 8 },
{ 0x3A, 8 }, { 0x38, 8 }, { 0x37, 8 }, { 0x36, 8 },
{ 0x35, 8 }, { 0x34, 8 }, { 0x33, 8 }, { 0x32, 8 },
{ 0x31, 8 }, { 0x30, 8 }, { 0x2D, 8 }, { 0x2B, 8 },
{ 0x2A, 8 }, { 0x27, 8 }, { 0x40, 8 }, { 0x46, 8 },
{ 0x47, 8 }, { 0x26, 9 }, { 0x25, 9 }, { 0x24, 9 },
{ 0x23, 9 }, { 0x22, 9 }, { 0x2E, 8 }, { 0x2F, 8 },
{ 0x1F, 9 }, { 0x36, 9 }, { 0x1D, 9 }, { 0x21, 9 },
{ 0x1B, 9 }, { 0x1C, 9 }, { 0x19, 9 }, { 0x1A, 9 },
{ 0x18, 9 }, { 0x17, 9 }, { 0x16, 9 }, { 0x1E, 9 },
{ 0x20, 9 }, { 0x27, 9 }, { 0x28, 9 }, { 0x29, 9 },
{ 0x2A, 9 }, { 0x2B, 9 }, { 0x2C, 9 }, { 0x2D, 9 },
{ 0x2E, 9 }, { 0x2F, 9 }, { 0x30, 9 }, { 0x35, 9 },
{ 0x31, 9 }, { 0x32, 9 }, { 0x33, 9 }, { 0x34, 9 },
{ 0x19, 10 }, { 0x2A, 10 }, { 0x17, 10 }, { 0x16, 10 }, { 0x19, 10 }, { 0x2A, 10 }, { 0x17, 10 }, { 0x16, 10 },
{ 0x15, 10 }, { 0x28, 10 }, { 0x26, 10 }, { 0x25, 10 }, { 0x15, 10 }, { 0x28, 10 }, { 0x26, 10 }, { 0x25, 10 },
{ 0x22, 10 }, { 0x21, 10 }, { 0x18, 10 }, { 0x14, 10 }, { 0x22, 10 }, { 0x21, 10 }, { 0x18, 10 }, { 0x14, 10 },
{ 0x29, 10 }, { 0x12, 10 }, { 0xD, 10 }, { 0xE, 10 },
{ 0xF, 10 }, { 0x10, 10 }, { 0x11, 10 }, { 0x1A, 10 },
{ 0x29, 10 }, { 0x12, 10 }, { 0x0D, 10 }, { 0x0E, 10 },
{ 0x0F, 10 }, { 0x10, 10 }, { 0x11, 10 }, { 0x1A, 10 },
{ 0x1B, 10 }, { 0x1C, 10 }, { 0x1D, 10 }, { 0x1E, 10 }, { 0x1B, 10 }, { 0x1C, 10 }, { 0x1D, 10 }, { 0x1E, 10 },
{ 0x1F, 10 }, { 0x20, 10 }, { 0x13, 10 }, { 0x23, 10 }, { 0x1F, 10 }, { 0x20, 10 }, { 0x13, 10 }, { 0x23, 10 },
{ 0x24, 10 }, { 0x9, 11 }, { 0x8, 11 }, { 0x7, 11 },
{ 0x27, 10 }, { 0x5, 11 }, { 0xB, 11 }, { 0x6, 11 },
{ 0x4, 11 }, { 0x3, 11 }, { 0x2, 11 }, { 0x1, 11 },
{ 0xA, 11 }, { 0x16, 11 }, { 0x19, 11 }, { 0x17, 11 },
{ 0xD, 11 }, { 0xE, 11 }, { 0xF, 11 }, { 0x10, 11 },
{ 0x11, 11 }, { 0x12, 11 }, { 0x13, 11 }, { 0x1, 14 }
{ 0x24, 10 }, { 0x09, 11 }, { 0x08, 11 }, { 0x07, 11 },
{ 0x27, 10 }, { 0x05, 11 }, { 0x0B, 11 }, { 0x06, 11 },
{ 0x04, 11 }, { 0x03, 11 }, { 0x02, 11 }, { 0x01, 11 },
{ 0x0A, 11 }, { 0x16, 11 }, { 0x19, 11 }, { 0x17, 11 },
{ 0x0D, 11 }, { 0x0E, 11 }, { 0x0F, 11 }, { 0x10, 11 },
{ 0x11, 11 }, { 0x12, 11 }, { 0x13, 11 }, { 0x01, 14 }
}; };


/* values in this table range from -256..255; adjust retrieved value by -256 */ /* values in this table range from -256..255; adjust retrieved value by -256 */
const uint16_t ff_svq1_inter_mean_vlc[512][2] = { const uint16_t ff_svq1_inter_mean_vlc[512][2] = {
/* { code, length } */
/* { code, length } */
{ 0x5A, 22 }, { 0xD4, 22 }, { 0xD5, 22 }, { 0xD6, 22 }, { 0x5A, 22 }, { 0xD4, 22 }, { 0xD5, 22 }, { 0xD6, 22 },
{ 0xD7, 22 }, { 0xD8, 22 }, { 0xD9, 22 }, { 0xDA, 22 }, { 0xD7, 22 }, { 0xD8, 22 }, { 0xD9, 22 }, { 0xDA, 22 },
{ 0xDB, 22 }, { 0xDC, 22 }, { 0xDD, 22 }, { 0xDE, 22 }, { 0xDB, 22 }, { 0xDC, 22 }, { 0xDD, 22 }, { 0xDE, 22 },
@@ -159,12 +144,12 @@ const uint16_t ff_svq1_inter_mean_vlc[512][2] = {
{ 0xE7, 22 }, { 0xEC, 22 }, { 0xED, 22 }, { 0xEE, 22 }, { 0xE7, 22 }, { 0xEC, 22 }, { 0xED, 22 }, { 0xEE, 22 },
{ 0xEF, 22 }, { 0xF0, 22 }, { 0xF1, 22 }, { 0xF2, 22 }, { 0xEF, 22 }, { 0xF0, 22 }, { 0xF1, 22 }, { 0xF2, 22 },
{ 0xF3, 22 }, { 0xF4, 22 }, { 0xF5, 22 }, { 0xF6, 22 }, { 0xF3, 22 }, { 0xF4, 22 }, { 0xF5, 22 }, { 0xF6, 22 },
{ 0xF7, 22 }, { 0xF8, 22 }, { 0x102, 22 }, { 0xEB, 22 },
{ 0xF7, 22 }, { 0xF8, 22 }, { 0x102,22 }, { 0xEB, 22 },
{ 0xF9, 22 }, { 0xFC, 22 }, { 0xFD, 22 }, { 0xFE, 22 }, { 0xF9, 22 }, { 0xFC, 22 }, { 0xFD, 22 }, { 0xFE, 22 },
{ 0x100, 22 }, { 0x5C, 22 }, { 0x60, 22 }, { 0x101, 22 },
{ 0x71, 22 }, { 0x104, 22 }, { 0x105, 22 }, { 0xFB, 22 },
{ 0x100,22 }, { 0x5C, 22 }, { 0x60, 22 }, { 0x101,22 },
{ 0x71, 22 }, { 0x104,22 }, { 0x105,22 }, { 0xFB, 22 },
{ 0xFF, 22 }, { 0x86, 21 }, { 0xFA, 22 }, { 0x7C, 22 }, { 0xFF, 22 }, { 0x86, 21 }, { 0xFA, 22 }, { 0x7C, 22 },
{ 0x75, 22 }, { 0x103, 22 }, { 0x78, 22 }, { 0xD3, 22 },
{ 0x75, 22 }, { 0x103,22 }, { 0x78, 22 }, { 0xD3, 22 },
{ 0x7B, 22 }, { 0x82, 22 }, { 0xD2, 22 }, { 0xD1, 22 }, { 0x7B, 22 }, { 0x82, 22 }, { 0xD2, 22 }, { 0xD1, 22 },
{ 0xD0, 22 }, { 0xCF, 22 }, { 0xCE, 22 }, { 0xCD, 22 }, { 0xD0, 22 }, { 0xCF, 22 }, { 0xCE, 22 }, { 0xCD, 22 },
{ 0xCC, 22 }, { 0xC3, 22 }, { 0xCA, 22 }, { 0xC9, 22 }, { 0xCC, 22 }, { 0xC3, 22 }, { 0xCA, 22 }, { 0xC9, 22 },
@@ -206,19 +191,19 @@ const uint16_t ff_svq1_inter_mean_vlc[512][2] = {
{ 0x21, 14 }, { 0x13, 13 }, { 0x14, 13 }, { 0x15, 13 }, { 0x21, 14 }, { 0x13, 13 }, { 0x14, 13 }, { 0x15, 13 },
{ 0x16, 13 }, { 0x17, 13 }, { 0x18, 13 }, { 0x19, 13 }, { 0x16, 13 }, { 0x17, 13 }, { 0x18, 13 }, { 0x19, 13 },
{ 0x1A, 13 }, { 0x18, 12 }, { 0x17, 12 }, { 0x15, 12 }, { 0x1A, 13 }, { 0x18, 12 }, { 0x17, 12 }, { 0x15, 12 },
{ 0x14, 12 }, { 0x13, 12 }, { 0x12, 12 }, { 0xF, 11 },
{ 0x14, 12 }, { 0x13, 12 }, { 0x12, 12 }, { 0x0F, 11 },
{ 0x10, 11 }, { 0x12, 11 }, { 0x13, 11 }, { 0x1B, 11 }, { 0x10, 11 }, { 0x12, 11 }, { 0x13, 11 }, { 0x1B, 11 },
{ 0x1A, 11 }, { 0xE, 10 }, { 0x13, 10 }, { 0xF, 10 },
{ 0x10, 10 }, { 0x11, 10 }, { 0x12, 10 }, { 0xD, 9 },
{ 0x14, 9 }, { 0x15, 9 }, { 0xC, 9 }, { 0x13, 9 },
{ 0xF, 8 }, { 0xE, 8 }, { 0x10, 8 }, { 0x11, 8 },
{ 0xC, 7 }, { 0x9, 7 }, { 0xA, 7 }, { 0x8, 6 },
{ 0x9, 6 }, { 0x9, 5 }, { 0x8, 5 }, { 0x5, 4 },
{ 0x1, 1 }, { 0x3, 3 }, { 0x7, 5 }, { 0x6, 5 },
{ 0xB, 6 }, { 0xA, 6 }, { 0xE, 7 }, { 0xF, 7 },
{ 0xB, 7 }, { 0xD, 7 }, { 0xB, 8 }, { 0xD, 8 },
{ 0xC, 8 }, { 0xF, 9 }, { 0x10, 9 }, { 0x11, 9 },
{ 0xE, 9 }, { 0x12, 9 }, { 0x17, 10 }, { 0x14, 10 },
{ 0x1A, 11 }, { 0x0E, 10 }, { 0x13, 10 }, { 0x0F, 10 },
{ 0x10, 10 }, { 0x11, 10 }, { 0x12, 10 }, { 0x0D, 9 },
{ 0x14, 9 }, { 0x15, 9 }, { 0x0C, 9 }, { 0x13, 9 },
{ 0x0F, 8 }, { 0x0E, 8 }, { 0x10, 8 }, { 0x11, 8 },
{ 0x0C, 7 }, { 0x09, 7 }, { 0x0A, 7 }, { 0x08, 6 },
{ 0x09, 6 }, { 0x09, 5 }, { 0x08, 5 }, { 0x05, 4 },
{ 0x01, 1 }, { 0x03, 3 }, { 0x07, 5 }, { 0x06, 5 },
{ 0x0B, 6 }, { 0x0A, 6 }, { 0x0E, 7 }, { 0x0F, 7 },
{ 0x0B, 7 }, { 0x0D, 7 }, { 0x0B, 8 }, { 0x0D, 8 },
{ 0x0C, 8 }, { 0x0F, 9 }, { 0x10, 9 }, { 0x11, 9 },
{ 0x0E, 9 }, { 0x12, 9 }, { 0x17, 10 }, { 0x14, 10 },
{ 0x16, 10 }, { 0x15, 10 }, { 0x19, 11 }, { 0x18, 11 }, { 0x16, 10 }, { 0x15, 10 }, { 0x19, 11 }, { 0x18, 11 },
{ 0x17, 11 }, { 0x16, 11 }, { 0x15, 11 }, { 0x14, 11 }, { 0x17, 11 }, { 0x16, 11 }, { 0x15, 11 }, { 0x14, 11 },
{ 0x11, 11 }, { 0x19, 12 }, { 0x1A, 12 }, { 0x16, 12 }, { 0x11, 11 }, { 0x19, 12 }, { 0x1A, 12 }, { 0x16, 12 },
@@ -274,10 +259,10 @@ const uint16_t ff_svq1_inter_mean_vlc[512][2] = {
{ 0x1B, 22 }, { 0x1A, 22 }, { 0x19, 22 }, { 0x18, 22 }, { 0x1B, 22 }, { 0x1A, 22 }, { 0x19, 22 }, { 0x18, 22 },
{ 0x17, 22 }, { 0x16, 22 }, { 0x15, 22 }, { 0x14, 22 }, { 0x17, 22 }, { 0x16, 22 }, { 0x15, 22 }, { 0x14, 22 },
{ 0x13, 22 }, { 0x12, 22 }, { 0x11, 22 }, { 0x10, 22 }, { 0x13, 22 }, { 0x12, 22 }, { 0x11, 22 }, { 0x10, 22 },
{ 0xF, 22 }, { 0xE, 22 }, { 0xD, 22 }, { 0xC, 22 },
{ 0xB, 22 }, { 0xA, 22 }, { 0x9, 22 }, { 0x8, 22 },
{ 0x7, 22 }, { 0x6, 22 }, { 0x5, 22 }, { 0x4, 22 },
{ 0x3, 22 }, { 0x2, 22 }, { 0x1, 22 }, { 0x0, 22 }
{ 0x0F, 22 }, { 0x0E, 22 }, { 0x0D, 22 }, { 0x0C, 22 },
{ 0x0B, 22 }, { 0x0A, 22 }, { 0x09, 22 }, { 0x08, 22 },
{ 0x07, 22 }, { 0x06, 22 }, { 0x05, 22 }, { 0x04, 22 },
{ 0x03, 22 }, { 0x02, 22 }, { 0x01, 22 }, { 0x00, 22 }
}; };


#endif /* AVCODEC_SVQ1_VLC_H */ #endif /* AVCODEC_SVQ1_VLC_H */

+ 586
- 567
libavcodec/svq1dec.c
File diff suppressed because it is too large
View File


+ 322
- 283
libavcodec/svq1enc.c View File

@@ -26,22 +26,22 @@
* http://www.pcisys.net/~melanson/codecs/ * http://www.pcisys.net/~melanson/codecs/
*/ */



#include "avcodec.h" #include "avcodec.h"
#include "dsputil.h" #include "dsputil.h"
#include "mpegvideo.h" #include "mpegvideo.h"
#include "h263.h" #include "h263.h"
#include "internal.h" #include "internal.h"

#include "svq1.h" #include "svq1.h"
#include "svq1enc_cb.h" #include "svq1enc_cb.h"


#undef NDEBUG #undef NDEBUG
#include <assert.h> #include <assert.h>



typedef struct SVQ1Context { typedef struct SVQ1Context {
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)
/* FIXME: 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. */
MpegEncContext m;
AVCodecContext *avctx; AVCodecContext *avctx;
DSPContext dsp; DSPContext dsp;
AVFrame picture; AVFrame picture;
@@ -50,7 +50,9 @@ typedef struct SVQ1Context {
PutBitContext pb; PutBitContext pb;
GetBitContext gb; GetBitContext gb;


PutBitContext reorder_pb[6]; //why ooh why this sick breadth first order, everything is slower and more complex
/* why ooh why this sick breadth first order,
* everything is slower and more complex */
PutBitContext reorder_pb[6];


int frame_width; int frame_width;
int frame_height; int frame_height;
@@ -87,21 +89,19 @@ static void svq1_write_header(SVQ1Context *s, int frame_type)
put_bits(&s->pb, 2, frame_type - 1); put_bits(&s->pb, 2, frame_type - 1);


if (frame_type == AV_PICTURE_TYPE_I) { if (frame_type == AV_PICTURE_TYPE_I) {

/* no checksum since frame code is 0x20 */ /* no checksum since frame code is 0x20 */

/* no embedded string either */ /* no embedded string either */

/* output 5 unknown bits (2 + 2 + 1) */ /* output 5 unknown bits (2 + 2 + 1) */
put_bits(&s->pb, 5, 2); /* 2 needed by quicktime decoder */ put_bits(&s->pb, 5, 2); /* 2 needed by quicktime decoder */


i= ff_match_2uint16(ff_svq1_frame_size_table, FF_ARRAY_ELEMS(ff_svq1_frame_size_table), s->frame_width, s->frame_height);
i = ff_match_2uint16(ff_svq1_frame_size_table,
FF_ARRAY_ELEMS(ff_svq1_frame_size_table),
s->frame_width, s->frame_height);
put_bits(&s->pb, 3, i); put_bits(&s->pb, 3, i);


if (i == 7)
{
put_bits(&s->pb, 12, s->frame_width);
put_bits(&s->pb, 12, s->frame_height);
if (i == 7) {
put_bits(&s->pb, 12, s->frame_width);
put_bits(&s->pb, 12, s->frame_height);
} }
} }


@@ -109,391 +109,423 @@ static void svq1_write_header(SVQ1Context *s, int frame_type)
put_bits(&s->pb, 2, 0); put_bits(&s->pb, 2, 0);
} }



#define QUALITY_THRESHOLD 100
#define QUALITY_THRESHOLD 100
#define THRESHOLD_MULTIPLIER 0.6 #define THRESHOLD_MULTIPLIER 0.6


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){
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)
{
int count, y, x, i, j, split, best_mean, best_score, best_count; int count, y, x, i, j, split, best_mean, best_score, best_count;
int best_vector[6]; int best_vector[6];
int block_sum[7]= {0, 0, 0, 0, 0, 0};
int w= 2<<((level+2)>>1);
int h= 2<<((level+1)>>1);
int size=w*h;
int block_sum[7] = { 0, 0, 0, 0, 0, 0 };
int w = 2 << ((level + 2) >> 1);
int h = 2 << ((level + 1) >> 1);
int size = w * h;
int16_t block[7][256]; int16_t block[7][256];
const int8_t *codebook_sum, *codebook; const int8_t *codebook_sum, *codebook;
const uint16_t (*mean_vlc)[2];
const uint8_t (*multistage_vlc)[2];
best_score=0;
//FIXME optimize, this doenst need to be done multiple times
if(intra){
codebook_sum= svq1_intra_codebook_sum[level];
codebook= ff_svq1_intra_codebooks[level];
mean_vlc= ff_svq1_intra_mean_vlc;
multistage_vlc= ff_svq1_intra_multistage_vlc[level];
for(y=0; y<h; y++){
for(x=0; x<w; x++){
int v= src[x + y*stride];
block[0][x + w*y]= v;
best_score += v*v;
block_sum[0] += v;
const uint16_t(*mean_vlc)[2];
const uint8_t(*multistage_vlc)[2];
best_score = 0;
// FIXME: Optimize, this does not need to be done multiple times.
if (intra) {
codebook_sum = svq1_intra_codebook_sum[level];
codebook = ff_svq1_intra_codebooks[level];
mean_vlc = ff_svq1_intra_mean_vlc;
multistage_vlc = ff_svq1_intra_multistage_vlc[level];
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
int v = src[x + y * stride];
block[0][x + w * y] = v;
best_score += v * v;
block_sum[0] += v;
} }
} }
}else{
codebook_sum= svq1_inter_codebook_sum[level];
codebook= ff_svq1_inter_codebooks[level];
mean_vlc= ff_svq1_inter_mean_vlc + 256;
multistage_vlc= ff_svq1_inter_multistage_vlc[level];
for(y=0; y<h; y++){
for(x=0; x<w; x++){
int v= src[x + y*stride] - ref[x + y*stride];
block[0][x + w*y]= v;
best_score += v*v;
block_sum[0] += v;
} else {
codebook_sum = svq1_inter_codebook_sum[level];
codebook = ff_svq1_inter_codebooks[level];
mean_vlc = ff_svq1_inter_mean_vlc + 256;
multistage_vlc = ff_svq1_inter_multistage_vlc[level];
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
int v = src[x + y * stride] - ref[x + y * stride];
block[0][x + w * y] = v;
best_score += v * v;
block_sum[0] += v;
} }
} }
} }


best_count=0;
best_score -= (int)(((unsigned)block_sum[0]*block_sum[0])>>(level+3));
best_mean= (block_sum[0] + (size>>1)) >> (level+3);
best_count = 0;
best_score -= (int)(((unsigned)block_sum[0] * block_sum[0]) >> (level + 3));
best_mean = (block_sum[0] + (size >> 1)) >> (level + 3);


if(level<4){
for(count=1; count<7; count++){
int best_vector_score= INT_MAX;
int best_vector_sum=-999, best_vector_mean=-999;
const int stage= count-1;
if (level < 4) {
for (count = 1; count < 7; count++) {
int best_vector_score = INT_MAX;
int best_vector_sum = -999, best_vector_mean = -999;
const int stage = count - 1;
const int8_t *vector; const int8_t *vector;


for(i=0; i<16; i++){
int sum= codebook_sum[stage*16 + i];
for (i = 0; i < 16; i++) {
int sum = codebook_sum[stage * 16 + i];
int sqr, diff, score; int sqr, diff, score;


vector = codebook + stage*size*16 + i*size;
sqr = s->dsp.ssd_int8_vs_int16(vector, block[stage], size);
diff= block_sum[stage] - sum;
score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
if(score < best_vector_score){
int mean= (diff + (size>>1)) >> (level+3);
assert(mean >-300 && mean<300);
mean= av_clip(mean, intra?0:-256, 255);
best_vector_score= score;
best_vector[stage]= i;
best_vector_sum= sum;
best_vector_mean= mean;
vector = codebook + stage * size * 16 + i * size;
sqr = s->dsp.ssd_int8_vs_int16(vector, block[stage], size);
diff = block_sum[stage] - sum;
score = sqr - ((diff * (int64_t)diff) >> (level + 3)); // FIXME: 64bit slooow
if (score < best_vector_score) {
int mean = (diff + (size >> 1)) >> (level + 3);
assert(mean > -300 && mean < 300);
mean = av_clip(mean, intra ? 0 : -256, 255);
best_vector_score = score;
best_vector[stage] = i;
best_vector_sum = sum;
best_vector_mean = mean;
} }
} }
assert(best_vector_mean != -999); assert(best_vector_mean != -999);
vector= codebook + stage*size*16 + best_vector[stage]*size;
for(j=0; j<size; j++){
block[stage+1][j] = block[stage][j] - vector[j];
}
block_sum[stage+1]= block_sum[stage] - best_vector_sum;
best_vector_score +=
lambda*(+ 1 + 4*count
+ multistage_vlc[1+count][1]
+ mean_vlc[best_vector_mean][1]);

if(best_vector_score < best_score){
best_score= best_vector_score;
best_count= count;
best_mean= best_vector_mean;
vector = codebook + stage * size * 16 + best_vector[stage] * size;
for (j = 0; j < size; j++)
block[stage + 1][j] = block[stage][j] - vector[j];
block_sum[stage + 1] = block_sum[stage] - best_vector_sum;
best_vector_score += lambda *
(+1 + 4 * count +
multistage_vlc[1 + count][1]
+ mean_vlc[best_vector_mean][1]);

if (best_vector_score < best_score) {
best_score = best_vector_score;
best_count = count;
best_mean = best_vector_mean;
} }
} }
} }


split=0;
if(best_score > threshold && level){
int score=0;
int offset= (level&1) ? stride*h/2 : w/2;
split = 0;
if (best_score > threshold && level) {
int score = 0;
int offset = (level & 1) ? stride * h / 2 : w / 2;
PutBitContext backup[6]; PutBitContext backup[6];


for(i=level-1; i>=0; i--){
backup[i]= s->reorder_pb[i];
}
score += encode_block(s, src , ref , decoded , stride, level-1, threshold>>1, lambda, intra);
score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
for (i = level - 1; i >= 0; i--)
backup[i] = s->reorder_pb[i];
score += encode_block(s, src, ref, decoded, stride, level - 1,
threshold >> 1, lambda, intra);
score += encode_block(s, src + offset, ref + offset, decoded + offset,
stride, level - 1, threshold >> 1, lambda, intra);
score += lambda; score += lambda;


if(score < best_score){
best_score= score;
split=1;
}else{
for(i=level-1; i>=0; i--){
s->reorder_pb[i]= backup[i];
}
if (score < best_score) {
best_score = score;
split = 1;
} else {
for (i = level - 1; i >= 0; i--)
s->reorder_pb[i] = backup[i];
} }
} }
if (level > 0) if (level > 0)
put_bits(&s->reorder_pb[level], 1, split); put_bits(&s->reorder_pb[level], 1, split);


if(!split){
assert((best_mean >= 0 && best_mean<256) || !intra);
assert(best_mean >= -256 && best_mean<256);
assert(best_count >=0 && best_count<7);
assert(level<4 || best_count==0);
if (!split) {
assert((best_mean >= 0 && best_mean < 256) || !intra);
assert(best_mean >= -256 && best_mean < 256);
assert(best_count >= 0 && best_count < 7);
assert(level < 4 || best_count == 0);


/* output the encoding */ /* output the encoding */
put_bits(&s->reorder_pb[level], put_bits(&s->reorder_pb[level],
multistage_vlc[1 + best_count][1],
multistage_vlc[1 + best_count][0]);
multistage_vlc[1 + best_count][1],
multistage_vlc[1 + best_count][0]);
put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1], put_bits(&s->reorder_pb[level], mean_vlc[best_mean][1],
mean_vlc[best_mean][0]);
mean_vlc[best_mean][0]);


for (i = 0; i < best_count; i++){
assert(best_vector[i]>=0 && best_vector[i]<16);
for (i = 0; i < best_count; i++) {
assert(best_vector[i] >= 0 && best_vector[i] < 16);
put_bits(&s->reorder_pb[level], 4, best_vector[i]); put_bits(&s->reorder_pb[level], 4, best_vector[i]);
} }


for(y=0; y<h; y++){
for(x=0; x<w; x++){
decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
}
}
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
decoded[x + y * stride] = src[x + y * stride] -
block[best_count][x + w * y] +
best_mean;
} }


return best_score; return best_score;
} }



static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
int width, int height, int src_stride, int stride)
static int svq1_encode_plane(SVQ1Context *s, int plane,
unsigned char *src_plane,
unsigned char *ref_plane,
unsigned char *decoded_plane,
int width, int height, int src_stride, int stride)
{ {
int x, y; int x, y;
int i; int i;
int block_width, block_height; int block_width, block_height;
int level; int level;
int threshold[6]; int threshold[6];
uint8_t *src = s->scratchbuf + stride * 16;
const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT);
uint8_t *src = s->scratchbuf + stride * 16;
const int lambda = (s->picture.quality * s->picture.quality) >>
(2 * FF_LAMBDA_SHIFT);


/* figure out the acceptable level thresholds in advance */ /* figure out the acceptable level thresholds in advance */
threshold[5] = QUALITY_THRESHOLD; threshold[5] = QUALITY_THRESHOLD;
for (level = 4; level >= 0; level--) for (level = 4; level >= 0; level--)
threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER; threshold[level] = threshold[level + 1] * THRESHOLD_MULTIPLIER;


block_width = (width + 15) / 16;
block_width = (width + 15) / 16;
block_height = (height + 15) / 16; block_height = (height + 15) / 16;


if(s->picture.pict_type == AV_PICTURE_TYPE_P){
s->m.avctx= s->avctx;
s->m.current_picture_ptr= &s->m.current_picture;
s->m.last_picture_ptr = &s->m.last_picture;
s->m.last_picture.f.data[0] = ref_plane;
s->m.linesize=
s->m.last_picture.f.linesize[0] =
s->m.new_picture.f.linesize[0] =
if (s->picture.pict_type == AV_PICTURE_TYPE_P) {
s->m.avctx = s->avctx;
s->m.current_picture_ptr = &s->m.current_picture;
s->m.last_picture_ptr = &s->m.last_picture;
s->m.last_picture.f.data[0] = ref_plane;
s->m.linesize =
s->m.last_picture.f.linesize[0] =
s->m.new_picture.f.linesize[0] =
s->m.current_picture.f.linesize[0] = stride; s->m.current_picture.f.linesize[0] = stride;
s->m.width= width;
s->m.height= height;
s->m.mb_width= block_width;
s->m.mb_height= block_height;
s->m.mb_stride= s->m.mb_width+1;
s->m.b8_stride= 2*s->m.mb_width+1;
s->m.f_code=1;
s->m.pict_type= s->picture.pict_type;
s->m.me_method= s->avctx->me_method;
s->m.me.scene_change_score=0;
s->m.flags= s->avctx->flags;
// s->m.out_format = FMT_H263;
// s->m.unrestricted_mv= 1;

s->m.lambda= s->picture.quality;
s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;

if(!s->motion_val8[plane]){
s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
s->m.width = width;
s->m.height = height;
s->m.mb_width = block_width;
s->m.mb_height = block_height;
s->m.mb_stride = s->m.mb_width + 1;
s->m.b8_stride = 2 * s->m.mb_width + 1;
s->m.f_code = 1;
s->m.pict_type = s->picture.pict_type;
s->m.me_method = s->avctx->me_method;
s->m.me.scene_change_score = 0;
s->m.flags = s->avctx->flags;
// s->m.out_format = FMT_H263;
// s->m.unrestricted_mv = 1;
s->m.lambda = s->picture.quality;
s->m.qscale = (s->m.lambda * 139 +
FF_LAMBDA_SCALE * 64) >>
(FF_LAMBDA_SHIFT + 7);
s->m.lambda2 = (s->m.lambda * s->m.lambda +
FF_LAMBDA_SCALE / 2) >>
FF_LAMBDA_SHIFT;

if (!s->motion_val8[plane]) {
s->motion_val8[plane] = av_mallocz((s->m.b8_stride *
block_height * 2 + 2) *
2 * sizeof(int16_t));
s->motion_val16[plane] = av_mallocz((s->m.mb_stride *
(block_height + 2) + 1) *
2 * sizeof(int16_t));
} }


s->m.mb_type= s->mb_type;
s->m.mb_type = s->mb_type;


//dummies, to avoid segfaults
s->m.current_picture.mb_mean= (uint8_t *)s->dummy;
s->m.current_picture.mb_var= (uint16_t*)s->dummy;
s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy;
// dummies, to avoid segfaults
s->m.current_picture.mb_mean = (uint8_t *)s->dummy;
s->m.current_picture.mb_var = (uint16_t *)s->dummy;
s->m.current_picture.mc_mb_var = (uint16_t *)s->dummy;
s->m.current_picture.f.mb_type = s->dummy; s->m.current_picture.f.mb_type = s->dummy;


s->m.current_picture.f.motion_val[0] = s->motion_val8[plane] + 2; s->m.current_picture.f.motion_val[0] = s->motion_val8[plane] + 2;
s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
s->m.dsp= s->dsp; //move
s->m.p_mv_table = s->motion_val16[plane] +
s->m.mb_stride + 1;
s->m.dsp = s->dsp; // move
ff_init_me(&s->m); ff_init_me(&s->m);


s->m.me.dia_size= s->avctx->dia_size;
s->m.first_slice_line=1;
s->m.me.dia_size = s->avctx->dia_size;
s->m.first_slice_line = 1;
for (y = 0; y < block_height; y++) { for (y = 0; y < block_height; y++) {
s->m.new_picture.f.data[0] = src - y*16*stride; //ugly
s->m.mb_y= y;

for(i=0; i<16 && i + 16*y<height; i++){
memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
for(x=width; x<16*block_width; x++)
src[i*stride+x]= src[i*stride+x-1];
s->m.new_picture.f.data[0] = src - y * 16 * stride; // ugly
s->m.mb_y = y;

for (i = 0; i < 16 && i + 16 * y < height; i++) {
memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
width);
for (x = width; x < 16 * block_width; x++)
src[i * stride + x] = src[i * stride + x - 1];
} }
for(; i<16 && i + 16*y<16*block_height; i++)
memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
for (; i < 16 && i + 16 * y < 16 * block_height; i++)
memcpy(&src[i * stride], &src[(i - 1) * stride],
16 * block_width);


for (x = 0; x < block_width; x++) { for (x = 0; x < block_width; x++) {
s->m.mb_x= x;
s->m.mb_x = x;
ff_init_block_index(&s->m); ff_init_block_index(&s->m);
ff_update_block_index(&s->m); ff_update_block_index(&s->m);


ff_estimate_p_frame_motion(&s->m, x, y); ff_estimate_p_frame_motion(&s->m, x, y);
} }
s->m.first_slice_line=0;
s->m.first_slice_line = 0;
} }


ff_fix_long_p_mvs(&s->m); ff_fix_long_p_mvs(&s->m);
ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code, CANDIDATE_MB_TYPE_INTER, 0);
ff_fix_long_mvs(&s->m, NULL, 0, s->m.p_mv_table, s->m.f_code,
CANDIDATE_MB_TYPE_INTER, 0);
} }


s->m.first_slice_line=1;
s->m.first_slice_line = 1;
for (y = 0; y < block_height; y++) { for (y = 0; y < block_height; y++) {
for(i=0; i<16 && i + 16*y<height; i++){
memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
for(x=width; x<16*block_width; x++)
src[i*stride+x]= src[i*stride+x-1];
for (i = 0; i < 16 && i + 16 * y < height; i++) {
memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
width);
for (x = width; x < 16 * block_width; x++)
src[i * stride + x] = src[i * stride + x - 1];
} }
for(; i<16 && i + 16*y<16*block_height; i++)
memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
for (; i < 16 && i + 16 * y < 16 * block_height; i++)
memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width);


s->m.mb_y= y;
s->m.mb_y = y;
for (x = 0; x < block_width; x++) { for (x = 0; x < block_width; x++) {
uint8_t reorder_buffer[3][6][7*32];
uint8_t reorder_buffer[3][6][7 * 32];
int count[3][6]; int count[3][6];
int offset = y * 16 * stride + x * 16;
uint8_t *decoded= decoded_plane + offset;
uint8_t *ref= ref_plane + offset;
int score[4]={0,0,0,0}, best;
uint8_t *temp = s->scratchbuf;

if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size
int offset = y * 16 * stride + x * 16;
uint8_t *decoded = decoded_plane + offset;
uint8_t *ref = ref_plane + offset;
int score[4] = { 0, 0, 0, 0 }, best;
uint8_t *temp = s->scratchbuf;

if (s->pb.buf_end - s->pb.buf -
(put_bits_count(&s->pb) >> 3) < 3000) { // FIXME: check size
av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
return -1; return -1;
} }


s->m.mb_x= x;
s->m.mb_x = x;
ff_init_block_index(&s->m); ff_init_block_index(&s->m);
ff_update_block_index(&s->m); ff_update_block_index(&s->m);


if(s->picture.pict_type == AV_PICTURE_TYPE_I || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
for(i=0; i<6; i++){
init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
}
if(s->picture.pict_type == AV_PICTURE_TYPE_P){
const uint8_t *vlc= ff_svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
if (s->picture.pict_type == AV_PICTURE_TYPE_I ||
(s->m.mb_type[x + y * s->m.mb_stride] &
CANDIDATE_MB_TYPE_INTRA)) {
for (i = 0; i < 6; i++)
init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],
7 * 32);
if (s->picture.pict_type == AV_PICTURE_TYPE_P) {
const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
put_bits(&s->reorder_pb[5], vlc[1], vlc[0]); put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
score[0]= vlc[1]*lambda;
score[0] = vlc[1] * lambda;
} }
score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
for(i=0; i<6; i++){
count[0][i]= put_bits_count(&s->reorder_pb[i]);
score[0] += encode_block(s, src + 16 * x, NULL, temp, stride,
5, 64, lambda, 1);
for (i = 0; i < 6; i++) {
count[0][i] = put_bits_count(&s->reorder_pb[i]);
flush_put_bits(&s->reorder_pb[i]); flush_put_bits(&s->reorder_pb[i]);
} }
}else
score[0]= INT_MAX;
} else
score[0] = INT_MAX;


best=0;
best = 0;


if(s->picture.pict_type == AV_PICTURE_TYPE_P){
const uint8_t *vlc= ff_svq1_block_type_vlc[SVQ1_BLOCK_INTER];
if (s->picture.pict_type == AV_PICTURE_TYPE_P) {
const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTER];
int mx, my, pred_x, pred_y, dxy; int mx, my, pred_x, pred_y, dxy;
int16_t *motion_ptr; int16_t *motion_ptr;


motion_ptr= ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
for(i=0; i<6; i++)
init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
motion_ptr = ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
if (s->m.mb_type[x + y * s->m.mb_stride] &
CANDIDATE_MB_TYPE_INTER) {
for (i = 0; i < 6; i++)
init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i],
7 * 32);


put_bits(&s->reorder_pb[5], vlc[1], vlc[0]); put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);


s->m.pb= s->reorder_pb[5];
mx= motion_ptr[0];
my= motion_ptr[1];
assert(mx>=-32 && mx<=31);
assert(my>=-32 && my<=31);
assert(pred_x>=-32 && pred_x<=31);
assert(pred_y>=-32 && pred_y<=31);
s->m.pb = s->reorder_pb[5];
mx = motion_ptr[0];
my = motion_ptr[1];
assert(mx >= -32 && mx <= 31);
assert(my >= -32 && my <= 31);
assert(pred_x >= -32 && pred_x <= 31);
assert(pred_y >= -32 && pred_y <= 31);
ff_h263_encode_motion(&s->m, mx - pred_x, 1); ff_h263_encode_motion(&s->m, mx - pred_x, 1);
ff_h263_encode_motion(&s->m, my - pred_y, 1); ff_h263_encode_motion(&s->m, my - pred_y, 1);
s->reorder_pb[5]= s->m.pb;
score[1] += lambda*put_bits_count(&s->reorder_pb[5]);

dxy= (mx&1) + 2*(my&1);

s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);

score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
best= score[1] <= score[0];

vlc= ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
score[2]+= vlc[1]*lambda;
if(score[2] < score[best] && mx==0 && my==0){
best=2;
s->reorder_pb[5] = s->m.pb;
score[1] += lambda * put_bits_count(&s->reorder_pb[5]);

dxy = (mx & 1) + 2 * (my & 1);

s->dsp.put_pixels_tab[0][dxy](temp + 16,
ref + (mx >> 1) +
stride * (my >> 1),
stride, 16);

score[1] += encode_block(s, src + 16 * x, temp + 16,
decoded, stride, 5, 64, lambda, 0);
best = score[1] <= score[0];

vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
score[2] = s->dsp.sse[0](NULL, src + 16 * x, ref,
stride, 16);
score[2] += vlc[1] * lambda;
if (score[2] < score[best] && mx == 0 && my == 0) {
best = 2;
s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16); s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
for(i=0; i<6; i++){
count[2][i]=0;
}
for (i = 0; i < 6; i++)
count[2][i] = 0;
put_bits(&s->pb, vlc[1], vlc[0]); put_bits(&s->pb, vlc[1], vlc[0]);
} }
} }


if(best==1){
for(i=0; i<6; i++){
count[1][i]= put_bits_count(&s->reorder_pb[i]);
if (best == 1) {
for (i = 0; i < 6; i++) {
count[1][i] = put_bits_count(&s->reorder_pb[i]);
flush_put_bits(&s->reorder_pb[i]); flush_put_bits(&s->reorder_pb[i]);
} }
}else{
motion_ptr[0 ] = motion_ptr[1 ]=
motion_ptr[2 ] = motion_ptr[3 ]=
motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
} else {
motion_ptr[0] =
motion_ptr[1] =
motion_ptr[2] =
motion_ptr[3] =
motion_ptr[0 + 2 * s->m.b8_stride] =
motion_ptr[1 + 2 * s->m.b8_stride] =
motion_ptr[2 + 2 * s->m.b8_stride] =
motion_ptr[3 + 2 * s->m.b8_stride] = 0;
} }
} }


s->rd_total += score[best]; s->rd_total += score[best];


for(i=5; i>=0; i--){
avpriv_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
}
if(best==0){
for (i = 5; i >= 0; i--)
avpriv_copy_bits(&s->pb, reorder_buffer[best][i],
count[best][i]);
if (best == 0)
s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16); s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
}
} }
s->m.first_slice_line=0;
s->m.first_slice_line = 0;
} }
return 0; return 0;
} }


static av_cold int svq1_encode_init(AVCodecContext *avctx) static av_cold int svq1_encode_init(AVCodecContext *avctx)
{ {
SVQ1Context * const s = avctx->priv_data;
SVQ1Context *const s = avctx->priv_data;


ff_dsputil_init(&s->dsp, avctx); ff_dsputil_init(&s->dsp, avctx);
avctx->coded_frame = &s->picture; avctx->coded_frame = &s->picture;


s->frame_width = avctx->width;
s->frame_width = avctx->width;
s->frame_height = avctx->height; s->frame_height = avctx->height;


s->y_block_width = (s->frame_width + 15) / 16;
s->y_block_width = (s->frame_width + 15) / 16;
s->y_block_height = (s->frame_height + 15) / 16; s->y_block_height = (s->frame_height + 15) / 16;


s->c_block_width = (s->frame_width / 4 + 15) / 16;
s->c_block_width = (s->frame_width / 4 + 15) / 16;
s->c_block_height = (s->frame_height / 4 + 15) / 16; s->c_block_height = (s->frame_height / 4 + 15) / 16;


s->avctx= avctx;
s->m.avctx= avctx;
s->avctx = avctx;
s->m.avctx = avctx;
s->m.picture_structure = PICT_FRAME; s->m.picture_structure = PICT_FRAME;
s->m.me.temp =
s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
ff_h263_encode_init(&s->m); //mv_penalty
s->m.me.temp =
s->m.me.scratchpad = av_mallocz((avctx->width + 64) *
2 * 16 * 2 * sizeof(uint8_t));
s->m.me.map = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
s->m.me.score_map = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
s->mb_type = av_mallocz((s->y_block_width + 1) *
s->y_block_height * sizeof(int16_t));
s->dummy = av_mallocz((s->y_block_width + 1) *
s->y_block_height * sizeof(int32_t));
ff_h263_encode_init(&s->m); // mv_penalty


return 0; return 0;
} }
@@ -501,49 +533,54 @@ static av_cold int svq1_encode_init(AVCodecContext *avctx)
static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt, static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pict, int *got_packet) const AVFrame *pict, int *got_packet)
{ {
SVQ1Context * const s = avctx->priv_data;
AVFrame * const p = &s->picture;
SVQ1Context *const s = avctx->priv_data;
AVFrame *const p = &s->picture;
AVFrame temp; AVFrame temp;
int i, ret; int i, ret;


if (!pkt->data && if (!pkt->data &&
(ret = av_new_packet(pkt, s->y_block_width*s->y_block_height*MAX_MB_BYTES*3 + FF_MIN_BUFFER_SIZE) < 0)) {
(ret = av_new_packet(pkt, s->y_block_width * s->y_block_height *
MAX_MB_BYTES * 3 + FF_MIN_BUFFER_SIZE) < 0)) {
av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n"); av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
return ret; return ret;
} }


if(avctx->pix_fmt != AV_PIX_FMT_YUV410P){
if (avctx->pix_fmt != AV_PIX_FMT_YUV410P) {
av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n"); av_log(avctx, AV_LOG_ERROR, "unsupported pixel format\n");
return -1; return -1;
} }


if(!s->current_picture.data[0]){
if (!s->current_picture.data[0]) {
avctx->get_buffer(avctx, &s->current_picture); avctx->get_buffer(avctx, &s->current_picture);
avctx->get_buffer(avctx, &s->last_picture); avctx->get_buffer(avctx, &s->last_picture);
s->scratchbuf = av_malloc(s->current_picture.linesize[0] * 16 * 2); s->scratchbuf = av_malloc(s->current_picture.linesize[0] * 16 * 2);
} }


temp= s->current_picture;
s->current_picture= s->last_picture;
s->last_picture= temp;
temp = s->current_picture;
s->current_picture = s->last_picture;
s->last_picture = temp;


init_put_bits(&s->pb, pkt->data, pkt->size); init_put_bits(&s->pb, pkt->data, pkt->size);


*p = *pict;
p->pict_type = avctx->gop_size && avctx->frame_number % avctx->gop_size ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
*p = *pict;
p->pict_type = avctx->gop_size && avctx->frame_number % avctx->gop_size ?
AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I;
p->key_frame = p->pict_type == AV_PICTURE_TYPE_I; p->key_frame = p->pict_type == AV_PICTURE_TYPE_I;


svq1_write_header(s, p->pict_type); svq1_write_header(s, p->pict_type);
for(i=0; i<3; i++){
if(svq1_encode_plane(s, i,
s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
s->frame_width / (i?4:1), s->frame_height / (i?4:1),
s->picture.linesize[i], s->current_picture.linesize[i]) < 0)
return -1;
}

// avpriv_align_put_bits(&s->pb);
while(put_bits_count(&s->pb) & 31)
for (i = 0; i < 3; i++)
if (svq1_encode_plane(s, i,
s->picture.data[i],
s->last_picture.data[i],
s->current_picture.data[i],
s->frame_width / (i ? 4 : 1),
s->frame_height / (i ? 4 : 1),
s->picture.linesize[i],
s->current_picture.linesize[i]) < 0)
return -1;

// avpriv_align_put_bits(&s->pb);
while (put_bits_count(&s->pb) & 31)
put_bits(&s->pb, 1, 0); put_bits(&s->pb, 1, 0);


flush_put_bits(&s->pb); flush_put_bits(&s->pb);
@@ -558,10 +595,12 @@ static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt,


static av_cold int svq1_encode_end(AVCodecContext *avctx) static av_cold int svq1_encode_end(AVCodecContext *avctx)
{ {
SVQ1Context * const s = avctx->priv_data;
SVQ1Context *const s = avctx->priv_data;
int i; int i;


av_log(avctx, AV_LOG_DEBUG, "RD: %f\n", s->rd_total/(double)(avctx->width*avctx->height*avctx->frame_number));
av_log(avctx, AV_LOG_DEBUG, "RD: %f\n",
s->rd_total / (double)(avctx->width * avctx->height *
avctx->frame_number));


av_freep(&s->m.me.scratchpad); av_freep(&s->m.me.scratchpad);
av_freep(&s->m.me.map); av_freep(&s->m.me.map);
@@ -570,7 +609,7 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx)
av_freep(&s->dummy); av_freep(&s->dummy);
av_freep(&s->scratchbuf); av_freep(&s->scratchbuf);


for(i=0; i<3; i++){
for (i = 0; i < 3; i++) {
av_freep(&s->motion_val8[i]); av_freep(&s->motion_val8[i]);
av_freep(&s->motion_val16[i]); av_freep(&s->motion_val16[i]);
} }
@@ -578,7 +617,6 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx)
return 0; return 0;
} }



AVCodec ff_svq1_encoder = { AVCodec ff_svq1_encoder = {
.name = "svq1", .name = "svq1",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
@@ -587,6 +625,7 @@ AVCodec ff_svq1_encoder = {
.init = svq1_encode_init, .init = svq1_encode_init,
.encode2 = svq1_encode_frame, .encode2 = svq1_encode_frame,
.close = svq1_encode_end, .close = svq1_encode_end,
.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV410P, AV_PIX_FMT_NONE },
.pix_fmts = (const enum PixelFormat[]) { AV_PIX_FMT_YUV410P,
AV_PIX_FMT_NONE },
.long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"), .long_name = NULL_IF_CONFIG_SMALL("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),
}; };

+ 48
- 58
libavcodec/svq1enc_cb.h View File

@@ -30,67 +30,57 @@
#include <stdint.h> #include <stdint.h>


static const int8_t svq1_inter_codebook_sum[4][16*6] = { static const int8_t svq1_inter_codebook_sum[4][16*6] = {
{
-1, 1, -2, 0, 1, -1, -1, -1, -2, -1, 1, -1, -1, 0, -1, -1,
0, -1, -1, -1, -1, 0, -1, 0, 0, 0, -3, 1, -1, 0, 1, -1,
1, -1, 2, 2, 1, 1, 2, 0, 0, 0, -1, 1, 1, 0, 0, 0,
1, -1, 0, 1, -1, 1, 1, 0, 1, 0, -1, 1, 1, 0, 0, 0,
-2, 0, 0, -2, 0, 0, -2, 0, -2, -1, -2, -1, 0, 0, -1, 0,
1, 0, 1, -1, 2, 2, 1, 2, 2, 1, 0, 1, 1, 0, 1, 1,
},{
-2, 1, -1, -1, 1, 0, 1, -1, -1, -1, 1, -1, 0, -1, 0, -1,
0, 0, 0, -2, 0, 1, 0, -1, -1, 0, 2, -3, 1, -2, 3, -1,
2, 0, 2, 1, 1, -1, 1, 1, 0, 0, 1, 1, 2, -2, 1, 0,
-2, -1, 2, -2, -2, 0, -3, 0, -1, 0, -1, 0, -1, 0, -2, -3,
1, -2, -2, -1, 1, -1, -1, 1, -1, 1, 1, 0, -2, 0, 1, 1,
1, 1, 2, 1, 0, 0, -1, 0, 0, 1, 0, 1, -1, 1, 0, 2,
},{
0, 0, 0, -3, 1, 1, 1, -3, 0, -1, 0, -3, 1, -3, 0, -2,
1, 2, -1, -3, 0, -3, 1, -1, 0, -1, 0, 0, 1, 2, 1, 1,
-1, 2, -3, 3, 1, 0, -5, 1, 0, -1, -3, 1, 0, 2, 0, -3,
4, 2, 0, -2, 1, -2, 3, -2, 1, 1, 0, -1, 2, 5, 3, 1,
-1, 0, 2, -3, -2, 0, 0, -2, 2, -3, -1, -1, 2, 1, 0, -2,
3, -1, 1, -1, 2, 4, 0, 1, 0, 1, 0, -1, -3, -2, -1, 0,
},{
0, 2, -1, -1, 2, -4, -2, 3, 0, -1, -5, 1, 0, 1, 0, 6,
-2, 2, 0, 1, 1, -1, -1, -2, 1, -2, -1, 0, 2, -2, -2, -1,
-4, 2, -1, -3, -1, -2, 2, -1, 2, -1, 2, 0, 3, -3, -3, 0,
-3, 0, 0, -2, 4, -4, 0, -1, 4, 0, -2, -2, 3, -2, 0, 4,
5, 0, 1, 0, -3, 3, 3, 2, 0, 0, 1, 2, -5, -2, -3, 0,
-3, 2, -2, 2, -2, 4, 7, -3, 4, 2, 3, 2, -1, 0, -3, 1,
}
{ -1, 1, -2, 0, 1, -1, -1, -1, -2, -1, 1, -1, -1, 0, -1, -1,
0, -1, -1, -1, -1, 0, -1, 0, 0, 0, -3, 1, -1, 0, 1, -1,
1, -1, 2, 2, 1, 1, 2, 0, 0, 0, -1, 1, 1, 0, 0, 0,
1, -1, 0, 1, -1, 1, 1, 0, 1, 0, -1, 1, 1, 0, 0, 0,
-2, 0, 0, -2, 0, 0, -2, 0, -2, -1, -2, -1, 0, 0, -1, 0,
1, 0, 1, -1, 2, 2, 1, 2, 2, 1, 0, 1, 1, 0, 1, 1, },
{ -2, 1, -1, -1, 1, 0, 1, -1, -1, -1, 1, -1, 0, -1, 0, -1,
0, 0, 0, -2, 0, 1, 0, -1, -1, 0, 2, -3, 1, -2, 3, -1,
2, 0, 2, 1, 1, -1, 1, 1, 0, 0, 1, 1, 2, -2, 1, 0,
-2, -1, 2, -2, -2, 0, -3, 0, -1, 0, -1, 0, -1, 0, -2, -3,
1, -2, -2, -1, 1, -1, -1, 1, -1, 1, 1, 0, -2, 0, 1, 1,
1, 1, 2, 1, 0, 0, -1, 0, 0, 1, 0, 1, -1, 1, 0, 2, },
{ 0, 0, 0, -3, 1, 1, 1, -3, 0, -1, 0, -3, 1, -3, 0, -2,
1, 2, -1, -3, 0, -3, 1, -1, 0, -1, 0, 0, 1, 2, 1, 1,
-1, 2, -3, 3, 1, 0, -5, 1, 0, -1, -3, 1, 0, 2, 0, -3,
4, 2, 0, -2, 1, -2, 3, -2, 1, 1, 0, -1, 2, 5, 3, 1,
-1, 0, 2, -3, -2, 0, 0, -2, 2, -3, -1, -1, 2, 1, 0, -2,
3, -1, 1, -1, 2, 4, 0, 1, 0, 1, 0, -1, -3, -2, -1, 0, },
{ 0, 2, -1, -1, 2, -4, -2, 3, 0, -1, -5, 1, 0, 1, 0, 6,
-2, 2, 0, 1, 1, -1, -1, -2, 1, -2, -1, 0, 2, -2, -2, -1,
-4, 2, -1, -3, -1, -2, 2, -1, 2, -1, 2, 0, 3, -3, -3, 0,
-3, 0, 0, -2, 4, -4, 0, -1, 4, 0, -2, -2, 3, -2, 0, 4,
5, 0, 1, 0, -3, 3, 3, 2, 0, 0, 1, 2, -5, -2, -3, 0,
-3, 2, -2, 2, -2, 4, 7, -3, 4, 2, 3, 2, -1, 0, -3, 1, }
}; };


static const int8_t svq1_intra_codebook_sum[4][16*6] = { static const int8_t svq1_intra_codebook_sum[4][16*6] = {
{
0, 0, 0, -1, -1, -1, -1, -2, 0, -1, -1, 0, -1, 0, 1, 0,
1, 0, -1, 1, 0, 0, -1, 1, -1, 0, 0, 0, -1, 1, 0, 0,
-1, 0, 0, 1, -1, 1, 0, -1, -1, 0, 1, 1, 0, 0, -1, 1,
0, 1, 0, 0, 1, -1, 0, 0, 0, -1, 1, 0, 1, 0, -2, 1,
0, -1, 1, 0, 0, 0, 1, 0, -1, 0, 0, 0, -1, 0, 0, 0,
0, 1, 1, 0, 0, -1, 0, 1, 0, 0, 0, 0, -1, 1, 1, -1,
},{
-1, -2, 0, -1, 1, 0, -1, 0, -1, -4, -1, -2, -1, -2, 1, -2,
0, 0, 4, -2, -1, 1, 1, 0, 2, 1, 1, 0, 2, 0, 0, 0,
1, 1, 0, -1, -1, -1, 1, 0, -1, -3, -3, 1, -1, 1, -2, -1,
1, -1, 0, 1, 2, 1, -1, -1, 1, 1, 1, 2, 1, 0, 1, -2,
-2, 0, -1, -2, -2, 0, -1, -1, -1, 0, 1, 0, -1, -1, 0, -1,
0, 2, 1, 2, 2, 1, -1, 1, 0, 2, 0, -1, 1, 0, 0, 0,
},{
-2, 0, -1, -1, 1, 1, -2, 0, -2, 0, 1, -2, -2, 1, -1, -1,
3, -2, 0, -3, -4, -3, 2, 1, 0, 3, -2, 2, 3, 2, 2, -1,
-3, 1, 0, 1, 0, 0, 0, 1, -2, 1, -2, -2, -1, -2, -2, 2,
0, -4, 0, 2, -1, 0, 2, 2, 2, 1, 0, -1, -1, 1, -3, 2,
2, 1, 0, 3, 1, -1, 1, 3, 1, 0, 1, 1, 2, -1, 1, -1,
-2, -1, 0, -1, 1, -1, 1, -2, -2, -1, -1, -3, 1, -4, -3, 1,
},{
-2, 0, -2, 3, -1, -1, 0, 2, 2, -1, -3, 2, 1, 0, -2, -1,
-3, -2, -2, 1, 2, -3, 0, 1, -5, -2, -3, 0, -2, -1, 2, 0,
-1, -1, 0, -2, 1, 3, -7, -2, -2, -1, 2, -1, 0, 3, 1, 3,
1, 0, 0, 1, 2, 3, 1, 2, 0, -2, -2, 1, 1, 2, 2, 3,
4, 1, -1, 2, -2, 4, 0, 0, 0, 4, 2, 0, -2, -2, 2, -4,
-1, 5, -2, -2, -3, 2, -3, -1, 3, -3, 0, 4, 3, 0, 1, -2,
}
{ 0, 0, 0, -1, -1, -1, -1, -2, 0, -1, -1, 0, -1, 0, 1, 0,
1, 0, -1, 1, 0, 0, -1, 1, -1, 0, 0, 0, -1, 1, 0, 0,
-1, 0, 0, 1, -1, 1, 0, -1, -1, 0, 1, 1, 0, 0, -1, 1,
0, 1, 0, 0, 1, -1, 0, 0, 0, -1, 1, 0, 1, 0, -2, 1,
0, -1, 1, 0, 0, 0, 1, 0, -1, 0, 0, 0, -1, 0, 0, 0,
0, 1, 1, 0, 0, -1, 0, 1, 0, 0, 0, 0, -1, 1, 1, -1, },
{ -1, -2, 0, -1, 1, 0, -1, 0, -1, -4, -1, -2, -1, -2, 1, -2,
0, 0, 4, -2, -1, 1, 1, 0, 2, 1, 1, 0, 2, 0, 0, 0,
1, 1, 0, -1, -1, -1, 1, 0, -1, -3, -3, 1, -1, 1, -2, -1,
1, -1, 0, 1, 2, 1, -1, -1, 1, 1, 1, 2, 1, 0, 1, -2,
-2, 0, -1, -2, -2, 0, -1, -1, -1, 0, 1, 0, -1, -1, 0, -1,
0, 2, 1, 2, 2, 1, -1, 1, 0, 2, 0, -1, 1, 0, 0, 0, },
{ -2, 0, -1, -1, 1, 1, -2, 0, -2, 0, 1, -2, -2, 1, -1, -1,
3, -2, 0, -3, -4, -3, 2, 1, 0, 3, -2, 2, 3, 2, 2, -1,
-3, 1, 0, 1, 0, 0, 0, 1, -2, 1, -2, -2, -1, -2, -2, 2,
0, -4, 0, 2, -1, 0, 2, 2, 2, 1, 0, -1, -1, 1, -3, 2,
2, 1, 0, 3, 1, -1, 1, 3, 1, 0, 1, 1, 2, -1, 1, -1,
-2, -1, 0, -1, 1, -1, 1, -2, -2, -1, -1, -3, 1, -4, -3, 1, },
{ -2, 0, -2, 3, -1, -1, 0, 2, 2, -1, -3, 2, 1, 0, -2, -1,
-3, -2, -2, 1, 2, -3, 0, 1, -5, -2, -3, 0, -2, -1, 2, 0,
-1, -1, 0, -2, 1, 3, -7, -2, -2, -1, 2, -1, 0, 3, 1, 3,
1, 0, 0, 1, 2, 3, 1, 2, 0, -2, -2, 1, 1, 2, 2, 3,
4, 1, -1, 2, -2, 4, 0, 0, 0, 4, 2, 0, -2, -2, 2, -4,
-1, 5, -2, -2, -3, 2, -3, -1, 3, -3, 0, 4, 3, 0, 1, -2, }
}; };


#endif /* AVCODEC_SVQ1ENC_CB_H */ #endif /* AVCODEC_SVQ1ENC_CB_H */

Write Preview
Loading…
Cancel
Save