Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

svq1: K&R formatting cosmetics

Browse Source
pull/6/head
Diego Biurrun 13 years ago
parent 4b895cb294
commit ada12f8366
7 changed files with 1109 additions and 1075 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 4
      libavcodec/svq1.c
  2. 8
      libavcodec/svq1.h
  3. 77
      libavcodec/svq13.c
  4. 231
      libavcodec/svq1_vlc.h
  5. 1153
      libavcodec/svq1dec.c
  6. 605
      libavcodec/svq1enc.c
  7. 106
      libavcodec/svq1enc_cb.h

4
libavcodec/svq1.c
Unescape 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 }, { 160, 120 }, { 128, 96 }, { 176, 144 }, { 352, 288 },
{ 704, 576 }, { 240, 180 }, { 320, 240 } { 704, 576 }, { 240, 180 }, { 320, 240 }
}; };

8
libavcodec/svq1.h
Unescape 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, uint16_t ff_svq1_packet_checksum(const uint8_t *data,
int value); const int length, int value);
extern const int8_t* const ff_svq1_inter_codebooks[6]; 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_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];

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

231
libavcodec/svq1_vlc.h
Unescape 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 } */ /* { code, length } */
{ { { 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 },
{ 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 }, { 0x2, 4 }, { 0x0, 5 }, { 0x1, 4 } },
{ 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, 4 }, { 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { { 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x0, 5 },
{ 0x3, 3 }, { 0x2, 3 }, { 0x0, 4 }, { 0x1, 3 } { 0x3, 4 }, { 0x2, 3 }, { 0x2, 4 }, { 0x1, 4 } },
},{ { { 0x1, 6 }, { 0x1, 1 }, { 0x1, 2 }, { 0x0, 6 },
{ 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x0, 5 }, { 0x3, 4 }, { 0x2, 4 }, { 0x1, 5 }, { 0x1, 4 } },
{ 0x3, 4 }, { 0x2, 3 }, { 0x2, 4 }, { 0x1, 4 } { { 0x1, 6 }, { 0x1, 1 }, { 0x1, 2 }, { 0x3, 5 },
},{ { 0x2, 5 }, { 0x0, 6 }, { 0x1, 5 }, { 0x1, 3 } },
{ 0x1, 6 }, { 0x1, 1 }, { 0x1, 2 }, { 0x0, 6 }, { { 0x1, 7 }, { 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 },
{ 0x3, 4 }, { 0x2, 4 }, { 0x1, 5 }, { 0x1, 4 } { 0x1, 4 }, { 0x1, 6 }, { 0x0, 7 }, { 0x1, 5 } }
},{
{ 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 } */ /* { code, length } */
{ { { 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 },
{ 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 }, { 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 } },
{ 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 } { { 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 },
},{ { 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 } },
{ 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 }, { { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 } { 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 } },
},{ { { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 }, { 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 } },
{ 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 }, { { 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 }, { 0x3, 5 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 } { 0x2, 5 }, { 0x1, 5 }, { 0x1, 6 }, { 0x0, 6 } }
},{
{ 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 } */ /* { code, length } */
{ 0x37, 6 }, { 0x56, 7 }, { 0x1, 17 }, { 0x1, 20 }, { 0x37, 6 }, { 0x56, 7 }, { 0x01, 17 }, { 0x01, 20 },
{ 0x2, 20 }, { 0x3, 20 }, { 0x0, 20 }, { 0x4, 20 }, { 0x02, 20 }, { 0x03, 20 }, { 0x00, 20 }, { 0x04, 20 },
{ 0x5, 20 }, { 0x3, 19 }, { 0x15, 11 }, { 0x42, 9 }, { 0x05, 20 }, { 0x03, 19 }, { 0x15, 11 }, { 0x42, 9 },
{ 0x14, 11 }, { 0x3, 14 }, { 0x2, 14 }, { 0x1, 15 }, { 0x14, 11 }, { 0x03, 14 }, { 0x02, 14 }, { 0x01, 15 },
{ 0x1, 16 }, { 0x1, 12 }, { 0x2B, 10 }, { 0x18, 11 }, { 0x01, 16 }, { 0x01, 12 }, { 0x2B, 10 }, { 0x18, 11 },
{ 0xC, 11 }, { 0x41, 9 }, { 0x78, 8 }, { 0x6C, 8 }, { 0x0C, 11 }, { 0x41, 9 }, { 0x78, 8 }, { 0x6C, 8 },
{ 0x55, 7 }, { 0xF, 4 }, { 0xE, 4 }, { 0x34, 6 }, { 0x55, 7 }, { 0x0F, 4 }, { 0x0E, 4 }, { 0x34, 6 },
{ 0x51, 7 }, { 0x72, 8 }, { 0x6E, 8 }, { 0x40, 9 }, { 0x51, 7 }, { 0x72, 8 }, { 0x6E, 8 }, { 0x40, 9 },
{ 0x3F, 9 }, { 0x3E, 9 }, { 0x3D, 9 }, { 0x3C, 9 }, { 0x3F, 9 }, { 0x3E, 9 }, { 0x3D, 9 }, { 0x3C, 9 },
{ 0x3B, 9 }, { 0x3A, 9 }, { 0x39, 9 }, { 0x38, 9 }, { 0x3B, 9 }, { 0x3A, 9 }, { 0x39, 9 }, { 0x38, 9 },
{ 0x37, 9 }, { 0x43, 9 }, { 0x46, 9 }, { 0x47, 9 }, { 0x37, 9 }, { 0x43, 9 }, { 0x46, 9 }, { 0x47, 9 },
{ 0x45, 9 }, { 0x44, 9 }, { 0x49, 9 }, { 0x48, 9 }, { 0x45, 9 }, { 0x44, 9 }, { 0x49, 9 }, { 0x48, 9 },
{ 0x4A, 8 }, { 0x79, 8 }, { 0x76, 8 }, { 0x77, 8 }, { 0x4A, 8 }, { 0x79, 8 }, { 0x76, 8 }, { 0x77, 8 },
{ 0x71, 8 }, { 0x75, 8 }, { 0x74, 8 }, { 0x73, 8 }, { 0x71, 8 }, { 0x75, 8 }, { 0x74, 8 }, { 0x73, 8 },
{ 0x6A, 8 }, { 0x55, 8 }, { 0x70, 8 }, { 0x6F, 8 }, { 0x6A, 8 }, { 0x55, 8 }, { 0x70, 8 }, { 0x6F, 8 },
{ 0x52, 8 }, { 0x6D, 8 }, { 0x4C, 8 }, { 0x6B, 8 }, { 0x52, 8 }, { 0x6D, 8 }, { 0x4C, 8 }, { 0x6B, 8 },
{ 0x40, 7 }, { 0x69, 8 }, { 0x68, 8 }, { 0x67, 8 }, { 0x40, 7 }, { 0x69, 8 }, { 0x68, 8 }, { 0x67, 8 },
{ 0x66, 8 }, { 0x65, 8 }, { 0x64, 8 }, { 0x63, 8 }, { 0x66, 8 }, { 0x65, 8 }, { 0x64, 8 }, { 0x63, 8 },
{ 0x62, 8 }, { 0x61, 8 }, { 0x60, 8 }, { 0x5F, 8 }, { 0x62, 8 }, { 0x61, 8 }, { 0x60, 8 }, { 0x5F, 8 },
{ 0x5E, 8 }, { 0x5D, 8 }, { 0x5C, 8 }, { 0x5B, 8 }, { 0x5E, 8 }, { 0x5D, 8 }, { 0x5C, 8 }, { 0x5B, 8 },
{ 0x5A, 8 }, { 0x59, 8 }, { 0x58, 8 }, { 0x57, 8 }, { 0x5A, 8 }, { 0x59, 8 }, { 0x58, 8 }, { 0x57, 8 },
{ 0x56, 8 }, { 0x3D, 7 }, { 0x54, 8 }, { 0x53, 8 }, { 0x56, 8 }, { 0x3D, 7 }, { 0x54, 8 }, { 0x53, 8 },
{ 0x3F, 7 }, { 0x51, 8 }, { 0x50, 8 }, { 0x4F, 8 }, { 0x3F, 7 }, { 0x51, 8 }, { 0x50, 8 }, { 0x4F, 8 },
{ 0x4E, 8 }, { 0x4D, 8 }, { 0x41, 7 }, { 0x4B, 8 }, { 0x4E, 8 }, { 0x4D, 8 }, { 0x41, 7 }, { 0x4B, 8 },
{ 0x53, 7 }, { 0x3E, 7 }, { 0x48, 8 }, { 0x4F, 7 }, { 0x53, 7 }, { 0x3E, 7 }, { 0x48, 8 }, { 0x4F, 7 },
{ 0x52, 7 }, { 0x45, 8 }, { 0x50, 7 }, { 0x43, 8 }, { 0x52, 7 }, { 0x45, 8 }, { 0x50, 7 }, { 0x43, 8 },
{ 0x42, 8 }, { 0x41, 8 }, { 0x42, 7 }, { 0x43, 7 }, { 0x42, 8 }, { 0x41, 8 }, { 0x42, 7 }, { 0x43, 7 },
{ 0x3E, 8 }, { 0x44, 7 }, { 0x3C, 8 }, { 0x45, 7 }, { 0x3E, 8 }, { 0x44, 7 }, { 0x3C, 8 }, { 0x45, 7 },
{ 0x46, 7 }, { 0x47, 7 }, { 0x48, 7 }, { 0x49, 7 }, { 0x46, 7 }, { 0x47, 7 }, { 0x48, 7 }, { 0x49, 7 },
{ 0x4A, 7 }, { 0x4B, 7 }, { 0x4C, 7 }, { 0x4D, 7 }, { 0x4A, 7 }, { 0x4B, 7 }, { 0x4C, 7 }, { 0x4D, 7 },
{ 0x4E, 7 }, { 0x58, 7 }, { 0x59, 7 }, { 0x5A, 7 }, { 0x4E, 7 }, { 0x58, 7 }, { 0x59, 7 }, { 0x5A, 7 },
{ 0x5B, 7 }, { 0x5C, 7 }, { 0x5D, 7 }, { 0x44, 8 }, { 0x5B, 7 }, { 0x5C, 7 }, { 0x5D, 7 }, { 0x44, 8 },
{ 0x49, 8 }, { 0x29, 8 }, { 0x3F, 8 }, { 0x3D, 8 }, { 0x49, 8 }, { 0x29, 8 }, { 0x3F, 8 }, { 0x3D, 8 },
{ 0x3B, 8 }, { 0x2C, 8 }, { 0x28, 8 }, { 0x25, 8 }, { 0x3B, 8 }, { 0x2C, 8 }, { 0x28, 8 }, { 0x25, 8 },
{ 0x26, 8 }, { 0x5E, 7 }, { 0x57, 7 }, { 0x54, 7 }, { 0x26, 8 }, { 0x5E, 7 }, { 0x57, 7 }, { 0x54, 7 },
{ 0x5F, 7 }, { 0x62, 7 }, { 0x63, 7 }, { 0x64, 7 }, { 0x5F, 7 }, { 0x62, 7 }, { 0x63, 7 }, { 0x64, 7 },
{ 0x61, 7 }, { 0x65, 7 }, { 0x67, 7 }, { 0x66, 7 }, { 0x61, 7 }, { 0x65, 7 }, { 0x67, 7 }, { 0x66, 7 },
{ 0x35, 6 }, { 0x36, 6 }, { 0x60, 7 }, { 0x39, 8 }, { 0x35, 6 }, { 0x36, 6 }, { 0x60, 7 }, { 0x39, 8 },
{ 0x3A, 8 }, { 0x38, 8 }, { 0x37, 8 }, { 0x36, 8 }, { 0x3A, 8 }, { 0x38, 8 }, { 0x37, 8 }, { 0x36, 8 },
{ 0x35, 8 }, { 0x34, 8 }, { 0x33, 8 }, { 0x32, 8 }, { 0x35, 8 }, { 0x34, 8 }, { 0x33, 8 }, { 0x32, 8 },
{ 0x31, 8 }, { 0x30, 8 }, { 0x2D, 8 }, { 0x2B, 8 }, { 0x31, 8 }, { 0x30, 8 }, { 0x2D, 8 }, { 0x2B, 8 },
{ 0x2A, 8 }, { 0x27, 8 }, { 0x40, 8 }, { 0x46, 8 }, { 0x2A, 8 }, { 0x27, 8 }, { 0x40, 8 }, { 0x46, 8 },
{ 0x47, 8 }, { 0x26, 9 }, { 0x25, 9 }, { 0x24, 9 }, { 0x47, 8 }, { 0x26, 9 }, { 0x25, 9 }, { 0x24, 9 },
{ 0x23, 9 }, { 0x22, 9 }, { 0x2E, 8 }, { 0x2F, 8 }, { 0x23, 9 }, { 0x22, 9 }, { 0x2E, 8 }, { 0x2F, 8 },
{ 0x1F, 9 }, { 0x36, 9 }, { 0x1D, 9 }, { 0x21, 9 }, { 0x1F, 9 }, { 0x36, 9 }, { 0x1D, 9 }, { 0x21, 9 },
{ 0x1B, 9 }, { 0x1C, 9 }, { 0x19, 9 }, { 0x1A, 9 }, { 0x1B, 9 }, { 0x1C, 9 }, { 0x19, 9 }, { 0x1A, 9 },
{ 0x18, 9 }, { 0x17, 9 }, { 0x16, 9 }, { 0x1E, 9 }, { 0x18, 9 }, { 0x17, 9 }, { 0x16, 9 }, { 0x1E, 9 },
{ 0x20, 9 }, { 0x27, 9 }, { 0x28, 9 }, { 0x29, 9 }, { 0x20, 9 }, { 0x27, 9 }, { 0x28, 9 }, { 0x29, 9 },
{ 0x2A, 9 }, { 0x2B, 9 }, { 0x2C, 9 }, { 0x2D, 9 }, { 0x2A, 9 }, { 0x2B, 9 }, { 0x2C, 9 }, { 0x2D, 9 },
{ 0x2E, 9 }, { 0x2F, 9 }, { 0x30, 9 }, { 0x35, 9 }, { 0x2E, 9 }, { 0x2F, 9 }, { 0x30, 9 }, { 0x35, 9 },
{ 0x31, 9 }, { 0x32, 9 }, { 0x33, 9 }, { 0x34, 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 }, { 0x29, 10 }, { 0x12, 10 }, { 0x0D, 10 }, { 0x0E, 10 },
{ 0xF, 10 }, { 0x10, 10 }, { 0x11, 10 }, { 0x1A, 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 }, { 0x24, 10 }, { 0x09, 11 }, { 0x08, 11 }, { 0x07, 11 },
{ 0x27, 10 }, { 0x5, 11 }, { 0xB, 11 }, { 0x6, 11 }, { 0x27, 10 }, { 0x05, 11 }, { 0x0B, 11 }, { 0x06, 11 },
{ 0x4, 11 }, { 0x3, 11 }, { 0x2, 11 }, { 0x1, 11 }, { 0x04, 11 }, { 0x03, 11 }, { 0x02, 11 }, { 0x01, 11 },
{ 0xA, 11 }, { 0x16, 11 }, { 0x19, 11 }, { 0x17, 11 }, { 0x0A, 11 }, { 0x16, 11 }, { 0x19, 11 }, { 0x17, 11 },
{ 0xD, 11 }, { 0xE, 11 }, { 0xF, 11 }, { 0x10, 11 }, { 0x0D, 11 }, { 0x0E, 11 }, { 0x0F, 11 }, { 0x10, 11 },
{ 0x11, 11 }, { 0x12, 11 }, { 0x13, 11 }, { 0x1, 14 } { 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 }, { 0x100,22 }, { 0x5C, 22 }, { 0x60, 22 }, { 0x101,22 },
{ 0x71, 22 }, { 0x104, 22 }, { 0x105, 22 }, { 0xFB, 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 }, { 0x1A, 11 }, { 0x0E, 10 }, { 0x13, 10 }, { 0x0F, 10 },
{ 0x10, 10 }, { 0x11, 10 }, { 0x12, 10 }, { 0xD, 9 }, { 0x10, 10 }, { 0x11, 10 }, { 0x12, 10 }, { 0x0D, 9 },
{ 0x14, 9 }, { 0x15, 9 }, { 0xC, 9 }, { 0x13, 9 }, { 0x14, 9 }, { 0x15, 9 }, { 0x0C, 9 }, { 0x13, 9 },
{ 0xF, 8 }, { 0xE, 8 }, { 0x10, 8 }, { 0x11, 8 }, { 0x0F, 8 }, { 0x0E, 8 }, { 0x10, 8 }, { 0x11, 8 },
{ 0xC, 7 }, { 0x9, 7 }, { 0xA, 7 }, { 0x8, 6 }, { 0x0C, 7 }, { 0x09, 7 }, { 0x0A, 7 }, { 0x08, 6 },
{ 0x9, 6 }, { 0x9, 5 }, { 0x8, 5 }, { 0x5, 4 }, { 0x09, 6 }, { 0x09, 5 }, { 0x08, 5 }, { 0x05, 4 },
{ 0x1, 1 }, { 0x3, 3 }, { 0x7, 5 }, { 0x6, 5 }, { 0x01, 1 }, { 0x03, 3 }, { 0x07, 5 }, { 0x06, 5 },
{ 0xB, 6 }, { 0xA, 6 }, { 0xE, 7 }, { 0xF, 7 }, { 0x0B, 6 }, { 0x0A, 6 }, { 0x0E, 7 }, { 0x0F, 7 },
{ 0xB, 7 }, { 0xD, 7 }, { 0xB, 8 }, { 0xD, 8 }, { 0x0B, 7 }, { 0x0D, 7 }, { 0x0B, 8 }, { 0x0D, 8 },
{ 0xC, 8 }, { 0xF, 9 }, { 0x10, 9 }, { 0x11, 9 }, { 0x0C, 8 }, { 0x0F, 9 }, { 0x10, 9 }, { 0x11, 9 },
{ 0xE, 9 }, { 0x12, 9 }, { 0x17, 10 }, { 0x14, 10 }, { 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 }, { 0x0F, 22 }, { 0x0E, 22 }, { 0x0D, 22 }, { 0x0C, 22 },
{ 0xB, 22 }, { 0xA, 22 }, { 0x9, 22 }, { 0x8, 22 }, { 0x0B, 22 }, { 0x0A, 22 }, { 0x09, 22 }, { 0x08, 22 },
{ 0x7, 22 }, { 0x6, 22 }, { 0x5, 22 }, { 0x4, 22 }, { 0x07, 22 }, { 0x06, 22 }, { 0x05, 22 }, { 0x04, 22 },
{ 0x3, 22 }, { 0x2, 22 }, { 0x1, 22 }, { 0x0, 22 } { 0x03, 22 }, { 0x02, 22 }, { 0x01, 22 }, { 0x00, 22 }
}; };
#endif /* AVCODEC_SVQ1_VLC_H */ #endif /* AVCODEC_SVQ1_VLC_H */

1153
libavcodec/svq1dec.c
View File

File diff suppressed because it is too large Load Diff

605
libavcodec/svq1enc.c
Unescape 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) if (i == 7) {
{ put_bits(&s->pb, 12, s->frame_width);
put_bits(&s->pb, 12, s->frame_width); put_bits(&s->pb, 12, s->frame_height);
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 block_sum[7] = { 0, 0, 0, 0, 0, 0 };
int w= 2<<((level+2)>>1); int w = 2 << ((level + 2) >> 1);
int h= 2<<((level+1)>>1); int h = 2 << ((level + 1) >> 1);
int size=w*h; 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 uint16_t(*mean_vlc)[2];
const uint8_t (*multistage_vlc)[2]; const uint8_t(*multistage_vlc)[2];
best_score=0; best_score = 0;
//FIXME optimize, this doenst need to be done multiple times // FIXME: Optimize, this does not need to be done multiple times.
if(intra){ if (intra) {
codebook_sum= svq1_intra_codebook_sum[level]; codebook_sum = svq1_intra_codebook_sum[level];
codebook= ff_svq1_intra_codebooks[level]; codebook = ff_svq1_intra_codebooks[level];
mean_vlc= ff_svq1_intra_mean_vlc; mean_vlc = ff_svq1_intra_mean_vlc;
multistage_vlc= ff_svq1_intra_multistage_vlc[level]; multistage_vlc = ff_svq1_intra_multistage_vlc[level];
for(y=0; y<h; y++){ for (y = 0; y < h; y++) {
for(x=0; x<w; x++){ for (x = 0; x < w; x++) {
int v= src[x + y*stride]; int v = src[x + y * stride];
block[0][x + w*y]= v; block[0][x + w * y] = v;
best_score += v*v; best_score += v * v;
block_sum[0] += v; block_sum[0] += v;
} }
} }
}else{ } else {
codebook_sum= svq1_inter_codebook_sum[level]; codebook_sum = svq1_inter_codebook_sum[level];
codebook= ff_svq1_inter_codebooks[level]; codebook = ff_svq1_inter_codebooks[level];
mean_vlc= ff_svq1_inter_mean_vlc + 256; mean_vlc = ff_svq1_inter_mean_vlc + 256;
multistage_vlc= ff_svq1_inter_multistage_vlc[level]; multistage_vlc = ff_svq1_inter_multistage_vlc[level];
for(y=0; y<h; y++){ for (y = 0; y < h; y++) {
for(x=0; x<w; x++){ for (x = 0; x < w; x++) {
int v= src[x + y*stride] - ref[x + y*stride]; int v = src[x + y * stride] - ref[x + y * stride];
block[0][x + w*y]= v; block[0][x + w * y] = v;
best_score += v*v; best_score += v * v;
block_sum[0] += v; block_sum[0] += v;
} }
} }
} }
best_count=0; best_count = 0;
best_score -= (int)(((unsigned)block_sum[0]*block_sum[0])>>(level+3)); best_score -= (int)(((unsigned)block_sum[0] * block_sum[0]) >> (level + 3));
best_mean= (block_sum[0] + (size>>1)) >> (level+3); best_mean = (block_sum[0] + (size >> 1)) >> (level + 3);
if(level<4){ if (level < 4) {
for(count=1; count<7; count++){ for (count = 1; count < 7; count++) {
int best_vector_score= INT_MAX; int best_vector_score = INT_MAX;
int best_vector_sum=-999, best_vector_mean=-999; int best_vector_sum = -999, best_vector_mean = -999;
const int stage= count-1; const int stage = count - 1;
const int8_t *vector; const int8_t *vector;
for(i=0; i<16; i++){ for (i = 0; i < 16; i++) {
int sum= codebook_sum[stage*16 + i]; int sum = codebook_sum[stage * 16 + i];
int sqr, diff, score; int sqr, diff, score;
vector = codebook + stage*size*16 + i*size; vector = codebook + stage * size * 16 + i * size;
sqr = s->dsp.ssd_int8_vs_int16(vector, block[stage], size); sqr = s->dsp.ssd_int8_vs_int16(vector, block[stage], size);
diff= block_sum[stage] - sum; diff = block_sum[stage] - sum;
score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow score = sqr - ((diff * (int64_t)diff) >> (level + 3)); // FIXME: 64bit slooow
if(score < best_vector_score){ if (score < best_vector_score) {
int mean= (diff + (size>>1)) >> (level+3); int mean = (diff + (size >> 1)) >> (level + 3);
assert(mean >-300 && mean<300); assert(mean > -300 && mean < 300);
mean= av_clip(mean, intra?0:-256, 255); mean = av_clip(mean, intra ? 0 : -256, 255);
best_vector_score= score; best_vector_score = score;
best_vector[stage]= i; best_vector[stage] = i;
best_vector_sum= sum; best_vector_sum = sum;
best_vector_mean= mean; best_vector_mean = mean;
} }
} }
assert(best_vector_mean != -999); assert(best_vector_mean != -999);
vector= codebook + stage*size*16 + best_vector[stage]*size; vector = codebook + stage * size * 16 + best_vector[stage] * size;
for(j=0; j<size; j++){ for (j = 0; j < size; j++)
block[stage+1][j] = block[stage][j] - vector[j]; block[stage + 1][j] = block[stage][j] - vector[j];
} block_sum[stage + 1] = block_sum[stage] - best_vector_sum;
block_sum[stage+1]= block_sum[stage] - best_vector_sum; best_vector_score += lambda *
best_vector_score += (+1 + 4 * count +
lambda*(+ 1 + 4*count multistage_vlc[1 + count][1]
+ multistage_vlc[1+count][1] + mean_vlc[best_vector_mean][1]);
+ mean_vlc[best_vector_mean][1]);
if (best_vector_score < best_score) {
if(best_vector_score < best_score){ best_score = best_vector_score;
best_score= best_vector_score; best_count = count;
best_count= count; best_mean = best_vector_mean;
best_mean= best_vector_mean;
} }
} }
} }
split=0; split = 0;
if(best_score > threshold && level){ if (best_score > threshold && level) {
int score=0; int score = 0;
int offset= (level&1) ? stride*h/2 : w/2; int offset = (level & 1) ? stride * h / 2 : w / 2;
PutBitContext backup[6]; PutBitContext backup[6];
for(i=level-1; i>=0; i--){ for (i = level - 1; i >= 0; i--)
backup[i]= s->reorder_pb[i]; backup[i] = s->reorder_pb[i];
} score += encode_block(s, src, ref, decoded, stride, level - 1,
score += encode_block(s, src , ref , decoded , stride, level-1, threshold>>1, lambda, intra); threshold >> 1, lambda, intra);
score += encode_block(s, src + offset, ref + offset, decoded + offset, 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){ if (score < best_score) {
best_score= score; best_score = score;
split=1; split = 1;
}else{ } else {
for(i=level-1; i>=0; i--){ for (i = level - 1; i >= 0; i--)
s->reorder_pb[i]= backup[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){ if (!split) {
assert((best_mean >= 0 && best_mean<256) || !intra); assert((best_mean >= 0 && best_mean < 256) || !intra);
assert(best_mean >= -256 && best_mean<256); assert(best_mean >= -256 && best_mean < 256);
assert(best_count >=0 && best_count<7); assert(best_count >= 0 && best_count < 7);
assert(level<4 || best_count==0); 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][1],
multistage_vlc[1 + best_count][0]); 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++){ for (i = 0; i < best_count; i++) {
assert(best_vector[i]>=0 && best_vector[i]<16); 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 (y = 0; y < h; y++)
for(x=0; x<w; x++){ for (x = 0; x < w; x++)
decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean; 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,
static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane, unsigned char *src_plane,
int width, int height, int src_stride, int stride) 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; uint8_t *src = s->scratchbuf + stride * 16;
const int lambda= (s->picture.quality*s->picture.quality) >> (2*FF_LAMBDA_SHIFT); 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){ if (s->picture.pict_type == AV_PICTURE_TYPE_P) {
s->m.avctx= s->avctx; s->m.avctx = s->avctx;
s->m.current_picture_ptr= &s->m.current_picture; s->m.current_picture_ptr = &s->m.current_picture;
s->m.last_picture_ptr = &s->m.last_picture; s->m.last_picture_ptr = &s->m.last_picture;
s->m.last_picture.f.data[0] = ref_plane; s->m.last_picture.f.data[0] = ref_plane;
s->m.linesize= s->m.linesize =
s->m.last_picture.f.linesize[0] = s->m.last_picture.f.linesize[0] =
s->m.new_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.width = width;
s->m.height= height; s->m.height = height;
s->m.mb_width= block_width; s->m.mb_width = block_width;
s->m.mb_height= block_height; s->m.mb_height = block_height;
s->m.mb_stride= s->m.mb_width+1; s->m.mb_stride = s->m.mb_width + 1;
s->m.b8_stride= 2*s->m.mb_width+1; s->m.b8_stride = 2 * s->m.mb_width + 1;
s->m.f_code=1; s->m.f_code = 1;
s->m.pict_type= s->picture.pict_type; s->m.pict_type = s->picture.pict_type;
s->m.me_method= s->avctx->me_method; s->m.me_method = s->avctx->me_method;
s->m.me.scene_change_score=0; s->m.me.scene_change_score = 0;
s->m.flags= s->avctx->flags; s->m.flags = s->avctx->flags;
// s->m.out_format = FMT_H263; // s->m.out_format = FMT_H263;
// s->m.unrestricted_mv= 1; // s->m.unrestricted_mv = 1;
s->m.lambda = s->picture.quality;
s->m.lambda= s->picture.quality; s->m.qscale = (s->m.lambda * 139 +
s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); FF_LAMBDA_SCALE * 64) >>
s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT; (FF_LAMBDA_SHIFT + 7);
s->m.lambda2 = (s->m.lambda * s->m.lambda +
if(!s->motion_val8[plane]){ FF_LAMBDA_SCALE / 2) >>
s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t)); FF_LAMBDA_SHIFT;
s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
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 // dummies, to avoid segfaults
s->m.current_picture.mb_mean= (uint8_t *)s->dummy; s->m.current_picture.mb_mean = (uint8_t *)s->dummy;
s->m.current_picture.mb_var= (uint16_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.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.p_mv_table = s->motion_val16[plane] +
s->m.dsp= s->dsp; //move 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.me.dia_size = s->avctx->dia_size;
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++) {
s->m.new_picture.f.data[0] = src - y*16*stride; //ugly s->m.new_picture.f.data[0] = src - y * 16 * stride; // ugly
s->m.mb_y= y; s->m.mb_y = y;
for(i=0; i<16 && i + 16*y<height; i++){ for (i = 0; i < 16 && i + 16 * y < height; i++) {
memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width); memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
for(x=width; x<16*block_width; x++) width);
src[i*stride+x]= src[i*stride+x-1]; 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++) for (; i < 16 && i + 16 * y < 16 * block_height; i++)
memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width); 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++){ for (i = 0; i < 16 && i + 16 * y < height; i++) {
memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width); memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
for(x=width; x<16*block_width; x++) width);
src[i*stride+x]= src[i*stride+x-1]; 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++) for (; i < 16 && i + 16 * y < 16 * block_height; i++)
memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width); 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; int offset = y * 16 * stride + x * 16;
uint8_t *decoded= decoded_plane + offset; uint8_t *decoded = decoded_plane + offset;
uint8_t *ref= ref_plane + offset; uint8_t *ref = ref_plane + offset;
int score[4]={0,0,0,0}, best; int score[4] = { 0, 0, 0, 0 }, best;
uint8_t *temp = s->scratchbuf; uint8_t *temp = s->scratchbuf;
if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size 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)){ if (s->picture.pict_type == AV_PICTURE_TYPE_I ||
for(i=0; i<6; i++){ (s->m.mb_type[x + y * s->m.mb_stride] &
init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32); CANDIDATE_MB_TYPE_INTRA)) {
} for (i = 0; i < 6; i++)
if(s->picture.pict_type == AV_PICTURE_TYPE_P){ init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],
const uint8_t *vlc= ff_svq1_block_type_vlc[SVQ1_BLOCK_INTRA]; 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); score[0] += encode_block(s, src + 16 * x, NULL, temp, stride,
for(i=0; i<6; i++){ 5, 64, lambda, 1);
count[0][i]= put_bits_count(&s->reorder_pb[i]); 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 } else
score[0]= INT_MAX; score[0] = INT_MAX;
best=0; best = 0;
if(s->picture.pict_type == AV_PICTURE_TYPE_P){ if (s->picture.pict_type == AV_PICTURE_TYPE_P) {
const uint8_t *vlc= ff_svq1_block_type_vlc[SVQ1_BLOCK_INTER]; 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); 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){ if (s->m.mb_type[x + y * s->m.mb_stride] &
for(i=0; i<6; i++) CANDIDATE_MB_TYPE_INTER) {
init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32); 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]; s->m.pb = s->reorder_pb[5];
mx= motion_ptr[0]; mx = motion_ptr[0];
my= motion_ptr[1]; my = motion_ptr[1];
assert(mx>=-32 && mx<=31); assert(mx >= -32 && mx <= 31);
assert(my>=-32 && my<=31); assert(my >= -32 && my <= 31);
assert(pred_x>=-32 && pred_x<=31); assert(pred_x >= -32 && pred_x <= 31);
assert(pred_y>=-32 && pred_y<=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; s->reorder_pb[5] = s->m.pb;
score[1] += lambda*put_bits_count(&s->reorder_pb[5]); score[1] += lambda * put_bits_count(&s->reorder_pb[5]);
dxy= (mx&1) + 2*(my&1); dxy = (mx & 1) + 2 * (my & 1);
s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16); s->dsp.put_pixels_tab[0][dxy](temp + 16,
ref + (mx >> 1) +
score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0); stride * (my >> 1),
best= score[1] <= score[0]; stride, 16);
vlc= ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP]; score[1] += encode_block(s, src + 16 * x, temp + 16,
score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16); decoded, stride, 5, 64, lambda, 0);
score[2]+= vlc[1]*lambda; best = score[1] <= score[0];
if(score[2] < score[best] && mx==0 && my==0){
best=2; 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++){ for (i = 0; i < 6; i++)
count[2][i]=0; count[2][i] = 0;
}
put_bits(&s->pb, vlc[1], vlc[0]); put_bits(&s->pb, vlc[1], vlc[0]);
} }
} }
if(best==1){ if (best == 1) {
for(i=0; i<6; i++){ for (i = 0; i < 6; i++) {
count[1][i]= put_bits_count(&s->reorder_pb[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{ } else {
motion_ptr[0 ] = motion_ptr[1 ]= motion_ptr[0] =
motion_ptr[2 ] = motion_ptr[3 ]= motion_ptr[1] =
motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]= motion_ptr[2] =
motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0; 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--){ for (i = 5; i >= 0; i--)
avpriv_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]); avpriv_copy_bits(&s->pb, reorder_buffer[best][i],
} count[best][i]);
if(best==0){ 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->avctx = avctx;
s->m.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.temp =
s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t)); s->m.me.scratchpad = av_mallocz((avctx->width + 64) *
s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t)); 2 * 16 * 2 * sizeof(uint8_t));
s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t)); s->m.me.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->m.me.score_map = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t)); s->mb_type = av_mallocz((s->y_block_width + 1) *
ff_h263_encode_init(&s->m); //mv_penalty 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; SVQ1Context *const s = avctx->priv_data;
AVFrame * const p = &s->picture; 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; temp = s->current_picture;
s->current_picture= s->last_picture; s->current_picture = s->last_picture;
s->last_picture= temp; 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;
p->pict_type = avctx->gop_size && avctx->frame_number % avctx->gop_size ? AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_I; 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++){ for (i = 0; i < 3; i++)
if(svq1_encode_plane(s, i, if (svq1_encode_plane(s, i,
s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i], s->picture.data[i],
s->frame_width / (i?4:1), s->frame_height / (i?4:1), s->last_picture.data[i],
s->picture.linesize[i], s->current_picture.linesize[i]) < 0) s->current_picture.data[i],
return -1; s->frame_width / (i ? 4 : 1),
} s->frame_height / (i ? 4 : 1),
s->picture.linesize[i],
// avpriv_align_put_bits(&s->pb); s->current_picture.linesize[i]) < 0)
while(put_bits_count(&s->pb) & 31) 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"),
}; };

106
libavcodec/svq1enc_cb.h
Unescape 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,
-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,
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, 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,
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,
-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, },
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, 1, -1, -1, 1, 0, 1, -1, -1, -1, 1, -1, 0, -1, 0, -1, 2, 0, 2, 1, 1, -1, 1, 1, 0, 0, 1, 1, 2, -2, 1, 0,
0, 0, 0, -2, 0, 1, 0, -1, -1, 0, 2, -3, 1, -2, 3, -1, -2, -1, 2, -2, -2, 0, -3, 0, -1, 0, -1, 0, -1, 0, -2, -3,
2, 0, 2, 1, 1, -1, 1, 1, 0, 0, 1, 1, 2, -2, 1, 0, 1, -2, -2, -1, 1, -1, -1, 1, -1, 1, 1, 0, -2, 0, 1, 1,
-2, -1, 2, -2, -2, 0, -3, 0, -1, 0, -1, 0, -1, 0, -2, -3, 1, 1, 2, 1, 0, 0, -1, 0, 0, 1, 0, 1, -1, 1, 0, 2, },
1, -2, -2, -1, 1, -1, -1, 1, -1, 1, 1, 0, -2, 0, 1, 1, { 0, 0, 0, -3, 1, 1, 1, -3, 0, -1, 0, -3, 1, -3, 0, -2,
1, 1, 2, 1, 0, 0, -1, 0, 0, 1, 0, 1, -1, 1, 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,
0, 0, 0, -3, 1, 1, 1, -3, 0, -1, 0, -3, 1, -3, 0, -2, 4, 2, 0, -2, 1, -2, 3, -2, 1, 1, 0, -1, 2, 5, 3, 1,
1, 2, -1, -3, 0, -3, 1, -1, 0, -1, 0, 0, 1, 2, 1, 1, -1, 0, 2, -3, -2, 0, 0, -2, 2, -3, -1, -1, 2, 1, 0, -2,
-1, 2, -3, 3, 1, 0, -5, 1, 0, -1, -3, 1, 0, 2, 0, -3, 3, -1, 1, -1, 2, 4, 0, 1, 0, 1, 0, -1, -3, -2, -1, 0, },
4, 2, 0, -2, 1, -2, 3, -2, 1, 1, 0, -1, 2, 5, 3, 1, { 0, 2, -1, -1, 2, -4, -2, 3, 0, -1, -5, 1, 0, 1, 0, 6,
-1, 0, 2, -3, -2, 0, 0, -2, 2, -3, -1, -1, 2, 1, 0, -2, -2, 2, 0, 1, 1, -1, -1, -2, 1, -2, -1, 0, 2, -2, -2, -1,
3, -1, 1, -1, 2, 4, 0, 1, 0, 1, 0, -1, -3, -2, -1, 0, -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,
0, 2, -1, -1, 2, -4, -2, 3, 0, -1, -5, 1, 0, 1, 0, 6, 5, 0, 1, 0, -3, 3, 3, 2, 0, 0, 1, 2, -5, -2, -3, 0,
-2, 2, 0, 1, 1, -1, -1, -2, 1, -2, -1, 0, 2, -2, -2, -1, -3, 2, -2, 2, -2, 4, 7, -3, 4, 2, 3, 2, -1, 0, -3, 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,
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, -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,
-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, 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, 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, },
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, -2, 0, -1, 1, 0, -1, 0, -1, -4, -1, -2, -1, -2, 1, -2, 1, 1, 0, -1, -1, -1, 1, 0, -1, -3, -3, 1, -1, 1, -2, -1,
0, 0, 4, -2, -1, 1, 1, 0, 2, 1, 1, 0, 2, 0, 0, 0, 1, -1, 0, 1, 2, 1, -1, -1, 1, 1, 1, 2, 1, 0, 1, -2,
1, 1, 0, -1, -1, -1, 1, 0, -1, -3, -3, 1, -1, 1, -2, -1, -2, 0, -1, -2, -2, 0, -1, -1, -1, 0, 1, 0, -1, -1, 0, -1,
1, -1, 0, 1, 2, 1, -1, -1, 1, 1, 1, 2, 1, 0, 1, -2, 0, 2, 1, 2, 2, 1, -1, 1, 0, 2, 0, -1, 1, 0, 0, 0, },
-2, 0, -1, -2, -2, 0, -1, -1, -1, 0, 1, 0, -1, -1, 0, -1, { -2, 0, -1, -1, 1, 1, -2, 0, -2, 0, 1, -2, -2, 1, -1, -1,
0, 2, 1, 2, 2, 1, -1, 1, 0, 2, 0, -1, 1, 0, 0, 0, 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,
-2, 0, -1, -1, 1, 1, -2, 0, -2, 0, 1, -2, -2, 1, -1, -1, 0, -4, 0, 2, -1, 0, 2, 2, 2, 1, 0, -1, -1, 1, -3, 2,
3, -2, 0, -3, -4, -3, 2, 1, 0, 3, -2, 2, 3, 2, 2, -1, 2, 1, 0, 3, 1, -1, 1, 3, 1, 0, 1, 1, 2, -1, 1, -1,
-3, 1, 0, 1, 0, 0, 0, 1, -2, 1, -2, -2, -1, -2, -2, 2, -2, -1, 0, -1, 1, -1, 1, -2, -2, -1, -1, -3, 1, -4, -3, 1, },
0, -4, 0, 2, -1, 0, 2, 2, 2, 1, 0, -1, -1, 1, -3, 2, { -2, 0, -2, 3, -1, -1, 0, 2, 2, -1, -3, 2, 1, 0, -2, -1,
2, 1, 0, 3, 1, -1, 1, 3, 1, 0, 1, 1, 2, -1, 1, -1, -3, -2, -2, 1, 2, -3, 0, 1, -5, -2, -3, 0, -2, -1, 2, 0,
-2, -1, 0, -1, 1, -1, 1, -2, -2, -1, -1, -3, 1, -4, -3, 1, -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,
-2, 0, -2, 3, -1, -1, 0, 2, 2, -1, -3, 2, 1, 0, -2, -1, 4, 1, -1, 2, -2, 4, 0, 0, 0, 4, 2, 0, -2, -2, 2, -4,
-3, -2, -2, 1, 2, -3, 0, 1, -5, -2, -3, 0, -2, -1, 2, 0, -1, 5, -2, -2, -3, 2, -3, -1, 3, -3, 0, 4, 3, 0, 1, -2, }
-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