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. 8
      libavcodec/svq1.h
  2. 7
      libavcodec/svq13.c
  3. 133
      libavcodec/svq1_vlc.h
  4. 509
      libavcodec/svq1dec.c
  5. 553
      libavcodec/svq1enc.c
  6. 42
      libavcodec/svq1enc_cb.h

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];

7
libavcodec/svq13.c
Unescape View File

@ -57,12 +57,13 @@ static const uint16_t checksum_table[256] = {
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,
const int length, int value)
{
int i; 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;
} }

133
libavcodec/svq1_vlc.h
Unescape View File

@ -27,67 +27,52 @@
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 },
@ -135,16 +120,16 @@ const uint16_t ff_svq1_intra_mean_vlc[256][2] = {
{ 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 */
@ -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 */

509
libavcodec/svq1dec.c
Unescape View File

@ -32,12 +32,10 @@
* 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 "mathops.h" #include "mathops.h"
#include "svq1.h" #include "svq1.h"
#undef NDEBUG #undef NDEBUG
@ -93,83 +91,87 @@ static const uint8_t string_table[256] = {
0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9
}; };
#define SVQ1_PROCESS_VECTOR()\ #define SVQ1_PROCESS_VECTOR() \
for (; level > 0; i++) {\ for (; level > 0; i++) { \
/* process next depth */\ /* process next depth */ \
if (i == m) {\ if (i == m) { \
m = n;\ m = n; \
if (--level == 0)\ if (--level == 0) \
break;\ break; \
}\ } \
/* divide block if next bit set */\ /* divide block if next bit set */ \
if (get_bits1 (bitbuf) == 0)\ if (get_bits1(bitbuf) == 0) \
break;\ break; \
/* add child nodes */\ /* add child nodes */ \
list[n++] = list[i];\ list[n++] = list[i]; \
list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level / 2) + 1));\ list[n++] = list[i] + \
} (((level & 1) ? pitch : 1) << ((level / 2) + 1)); \
}
#define SVQ1_ADD_CODEBOOK()\
/* add codebook entries to vector */\ #define SVQ1_ADD_CODEBOOK() \
for (j=0; j < stages; j++) {\ /* add codebook entries to vector */ \
n3 = codebook[entries[j]] ^ 0x80808080;\ for (j = 0; j < stages; j++) { \
n1 += ((n3 & 0xFF00FF00) >> 8);\ n3 = codebook[entries[j]] ^ 0x80808080; \
n2 += (n3 & 0x00FF00FF);\ n1 += ((n3 & 0xFF00FF00) >> 8); \
}\ n2 += (n3 & 0x00FF00FF); \
\ } \
/* clip to [0..255] */\ \
if (n1 & 0xFF00FF00) {\ /* clip to [0..255] */ \
n3 = ((( n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ if (n1 & 0xFF00FF00) { \
n1 += 0x7F007F00;\ n3 = (((n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001; \
n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ n1 += 0x7F007F00; \
n1 &= (n3 & 0x00FF00FF);\ n1 |= (((~n1 >> 15) & 0x00010001) | 0x01000100) - 0x00010001; \
}\ n1 &= (n3 & 0x00FF00FF); \
\ } \
if (n2 & 0xFF00FF00) {\ \
n3 = ((( n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ if (n2 & 0xFF00FF00) { \
n2 += 0x7F007F00;\ n3 = (((n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001; \
n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001;\ n2 += 0x7F007F00; \
n2 &= (n3 & 0x00FF00FF);\ n2 |= (((~n2 >> 15) & 0x00010001) | 0x01000100) - 0x00010001; \
} n2 &= (n3 & 0x00FF00FF); \
}
#define SVQ1_DO_CODEBOOK_INTRA()\
for (y=0; y < height; y++) {\ #define SVQ1_DO_CODEBOOK_INTRA() \
for (x=0; x < (width / 4); x++, codebook++) {\ for (y = 0; y < height; y++) { \
n1 = n4;\ for (x = 0; x < (width / 4); x++, codebook++) { \
n2 = n4;\ n1 = n4; \
SVQ1_ADD_CODEBOOK()\ n2 = n4; \
/* store result */\ SVQ1_ADD_CODEBOOK() \
dst[x] = (n1 << 8) | n2;\ /* store result */ \
}\ dst[x] = (n1 << 8) | n2; \
dst += (pitch / 4);\ } \
} dst += (pitch / 4); \
}
#define SVQ1_DO_CODEBOOK_NONINTRA()\
for (y=0; y < height; y++) {\ #define SVQ1_DO_CODEBOOK_NONINTRA() \
for (x=0; x < (width / 4); x++, codebook++) {\ for (y = 0; y < height; y++) { \
n3 = dst[x];\ for (x = 0; x < (width / 4); x++, codebook++) { \
/* add mean value to vector */\ n3 = dst[x]; \
n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\ /* add mean value to vector */ \
n2 = (n3 & 0x00FF00FF) + n4;\ n1 = n4 + ((n3 & 0xFF00FF00) >> 8); \
SVQ1_ADD_CODEBOOK()\ n2 = n4 + (n3 & 0x00FF00FF); \
/* store result */\ SVQ1_ADD_CODEBOOK() \
dst[x] = (n1 << 8) | n2;\ /* store result */ \
}\ dst[x] = (n1 << 8) | n2; \
dst += (pitch / 4);\ } \
} dst += (pitch / 4); \
}
#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)\
codebook = (const uint32_t *) cbook[level];\ #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \
if (stages > 0)\ codebook = (const uint32_t *)cbook[level]; \
bit_cache = get_bits (bitbuf, 4*stages);\ if (stages > 0) \
/* calculate codebook entries for this vector */\ bit_cache = get_bits(bitbuf, 4 * stages); \
for (j=0; j < stages; j++) {\ /* calculate codebook entries for this vector */ \
entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\ for (j = 0; j < stages; j++) { \
}\ entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
mean -= (stages * 128);\ 16 * j) << (level + 1); \
} \
mean -= (stages * 128); \
n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF); n4 = ((mean + (mean >> 31)) << 16) | (mean & 0xFFFF);
static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) { static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,
int pitch)
{
uint32_t bit_cache; uint32_t bit_cache;
uint8_t *list[63]; uint8_t *list[63];
uint32_t *dst; uint32_t *dst;
@ -184,21 +186,20 @@ static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int
list[0] = pixels; list[0] = pixels;
/* recursively process vector */ /* recursively process vector */
for (i=0, m=1, n=1, level=5; i < n; i++) { for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
SVQ1_PROCESS_VECTOR(); SVQ1_PROCESS_VECTOR();
/* destination address and vector size */ /* destination address and vector size */
dst = (uint32_t *) list[i]; dst = (uint32_t *)list[i];
width = 1 << ((4 + level) /2); width = 1 << ((4 + level) / 2);
height = 1 << ((3 + level) /2); height = 1 << ((3 + level) / 2);
/* get number of stages (-1 skips vector, 0 for mean only) */ /* get number of stages (-1 skips vector, 0 for mean only) */
stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1; stages = get_vlc2(bitbuf, svq1_intra_multistage[level].table, 3, 3) - 1;
if (stages == -1) { if (stages == -1) {
for (y=0; y < height; y++) { for (y = 0; y < height; y++)
memset (&dst[y*(pitch / 4)], 0, width); memset(&dst[y * (pitch / 4)], 0, width);
}
continue; /* skip vector */ continue; /* skip vector */
} }
@ -212,9 +213,8 @@ static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int
mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3); mean = get_vlc2(bitbuf, svq1_intra_mean.table, 8, 3);
if (stages == 0) { if (stages == 0) {
for (y=0; y < height; y++) { for (y = 0; y < height; y++)
memset (&dst[y*(pitch / 4)], mean, width); memset(&dst[y * (pitch / 4)], mean, width);
}
} else { } else {
SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks); SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);
SVQ1_DO_CODEBOOK_INTRA() SVQ1_DO_CODEBOOK_INTRA()
@ -224,7 +224,9 @@ static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int
return 0; return 0;
} }
static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels, int pitch ) { static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,
int pitch)
{
uint32_t bit_cache; uint32_t bit_cache;
uint8_t *list[63]; uint8_t *list[63];
uint32_t *dst; uint32_t *dst;
@ -239,18 +241,19 @@ static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels,
list[0] = pixels; list[0] = pixels;
/* recursively process vector */ /* recursively process vector */
for (i=0, m=1, n=1, level=5; i < n; i++) { for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {
SVQ1_PROCESS_VECTOR(); SVQ1_PROCESS_VECTOR();
/* destination address and vector size */ /* destination address and vector size */
dst = (uint32_t *) list[i]; dst = (uint32_t *)list[i];
width = 1 << ((4 + level) /2); width = 1 << ((4 + level) / 2);
height = 1 << ((3 + level) /2); height = 1 << ((3 + level) / 2);
/* get number of stages (-1 skips vector, 0 for mean only) */ /* get number of stages (-1 skips vector, 0 for mean only) */
stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1; stages = get_vlc2(bitbuf, svq1_inter_multistage[level].table, 3, 2) - 1;
if (stages == -1) continue; /* skip vector */ if (stages == -1)
continue; /* skip vector */
if ((stages > 0) && (level >= 4)) { if ((stages > 0) && (level >= 4)) {
av_dlog(NULL, av_dlog(NULL,
@ -267,18 +270,20 @@ static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels,
return 0; return 0;
} }
static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv) { static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,
svq1_pmv **pmv)
{
int diff; int diff;
int i; int i;
for (i=0; i < 2; i++) { for (i = 0; i < 2; i++) {
/* get motion code */ /* get motion code */
diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2); diff = get_vlc2(bitbuf, svq1_motion_component.table, 7, 2);
if(diff<0) if (diff < 0)
return -1; return -1;
else if(diff){ else if (diff) {
if(get_bits1(bitbuf)) diff= -diff; if (get_bits1(bitbuf))
diff = -diff;
} }
/* add median of motion vector predictors and clip result */ /* add median of motion vector predictors and clip result */
@ -291,24 +296,27 @@ static int svq1_decode_motion_vector (GetBitContext *bitbuf, svq1_pmv *mv, svq1_
return 0; return 0;
} }
static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) { static void svq1_skip_block(uint8_t *current, uint8_t *previous,
int pitch, int x, int y)
{
uint8_t *src; uint8_t *src;
uint8_t *dst; uint8_t *dst;
int i; int i;
src = &previous[x + y*pitch]; src = &previous[x + y * pitch];
dst = current; dst = current;
for (i=0; i < 16; i++) { for (i = 0; i < 16; i++) {
memcpy (dst, src, 16); memcpy(dst, src, 16);
src += pitch; src += pitch;
dst += pitch; dst += pitch;
} }
} }
static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf, static int svq1_motion_inter_block(MpegEncContext *s, GetBitContext *bitbuf,
uint8_t *current, uint8_t *previous, int pitch, uint8_t *current, uint8_t *previous,
svq1_pmv *motion, int x, int y) { int pitch, svq1_pmv *motion, int x, int y)
{
uint8_t *src; uint8_t *src;
uint8_t *dst; uint8_t *dst;
svq1_pmv mv; svq1_pmv mv;
@ -320,13 +328,12 @@ static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
if (y == 0) { if (y == 0) {
pmv[1] = pmv[1] =
pmv[2] = pmv[0]; pmv[2] = pmv[0];
} } else {
else {
pmv[1] = &motion[(x / 8) + 2]; pmv[1] = &motion[(x / 8) + 2];
pmv[2] = &motion[(x / 8) + 4]; pmv[2] = &motion[(x / 8) + 4];
} }
result = svq1_decode_motion_vector (bitbuf, &mv, pmv); result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
if (result != 0) if (result != 0)
return result; return result;
@ -338,22 +345,23 @@ static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
motion[(x / 8) + 2].y = motion[(x / 8) + 2].y =
motion[(x / 8) + 3].y = mv.y; motion[(x / 8) + 3].y = mv.y;
if(y + (mv.y >> 1)<0) if (y + (mv.y >> 1) < 0)
mv.y= 0; mv.y = 0;
if(x + (mv.x >> 1)<0) if (x + (mv.x >> 1) < 0)
mv.x= 0; mv.x = 0;
src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1))*pitch]; src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];
dst = current; dst = current;
s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst,src,pitch,16); s->dsp.put_pixels_tab[0][((mv.y & 1) << 1) | (mv.x & 1)](dst, src, pitch, 16);
return 0; return 0;
} }
static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf, static int svq1_motion_inter_4v_block(MpegEncContext *s, GetBitContext *bitbuf,
uint8_t *current, uint8_t *previous, int pitch, uint8_t *current, uint8_t *previous,
svq1_pmv *motion,int x, int y) { int pitch, svq1_pmv *motion, int x, int y)
{
uint8_t *src; uint8_t *src;
uint8_t *dst; uint8_t *dst;
svq1_pmv mv; svq1_pmv mv;
@ -365,13 +373,12 @@ static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
if (y == 0) { if (y == 0) {
pmv[1] = pmv[1] =
pmv[2] = pmv[0]; pmv[2] = pmv[0];
} } else {
else {
pmv[1] = &motion[(x / 8) + 2]; pmv[1] = &motion[(x / 8) + 2];
pmv[2] = &motion[(x / 8) + 4]; pmv[2] = &motion[(x / 8) + 4];
} }
result = svq1_decode_motion_vector (bitbuf, &mv, pmv); result = svq1_decode_motion_vector(bitbuf, &mv, pmv);
if (result != 0) if (result != 0)
return result; return result;
@ -381,11 +388,10 @@ static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
if (y == 0) { if (y == 0) {
pmv[1] = pmv[1] =
pmv[2] = pmv[0]; pmv[2] = pmv[0];
} } else {
else {
pmv[1] = &motion[(x / 8) + 3]; pmv[1] = &motion[(x / 8) + 3];
} }
result = svq1_decode_motion_vector (bitbuf, &motion[0], pmv); result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);
if (result != 0) if (result != 0)
return result; return result;
@ -394,7 +400,7 @@ static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
pmv[1] = &motion[0]; pmv[1] = &motion[0];
pmv[2] = &motion[(x / 8) + 1]; pmv[2] = &motion[(x / 8) + 1];
result = svq1_decode_motion_vector (bitbuf, &motion[(x / 8) + 2], pmv); result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);
if (result != 0) if (result != 0)
return result; return result;
@ -403,41 +409,41 @@ static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
pmv[2] = &motion[(x / 8) + 2]; pmv[2] = &motion[(x / 8) + 2];
pmv[3] = &motion[(x / 8) + 3]; pmv[3] = &motion[(x / 8) + 3];
result = svq1_decode_motion_vector (bitbuf, pmv[3], pmv); result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);
if (result != 0) if (result != 0)
return result; return result;
/* form predictions */ /* form predictions */
for (i=0; i < 4; i++) { for (i = 0; i < 4; i++) {
int mvx= pmv[i]->x + (i&1)*16; int mvx = pmv[i]->x + (i & 1) * 16;
int mvy= pmv[i]->y + (i>>1)*16; int mvy = pmv[i]->y + (i >> 1) * 16;
///XXX /FIXME clipping or padding? // FIXME: clipping or padding?
if(y + (mvy >> 1)<0) if (y + (mvy >> 1) < 0)
mvy= 0; mvy = 0;
if(x + (mvx >> 1)<0) if (x + (mvx >> 1) < 0)
mvx= 0; mvx = 0;
src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1))*pitch]; src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];
dst = current; dst = current;
s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst,src,pitch,8); s->dsp.put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);
/* select next block */ /* select next block */
if (i & 1) { if (i & 1)
current += 8*(pitch - 1); current += 8 * (pitch - 1);
} else { else
current += 8; current += 8;
} }
}
return 0; return 0;
} }
static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf, static int svq1_decode_delta_block(MpegEncContext *s, GetBitContext *bitbuf,
uint8_t *current, uint8_t *previous, int pitch, uint8_t *current, uint8_t *previous,
svq1_pmv *motion, int x, int y) { int pitch, svq1_pmv *motion, int x, int y)
{
uint32_t block_type; uint32_t block_type;
int result = 0; int result = 0;
@ -456,70 +462,73 @@ static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
switch (block_type) { switch (block_type) {
case SVQ1_BLOCK_SKIP: case SVQ1_BLOCK_SKIP:
svq1_skip_block (current, previous, pitch, x, y); svq1_skip_block(current, previous, pitch, x, y);
break; break;
case SVQ1_BLOCK_INTER: case SVQ1_BLOCK_INTER:
result = svq1_motion_inter_block (s, bitbuf, current, previous, pitch, motion, x, y); result = svq1_motion_inter_block(s, bitbuf, current, previous,
pitch, motion, x, y);
if (result != 0) if (result != 0) {
{
av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result); av_dlog(s->avctx, "Error in svq1_motion_inter_block %i\n", result);
break; break;
} }
result = svq1_decode_block_non_intra (bitbuf, current, pitch); result = svq1_decode_block_non_intra(bitbuf, current, pitch);
break; break;
case SVQ1_BLOCK_INTER_4V: case SVQ1_BLOCK_INTER_4V:
result = svq1_motion_inter_4v_block (s, bitbuf, current, previous, pitch, motion, x, y); result = svq1_motion_inter_4v_block(s, bitbuf, current, previous,
pitch, motion, x, y);
if (result != 0) if (result != 0) {
{ av_dlog(s->avctx,
av_dlog(s->avctx, "Error in svq1_motion_inter_4v_block %i\n", result); "Error in svq1_motion_inter_4v_block %i\n", result);
break; break;
} }
result = svq1_decode_block_non_intra (bitbuf, current, pitch); result = svq1_decode_block_non_intra(bitbuf, current, pitch);
break; break;
case SVQ1_BLOCK_INTRA: case SVQ1_BLOCK_INTRA:
result = svq1_decode_block_intra (bitbuf, current, pitch); result = svq1_decode_block_intra(bitbuf, current, pitch);
break; break;
} }
return result; return result;
} }
static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) { static void svq1_parse_string(GetBitContext *bitbuf, uint8_t *out)
{
uint8_t seed; uint8_t seed;
int i; int i;
out[0] = get_bits (bitbuf, 8); out[0] = get_bits(bitbuf, 8);
seed = string_table[out[0]]; seed = string_table[out[0]];
for (i=1; i <= out[0]; i++) { for (i = 1; i <= out[0]; i++) {
out[i] = get_bits (bitbuf, 8) ^ seed; out[i] = get_bits(bitbuf, 8) ^ seed;
seed = string_table[out[i] ^ seed]; seed = string_table[out[i] ^ seed];
} }
} }
static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) { static int svq1_decode_frame_header(GetBitContext *bitbuf, MpegEncContext *s)
{
int frame_size_code; int frame_size_code;
skip_bits(bitbuf, 8); /* temporal_reference */ skip_bits(bitbuf, 8); /* temporal_reference */
/* frame type */ /* frame type */
s->pict_type= get_bits (bitbuf, 2)+1; s->pict_type = get_bits(bitbuf, 2) + 1;
if(s->pict_type==4) if (s->pict_type == 4)
return -1; return -1;
if (s->pict_type == AV_PICTURE_TYPE_I) { if (s->pict_type == AV_PICTURE_TYPE_I) {
/* unknown fields */ /* unknown fields */
if (s->f_code == 0x50 || s->f_code == 0x60) { if (s->f_code == 0x50 || s->f_code == 0x60) {
int csum = get_bits (bitbuf, 16); int csum = get_bits(bitbuf, 16);
csum = ff_svq1_packet_checksum (bitbuf->buffer, bitbuf->size_in_bits>>3, csum); csum = ff_svq1_packet_checksum(bitbuf->buffer,
bitbuf->size_in_bits >> 3,
csum);
av_dlog(s->avctx, "%s checksum (%02x) for packet data\n", av_dlog(s->avctx, "%s checksum (%02x) for packet data\n",
(csum == 0) ? "correct" : "incorrect", csum); (csum == 0) ? "correct" : "incorrect", csum);
@ -528,22 +537,23 @@ static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
if ((s->f_code ^ 0x10) >= 0x50) { if ((s->f_code ^ 0x10) >= 0x50) {
uint8_t msg[256]; uint8_t msg[256];
svq1_parse_string (bitbuf, msg); svq1_parse_string(bitbuf, msg);
av_log(s->avctx, AV_LOG_INFO, "embedded message: \"%s\"\n", (char *) msg); av_log(s->avctx, AV_LOG_INFO,
"embedded message: \"%s\"\n", (char *)msg);
} }
skip_bits (bitbuf, 2); skip_bits(bitbuf, 2);
skip_bits (bitbuf, 2); skip_bits(bitbuf, 2);
skip_bits1 (bitbuf); skip_bits1(bitbuf);
/* load frame size */ /* load frame size */
frame_size_code = get_bits (bitbuf, 3); frame_size_code = get_bits(bitbuf, 3);
if (frame_size_code == 7) { if (frame_size_code == 7) {
/* load width, height (12 bits each) */ /* load width, height (12 bits each) */
s->width = get_bits (bitbuf, 12); s->width = get_bits(bitbuf, 12);
s->height = get_bits (bitbuf, 12); s->height = get_bits(bitbuf, 12);
if (!s->width || !s->height) if (!s->width || !s->height)
return -1; return -1;
@ -555,129 +565,133 @@ static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
} }
/* unknown fields */ /* unknown fields */
if (get_bits1 (bitbuf) == 1) { if (get_bits1(bitbuf) == 1) {
skip_bits1 (bitbuf); /* use packet checksum if (1) */ skip_bits1(bitbuf); /* use packet checksum if (1) */
skip_bits1 (bitbuf); /* component checksums after image data if (1) */ skip_bits1(bitbuf); /* component checksums after image data if (1) */
if (get_bits (bitbuf, 2) != 0) if (get_bits(bitbuf, 2) != 0)
return -1; return -1;
} }
if (get_bits1 (bitbuf) == 1) { if (get_bits1(bitbuf) == 1) {
skip_bits1 (bitbuf); skip_bits1(bitbuf);
skip_bits (bitbuf, 4); skip_bits(bitbuf, 4);
skip_bits1 (bitbuf); skip_bits1(bitbuf);
skip_bits (bitbuf, 2); skip_bits(bitbuf, 2);
while (get_bits1 (bitbuf) == 1) { while (get_bits1(bitbuf) == 1)
skip_bits (bitbuf, 8); skip_bits(bitbuf, 8);
}
} }
return 0; return 0;
} }
static int svq1_decode_frame(AVCodecContext *avctx, static int svq1_decode_frame(AVCodecContext *avctx, void *data,
void *data, int *data_size, int *data_size, AVPacket *avpkt)
AVPacket *avpkt)
{ {
const uint8_t *buf = avpkt->data; const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size; int buf_size = avpkt->size;
MpegEncContext *s=avctx->priv_data; MpegEncContext *s = avctx->priv_data;
uint8_t *current, *previous; uint8_t *current, *previous;
int result, i, x, y, width, height; int result, i, x, y, width, height;
AVFrame *pict = data; AVFrame *pict = data;
svq1_pmv *pmv; svq1_pmv *pmv;
/* initialize bit buffer */ /* initialize bit buffer */
init_get_bits(&s->gb,buf,buf_size*8); init_get_bits(&s->gb, buf, buf_size * 8);
/* decode frame header */ /* decode frame header */
s->f_code = get_bits (&s->gb, 22); s->f_code = get_bits(&s->gb, 22);
if ((s->f_code & ~0x70) || !(s->f_code & 0x60)) if ((s->f_code & ~0x70) || !(s->f_code & 0x60))
return -1; return -1;
/* swap some header bytes (why?) */ /* swap some header bytes (why?) */
if (s->f_code != 0x20) { if (s->f_code != 0x20) {
uint32_t *src = (uint32_t *) (buf + 4); uint32_t *src = (uint32_t *)(buf + 4);
for (i=0; i < 4; i++) { for (i = 0; i < 4; i++)
src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i]; src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];
} }
}
result = svq1_decode_frame_header (&s->gb, s); result = svq1_decode_frame_header(&s->gb, s);
if (result != 0) if (result != 0) {
{ av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n", result);
av_dlog(s->avctx, "Error in svq1_decode_frame_header %i\n",result);
return result; return result;
} }
avcodec_set_dimensions(avctx, s->width, s->height); avcodec_set_dimensions(avctx, s->width, s->height);
//FIXME this avoids some confusion for "B frames" without 2 references /* FIXME: This avoids some confusion for "B frames" without 2 references.
//this should be removed after libavcodec can handle more flexible picture types & ordering * This should be removed after libavcodec can handle more flexible
if(s->pict_type==AV_PICTURE_TYPE_B && s->last_picture_ptr==NULL) return buf_size; * picture types & ordering */
if (s->pict_type == AV_PICTURE_TYPE_B && s->last_picture_ptr == NULL)
return buf_size;
if( (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B) if ((avctx->skip_frame >= AVDISCARD_NONREF &&
||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I) s->pict_type == AV_PICTURE_TYPE_B) ||
|| avctx->skip_frame >= AVDISCARD_ALL) (avctx->skip_frame >= AVDISCARD_NONKEY &&
s->pict_type != AV_PICTURE_TYPE_I) ||
avctx->skip_frame >= AVDISCARD_ALL)
return buf_size; return buf_size;
if(ff_MPV_frame_start(s, avctx) < 0) if (ff_MPV_frame_start(s, avctx) < 0)
return -1; return -1;
pmv = av_malloc((FFALIGN(s->width, 16)/8 + 3) * sizeof(*pmv)); pmv = av_malloc((FFALIGN(s->width, 16) / 8 + 3) * sizeof(*pmv));
if (!pmv) if (!pmv)
return -1; return -1;
/* decode y, u and v components */ /* decode y, u and v components */
for (i=0; i < 3; i++) { for (i = 0; i < 3; i++) {
int linesize; int linesize;
if (i == 0) { if (i == 0) {
width = FFALIGN(s->width, 16); width = FFALIGN(s->width, 16);
height = FFALIGN(s->height, 16); height = FFALIGN(s->height, 16);
linesize= s->linesize; linesize = s->linesize;
} else { } else {
if(s->flags&CODEC_FLAG_GRAY) break; if (s->flags & CODEC_FLAG_GRAY)
width = FFALIGN(s->width/4, 16); break;
height = FFALIGN(s->height/4, 16); width = FFALIGN(s->width / 4, 16);
linesize= s->uvlinesize; height = FFALIGN(s->height / 4, 16);
linesize = s->uvlinesize;
} }
current = s->current_picture.f.data[i]; current = s->current_picture.f.data[i];
if(s->pict_type==AV_PICTURE_TYPE_B){ if (s->pict_type == AV_PICTURE_TYPE_B)
previous = s->next_picture.f.data[i]; previous = s->next_picture.f.data[i];
}else{ else
previous = s->last_picture.f.data[i]; previous = s->last_picture.f.data[i];
}
if (s->pict_type == AV_PICTURE_TYPE_I) { if (s->pict_type == AV_PICTURE_TYPE_I) {
/* keyframe */ /* keyframe */
for (y=0; y < height; y+=16) { for (y = 0; y < height; y += 16) {
for (x=0; x < width; x+=16) { for (x = 0; x < width; x += 16) {
result = svq1_decode_block_intra (&s->gb, &current[x], linesize); result = svq1_decode_block_intra(&s->gb, &current[x],
if (result != 0) linesize);
{ if (result != 0) {
av_log(s->avctx, AV_LOG_INFO, "Error in svq1_decode_block %i (keyframe)\n",result); av_log(s->avctx, AV_LOG_INFO,
"Error in svq1_decode_block %i (keyframe)\n",
result);
goto err; goto err;
} }
} }
current += 16*linesize; current += 16 * linesize;
} }
} else { } else {
/* delta frame */ /* delta frame */
memset (pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv)); memset(pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));
for (y=0; y < height; y+=16) { for (y = 0; y < height; y += 16) {
for (x=0; x < width; x+=16) { for (x = 0; x < width; x += 16) {
result = svq1_decode_delta_block (s, &s->gb, &current[x], previous, result = svq1_decode_delta_block(s, &s->gb, &current[x],
linesize, pmv, x, y); previous, linesize,
if (result != 0) pmv, x, y);
{ if (result != 0) {
av_dlog(s->avctx, "Error in svq1_decode_delta_block %i\n",result); av_dlog(s->avctx,
"Error in svq1_decode_delta_block %i\n",
result);
goto err; goto err;
} }
} }
@ -685,18 +699,18 @@ static int svq1_decode_frame(AVCodecContext *avctx,
pmv[0].x = pmv[0].x =
pmv[0].y = 0; pmv[0].y = 0;
current += 16*linesize; current += 16 * linesize;
} }
} }
} }
*pict = s->current_picture.f; *pict = s->current_picture.f;
ff_MPV_frame_end(s); ff_MPV_frame_end(s);
*data_size=sizeof(AVFrame); *data_size = sizeof(AVFrame);
result = buf_size; result = buf_size;
err: err:
av_free(pmv); av_free(pmv);
return result; return result;
@ -711,13 +725,15 @@ static av_cold int svq1_decode_init(AVCodecContext *avctx)
ff_MPV_decode_defaults(s); ff_MPV_decode_defaults(s);
s->avctx = avctx; s->avctx = avctx;
s->width = (avctx->width+3)&~3; s->width = (avctx->width + 3) & ~3;
s->height = (avctx->height+3)&~3; s->height = (avctx->height + 3) & ~3;
s->codec_id= avctx->codec->id; s->codec_id = avctx->codec->id;
avctx->pix_fmt = AV_PIX_FMT_YUV410P; avctx->pix_fmt = AV_PIX_FMT_YUV410P;
avctx->has_b_frames= 1; // not true, but DP frames and these behave like unidirectional b frames /* Not true, but DP frames and these behave like unidirectional B-frames. */
s->flags= avctx->flags; avctx->has_b_frames = 1;
if (ff_MPV_common_init(s) < 0) return -1; s->flags = avctx->flags;
if (ff_MPV_common_init(s) < 0)
return -1;
INIT_VLC_STATIC(&svq1_block_type, 2, 4, INIT_VLC_STATIC(&svq1_block_type, 2, 4,
&ff_svq1_block_type_vlc[0][1], 2, 1, &ff_svq1_block_type_vlc[0][1], 2, 1,
@ -728,20 +744,23 @@ static av_cold int svq1_decode_init(AVCodecContext *avctx)
&ff_mvtab[0][0], 2, 1, 176); &ff_mvtab[0][0], 2, 1, 176);
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
static const uint8_t sizes[2][6] = {{14, 10, 14, 18, 16, 18}, {10, 10, 14, 14, 14, 16}}; static const uint8_t sizes[2][6] = { { 14, 10, 14, 18, 16, 18 },
{ 10, 10, 14, 14, 14, 16 } };
static VLC_TYPE table[168][2]; static VLC_TYPE table[168][2];
svq1_intra_multistage[i].table = &table[offset]; svq1_intra_multistage[i].table = &table[offset];
svq1_intra_multistage[i].table_allocated = sizes[0][i]; svq1_intra_multistage[i].table_allocated = sizes[0][i];
offset += sizes[0][i]; offset += sizes[0][i];
init_vlc(&svq1_intra_multistage[i], 3, 8, init_vlc(&svq1_intra_multistage[i], 3, 8,
&ff_svq1_intra_multistage_vlc[i][0][1], 2, 1, &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,
&ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC); &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1,
INIT_VLC_USE_NEW_STATIC);
svq1_inter_multistage[i].table = &table[offset]; svq1_inter_multistage[i].table = &table[offset];
svq1_inter_multistage[i].table_allocated = sizes[1][i]; svq1_inter_multistage[i].table_allocated = sizes[1][i];
offset += sizes[1][i]; offset += sizes[1][i];
init_vlc(&svq1_inter_multistage[i], 3, 8, init_vlc(&svq1_inter_multistage[i], 3, 8,
&ff_svq1_inter_multistage_vlc[i][0][1], 2, 1, &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,
&ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, INIT_VLC_USE_NEW_STATIC); &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1,
INIT_VLC_USE_NEW_STATIC);
} }
INIT_VLC_STATIC(&svq1_intra_mean, 8, 256, INIT_VLC_STATIC(&svq1_intra_mean, 8, 256,
@ -763,7 +782,6 @@ static av_cold int svq1_decode_end(AVCodecContext *avctx)
return 0; return 0;
} }
AVCodec ff_svq1_decoder = { AVCodec ff_svq1_decoder = {
.name = "svq1", .name = "svq1",
.type = AVMEDIA_TYPE_VIDEO, .type = AVMEDIA_TYPE_VIDEO,
@ -774,6 +792,7 @@ AVCodec ff_svq1_decoder = {
.decode = svq1_decode_frame, .decode = svq1_decode_frame,
.capabilities = CODEC_CAP_DR1, .capabilities = CODEC_CAP_DR1,
.flush = ff_mpeg_flush, .flush = ff_mpeg_flush,
.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"),
}; };

553
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,19 +89,17 @@ 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,130 +109,131 @@ 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],
@ -241,23 +242,25 @@ static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *dec
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,
unsigned char *ref_plane,
unsigned char *decoded_plane,
int width, int height, int src_stride, int stride) int width, int height, int src_stride, int stride)
{ {
int x, y; int x, y;
@ -266,7 +269,8 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
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;
@ -276,201 +280,226 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
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 *
s->m.mb_type= s->mb_type; block_height * 2 + 2) *
2 * sizeof(int16_t));
//dummies, to avoid segfaults s->motion_val16[plane] = av_mallocz((s->m.mb_stride *
s->m.current_picture.mb_mean= (uint8_t *)s->dummy; (block_height + 2) + 1) *
s->m.current_picture.mb_var= (uint16_t*)s->dummy; 2 * sizeof(int16_t));
s->m.current_picture.mc_mb_var= (uint16_t*)s->dummy; }
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;
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;
@ -484,16 +513,19 @@ static av_cold int svq1_encode_init(AVCodecContext *avctx)
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],
s->frame_width / (i ? 4 : 1),
s->frame_height / (i ? 4 : 1),
s->picture.linesize[i],
s->current_picture.linesize[i]) < 0)
return -1; return -1;
}
// avpriv_align_put_bits(&s->pb); // avpriv_align_put_bits(&s->pb);
while(put_bits_count(&s->pb) & 31) 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"),
}; };

42
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,
-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, 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, 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, -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, -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, 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,
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, -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, -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, 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, -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, 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,
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, -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, -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, -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, 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, -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,
-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, 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, -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, 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, -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, 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,
-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, -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, -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, 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, 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, -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,
-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, -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, -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, 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, 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, -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