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
Split 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 ff_svq1_packet_checksum (const uint8_t *data, const int length,
int value);
uint16_t ff_svq1_packet_checksum(const uint8_t *data,
const int length, int value);
extern const int8_t* const ff_svq1_inter_codebooks[6];
extern const int8_t* const ff_svq1_intra_codebooks[6];
extern const int8_t *const ff_svq1_inter_codebooks[6];
extern const int8_t *const ff_svq1_intra_codebooks[6];
extern const uint8_t ff_svq1_block_type_vlc[4][2];
extern const uint8_t ff_svq1_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
};
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;
for (i=0; i < length; i++) {
for (i = 0; i < length; i++)
value = checksum_table[data[i] ^ (value >> 8)] ^ ((value & 0xFF) << 8);
}
return value;
}

133
libavcodec/svq1_vlc.h
Unescape View File

@ -27,67 +27,52 @@
const uint8_t ff_svq1_block_type_vlc[4][2] = {
/* { code, length } */
{ 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 }, { 0x0, 3 }
};
/* values in this table range from -1..6; adjust retrieved value by -1 */
const uint8_t ff_svq1_intra_multistage_vlc[6][8][2] = {
/* { code, length } */
{
{ 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 },
{ 0x3, 4 }, { 0x2, 4 }, { 0x0, 5 }, { 0x1, 4 }
},{
{ 0x1, 4 }, { 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 },
{ 0x3, 3 }, { 0x2, 3 }, { 0x0, 4 }, { 0x1, 3 }
},{
{ 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x0, 5 },
{ 0x3, 4 }, { 0x2, 3 }, { 0x2, 4 }, { 0x1, 4 }
},{
{ 0x1, 6 }, { 0x1, 1 }, { 0x1, 2 }, { 0x0, 6 },
{ 0x3, 4 }, { 0x2, 4 }, { 0x1, 5 }, { 0x1, 4 }
},{
{ 0x1, 6 }, { 0x1, 1 }, { 0x1, 2 }, { 0x3, 5 },
{ 0x2, 5 }, { 0x0, 6 }, { 0x1, 5 }, { 0x1, 3 }
},{
{ 0x1, 7 }, { 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 },
{ 0x1, 4 }, { 0x1, 6 }, { 0x0, 7 }, { 0x1, 5 }
}
{ { 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 },
{ 0x3, 4 }, { 0x2, 4 }, { 0x0, 5 }, { 0x1, 4 } },
{ { 0x1, 4 }, { 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 },
{ 0x3, 3 }, { 0x2, 3 }, { 0x0, 4 }, { 0x1, 3 } },
{ { 0x1, 5 }, { 0x1, 1 }, { 0x3, 3 }, { 0x0, 5 },
{ 0x3, 4 }, { 0x2, 3 }, { 0x2, 4 }, { 0x1, 4 } },
{ { 0x1, 6 }, { 0x1, 1 }, { 0x1, 2 }, { 0x0, 6 },
{ 0x3, 4 }, { 0x2, 4 }, { 0x1, 5 }, { 0x1, 4 } },
{ { 0x1, 6 }, { 0x1, 1 }, { 0x1, 2 }, { 0x3, 5 },
{ 0x2, 5 }, { 0x0, 6 }, { 0x1, 5 }, { 0x1, 3 } },
{ { 0x1, 7 }, { 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 },
{ 0x1, 4 }, { 0x1, 6 }, { 0x0, 7 }, { 0x1, 5 } }
};
/* values in this table range from -1..6; adjust retrieved value by -1 */
const uint8_t ff_svq1_inter_multistage_vlc[6][8][2] = {
/* { code, length } */
{
{ 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 },
{ 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 }
},{
{ 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 },
{ 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 }
},{
{ 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 }
},{
{ 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 }
},{
{ 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 }
},{
{ 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 }, { 0x3, 5 },
{ 0x2, 5 }, { 0x1, 5 }, { 0x1, 6 }, { 0x0, 6 }
}
{ { 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 },
{ 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 } },
{ { 0x3, 2 }, { 0x5, 3 }, { 0x4, 3 }, { 0x3, 3 },
{ 0x2, 3 }, { 0x1, 3 }, { 0x1, 4 }, { 0x0, 4 } },
{ { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 } },
{ { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 } },
{ { 0x1, 1 }, { 0x3, 3 }, { 0x2, 3 }, { 0x3, 4 },
{ 0x2, 4 }, { 0x1, 4 }, { 0x1, 5 }, { 0x0, 5 } },
{ { 0x1, 1 }, { 0x1, 2 }, { 0x1, 3 }, { 0x3, 5 },
{ 0x2, 5 }, { 0x1, 5 }, { 0x1, 6 }, { 0x0, 6 } }
};
/* values in this table range from 0..255; adjust retrieved value by +0 */
const uint16_t ff_svq1_intra_mean_vlc[256][2] = {
/* { code, length } */
{ 0x37, 6 }, { 0x56, 7 }, { 0x1, 17 }, { 0x1, 20 },
{ 0x2, 20 }, { 0x3, 20 }, { 0x0, 20 }, { 0x4, 20 },
{ 0x5, 20 }, { 0x3, 19 }, { 0x15, 11 }, { 0x42, 9 },
{ 0x14, 11 }, { 0x3, 14 }, { 0x2, 14 }, { 0x1, 15 },
{ 0x1, 16 }, { 0x1, 12 }, { 0x2B, 10 }, { 0x18, 11 },
{ 0xC, 11 }, { 0x41, 9 }, { 0x78, 8 }, { 0x6C, 8 },
{ 0x55, 7 }, { 0xF, 4 }, { 0xE, 4 }, { 0x34, 6 },
{ 0x37, 6 }, { 0x56, 7 }, { 0x01, 17 }, { 0x01, 20 },
{ 0x02, 20 }, { 0x03, 20 }, { 0x00, 20 }, { 0x04, 20 },
{ 0x05, 20 }, { 0x03, 19 }, { 0x15, 11 }, { 0x42, 9 },
{ 0x14, 11 }, { 0x03, 14 }, { 0x02, 14 }, { 0x01, 15 },
{ 0x01, 16 }, { 0x01, 12 }, { 0x2B, 10 }, { 0x18, 11 },
{ 0x0C, 11 }, { 0x41, 9 }, { 0x78, 8 }, { 0x6C, 8 },
{ 0x55, 7 }, { 0x0F, 4 }, { 0x0E, 4 }, { 0x34, 6 },
{ 0x51, 7 }, { 0x72, 8 }, { 0x6E, 8 }, { 0x40, 9 },
{ 0x3F, 9 }, { 0x3E, 9 }, { 0x3D, 9 }, { 0x3C, 9 },
{ 0x3B, 9 }, { 0x3A, 9 }, { 0x39, 9 }, { 0x38, 9 },
@ -135,16 +120,16 @@ const uint16_t ff_svq1_intra_mean_vlc[256][2] = {
{ 0x19, 10 }, { 0x2A, 10 }, { 0x17, 10 }, { 0x16, 10 },
{ 0x15, 10 }, { 0x28, 10 }, { 0x26, 10 }, { 0x25, 10 },
{ 0x22, 10 }, { 0x21, 10 }, { 0x18, 10 }, { 0x14, 10 },
{ 0x29, 10 }, { 0x12, 10 }, { 0xD, 10 }, { 0xE, 10 },
{ 0xF, 10 }, { 0x10, 10 }, { 0x11, 10 }, { 0x1A, 10 },
{ 0x29, 10 }, { 0x12, 10 }, { 0x0D, 10 }, { 0x0E, 10 },
{ 0x0F, 10 }, { 0x10, 10 }, { 0x11, 10 }, { 0x1A, 10 },
{ 0x1B, 10 }, { 0x1C, 10 }, { 0x1D, 10 }, { 0x1E, 10 },
{ 0x1F, 10 }, { 0x20, 10 }, { 0x13, 10 }, { 0x23, 10 },
{ 0x24, 10 }, { 0x9, 11 }, { 0x8, 11 }, { 0x7, 11 },
{ 0x27, 10 }, { 0x5, 11 }, { 0xB, 11 }, { 0x6, 11 },
{ 0x4, 11 }, { 0x3, 11 }, { 0x2, 11 }, { 0x1, 11 },
{ 0xA, 11 }, { 0x16, 11 }, { 0x19, 11 }, { 0x17, 11 },
{ 0xD, 11 }, { 0xE, 11 }, { 0xF, 11 }, { 0x10, 11 },
{ 0x11, 11 }, { 0x12, 11 }, { 0x13, 11 }, { 0x1, 14 }
{ 0x24, 10 }, { 0x09, 11 }, { 0x08, 11 }, { 0x07, 11 },
{ 0x27, 10 }, { 0x05, 11 }, { 0x0B, 11 }, { 0x06, 11 },
{ 0x04, 11 }, { 0x03, 11 }, { 0x02, 11 }, { 0x01, 11 },
{ 0x0A, 11 }, { 0x16, 11 }, { 0x19, 11 }, { 0x17, 11 },
{ 0x0D, 11 }, { 0x0E, 11 }, { 0x0F, 11 }, { 0x10, 11 },
{ 0x11, 11 }, { 0x12, 11 }, { 0x13, 11 }, { 0x01, 14 }
};
/* values in this table range from -256..255; adjust retrieved value by -256 */
@ -159,12 +144,12 @@ const uint16_t ff_svq1_inter_mean_vlc[512][2] = {
{ 0xE7, 22 }, { 0xEC, 22 }, { 0xED, 22 }, { 0xEE, 22 },
{ 0xEF, 22 }, { 0xF0, 22 }, { 0xF1, 22 }, { 0xF2, 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 },
{ 0x100, 22 }, { 0x5C, 22 }, { 0x60, 22 }, { 0x101, 22 },
{ 0x71, 22 }, { 0x104, 22 }, { 0x105, 22 }, { 0xFB, 22 },
{ 0x100,22 }, { 0x5C, 22 }, { 0x60, 22 }, { 0x101,22 },
{ 0x71, 22 }, { 0x104,22 }, { 0x105,22 }, { 0xFB, 22 },
{ 0xFF, 22 }, { 0x86, 21 }, { 0xFA, 22 }, { 0x7C, 22 },
{ 0x75, 22 }, { 0x103, 22 }, { 0x78, 22 }, { 0xD3, 22 },
{ 0x75, 22 }, { 0x103,22 }, { 0x78, 22 }, { 0xD3, 22 },
{ 0x7B, 22 }, { 0x82, 22 }, { 0xD2, 22 }, { 0xD1, 22 },
{ 0xD0, 22 }, { 0xCF, 22 }, { 0xCE, 22 }, { 0xCD, 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 },
{ 0x16, 13 }, { 0x17, 13 }, { 0x18, 13 }, { 0x19, 13 },
{ 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 },
{ 0x1A, 11 }, { 0xE, 10 }, { 0x13, 10 }, { 0xF, 10 },
{ 0x10, 10 }, { 0x11, 10 }, { 0x12, 10 }, { 0xD, 9 },
{ 0x14, 9 }, { 0x15, 9 }, { 0xC, 9 }, { 0x13, 9 },
{ 0xF, 8 }, { 0xE, 8 }, { 0x10, 8 }, { 0x11, 8 },
{ 0xC, 7 }, { 0x9, 7 }, { 0xA, 7 }, { 0x8, 6 },
{ 0x9, 6 }, { 0x9, 5 }, { 0x8, 5 }, { 0x5, 4 },
{ 0x1, 1 }, { 0x3, 3 }, { 0x7, 5 }, { 0x6, 5 },
{ 0xB, 6 }, { 0xA, 6 }, { 0xE, 7 }, { 0xF, 7 },
{ 0xB, 7 }, { 0xD, 7 }, { 0xB, 8 }, { 0xD, 8 },
{ 0xC, 8 }, { 0xF, 9 }, { 0x10, 9 }, { 0x11, 9 },
{ 0xE, 9 }, { 0x12, 9 }, { 0x17, 10 }, { 0x14, 10 },
{ 0x1A, 11 }, { 0x0E, 10 }, { 0x13, 10 }, { 0x0F, 10 },
{ 0x10, 10 }, { 0x11, 10 }, { 0x12, 10 }, { 0x0D, 9 },
{ 0x14, 9 }, { 0x15, 9 }, { 0x0C, 9 }, { 0x13, 9 },
{ 0x0F, 8 }, { 0x0E, 8 }, { 0x10, 8 }, { 0x11, 8 },
{ 0x0C, 7 }, { 0x09, 7 }, { 0x0A, 7 }, { 0x08, 6 },
{ 0x09, 6 }, { 0x09, 5 }, { 0x08, 5 }, { 0x05, 4 },
{ 0x01, 1 }, { 0x03, 3 }, { 0x07, 5 }, { 0x06, 5 },
{ 0x0B, 6 }, { 0x0A, 6 }, { 0x0E, 7 }, { 0x0F, 7 },
{ 0x0B, 7 }, { 0x0D, 7 }, { 0x0B, 8 }, { 0x0D, 8 },
{ 0x0C, 8 }, { 0x0F, 9 }, { 0x10, 9 }, { 0x11, 9 },
{ 0x0E, 9 }, { 0x12, 9 }, { 0x17, 10 }, { 0x14, 10 },
{ 0x16, 10 }, { 0x15, 10 }, { 0x19, 11 }, { 0x18, 11 },
{ 0x17, 11 }, { 0x16, 11 }, { 0x15, 11 }, { 0x14, 11 },
{ 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 },
{ 0x17, 22 }, { 0x16, 22 }, { 0x15, 22 }, { 0x14, 22 },
{ 0x13, 22 }, { 0x12, 22 }, { 0x11, 22 }, { 0x10, 22 },
{ 0xF, 22 }, { 0xE, 22 }, { 0xD, 22 }, { 0xC, 22 },
{ 0xB, 22 }, { 0xA, 22 }, { 0x9, 22 }, { 0x8, 22 },
{ 0x7, 22 }, { 0x6, 22 }, { 0x5, 22 }, { 0x4, 22 },
{ 0x3, 22 }, { 0x2, 22 }, { 0x1, 22 }, { 0x0, 22 }
{ 0x0F, 22 }, { 0x0E, 22 }, { 0x0D, 22 }, { 0x0C, 22 },
{ 0x0B, 22 }, { 0x0A, 22 }, { 0x09, 22 }, { 0x08, 22 },
{ 0x07, 22 }, { 0x06, 22 }, { 0x05, 22 }, { 0x04, 22 },
{ 0x03, 22 }, { 0x02, 22 }, { 0x01, 22 }, { 0x00, 22 }
};
#endif /* AVCODEC_SVQ1_VLC_H */

509
libavcodec/svq1dec.c
Unescape View File

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

553
libavcodec/svq1enc.c
Unescape View File

@ -26,22 +26,22 @@
* http://www.pcisys.net/~melanson/codecs/
*/
#include "avcodec.h"
#include "dsputil.h"
#include "mpegvideo.h"
#include "h263.h"
#include "internal.h"
#include "svq1.h"
#include "svq1enc_cb.h"
#undef NDEBUG
#include <assert.h>
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;
DSPContext dsp;
AVFrame picture;
@ -50,7 +50,9 @@ typedef struct SVQ1Context {
PutBitContext pb;
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_height;
@ -87,19 +89,17 @@ static void svq1_write_header(SVQ1Context *s, int frame_type)
put_bits(&s->pb, 2, frame_type - 1);
if (frame_type == AV_PICTURE_TYPE_I) {
/* no checksum since frame code is 0x20 */
/* no embedded string either */
/* output 5 unknown bits (2 + 2 + 1) */
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);
if (i == 7)
{
if (i == 7) {
put_bits(&s->pb, 12, s->frame_width);
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);
}
#define QUALITY_THRESHOLD 100
#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 best_vector[6];
int block_sum[7]= {0, 0, 0, 0, 0, 0};
int w= 2<<((level+2)>>1);
int h= 2<<((level+1)>>1);
int size=w*h;
int block_sum[7] = { 0, 0, 0, 0, 0, 0 };
int w = 2 << ((level + 2) >> 1);
int h = 2 << ((level + 1) >> 1);
int size = w * h;
int16_t block[7][256];
const int8_t *codebook_sum, *codebook;
const uint16_t (*mean_vlc)[2];
const uint8_t (*multistage_vlc)[2];
best_score=0;
//FIXME optimize, this doenst need to be done multiple times
if(intra){
codebook_sum= svq1_intra_codebook_sum[level];
codebook= ff_svq1_intra_codebooks[level];
mean_vlc= ff_svq1_intra_mean_vlc;
multistage_vlc= ff_svq1_intra_multistage_vlc[level];
for(y=0; y<h; y++){
for(x=0; x<w; x++){
int v= src[x + y*stride];
block[0][x + w*y]= v;
best_score += v*v;
const uint16_t(*mean_vlc)[2];
const uint8_t(*multistage_vlc)[2];
best_score = 0;
// FIXME: Optimize, this does not need to be done multiple times.
if (intra) {
codebook_sum = svq1_intra_codebook_sum[level];
codebook = ff_svq1_intra_codebooks[level];
mean_vlc = ff_svq1_intra_mean_vlc;
multistage_vlc = ff_svq1_intra_multistage_vlc[level];
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
int v = src[x + y * stride];
block[0][x + w * y] = v;
best_score += v * v;
block_sum[0] += v;
}
}
}else{
codebook_sum= svq1_inter_codebook_sum[level];
codebook= ff_svq1_inter_codebooks[level];
mean_vlc= ff_svq1_inter_mean_vlc + 256;
multistage_vlc= ff_svq1_inter_multistage_vlc[level];
for(y=0; y<h; y++){
for(x=0; x<w; x++){
int v= src[x + y*stride] - ref[x + y*stride];
block[0][x + w*y]= v;
best_score += v*v;
} else {
codebook_sum = svq1_inter_codebook_sum[level];
codebook = ff_svq1_inter_codebooks[level];
mean_vlc = ff_svq1_inter_mean_vlc + 256;
multistage_vlc = ff_svq1_inter_multistage_vlc[level];
for (y = 0; y < h; y++) {
for (x = 0; x < w; x++) {
int v = src[x + y * stride] - ref[x + y * stride];
block[0][x + w * y] = v;
best_score += v * v;
block_sum[0] += v;
}
}
}
best_count=0;
best_score -= (int)(((unsigned)block_sum[0]*block_sum[0])>>(level+3));
best_mean= (block_sum[0] + (size>>1)) >> (level+3);
best_count = 0;
best_score -= (int)(((unsigned)block_sum[0] * block_sum[0]) >> (level + 3));
best_mean = (block_sum[0] + (size >> 1)) >> (level + 3);
if(level<4){
for(count=1; count<7; count++){
int best_vector_score= INT_MAX;
int best_vector_sum=-999, best_vector_mean=-999;
const int stage= count-1;
if (level < 4) {
for (count = 1; count < 7; count++) {
int best_vector_score = INT_MAX;
int best_vector_sum = -999, best_vector_mean = -999;
const int stage = count - 1;
const int8_t *vector;
for(i=0; i<16; i++){
int sum= codebook_sum[stage*16 + i];
for (i = 0; i < 16; i++) {
int sum = codebook_sum[stage * 16 + i];
int sqr, diff, score;
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);
diff= block_sum[stage] - sum;
score= sqr - ((diff*(int64_t)diff)>>(level+3)); //FIXME 64bit slooow
if(score < best_vector_score){
int mean= (diff + (size>>1)) >> (level+3);
assert(mean >-300 && mean<300);
mean= av_clip(mean, intra?0:-256, 255);
best_vector_score= score;
best_vector[stage]= i;
best_vector_sum= sum;
best_vector_mean= mean;
diff = block_sum[stage] - sum;
score = sqr - ((diff * (int64_t)diff) >> (level + 3)); // FIXME: 64bit slooow
if (score < best_vector_score) {
int mean = (diff + (size >> 1)) >> (level + 3);
assert(mean > -300 && mean < 300);
mean = av_clip(mean, intra ? 0 : -256, 255);
best_vector_score = score;
best_vector[stage] = i;
best_vector_sum = sum;
best_vector_mean = mean;
}
}
assert(best_vector_mean != -999);
vector= codebook + stage*size*16 + best_vector[stage]*size;
for(j=0; j<size; j++){
block[stage+1][j] = block[stage][j] - vector[j];
}
block_sum[stage+1]= block_sum[stage] - best_vector_sum;
best_vector_score +=
lambda*(+ 1 + 4*count
+ multistage_vlc[1+count][1]
vector = codebook + stage * size * 16 + best_vector[stage] * size;
for (j = 0; j < size; j++)
block[stage + 1][j] = block[stage][j] - vector[j];
block_sum[stage + 1] = block_sum[stage] - best_vector_sum;
best_vector_score += lambda *
(+1 + 4 * count +
multistage_vlc[1 + count][1]
+ mean_vlc[best_vector_mean][1]);
if(best_vector_score < best_score){
best_score= best_vector_score;
best_count= count;
best_mean= best_vector_mean;
if (best_vector_score < best_score) {
best_score = best_vector_score;
best_count = count;
best_mean = best_vector_mean;
}
}
}
split=0;
if(best_score > threshold && level){
int score=0;
int offset= (level&1) ? stride*h/2 : w/2;
split = 0;
if (best_score > threshold && level) {
int score = 0;
int offset = (level & 1) ? stride * h / 2 : w / 2;
PutBitContext backup[6];
for(i=level-1; i>=0; i--){
backup[i]= s->reorder_pb[i];
}
score += encode_block(s, src , ref , decoded , stride, level-1, threshold>>1, lambda, intra);
score += encode_block(s, src + offset, ref + offset, decoded + offset, stride, level-1, threshold>>1, lambda, intra);
for (i = level - 1; i >= 0; i--)
backup[i] = s->reorder_pb[i];
score += encode_block(s, src, ref, decoded, stride, level - 1,
threshold >> 1, lambda, intra);
score += encode_block(s, src + offset, ref + offset, decoded + offset,
stride, level - 1, threshold >> 1, lambda, intra);
score += lambda;
if(score < best_score){
best_score= score;
split=1;
}else{
for(i=level-1; i>=0; i--){
s->reorder_pb[i]= backup[i];
}
if (score < best_score) {
best_score = score;
split = 1;
} else {
for (i = level - 1; i >= 0; i--)
s->reorder_pb[i] = backup[i];
}
}
if (level > 0)
put_bits(&s->reorder_pb[level], 1, split);
if(!split){
assert((best_mean >= 0 && best_mean<256) || !intra);
assert(best_mean >= -256 && best_mean<256);
assert(best_count >=0 && best_count<7);
assert(level<4 || best_count==0);
if (!split) {
assert((best_mean >= 0 && best_mean < 256) || !intra);
assert(best_mean >= -256 && best_mean < 256);
assert(best_count >= 0 && best_count < 7);
assert(level < 4 || best_count == 0);
/* output the encoding */
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],
mean_vlc[best_mean][0]);
for (i = 0; i < best_count; i++){
assert(best_vector[i]>=0 && best_vector[i]<16);
for (i = 0; i < best_count; i++) {
assert(best_vector[i] >= 0 && best_vector[i] < 16);
put_bits(&s->reorder_pb[level], 4, best_vector[i]);
}
for(y=0; y<h; y++){
for(x=0; x<w; x++){
decoded[x + y*stride]= src[x + y*stride] - block[best_count][x + w*y] + best_mean;
}
}
for (y = 0; y < h; y++)
for (x = 0; x < w; x++)
decoded[x + y * stride] = src[x + y * stride] -
block[best_count][x + w * y] +
best_mean;
}
return best_score;
}
static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane, unsigned char *ref_plane, unsigned char *decoded_plane,
static int svq1_encode_plane(SVQ1Context *s, int plane,
unsigned char *src_plane,
unsigned char *ref_plane,
unsigned char *decoded_plane,
int width, int height, int src_stride, int stride)
{
int x, y;
@ -266,7 +269,8 @@ static int svq1_encode_plane(SVQ1Context *s, int plane, unsigned char *src_plane
int level;
int threshold[6];
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 */
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_height = (height + 15) / 16;
if(s->picture.pict_type == AV_PICTURE_TYPE_P){
s->m.avctx= s->avctx;
s->m.current_picture_ptr= &s->m.current_picture;
if (s->picture.pict_type == AV_PICTURE_TYPE_P) {
s->m.avctx = s->avctx;
s->m.current_picture_ptr = &s->m.current_picture;
s->m.last_picture_ptr = &s->m.last_picture;
s->m.last_picture.f.data[0] = ref_plane;
s->m.linesize=
s->m.linesize =
s->m.last_picture.f.linesize[0] =
s->m.new_picture.f.linesize[0] =
s->m.current_picture.f.linesize[0] = stride;
s->m.width= width;
s->m.height= height;
s->m.mb_width= block_width;
s->m.mb_height= block_height;
s->m.mb_stride= s->m.mb_width+1;
s->m.b8_stride= 2*s->m.mb_width+1;
s->m.f_code=1;
s->m.pict_type= s->picture.pict_type;
s->m.me_method= s->avctx->me_method;
s->m.me.scene_change_score=0;
s->m.flags= s->avctx->flags;
// s->m.out_format = FMT_H263;
// s->m.unrestricted_mv= 1;
s->m.lambda= s->picture.quality;
s->m.qscale= (s->m.lambda*139 + FF_LAMBDA_SCALE*64) >> (FF_LAMBDA_SHIFT + 7);
s->m.lambda2= (s->m.lambda*s->m.lambda + FF_LAMBDA_SCALE/2) >> FF_LAMBDA_SHIFT;
if(!s->motion_val8[plane]){
s->motion_val8 [plane]= av_mallocz((s->m.b8_stride*block_height*2 + 2)*2*sizeof(int16_t));
s->motion_val16[plane]= av_mallocz((s->m.mb_stride*(block_height + 2) + 1)*2*sizeof(int16_t));
}
s->m.mb_type= s->mb_type;
//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.width = width;
s->m.height = height;
s->m.mb_width = block_width;
s->m.mb_height = block_height;
s->m.mb_stride = s->m.mb_width + 1;
s->m.b8_stride = 2 * s->m.mb_width + 1;
s->m.f_code = 1;
s->m.pict_type = s->picture.pict_type;
s->m.me_method = s->avctx->me_method;
s->m.me.scene_change_score = 0;
s->m.flags = s->avctx->flags;
// s->m.out_format = FMT_H263;
// s->m.unrestricted_mv = 1;
s->m.lambda = s->picture.quality;
s->m.qscale = (s->m.lambda * 139 +
FF_LAMBDA_SCALE * 64) >>
(FF_LAMBDA_SHIFT + 7);
s->m.lambda2 = (s->m.lambda * s->m.lambda +
FF_LAMBDA_SCALE / 2) >>
FF_LAMBDA_SHIFT;
if (!s->motion_val8[plane]) {
s->motion_val8[plane] = av_mallocz((s->m.b8_stride *
block_height * 2 + 2) *
2 * sizeof(int16_t));
s->motion_val16[plane] = av_mallocz((s->m.mb_stride *
(block_height + 2) + 1) *
2 * sizeof(int16_t));
}
s->m.mb_type = s->mb_type;
// 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.motion_val[0] = s->motion_val8[plane] + 2;
s->m.p_mv_table= s->motion_val16[plane] + s->m.mb_stride + 1;
s->m.dsp= s->dsp; //move
s->m.p_mv_table = s->motion_val16[plane] +
s->m.mb_stride + 1;
s->m.dsp = s->dsp; // move
ff_init_me(&s->m);
s->m.me.dia_size= s->avctx->dia_size;
s->m.first_slice_line=1;
s->m.me.dia_size = s->avctx->dia_size;
s->m.first_slice_line = 1;
for (y = 0; y < block_height; y++) {
s->m.new_picture.f.data[0] = src - y*16*stride; //ugly
s->m.mb_y= y;
s->m.new_picture.f.data[0] = src - y * 16 * stride; // ugly
s->m.mb_y = y;
for(i=0; i<16 && i + 16*y<height; i++){
memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
for(x=width; x<16*block_width; x++)
src[i*stride+x]= src[i*stride+x-1];
for (i = 0; i < 16 && i + 16 * y < height; i++) {
memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
width);
for (x = width; x < 16 * block_width; x++)
src[i * stride + x] = src[i * stride + x - 1];
}
for(; i<16 && i + 16*y<16*block_height; i++)
memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
for (; i < 16 && i + 16 * y < 16 * block_height; i++)
memcpy(&src[i * stride], &src[(i - 1) * stride],
16 * block_width);
for (x = 0; x < block_width; x++) {
s->m.mb_x= x;
s->m.mb_x = x;
ff_init_block_index(&s->m);
ff_update_block_index(&s->m);
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_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(i=0; i<16 && i + 16*y<height; i++){
memcpy(&src[i*stride], &src_plane[(i+16*y)*src_stride], width);
for(x=width; x<16*block_width; x++)
src[i*stride+x]= src[i*stride+x-1];
for (i = 0; i < 16 && i + 16 * y < height; i++) {
memcpy(&src[i * stride], &src_plane[(i + 16 * y) * src_stride],
width);
for (x = width; x < 16 * block_width; x++)
src[i * stride + x] = src[i * stride + x - 1];
}
for(; i<16 && i + 16*y<16*block_height; i++)
memcpy(&src[i*stride], &src[(i-1)*stride], 16*block_width);
for (; i < 16 && i + 16 * y < 16 * block_height; i++)
memcpy(&src[i * stride], &src[(i - 1) * stride], 16 * block_width);
s->m.mb_y= y;
s->m.mb_y = y;
for (x = 0; x < block_width; x++) {
uint8_t reorder_buffer[3][6][7*32];
uint8_t reorder_buffer[3][6][7 * 32];
int count[3][6];
int offset = y * 16 * stride + x * 16;
uint8_t *decoded= decoded_plane + offset;
uint8_t *ref= ref_plane + offset;
int score[4]={0,0,0,0}, best;
uint8_t *decoded = decoded_plane + offset;
uint8_t *ref = ref_plane + offset;
int score[4] = { 0, 0, 0, 0 }, best;
uint8_t *temp = s->scratchbuf;
if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3000){ //FIXME check size
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");
return -1;
}
s->m.mb_x= x;
s->m.mb_x = x;
ff_init_block_index(&s->m);
ff_update_block_index(&s->m);
if(s->picture.pict_type == AV_PICTURE_TYPE_I || (s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTRA)){
for(i=0; i<6; i++){
init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i], 7*32);
}
if(s->picture.pict_type == AV_PICTURE_TYPE_P){
const uint8_t *vlc= ff_svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
if (s->picture.pict_type == AV_PICTURE_TYPE_I ||
(s->m.mb_type[x + y * s->m.mb_stride] &
CANDIDATE_MB_TYPE_INTRA)) {
for (i = 0; i < 6; i++)
init_put_bits(&s->reorder_pb[i], reorder_buffer[0][i],
7 * 32);
if (s->picture.pict_type == AV_PICTURE_TYPE_P) {
const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTRA];
put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
score[0]= vlc[1]*lambda;
score[0] = vlc[1] * lambda;
}
score[0]+= encode_block(s, src+16*x, NULL, temp, stride, 5, 64, lambda, 1);
for(i=0; i<6; i++){
count[0][i]= put_bits_count(&s->reorder_pb[i]);
score[0] += encode_block(s, src + 16 * x, NULL, temp, stride,
5, 64, lambda, 1);
for (i = 0; i < 6; i++) {
count[0][i] = put_bits_count(&s->reorder_pb[i]);
flush_put_bits(&s->reorder_pb[i]);
}
}else
score[0]= INT_MAX;
} else
score[0] = INT_MAX;
best=0;
best = 0;
if(s->picture.pict_type == AV_PICTURE_TYPE_P){
const uint8_t *vlc= ff_svq1_block_type_vlc[SVQ1_BLOCK_INTER];
if (s->picture.pict_type == AV_PICTURE_TYPE_P) {
const uint8_t *vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_INTER];
int mx, my, pred_x, pred_y, dxy;
int16_t *motion_ptr;
motion_ptr= ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
if(s->m.mb_type[x + y*s->m.mb_stride]&CANDIDATE_MB_TYPE_INTER){
for(i=0; i<6; i++)
init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i], 7*32);
motion_ptr = ff_h263_pred_motion(&s->m, 0, 0, &pred_x, &pred_y);
if (s->m.mb_type[x + y * s->m.mb_stride] &
CANDIDATE_MB_TYPE_INTER) {
for (i = 0; i < 6; i++)
init_put_bits(&s->reorder_pb[i], reorder_buffer[1][i],
7 * 32);
put_bits(&s->reorder_pb[5], vlc[1], vlc[0]);
s->m.pb= s->reorder_pb[5];
mx= motion_ptr[0];
my= motion_ptr[1];
assert(mx>=-32 && mx<=31);
assert(my>=-32 && my<=31);
assert(pred_x>=-32 && pred_x<=31);
assert(pred_y>=-32 && pred_y<=31);
s->m.pb = s->reorder_pb[5];
mx = motion_ptr[0];
my = motion_ptr[1];
assert(mx >= -32 && mx <= 31);
assert(my >= -32 && my <= 31);
assert(pred_x >= -32 && pred_x <= 31);
assert(pred_y >= -32 && pred_y <= 31);
ff_h263_encode_motion(&s->m, mx - pred_x, 1);
ff_h263_encode_motion(&s->m, my - pred_y, 1);
s->reorder_pb[5]= s->m.pb;
score[1] += lambda*put_bits_count(&s->reorder_pb[5]);
dxy= (mx&1) + 2*(my&1);
s->dsp.put_pixels_tab[0][dxy](temp+16, ref + (mx>>1) + stride*(my>>1), stride, 16);
score[1]+= encode_block(s, src+16*x, temp+16, decoded, stride, 5, 64, lambda, 0);
best= score[1] <= score[0];
vlc= ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
score[2]= s->dsp.sse[0](NULL, src+16*x, ref, stride, 16);
score[2]+= vlc[1]*lambda;
if(score[2] < score[best] && mx==0 && my==0){
best=2;
s->reorder_pb[5] = s->m.pb;
score[1] += lambda * put_bits_count(&s->reorder_pb[5]);
dxy = (mx & 1) + 2 * (my & 1);
s->dsp.put_pixels_tab[0][dxy](temp + 16,
ref + (mx >> 1) +
stride * (my >> 1),
stride, 16);
score[1] += encode_block(s, src + 16 * x, temp + 16,
decoded, stride, 5, 64, lambda, 0);
best = score[1] <= score[0];
vlc = ff_svq1_block_type_vlc[SVQ1_BLOCK_SKIP];
score[2] = s->dsp.sse[0](NULL, src + 16 * x, ref,
stride, 16);
score[2] += vlc[1] * lambda;
if (score[2] < score[best] && mx == 0 && my == 0) {
best = 2;
s->dsp.put_pixels_tab[0][0](decoded, ref, stride, 16);
for(i=0; i<6; i++){
count[2][i]=0;
}
for (i = 0; i < 6; i++)
count[2][i] = 0;
put_bits(&s->pb, vlc[1], vlc[0]);
}
}
if(best==1){
for(i=0; i<6; i++){
count[1][i]= put_bits_count(&s->reorder_pb[i]);
if (best == 1) {
for (i = 0; i < 6; i++) {
count[1][i] = put_bits_count(&s->reorder_pb[i]);
flush_put_bits(&s->reorder_pb[i]);
}
}else{
motion_ptr[0 ] = motion_ptr[1 ]=
motion_ptr[2 ] = motion_ptr[3 ]=
motion_ptr[0+2*s->m.b8_stride] = motion_ptr[1+2*s->m.b8_stride]=
motion_ptr[2+2*s->m.b8_stride] = motion_ptr[3+2*s->m.b8_stride]=0;
} else {
motion_ptr[0] =
motion_ptr[1] =
motion_ptr[2] =
motion_ptr[3] =
motion_ptr[0 + 2 * s->m.b8_stride] =
motion_ptr[1 + 2 * s->m.b8_stride] =
motion_ptr[2 + 2 * s->m.b8_stride] =
motion_ptr[3 + 2 * s->m.b8_stride] = 0;
}
}
s->rd_total += score[best];
for(i=5; i>=0; i--){
avpriv_copy_bits(&s->pb, reorder_buffer[best][i], count[best][i]);
}
if(best==0){
for (i = 5; i >= 0; i--)
avpriv_copy_bits(&s->pb, reorder_buffer[best][i],
count[best][i]);
if (best == 0)
s->dsp.put_pixels_tab[0][0](decoded, temp, stride, 16);
}
}
s->m.first_slice_line=0;
s->m.first_slice_line = 0;
}
return 0;
}
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);
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_height = (s->frame_height / 4 + 15) / 16;
s->avctx= avctx;
s->m.avctx= avctx;
s->avctx = avctx;
s->m.avctx = avctx;
s->m.picture_structure = PICT_FRAME;
s->m.me.temp =
s->m.me.scratchpad= av_mallocz((avctx->width+64)*2*16*2*sizeof(uint8_t));
s->m.me.map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
s->m.me.score_map = av_mallocz(ME_MAP_SIZE*sizeof(uint32_t));
s->mb_type = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int16_t));
s->dummy = av_mallocz((s->y_block_width+1)*s->y_block_height*sizeof(int32_t));
ff_h263_encode_init(&s->m); //mv_penalty
s->m.me.scratchpad = av_mallocz((avctx->width + 64) *
2 * 16 * 2 * sizeof(uint8_t));
s->m.me.map = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
s->m.me.score_map = av_mallocz(ME_MAP_SIZE * sizeof(uint32_t));
s->mb_type = av_mallocz((s->y_block_width + 1) *
s->y_block_height * sizeof(int16_t));
s->dummy = av_mallocz((s->y_block_width + 1) *
s->y_block_height * sizeof(int32_t));
ff_h263_encode_init(&s->m); // mv_penalty
return 0;
}
@ -501,49 +533,54 @@ static av_cold int svq1_encode_init(AVCodecContext *avctx)
static int svq1_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pict, int *got_packet)
{
SVQ1Context * const s = avctx->priv_data;
AVFrame * const p = &s->picture;
SVQ1Context *const s = avctx->priv_data;
AVFrame *const p = &s->picture;
AVFrame temp;
int i, ret;
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");
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");
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->last_picture);
s->scratchbuf = av_malloc(s->current_picture.linesize[0] * 16 * 2);
}
temp= s->current_picture;
s->current_picture= s->last_picture;
s->last_picture= temp;
temp = s->current_picture;
s->current_picture = s->last_picture;
s->last_picture = temp;
init_put_bits(&s->pb, pkt->data, pkt->size);
*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;
svq1_write_header(s, p->pict_type);
for(i=0; i<3; i++){
if(svq1_encode_plane(s, i,
s->picture.data[i], s->last_picture.data[i], s->current_picture.data[i],
s->frame_width / (i?4:1), s->frame_height / (i?4:1),
s->picture.linesize[i], s->current_picture.linesize[i]) < 0)
for (i = 0; i < 3; i++)
if (svq1_encode_plane(s, i,
s->picture.data[i],
s->last_picture.data[i],
s->current_picture.data[i],
s->frame_width / (i ? 4 : 1),
s->frame_height / (i ? 4 : 1),
s->picture.linesize[i],
s->current_picture.linesize[i]) < 0)
return -1;
}
// avpriv_align_put_bits(&s->pb);
while(put_bits_count(&s->pb) & 31)
// avpriv_align_put_bits(&s->pb);
while (put_bits_count(&s->pb) & 31)
put_bits(&s->pb, 1, 0);
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)
{
SVQ1Context * const s = avctx->priv_data;
SVQ1Context *const s = avctx->priv_data;
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.map);
@ -570,7 +609,7 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx)
av_freep(&s->dummy);
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_val16[i]);
}
@ -578,7 +617,6 @@ static av_cold int svq1_encode_end(AVCodecContext *avctx)
return 0;
}
AVCodec ff_svq1_encoder = {
.name = "svq1",
.type = AVMEDIA_TYPE_VIDEO,
@ -587,6 +625,7 @@ AVCodec ff_svq1_encoder = {
.init = svq1_encode_init,
.encode2 = svq1_encode_frame,
.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"),
};

42
libavcodec/svq1enc_cb.h
Unescape View File

@ -30,67 +30,57 @@
#include <stdint.h>
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,
1, -1, 2, 2, 1, 1, 2, 0, 0, 0, -1, 1, 1, 0, 0, 0,
1, -1, 0, 1, -1, 1, 1, 0, 1, 0, -1, 1, 1, 0, 0, 0,
-2, 0, 0, -2, 0, 0, -2, 0, -2, -1, -2, -1, 0, 0, -1, 0,
1, 0, 1, -1, 2, 2, 1, 2, 2, 1, 0, 1, 1, 0, 1, 1,
},{
-2, 1, -1, -1, 1, 0, 1, -1, -1, -1, 1, -1, 0, -1, 0, -1,
1, 0, 1, -1, 2, 2, 1, 2, 2, 1, 0, 1, 1, 0, 1, 1, },
{ -2, 1, -1, -1, 1, 0, 1, -1, -1, -1, 1, -1, 0, -1, 0, -1,
0, 0, 0, -2, 0, 1, 0, -1, -1, 0, 2, -3, 1, -2, 3, -1,
2, 0, 2, 1, 1, -1, 1, 1, 0, 0, 1, 1, 2, -2, 1, 0,
-2, -1, 2, -2, -2, 0, -3, 0, -1, 0, -1, 0, -1, 0, -2, -3,
1, -2, -2, -1, 1, -1, -1, 1, -1, 1, 1, 0, -2, 0, 1, 1,
1, 1, 2, 1, 0, 0, -1, 0, 0, 1, 0, 1, -1, 1, 0, 2,
},{
0, 0, 0, -3, 1, 1, 1, -3, 0, -1, 0, -3, 1, -3, 0, -2,
1, 1, 2, 1, 0, 0, -1, 0, 0, 1, 0, 1, -1, 1, 0, 2, },
{ 0, 0, 0, -3, 1, 1, 1, -3, 0, -1, 0, -3, 1, -3, 0, -2,
1, 2, -1, -3, 0, -3, 1, -1, 0, -1, 0, 0, 1, 2, 1, 1,
-1, 2, -3, 3, 1, 0, -5, 1, 0, -1, -3, 1, 0, 2, 0, -3,
4, 2, 0, -2, 1, -2, 3, -2, 1, 1, 0, -1, 2, 5, 3, 1,
-1, 0, 2, -3, -2, 0, 0, -2, 2, -3, -1, -1, 2, 1, 0, -2,
3, -1, 1, -1, 2, 4, 0, 1, 0, 1, 0, -1, -3, -2, -1, 0,
},{
0, 2, -1, -1, 2, -4, -2, 3, 0, -1, -5, 1, 0, 1, 0, 6,
3, -1, 1, -1, 2, 4, 0, 1, 0, 1, 0, -1, -3, -2, -1, 0, },
{ 0, 2, -1, -1, 2, -4, -2, 3, 0, -1, -5, 1, 0, 1, 0, 6,
-2, 2, 0, 1, 1, -1, -1, -2, 1, -2, -1, 0, 2, -2, -2, -1,
-4, 2, -1, -3, -1, -2, 2, -1, 2, -1, 2, 0, 3, -3, -3, 0,
-3, 0, 0, -2, 4, -4, 0, -1, 4, 0, -2, -2, 3, -2, 0, 4,
5, 0, 1, 0, -3, 3, 3, 2, 0, 0, 1, 2, -5, -2, -3, 0,
-3, 2, -2, 2, -2, 4, 7, -3, 4, 2, 3, 2, -1, 0, -3, 1,
}
-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] = {
{
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, 0, 1, -1, 1, 0, -1, -1, 0, 1, 1, 0, 0, -1, 1,
0, 1, 0, 0, 1, -1, 0, 0, 0, -1, 1, 0, 1, 0, -2, 1,
0, -1, 1, 0, 0, 0, 1, 0, -1, 0, 0, 0, -1, 0, 0, 0,
0, 1, 1, 0, 0, -1, 0, 1, 0, 0, 0, 0, -1, 1, 1, -1,
},{
-1, -2, 0, -1, 1, 0, -1, 0, -1, -4, -1, -2, -1, -2, 1, -2,
0, 1, 1, 0, 0, -1, 0, 1, 0, 0, 0, 0, -1, 1, 1, -1, },
{ -1, -2, 0, -1, 1, 0, -1, 0, -1, -4, -1, -2, -1, -2, 1, -2,
0, 0, 4, -2, -1, 1, 1, 0, 2, 1, 1, 0, 2, 0, 0, 0,
1, 1, 0, -1, -1, -1, 1, 0, -1, -3, -3, 1, -1, 1, -2, -1,
1, -1, 0, 1, 2, 1, -1, -1, 1, 1, 1, 2, 1, 0, 1, -2,
-2, 0, -1, -2, -2, 0, -1, -1, -1, 0, 1, 0, -1, -1, 0, -1,
0, 2, 1, 2, 2, 1, -1, 1, 0, 2, 0, -1, 1, 0, 0, 0,
},{
-2, 0, -1, -1, 1, 1, -2, 0, -2, 0, 1, -2, -2, 1, -1, -1,
0, 2, 1, 2, 2, 1, -1, 1, 0, 2, 0, -1, 1, 0, 0, 0, },
{ -2, 0, -1, -1, 1, 1, -2, 0, -2, 0, 1, -2, -2, 1, -1, -1,
3, -2, 0, -3, -4, -3, 2, 1, 0, 3, -2, 2, 3, 2, 2, -1,
-3, 1, 0, 1, 0, 0, 0, 1, -2, 1, -2, -2, -1, -2, -2, 2,
0, -4, 0, 2, -1, 0, 2, 2, 2, 1, 0, -1, -1, 1, -3, 2,
2, 1, 0, 3, 1, -1, 1, 3, 1, 0, 1, 1, 2, -1, 1, -1,
-2, -1, 0, -1, 1, -1, 1, -2, -2, -1, -1, -3, 1, -4, -3, 1,
},{
-2, 0, -2, 3, -1, -1, 0, 2, 2, -1, -3, 2, 1, 0, -2, -1,
-2, -1, 0, -1, 1, -1, 1, -2, -2, -1, -1, -3, 1, -4, -3, 1, },
{ -2, 0, -2, 3, -1, -1, 0, 2, 2, -1, -3, 2, 1, 0, -2, -1,
-3, -2, -2, 1, 2, -3, 0, 1, -5, -2, -3, 0, -2, -1, 2, 0,
-1, -1, 0, -2, 1, 3, -7, -2, -2, -1, 2, -1, 0, 3, 1, 3,
1, 0, 0, 1, 2, 3, 1, 2, 0, -2, -2, 1, 1, 2, 2, 3,
4, 1, -1, 2, -2, 4, 0, 0, 0, 4, 2, 0, -2, -2, 2, -4,
-1, 5, -2, -2, -3, 2, -3, -1, 3, -3, 0, 4, 3, 0, 1, -2,
}
-1, 5, -2, -2, -3, 2, -3, -1, 3, -3, 0, 4, 3, 0, 1, -2, }
};
#endif /* AVCODEC_SVQ1ENC_CB_H */

Write Preview
Loading…
Cancel
Save