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.h
  2. 7
      libavcodec/svq13.c
  3. 125
      libavcodec/svq1_vlc.h
  4. 183
      libavcodec/svq1dec.c
  5. 197
      libavcodec/svq1enc.c
  6. 42
      libavcodec/svq1enc_cb.h

4
libavcodec/svq1.h
Unescape View File

@ -47,8 +47,8 @@ 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];

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

125
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 */
@ -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 */

183
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
@ -106,7 +104,8 @@ static const uint8_t string_table[256] = {
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() \ #define SVQ1_ADD_CODEBOOK() \
@ -149,8 +148,8 @@ static const uint8_t string_table[256] = {
for (x = 0; x < (width / 4); x++, codebook++) { \ for (x = 0; x < (width / 4); x++, codebook++) { \
n3 = dst[x]; \ n3 = dst[x]; \
/* add mean value to vector */ \ /* add mean value to vector */ \
n1 = ((n3 & 0xFF00FF00) >> 8) + n4;\ n1 = n4 + ((n3 & 0xFF00FF00) >> 8); \
n2 = (n3 & 0x00FF00FF) + n4;\ n2 = n4 + (n3 & 0x00FF00FF); \
SVQ1_ADD_CODEBOOK() \ SVQ1_ADD_CODEBOOK() \
/* store result */ \ /* store result */ \
dst[x] = (n1 << 8) | n2; \ dst[x] = (n1 << 8) | n2; \
@ -164,12 +163,15 @@ static const uint8_t string_table[256] = {
bit_cache = get_bits(bitbuf, 4 * stages); \ bit_cache = get_bits(bitbuf, 4 * stages); \
/* calculate codebook entries for this vector */ \ /* calculate codebook entries for this vector */ \
for (j = 0; j < stages; j++) { \ for (j = 0; j < stages; j++) { \
entries[j] = (((bit_cache >> (4*(stages - j - 1))) & 0xF) + 16*j) << (level + 1);\ entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \
16 * j) << (level + 1); \
} \ } \
mean -= (stages * 128); \ 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;
@ -196,9 +198,8 @@ static int svq1_decode_block_intra (GetBitContext *bitbuf, uint8_t *pixels, int
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;
@ -250,7 +252,8 @@ static int svq1_decode_block_non_intra (GetBitContext *bitbuf, uint8_t *pixels,
/* 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,7 +296,9 @@ 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;
@ -307,8 +314,9 @@ static void svq1_skip_block (uint8_t *current, uint8_t *previous, int pitch, int
} }
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,8 +328,7 @@ 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];
} }
@ -352,8 +359,9 @@ static int svq1_motion_inter_block (MpegEncContext *s, GetBitContext *bitbuf,
} }
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,8 +373,7 @@ 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];
} }
@ -381,8 +388,7 @@ 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);
@ -413,7 +419,7 @@ static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
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)
@ -425,19 +431,19 @@ static int svq1_motion_inter_4v_block (MpegEncContext *s, GetBitContext *bitbuf,
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;
@ -460,10 +466,10 @@ static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
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;
} }
@ -471,11 +477,12 @@ static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
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);
@ -489,12 +496,12 @@ static int svq1_decode_delta_block (MpegEncContext *s, GetBitContext *bitbuf,
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++) {
@ -503,7 +510,8 @@ static void svq1_parse_string (GetBitContext *bitbuf, uint8_t *out) {
} }
} }
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 */
@ -514,12 +522,13 @@ static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
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);
@ -530,7 +539,8 @@ static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
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);
@ -569,17 +579,15 @@ static int svq1_decode_frame_header (GetBitContext *bitbuf,MpegEncContext *s) {
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;
@ -602,27 +610,29 @@ static int svq1_decode_frame(AVCodecContext *avctx,
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)
@ -640,7 +650,8 @@ static int svq1_decode_frame(AVCodecContext *avctx,
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)
break;
width = FFALIGN(s->width / 4, 16); width = FFALIGN(s->width / 4, 16);
height = FFALIGN(s->height / 4, 16); height = FFALIGN(s->height / 4, 16);
linesize = s->uvlinesize; linesize = s->uvlinesize;
@ -648,20 +659,21 @@ static int svq1_decode_frame(AVCodecContext *avctx,
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;
} }
} }
@ -673,11 +685,13 @@ static int svq1_decode_frame(AVCodecContext *avctx,
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;
} }
} }
@ -692,11 +706,11 @@ static int svq1_decode_frame(AVCodecContext *avctx,
*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;
@ -715,9 +729,11 @@ static av_cold int svq1_decode_init(AVCodecContext *avctx)
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. */
avctx->has_b_frames = 1;
s->flags = avctx->flags; s->flags = avctx->flags;
if (ff_MPV_common_init(s) < 0) return -1; 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"),
}; };

197
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,11 +109,13 @@ 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 };
@ -126,7 +128,7 @@ static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *dec
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];
@ -173,7 +175,7 @@ static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *dec
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);
@ -186,13 +188,12 @@ static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *dec
} }
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 += best_vector_score += lambda *
lambda*(+ 1 + 4*count (+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) {
@ -209,22 +210,22 @@ static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *dec
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);
@ -246,18 +247,20 @@ static int encode_block(SVQ1Context *s, uint8_t *src, uint8_t *ref, uint8_t *dec
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;
@ -298,14 +302,21 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
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 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7); s->m.qscale = (s->m.lambda * 139 +
s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT; FF_LAMBDA_SCALE * 64) >>
(FF_LAMBDA_SHIFT + 7);
s->m.lambda2 = (s->m.lambda * s->m.lambda +
FF_LAMBDA_SCALE / 2) >>
FF_LAMBDA_SHIFT;
if (!s->motion_val8[plane]) { 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_val8[plane] = av_mallocz((s->m.b8_stride *
s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t)); 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;
@ -317,7 +328,8 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
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.mb_stride + 1;
s->m.dsp = s->dsp; // move s->m.dsp = s->dsp; // move
ff_init_me(&s->m); ff_init_me(&s->m);
@ -328,12 +340,14 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
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],
width);
for (x = width; x < 16 * block_width; x++) for (x = width; x < 16 * block_width; x++)
src[i * stride + x] = src[i * stride + x - 1]; 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;
@ -346,13 +360,15 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
} }
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],
width);
for (x = width; x < 16 * block_width; x++) for (x = width; x < 16 * block_width; x++)
src[i * stride + x] = src[i * stride + x - 1]; src[i * stride + x] = src[i * stride + x - 1];
} }
@ -369,7 +385,8 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
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;
} }
@ -378,16 +395,19 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
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++)
init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],
7 * 32);
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_INTRA]; 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,
5, 64, lambda, 1);
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
count[0][i] = put_bits_count(&s->reorder_pb[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]);
@ -403,9 +423,11 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
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] &
CANDIDATE_MB_TYPE_INTER) {
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++)
init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32); 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]);
@ -423,20 +445,24 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
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) +
stride * (my >> 1),
stride, 16);
score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0); score[1] += encode_block(s, src + 16 * x, temp + 16,
decoded, stride, 5, 64, lambda, 0);
best = score[1] <= score[0]; best = score[1] <= score[0];
vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP]; vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16); score[2] = s->dsp.sse[0](NULL, src + 16 * x, ref,
stride, 16);
score[2] += vlc[1] * lambda; score[2] += vlc[1] * lambda;
if (score[2] < score[best] && mx == 0 && my == 0) { if (score[2] < score[best] && mx == 0 && my == 0) {
best = 2; 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]);
} }
} }
@ -447,22 +473,25 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
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;
@ -488,11 +517,14 @@ static av_cold int svq1_encode_init(AVCodecContext *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) *
2 * 16 * 2 * sizeof(uint8_t));
s->m.me.map = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t)); s->m.me.map = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
s->m.me.score_map = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t)); s->m.me.score_map = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t)); s->mb_type = av_mallocz((s->y_block_width + 1) *
s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t)); 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 ff_h263_encode_init(&s->m); // mv_penalty
return 0; return 0;
@ -507,7 +539,8 @@ static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
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;
} }
@ -530,17 +563,21 @@ static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
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)
@ -561,7 +598,9 @@ 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);
@ -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