zk-station-control-video-relay/src/wasm/mpeg1.c

#include <string.h>
#include <stdlib.h>
#include "mpeg1.h"

static const float PICTURE_RATE[] = {
	0.000, 23.976, 24.000, 25.000, 29.970, 30.000, 50.000, 59.940,
	60.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000, 0.000
};

static const uint8_t ZIG_ZAG[] = {
	 0,  1,  8, 16,  9,  2,  3, 10,
	17, 24, 32, 25, 18, 11,  4,  5,
	12, 19, 26, 33, 40, 48, 41, 34,
	27, 20, 13,  6,  7, 14, 21, 28,
	35, 42, 49, 56, 57, 50, 43, 36,
	29, 22, 15, 23, 30, 37, 44, 51,
	58, 59, 52, 45, 38, 31, 39, 46,
	53, 60, 61, 54, 47, 55, 62, 63
};

static const uint8_t DEFAULT_INTRA_QUANT_MATRIX[] = {
	 8, 16, 19, 22, 26, 27, 29, 34,
	16, 16, 22, 24, 27, 29, 34, 37,
	19, 22, 26, 27, 29, 34, 34, 38,
	22, 22, 26, 27, 29, 34, 37, 40,
	22, 26, 27, 29, 32, 35, 40, 48,
	26, 27, 29, 32, 35, 40, 48, 58,
	26, 27, 29, 34, 38, 46, 56, 69,
	27, 29, 35, 38, 46, 56, 69, 83
};

static const uint8_t DEFAULT_NON_INTRA_QUANT_MATRIX[] = {
	16, 16, 16, 16, 16, 16, 16, 16,
	16, 16, 16, 16, 16, 16, 16, 16,
	16, 16, 16, 16, 16, 16, 16, 16,
	16, 16, 16, 16, 16, 16, 16, 16,
	16, 16, 16, 16, 16, 16, 16, 16,
	16, 16, 16, 16, 16, 16, 16, 16,
	16, 16, 16, 16, 16, 16, 16, 16,
	16, 16, 16, 16, 16, 16, 16, 16
};

static const uint8_t PREMULTIPLIER_MATRIX[] = {
	32, 44, 42, 38, 32, 25, 17,  9,
	44, 62, 58, 52, 44, 35, 24, 12,
	42, 58, 55, 49, 42, 33, 23, 12,
	38, 52, 49, 44, 38, 30, 20, 10,
	32, 44, 42, 38, 32, 25, 17,  9,
	25, 35, 33, 30, 25, 20, 14,  7,
	17, 24, 23, 20, 17, 14,  9,  5,
	 9, 12, 12, 10,  9,  7,  5,  2
};

// MPEG-1 VLC

//  macroblock_stuffing decodes as 34.
//  macroblock_escape decodes as 35.

static const int MACROBLOCK_ADDRESS_INCREMENT[] = {
	 1*3,  2*3,  0, //   0
	 3*3,  4*3,  0, //   1  0
	   0,    0,  1, //   2  1.
	 5*3,  6*3,  0, //   3  00
	 7*3,  8*3,  0, //   4  01
	 9*3, 10*3,  0, //   5  000
	11*3, 12*3,  0, //   6  001
	   0,    0,  3, //   7  010.
	   0,    0,  2, //   8  011.
	13*3, 14*3,  0, //   9  0000
	15*3, 16*3,  0, //  10  0001
	   0,    0,  5, //  11  0010.
	   0,    0,  4, //  12  0011.
	17*3, 18*3,  0, //  13  0000 0
	19*3, 20*3,  0, //  14  0000 1
	   0,    0,  7, //  15  0001 0.
	   0,    0,  6, //  16  0001 1.
	21*3, 22*3,  0, //  17  0000 00
	23*3, 24*3,  0, //  18  0000 01
	25*3, 26*3,  0, //  19  0000 10
	27*3, 28*3,  0, //  20  0000 11
	  -1, 29*3,  0, //  21  0000 000
	  -1, 30*3,  0, //  22  0000 001
	31*3, 32*3,  0, //  23  0000 010
	33*3, 34*3,  0, //  24  0000 011
	35*3, 36*3,  0, //  25  0000 100
	37*3, 38*3,  0, //  26  0000 101
	   0,    0,  9, //  27  0000 110.
	   0,    0,  8, //  28  0000 111.
	39*3, 40*3,  0, //  29  0000 0001
	41*3, 42*3,  0, //  30  0000 0011
	43*3, 44*3,  0, //  31  0000 0100
	45*3, 46*3,  0, //  32  0000 0101
	   0,    0, 15, //  33  0000 0110.
	   0,    0, 14, //  34  0000 0111.
	   0,    0, 13, //  35  0000 1000.
	   0,    0, 12, //  36  0000 1001.
	   0,    0, 11, //  37  0000 1010.
	   0,    0, 10, //  38  0000 1011.
	47*3,   -1,  0, //  39  0000 0001 0
	  -1, 48*3,  0, //  40  0000 0001 1
	49*3, 50*3,  0, //  41  0000 0011 0
	51*3, 52*3,  0, //  42  0000 0011 1
	53*3, 54*3,  0, //  43  0000 0100 0
	55*3, 56*3,  0, //  44  0000 0100 1
	57*3, 58*3,  0, //  45  0000 0101 0
	59*3, 60*3,  0, //  46  0000 0101 1
	61*3,   -1,  0, //  47  0000 0001 00
	  -1, 62*3,  0, //  48  0000 0001 11
	63*3, 64*3,  0, //  49  0000 0011 00
	65*3, 66*3,  0, //  50  0000 0011 01
	67*3, 68*3,  0, //  51  0000 0011 10
	69*3, 70*3,  0, //  52  0000 0011 11
	71*3, 72*3,  0, //  53  0000 0100 00
	73*3, 74*3,  0, //  54  0000 0100 01
	   0,    0, 21, //  55  0000 0100 10.
	   0,    0, 20, //  56  0000 0100 11.
	   0,    0, 19, //  57  0000 0101 00.
	   0,    0, 18, //  58  0000 0101 01.
	   0,    0, 17, //  59  0000 0101 10.
	   0,    0, 16, //  60  0000 0101 11.
	   0,    0, 35, //  61  0000 0001 000. -- macroblock_escape
	   0,    0, 34, //  62  0000 0001 111. -- macroblock_stuffing
	   0,    0, 33, //  63  0000 0011 000.
	   0,    0, 32, //  64  0000 0011 001.
	   0,    0, 31, //  65  0000 0011 010.
	   0,    0, 30, //  66  0000 0011 011.
	   0,    0, 29, //  67  0000 0011 100.
	   0,    0, 28, //  68  0000 0011 101.
	   0,    0, 27, //  69  0000 0011 110.
	   0,    0, 26, //  70  0000 0011 111.
	   0,    0, 25, //  71  0000 0100 000.
	   0,    0, 24, //  72  0000 0100 001.
	   0,    0, 23, //  73  0000 0100 010.
	   0,    0, 22  //  74  0000 0100 011.
};

//  macroblock_type bitmap:
//    0x10  macroblock_quant
//    0x08  macroblock_motion_forward
//    0x04  macroblock_motion_backward
//    0x02  macrobkock_pattern
//    0x01  macroblock_intra
//

static const int MACROBLOCK_TYPE_INTRA[] = {
	 1*3,  2*3,     0, //   0
	  -1,  3*3,     0, //   1  0
	   0,    0,  0x01, //   2  1.
	   0,    0,  0x11  //   3  01.
};

static const int MACROBLOCK_TYPE_PREDICTIVE[] = {
	 1*3,  2*3,     0, //  0
	 3*3,  4*3,     0, //  1  0
	   0,    0,  0x0a, //  2  1.
	 5*3,  6*3,     0, //  3  00
	   0,    0,  0x02, //  4  01.
	 7*3,  8*3,     0, //  5  000
	   0,    0,  0x08, //  6  001.
	 9*3, 10*3,     0, //  7  0000
	11*3, 12*3,     0, //  8  0001
	  -1, 13*3,     0, //  9  00000
	   0,    0,  0x12, // 10  00001.
	   0,    0,  0x1a, // 11  00010.
	   0,    0,  0x01, // 12  00011.
	   0,    0,  0x11  // 13  000001.
};

static const int MACROBLOCK_TYPE_B[] = {
	 1*3,  2*3,     0,  //  0
	 3*3,  5*3,     0,  //  1  0
	 4*3,  6*3,     0,  //  2  1
	 8*3,  7*3,     0,  //  3  00
	   0,    0,  0x0c,  //  4  10.
	 9*3, 10*3,     0,  //  5  01
	   0,    0,  0x0e,  //  6  11.
	13*3, 14*3,     0,  //  7  001
	12*3, 11*3,     0,  //  8  000
	   0,    0,  0x04,  //  9  010.
	   0,    0,  0x06,  // 10  011.
	18*3, 16*3,     0,  // 11  0001
	15*3, 17*3,     0,  // 12  0000
	   0,    0,  0x08,  // 13  0010.
	   0,    0,  0x0a,  // 14  0011.
	  -1, 19*3,     0,  // 15  00000
	   0,    0,  0x01,  // 16  00011.
	20*3, 21*3,     0,  // 17  00001
	   0,    0,  0x1e,  // 18  00010.
	   0,    0,  0x11,  // 19  000001.
	   0,    0,  0x16,  // 20  000010.
	   0,    0,  0x1a   // 21  000011.
};

static const int *MACROBLOCK_TYPE[] = {
	NULL,
	MACROBLOCK_TYPE_INTRA,
	MACROBLOCK_TYPE_PREDICTIVE,
	MACROBLOCK_TYPE_B
};

static const int CODE_BLOCK_PATTERN[] = {
	  2*3,   1*3,   0,  //   0
	  3*3,   6*3,   0,  //   1  1
	  4*3,   5*3,   0,  //   2  0
	  8*3,  11*3,   0,  //   3  10
	 12*3,  13*3,   0,  //   4  00
	  9*3,   7*3,   0,  //   5  01
	 10*3,  14*3,   0,  //   6  11
	 20*3,  19*3,   0,  //   7  011
	 18*3,  16*3,   0,  //   8  100
	 23*3,  17*3,   0,  //   9  010
	 27*3,  25*3,   0,  //  10  110
	 21*3,  28*3,   0,  //  11  101
	 15*3,  22*3,   0,  //  12  000
	 24*3,  26*3,   0,  //  13  001
	    0,     0,  60,  //  14  111.
	 35*3,  40*3,   0,  //  15  0000
	 44*3,  48*3,   0,  //  16  1001
	 38*3,  36*3,   0,  //  17  0101
	 42*3,  47*3,   0,  //  18  1000
	 29*3,  31*3,   0,  //  19  0111
	 39*3,  32*3,   0,  //  20  0110
	    0,     0,  32,  //  21  1010.
	 45*3,  46*3,   0,  //  22  0001
	 33*3,  41*3,   0,  //  23  0100
	 43*3,  34*3,   0,  //  24  0010
	    0,     0,   4,  //  25  1101.
	 30*3,  37*3,   0,  //  26  0011
	    0,     0,   8,  //  27  1100.
	    0,     0,  16,  //  28  1011.
	    0,     0,  44,  //  29  0111 0.
	 50*3,  56*3,   0,  //  30  0011 0
	    0,     0,  28,  //  31  0111 1.
	    0,     0,  52,  //  32  0110 1.
	    0,     0,  62,  //  33  0100 0.
	 61*3,  59*3,   0,  //  34  0010 1
	 52*3,  60*3,   0,  //  35  0000 0
	    0,     0,   1,  //  36  0101 1.
	 55*3,  54*3,   0,  //  37  0011 1
	    0,     0,  61,  //  38  0101 0.
	    0,     0,  56,  //  39  0110 0.
	 57*3,  58*3,   0,  //  40  0000 1
	    0,     0,   2,  //  41  0100 1.
	    0,     0,  40,  //  42  1000 0.
	 51*3,  62*3,   0,  //  43  0010 0
	    0,     0,  48,  //  44  1001 0.
	 64*3,  63*3,   0,  //  45  0001 0
	 49*3,  53*3,   0,  //  46  0001 1
	    0,     0,  20,  //  47  1000 1.
	    0,     0,  12,  //  48  1001 1.
	 80*3,  83*3,   0,  //  49  0001 10
	    0,     0,  63,  //  50  0011 00.
	 77*3,  75*3,   0,  //  51  0010 00
	 65*3,  73*3,   0,  //  52  0000 00
	 84*3,  66*3,   0,  //  53  0001 11
	    0,     0,  24,  //  54  0011 11.
	    0,     0,  36,  //  55  0011 10.
	    0,     0,   3,  //  56  0011 01.
	 69*3,  87*3,   0,  //  57  0000 10
	 81*3,  79*3,   0,  //  58  0000 11
	 68*3,  71*3,   0,  //  59  0010 11
	 70*3,  78*3,   0,  //  60  0000 01
	 67*3,  76*3,   0,  //  61  0010 10
	 72*3,  74*3,   0,  //  62  0010 01
	 86*3,  85*3,   0,  //  63  0001 01
	 88*3,  82*3,   0,  //  64  0001 00
	   -1,  94*3,   0,  //  65  0000 000
	 95*3,  97*3,   0,  //  66  0001 111
	    0,     0,  33,  //  67  0010 100.
	    0,     0,   9,  //  68  0010 110.
	106*3, 110*3,   0,  //  69  0000 100
	102*3, 116*3,   0,  //  70  0000 010
	    0,     0,   5,  //  71  0010 111.
	    0,     0,  10,  //  72  0010 010.
	 93*3,  89*3,   0,  //  73  0000 001
	    0,     0,   6,  //  74  0010 011.
	    0,     0,  18,  //  75  0010 001.
	    0,     0,  17,  //  76  0010 101.
	    0,     0,  34,  //  77  0010 000.
	113*3, 119*3,   0,  //  78  0000 011
	103*3, 104*3,   0,  //  79  0000 111
	 90*3,  92*3,   0,  //  80  0001 100
	109*3, 107*3,   0,  //  81  0000 110
	117*3, 118*3,   0,  //  82  0001 001
	101*3,  99*3,   0,  //  83  0001 101
	 98*3,  96*3,   0,  //  84  0001 110
	100*3,  91*3,   0,  //  85  0001 011
	114*3, 115*3,   0,  //  86  0001 010
	105*3, 108*3,   0,  //  87  0000 101
	112*3, 111*3,   0,  //  88  0001 000
	121*3, 125*3,   0,  //  89  0000 0011
	    0,     0,  41,  //  90  0001 1000.
	    0,     0,  14,  //  91  0001 0111.
	    0,     0,  21,  //  92  0001 1001.
	124*3, 122*3,   0,  //  93  0000 0010
	120*3, 123*3,   0,  //  94  0000 0001
	    0,     0,  11,  //  95  0001 1110.
	    0,     0,  19,  //  96  0001 1101.
	    0,     0,   7,  //  97  0001 1111.
	    0,     0,  35,  //  98  0001 1100.
	    0,     0,  13,  //  99  0001 1011.
	    0,     0,  50,  // 100  0001 0110.
	    0,     0,  49,  // 101  0001 1010.
	    0,     0,  58,  // 102  0000 0100.
	    0,     0,  37,  // 103  0000 1110.
	    0,     0,  25,  // 104  0000 1111.
	    0,     0,  45,  // 105  0000 1010.
	    0,     0,  57,  // 106  0000 1000.
	    0,     0,  26,  // 107  0000 1101.
	    0,     0,  29,  // 108  0000 1011.
	    0,     0,  38,  // 109  0000 1100.
	    0,     0,  53,  // 110  0000 1001.
	    0,     0,  23,  // 111  0001 0001.
	    0,     0,  43,  // 112  0001 0000.
	    0,     0,  46,  // 113  0000 0110.
	    0,     0,  42,  // 114  0001 0100.
	    0,     0,  22,  // 115  0001 0101.
	    0,     0,  54,  // 116  0000 0101.
	    0,     0,  51,  // 117  0001 0010.
	    0,     0,  15,  // 118  0001 0011.
	    0,     0,  30,  // 119  0000 0111.
	    0,     0,  39,  // 120  0000 0001 0.
	    0,     0,  47,  // 121  0000 0011 0.
	    0,     0,  55,  // 122  0000 0010 1.
	    0,     0,  27,  // 123  0000 0001 1.
	    0,     0,  59,  // 124  0000 0010 0.
	    0,     0,  31   // 125  0000 0011 1.
};

static const int MOTION[] = {
	  1*3,   2*3,   0,  //   0
	  4*3,   3*3,   0,  //   1  0
	    0,     0,   0,  //   2  1.
	  6*3,   5*3,   0,  //   3  01
	  8*3,   7*3,   0,  //   4  00
	    0,     0,  -1,  //   5  011.
	    0,     0,   1,  //   6  010.
	  9*3,  10*3,   0,  //   7  001
	 12*3,  11*3,   0,  //   8  000
	    0,     0,   2,  //   9  0010.
	    0,     0,  -2,  //  10  0011.
	 14*3,  15*3,   0,  //  11  0001
	 16*3,  13*3,   0,  //  12  0000
	 20*3,  18*3,   0,  //  13  0000 1
	    0,     0,   3,  //  14  0001 0.
	    0,     0,  -3,  //  15  0001 1.
	 17*3,  19*3,   0,  //  16  0000 0
	   -1,  23*3,   0,  //  17  0000 00
	 27*3,  25*3,   0,  //  18  0000 11
	 26*3,  21*3,   0,  //  19  0000 01
	 24*3,  22*3,   0,  //  20  0000 10
	 32*3,  28*3,   0,  //  21  0000 011
	 29*3,  31*3,   0,  //  22  0000 101
	   -1,  33*3,   0,  //  23  0000 001
	 36*3,  35*3,   0,  //  24  0000 100
	    0,     0,  -4,  //  25  0000 111.
	 30*3,  34*3,   0,  //  26  0000 010
	    0,     0,   4,  //  27  0000 110.
	    0,     0,  -7,  //  28  0000 0111.
	    0,     0,   5,  //  29  0000 1010.
	 37*3,  41*3,   0,  //  30  0000 0100
	    0,     0,  -5,  //  31  0000 1011.
	    0,     0,   7,  //  32  0000 0110.
	 38*3,  40*3,   0,  //  33  0000 0011
	 42*3,  39*3,   0,  //  34  0000 0101
	    0,     0,  -6,  //  35  0000 1001.
	    0,     0,   6,  //  36  0000 1000.
	 51*3,  54*3,   0,  //  37  0000 0100 0
	 50*3,  49*3,   0,  //  38  0000 0011 0
	 45*3,  46*3,   0,  //  39  0000 0101 1
	 52*3,  47*3,   0,  //  40  0000 0011 1
	 43*3,  53*3,   0,  //  41  0000 0100 1
	 44*3,  48*3,   0,  //  42  0000 0101 0
	    0,     0,  10,  //  43  0000 0100 10.
	    0,     0,   9,  //  44  0000 0101 00.
	    0,     0,   8,  //  45  0000 0101 10.
	    0,     0,  -8,  //  46  0000 0101 11.
	 57*3,  66*3,   0,  //  47  0000 0011 11
	    0,     0,  -9,  //  48  0000 0101 01.
	 60*3,  64*3,   0,  //  49  0000 0011 01
	 56*3,  61*3,   0,  //  50  0000 0011 00
	 55*3,  62*3,   0,  //  51  0000 0100 00
	 58*3,  63*3,   0,  //  52  0000 0011 10
	    0,     0, -10,  //  53  0000 0100 11.
	 59*3,  65*3,   0,  //  54  0000 0100 01
	    0,     0,  12,  //  55  0000 0100 000.
	    0,     0,  16,  //  56  0000 0011 000.
	    0,     0,  13,  //  57  0000 0011 110.
	    0,     0,  14,  //  58  0000 0011 100.
	    0,     0,  11,  //  59  0000 0100 010.
	    0,     0,  15,  //  60  0000 0011 010.
	    0,     0, -16,  //  61  0000 0011 001.
	    0,     0, -12,  //  62  0000 0100 001.
	    0,     0, -14,  //  63  0000 0011 101.
	    0,     0, -15,  //  64  0000 0011 011.
	    0,     0, -11,  //  65  0000 0100 011.
	    0,     0, -13   //  66  0000 0011 111.
};

static const int DCT_DC_SIZE_LUMINANCE[] = {
	  2*3,   1*3, 0,  //   0
	  6*3,   5*3, 0,  //   1  1
	  3*3,   4*3, 0,  //   2  0
	    0,     0, 1,  //   3  00.
	    0,     0, 2,  //   4  01.
	  9*3,   8*3, 0,  //   5  11
	  7*3,  10*3, 0,  //   6  10
	    0,     0, 0,  //   7  100.
	 12*3,  11*3, 0,  //   8  111
	    0,     0, 4,  //   9  110.
	    0,     0, 3,  //  10  101.
	 13*3,  14*3, 0,  //  11  1111
	    0,     0, 5,  //  12  1110.
	    0,     0, 6,  //  13  1111 0.
	 16*3,  15*3, 0,  //  14  1111 1
	 17*3,    -1, 0,  //  15  1111 11
	    0,     0, 7,  //  16  1111 10.
	    0,     0, 8   //  17  1111 110.
};

static const int DCT_DC_SIZE_CHROMINANCE[] = {
	  2*3,   1*3, 0,  //   0
	  4*3,   3*3, 0,  //   1  1
	  6*3,   5*3, 0,  //   2  0
	  8*3,   7*3, 0,  //   3  11
	    0,     0, 2,  //   4  10.
	    0,     0, 1,  //   5  01.
	    0,     0, 0,  //   6  00.
	 10*3,   9*3, 0,  //   7  111
	    0,     0, 3,  //   8  110.
	 12*3,  11*3, 0,  //   9  1111
	    0,     0, 4,  //  10  1110.
	 14*3,  13*3, 0,  //  11  1111 1
	    0,     0, 5,  //  12  1111 0.
	 16*3,  15*3, 0,  //  13  1111 11
	    0,     0, 6,  //  14  1111 10.
	 17*3,    -1, 0,  //  15  1111 111
	    0,     0, 7,  //  16  1111 110.
	    0,     0, 8   //  17  1111 1110.
};

//  dct_coeff bitmap:
//    0xff00  run
//    0x00ff  level

//  Decoded values are unsigned. Sign bit follows in the stream.

//  Interpretation of the value 0x0001
//    for dc_coeff_first:  run=0, level=1
//    for dc_coeff_next:   If the next bit is 1: run=0, level=1
//                         If the next bit is 0: end_of_block

//  escape decodes as 0xffff.

static const int DCT_COEFF[] = {
	  1*3,   2*3,      0,  //   0
	  4*3,   3*3,      0,  //   1  0
	    0,     0, 0x0001,  //   2  1.
	  7*3,   8*3,      0,  //   3  01
	  6*3,   5*3,      0,  //   4  00
	 13*3,   9*3,      0,  //   5  001
	 11*3,  10*3,      0,  //   6  000
	 14*3,  12*3,      0,  //   7  010
	    0,     0, 0x0101,  //   8  011.
	 20*3,  22*3,      0,  //   9  0011
	 18*3,  21*3,      0,  //  10  0001
	 16*3,  19*3,      0,  //  11  0000
	    0,     0, 0x0201,  //  12  0101.
	 17*3,  15*3,      0,  //  13  0010
	    0,     0, 0x0002,  //  14  0100.
	    0,     0, 0x0003,  //  15  0010 1.
	 27*3,  25*3,      0,  //  16  0000 0
	 29*3,  31*3,      0,  //  17  0010 0
	 24*3,  26*3,      0,  //  18  0001 0
	 32*3,  30*3,      0,  //  19  0000 1
	    0,     0, 0x0401,  //  20  0011 0.
	 23*3,  28*3,      0,  //  21  0001 1
	    0,     0, 0x0301,  //  22  0011 1.
	    0,     0, 0x0102,  //  23  0001 10.
	    0,     0, 0x0701,  //  24  0001 00.
	    0,     0, 0xffff,  //  25  0000 01. -- escape
	    0,     0, 0x0601,  //  26  0001 01.
	 37*3,  36*3,      0,  //  27  0000 00
	    0,     0, 0x0501,  //  28  0001 11.
	 35*3,  34*3,      0,  //  29  0010 00
	 39*3,  38*3,      0,  //  30  0000 11
	 33*3,  42*3,      0,  //  31  0010 01
	 40*3,  41*3,      0,  //  32  0000 10
	 52*3,  50*3,      0,  //  33  0010 010
	 54*3,  53*3,      0,  //  34  0010 001
	 48*3,  49*3,      0,  //  35  0010 000
	 43*3,  45*3,      0,  //  36  0000 001
	 46*3,  44*3,      0,  //  37  0000 000
	    0,     0, 0x0801,  //  38  0000 111.
	    0,     0, 0x0004,  //  39  0000 110.
	    0,     0, 0x0202,  //  40  0000 100.
	    0,     0, 0x0901,  //  41  0000 101.
	 51*3,  47*3,      0,  //  42  0010 011
	 55*3,  57*3,      0,  //  43  0000 0010
	 60*3,  56*3,      0,  //  44  0000 0001
	 59*3,  58*3,      0,  //  45  0000 0011
	 61*3,  62*3,      0,  //  46  0000 0000
	    0,     0, 0x0a01,  //  47  0010 0111.
	    0,     0, 0x0d01,  //  48  0010 0000.
	    0,     0, 0x0006,  //  49  0010 0001.
	    0,     0, 0x0103,  //  50  0010 0101.
	    0,     0, 0x0005,  //  51  0010 0110.
	    0,     0, 0x0302,  //  52  0010 0100.
	    0,     0, 0x0b01,  //  53  0010 0011.
	    0,     0, 0x0c01,  //  54  0010 0010.
	 76*3,  75*3,      0,  //  55  0000 0010 0
	 67*3,  70*3,      0,  //  56  0000 0001 1
	 73*3,  71*3,      0,  //  57  0000 0010 1
	 78*3,  74*3,      0,  //  58  0000 0011 1
	 72*3,  77*3,      0,  //  59  0000 0011 0
	 69*3,  64*3,      0,  //  60  0000 0001 0
	 68*3,  63*3,      0,  //  61  0000 0000 0
	 66*3,  65*3,      0,  //  62  0000 0000 1
	 81*3,  87*3,      0,  //  63  0000 0000 01
	 91*3,  80*3,      0,  //  64  0000 0001 01
	 82*3,  79*3,      0,  //  65  0000 0000 11
	 83*3,  86*3,      0,  //  66  0000 0000 10
	 93*3,  92*3,      0,  //  67  0000 0001 10
	 84*3,  85*3,      0,  //  68  0000 0000 00
	 90*3,  94*3,      0,  //  69  0000 0001 00
	 88*3,  89*3,      0,  //  70  0000 0001 11
	    0,     0, 0x0203,  //  71  0000 0010 11.
	    0,     0, 0x0104,  //  72  0000 0011 00.
	    0,     0, 0x0007,  //  73  0000 0010 10.
	    0,     0, 0x0402,  //  74  0000 0011 11.
	    0,     0, 0x0502,  //  75  0000 0010 01.
	    0,     0, 0x1001,  //  76  0000 0010 00.
	    0,     0, 0x0f01,  //  77  0000 0011 01.
	    0,     0, 0x0e01,  //  78  0000 0011 10.
	105*3, 107*3,      0,  //  79  0000 0000 111
	111*3, 114*3,      0,  //  80  0000 0001 011
	104*3,  97*3,      0,  //  81  0000 0000 010
	125*3, 119*3,      0,  //  82  0000 0000 110
	 96*3,  98*3,      0,  //  83  0000 0000 100
	   -1, 123*3,      0,  //  84  0000 0000 000
	 95*3, 101*3,      0,  //  85  0000 0000 001
	106*3, 121*3,      0,  //  86  0000 0000 101
	 99*3, 102*3,      0,  //  87  0000 0000 011
	113*3, 103*3,      0,  //  88  0000 0001 110
	112*3, 116*3,      0,  //  89  0000 0001 111
	110*3, 100*3,      0,  //  90  0000 0001 000
	124*3, 115*3,      0,  //  91  0000 0001 010
	117*3, 122*3,      0,  //  92  0000 0001 101
	109*3, 118*3,      0,  //  93  0000 0001 100
	120*3, 108*3,      0,  //  94  0000 0001 001
	127*3, 136*3,      0,  //  95  0000 0000 0010
	139*3, 140*3,      0,  //  96  0000 0000 1000
	130*3, 126*3,      0,  //  97  0000 0000 0101
	145*3, 146*3,      0,  //  98  0000 0000 1001
	128*3, 129*3,      0,  //  99  0000 0000 0110
	    0,     0, 0x0802,  // 100  0000 0001 0001.
	132*3, 134*3,      0,  // 101  0000 0000 0011
	155*3, 154*3,      0,  // 102  0000 0000 0111
	    0,     0, 0x0008,  // 103  0000 0001 1101.
	137*3, 133*3,      0,  // 104  0000 0000 0100
	143*3, 144*3,      0,  // 105  0000 0000 1110
	151*3, 138*3,      0,  // 106  0000 0000 1010
	142*3, 141*3,      0,  // 107  0000 0000 1111
	    0,     0, 0x000a,  // 108  0000 0001 0011.
	    0,     0, 0x0009,  // 109  0000 0001 1000.
	    0,     0, 0x000b,  // 110  0000 0001 0000.
	    0,     0, 0x1501,  // 111  0000 0001 0110.
	    0,     0, 0x0602,  // 112  0000 0001 1110.
	    0,     0, 0x0303,  // 113  0000 0001 1100.
	    0,     0, 0x1401,  // 114  0000 0001 0111.
	    0,     0, 0x0702,  // 115  0000 0001 0101.
	    0,     0, 0x1101,  // 116  0000 0001 1111.
	    0,     0, 0x1201,  // 117  0000 0001 1010.
	    0,     0, 0x1301,  // 118  0000 0001 1001.
	148*3, 152*3,      0,  // 119  0000 0000 1101
	    0,     0, 0x0403,  // 120  0000 0001 0010.
	153*3, 150*3,      0,  // 121  0000 0000 1011
	    0,     0, 0x0105,  // 122  0000 0001 1011.
	131*3, 135*3,      0,  // 123  0000 0000 0001
	    0,     0, 0x0204,  // 124  0000 0001 0100.
	149*3, 147*3,      0,  // 125  0000 0000 1100
	172*3, 173*3,      0,  // 126  0000 0000 0101 1
	162*3, 158*3,      0,  // 127  0000 0000 0010 0
	170*3, 161*3,      0,  // 128  0000 0000 0110 0
	168*3, 166*3,      0,  // 129  0000 0000 0110 1
	157*3, 179*3,      0,  // 130  0000 0000 0101 0
	169*3, 167*3,      0,  // 131  0000 0000 0001 0
	174*3, 171*3,      0,  // 132  0000 0000 0011 0
	178*3, 177*3,      0,  // 133  0000 0000 0100 1
	156*3, 159*3,      0,  // 134  0000 0000 0011 1
	164*3, 165*3,      0,  // 135  0000 0000 0001 1
	183*3, 182*3,      0,  // 136  0000 0000 0010 1
	175*3, 176*3,      0,  // 137  0000 0000 0100 0
	    0,     0, 0x0107,  // 138  0000 0000 1010 1.
	    0,     0, 0x0a02,  // 139  0000 0000 1000 0.
	    0,     0, 0x0902,  // 140  0000 0000 1000 1.
	    0,     0, 0x1601,  // 141  0000 0000 1111 1.
	    0,     0, 0x1701,  // 142  0000 0000 1111 0.
	    0,     0, 0x1901,  // 143  0000 0000 1110 0.
	    0,     0, 0x1801,  // 144  0000 0000 1110 1.
	    0,     0, 0x0503,  // 145  0000 0000 1001 0.
	    0,     0, 0x0304,  // 146  0000 0000 1001 1.
	    0,     0, 0x000d,  // 147  0000 0000 1100 1.
	    0,     0, 0x000c,  // 148  0000 0000 1101 0.
	    0,     0, 0x000e,  // 149  0000 0000 1100 0.
	    0,     0, 0x000f,  // 150  0000 0000 1011 1.
	    0,     0, 0x0205,  // 151  0000 0000 1010 0.
	    0,     0, 0x1a01,  // 152  0000 0000 1101 1.
	    0,     0, 0x0106,  // 153  0000 0000 1011 0.
	180*3, 181*3,      0,  // 154  0000 0000 0111 1
	160*3, 163*3,      0,  // 155  0000 0000 0111 0
	196*3, 199*3,      0,  // 156  0000 0000 0011 10
	    0,     0, 0x001b,  // 157  0000 0000 0101 00.
	203*3, 185*3,      0,  // 158  0000 0000 0010 01
	202*3, 201*3,      0,  // 159  0000 0000 0011 11
	    0,     0, 0x0013,  // 160  0000 0000 0111 00.
	    0,     0, 0x0016,  // 161  0000 0000 0110 01.
	197*3, 207*3,      0,  // 162  0000 0000 0010 00
	    0,     0, 0x0012,  // 163  0000 0000 0111 01.
	191*3, 192*3,      0,  // 164  0000 0000 0001 10
	188*3, 190*3,      0,  // 165  0000 0000 0001 11
	    0,     0, 0x0014,  // 166  0000 0000 0110 11.
	184*3, 194*3,      0,  // 167  0000 0000 0001 01
	    0,     0, 0x0015,  // 168  0000 0000 0110 10.
	186*3, 193*3,      0,  // 169  0000 0000 0001 00
	    0,     0, 0x0017,  // 170  0000 0000 0110 00.
	204*3, 198*3,      0,  // 171  0000 0000 0011 01
	    0,     0, 0x0019,  // 172  0000 0000 0101 10.
	    0,     0, 0x0018,  // 173  0000 0000 0101 11.
	200*3, 205*3,      0,  // 174  0000 0000 0011 00
	    0,     0, 0x001f,  // 175  0000 0000 0100 00.
	    0,     0, 0x001e,  // 176  0000 0000 0100 01.
	    0,     0, 0x001c,  // 177  0000 0000 0100 11.
	    0,     0, 0x001d,  // 178  0000 0000 0100 10.
	    0,     0, 0x001a,  // 179  0000 0000 0101 01.
	    0,     0, 0x0011,  // 180  0000 0000 0111 10.
	    0,     0, 0x0010,  // 181  0000 0000 0111 11.
	189*3, 206*3,      0,  // 182  0000 0000 0010 11
	187*3, 195*3,      0,  // 183  0000 0000 0010 10
	218*3, 211*3,      0,  // 184  0000 0000 0001 010
	    0,     0, 0x0025,  // 185  0000 0000 0010 011.
	215*3, 216*3,      0,  // 186  0000 0000 0001 000
	    0,     0, 0x0024,  // 187  0000 0000 0010 100.
	210*3, 212*3,      0,  // 188  0000 0000 0001 110
	    0,     0, 0x0022,  // 189  0000 0000 0010 110.
	213*3, 209*3,      0,  // 190  0000 0000 0001 111
	221*3, 222*3,      0,  // 191  0000 0000 0001 100
	219*3, 208*3,      0,  // 192  0000 0000 0001 101
	217*3, 214*3,      0,  // 193  0000 0000 0001 001
	223*3, 220*3,      0,  // 194  0000 0000 0001 011
	    0,     0, 0x0023,  // 195  0000 0000 0010 101.
	    0,     0, 0x010b,  // 196  0000 0000 0011 100.
	    0,     0, 0x0028,  // 197  0000 0000 0010 000.
	    0,     0, 0x010c,  // 198  0000 0000 0011 011.
	    0,     0, 0x010a,  // 199  0000 0000 0011 101.
	    0,     0, 0x0020,  // 200  0000 0000 0011 000.
	    0,     0, 0x0108,  // 201  0000 0000 0011 111.
	    0,     0, 0x0109,  // 202  0000 0000 0011 110.
	    0,     0, 0x0026,  // 203  0000 0000 0010 010.
	    0,     0, 0x010d,  // 204  0000 0000 0011 010.
	    0,     0, 0x010e,  // 205  0000 0000 0011 001.
	    0,     0, 0x0021,  // 206  0000 0000 0010 111.
	    0,     0, 0x0027,  // 207  0000 0000 0010 001.
	    0,     0, 0x1f01,  // 208  0000 0000 0001 1011.
	    0,     0, 0x1b01,  // 209  0000 0000 0001 1111.
	    0,     0, 0x1e01,  // 210  0000 0000 0001 1100.
	    0,     0, 0x1002,  // 211  0000 0000 0001 0101.
	    0,     0, 0x1d01,  // 212  0000 0000 0001 1101.
	    0,     0, 0x1c01,  // 213  0000 0000 0001 1110.
	    0,     0, 0x010f,  // 214  0000 0000 0001 0011.
	    0,     0, 0x0112,  // 215  0000 0000 0001 0000.
	    0,     0, 0x0111,  // 216  0000 0000 0001 0001.
	    0,     0, 0x0110,  // 217  0000 0000 0001 0010.
	    0,     0, 0x0603,  // 218  0000 0000 0001 0100.
	    0,     0, 0x0b02,  // 219  0000 0000 0001 1010.
	    0,     0, 0x0e02,  // 220  0000 0000 0001 0111.
	    0,     0, 0x0d02,  // 221  0000 0000 0001 1000.
	    0,     0, 0x0c02,  // 222  0000 0000 0001 1001.
	    0,     0, 0x0f02   // 223  0000 0000 0001 0110.
};

static const int PICTURE_TYPE_INTRA = 1;
static const int PICTURE_TYPE_PREDICTIVE = 2;
static const int PICTURE_TYPE_B = 3;

static const int START_SEQUENCE = 0xB3;
static const int START_SLICE_FIRST = 0x01;
static const int START_SLICE_LAST = 0xAF;
static const int START_PICTURE = 0x00;
static const int START_EXTENSION = 0xB5;
static const int START_USER_DATA = 0xB2;


typedef struct mpeg1_planes_t {
	uint8_t *y;
	uint8_t *cr;
	uint8_t *cb;
} mpeg1_planes_t;

typedef struct mpeg1_decoder_t {
	float frame_rate;
	int width;
	int height;
	int mb_width;
	int mb_height;
	int mb_size;

	int coded_width;
	int coded_height;
	int coded_size;

	int half_width;
	int half_height;

	int picture_type;
	int full_pel_forward;
	int forward_f_code;
	int forward_r_size;
	int forward_f;

	int has_sequence_header;

	int quantizer_scale;
	int slice_begin;
	int macroblock_address;

	int mb_row;
	int mb_col;

	int macroblock_type;
	int macroblock_intra;
	int macroblock_motion_fw;

	int motion_fw_h;
	int motion_fw_v;
	int motion_fw_h_prev;
	int motion_fw_v_prev;

	int dc_predictor_y;
	int dc_predictor_cr;
	int dc_predictor_cb;

	bit_buffer_t *bits;

	mpeg1_planes_t planes_current;
	mpeg1_planes_t planes_forward;

	int block_data[64];
	uint8_t intra_quant_matrix[64];
	uint8_t non_intra_quant_matrix[64];
} mpeg1_decoder_t;


void decode_sequence_header(mpeg1_decoder_t *self);
void decode_picture(mpeg1_decoder_t *self);
void init_buffers(mpeg1_decoder_t *self);
void decode_slice(mpeg1_decoder_t *self, int slice);
void decode_macroblock(mpeg1_decoder_t *self);
void decode_motion_vectors(mpeg1_decoder_t *self);
void copy_macroblock(mpeg1_decoder_t *self, int motion_h, int motion_v, uint8_t *s_y, uint8_t *s_cr, uint8_t *s_cb);
void decode_block(mpeg1_decoder_t *self, int block);

void copy_block_to_destination(int *block, uint8_t *dest, int index, int scan);
void add_block_to_destination(int *block, uint8_t *dest, int index, int scan);
void copy_value_to_destination(int value, uint8_t *dest, int index, int scan);
void add_value_to_destination(int value, uint8_t *dest, int index, int scan);
void idct(int *block);
void zero_block_data(mpeg1_decoder_t *self);
int read_huffman(bit_buffer_t *bits, const int *code_table);




// -----------------------------------------------------------------------------
// Public interface

mpeg1_decoder_t *mpeg1_decoder_create(unsigned int buffer_size, bit_buffer_mode_t buffer_mode) {
	mpeg1_decoder_t *self = malloc(sizeof(mpeg1_decoder_t));
	memset(self, 0, sizeof(mpeg1_decoder_t));
	self->bits = bit_buffer_create(buffer_size, buffer_mode);
	return self;
}

void mpeg1_decoder_destroy(mpeg1_decoder_t *self) {
	bit_buffer_destroy(self->bits);

	if (self->has_sequence_header) {
		free(self->planes_current.y);
		free(self->planes_current.cr);
		free(self->planes_current.cb);

		free(self->planes_forward.y);
		free(self->planes_forward.cr);
		free(self->planes_forward.cb);
	}

	free(self);
}

void *mpeg1_decoder_get_write_ptr(mpeg1_decoder_t *self, unsigned int byte_size) {
	return bit_buffer_get_write_ptr(self->bits, byte_size);
}

int mpeg1_decoder_get_index(mpeg1_decoder_t *self) {
	return bit_buffer_get_index(self->bits);
}

void mpeg1_decoder_set_index(mpeg1_decoder_t *self, unsigned int index) {
	bit_buffer_set_index(self->bits, index);
}

void mpeg1_decoder_did_write(mpeg1_decoder_t *self, unsigned int byte_size) {
	bit_buffer_did_write(self->bits, byte_size);
	if (!self->has_sequence_header) {
		if (bit_buffer_find_start_code(self->bits, START_SEQUENCE) != -1) {
			decode_sequence_header(self);
		}
	}
}

int mpeg1_decoder_has_sequence_header(mpeg1_decoder_t *self) {
	return self->has_sequence_header;
}

float mpeg1_decoder_get_frame_rate(mpeg1_decoder_t *self) {
	return self->frame_rate;
}

int mpeg1_decoder_get_coded_size(mpeg1_decoder_t *self) {
	return self->coded_size;
}

int mpeg1_decoder_get_width(mpeg1_decoder_t *self) {
	return self->width;
}

int mpeg1_decoder_get_height(mpeg1_decoder_t *self) {
	return self->height;
}

void *mpeg1_decoder_get_y_ptr(mpeg1_decoder_t *self) {
	return self->planes_forward.y;
}

void *mpeg1_decoder_get_cr_ptr(mpeg1_decoder_t *self) {
	return self->planes_forward.cr;
}

void *mpeg1_decoder_get_cb_ptr(mpeg1_decoder_t *self) {
	return self->planes_forward.cb;
}

bool mpeg1_decoder_decode(mpeg1_decoder_t *self) {
	if (!self->has_sequence_header) {
		return false;
	}

	if (bit_buffer_find_start_code(self->bits, START_PICTURE) == -1) {
		return false;
	}

	decode_picture(self);
	return true;
}




// -----------------------------------------------------------------------------
// Private methods

void decode_sequence_header(mpeg1_decoder_t *self) {
	int previous_width = self->width; 
	int previous_height = self->height;

	self->width = bit_buffer_read(self->bits, 12);
	self->height = bit_buffer_read(self->bits, 12);

	// skip pixel aspect ratio
	bit_buffer_skip(self->bits, 4);

	self->frame_rate = PICTURE_RATE[bit_buffer_read(self->bits, 4)];

	// skip bitRate, marker, bufferSize and constrained bit
	bit_buffer_skip(self->bits, 18 + 1 + 10 + 1);

	if (bit_buffer_read(self->bits, 1)) { // load custom intra quant matrix?
		for (int i = 0; i < 64; i++) {
			self->intra_quant_matrix[ZIG_ZAG[i]] = bit_buffer_read(self->bits, 8);
		}
	}
	else {
		memcpy(self->intra_quant_matrix, DEFAULT_INTRA_QUANT_MATRIX, 64);
	}

	if (bit_buffer_read(self->bits, 1)) { // load custom non intra quant matrix?
		for (int i = 0; i < 64; i++) {
			int idx = ZIG_ZAG[i];
			self->non_intra_quant_matrix[idx] = bit_buffer_read(self->bits, 8);
		}
	}
	else {
		memcpy(self->non_intra_quant_matrix, DEFAULT_NON_INTRA_QUANT_MATRIX, 64);
	}

	if (self->has_sequence_header) {
		if (self->width == previous_width && self->height == previous_height) {
			// We already had a sequence header with the same width/height;
			// nothing else to do here.
			return;
		}

		// We had a sequence header but with different dimensions;
		// delete the previous planes and allocate new.
		free(self->planes_current.y);
		free(self->planes_current.cr);
		free(self->planes_current.cb);

		free(self->planes_forward.y);
		free(self->planes_forward.cr);
		free(self->planes_forward.cb);
	}

	self->mb_width = (self->width + 15) >> 4;
	self->mb_height = (self->height + 15) >> 4;
	self->mb_size = self->mb_width * self->mb_height;

	self->coded_width = self->mb_width << 4;
	self->coded_height = self->mb_height << 4;
	self->coded_size = self->coded_width * self->coded_height;

	self->half_width = self->mb_width << 3;
	self->half_height = self->mb_height << 3;

	self->planes_current.y = (uint8_t*)malloc(self->coded_size);
	self->planes_current.cr = (uint8_t*)malloc(self->coded_size >> 2);
	self->planes_current.cb = (uint8_t*)malloc(self->coded_size >> 2);

	self->planes_forward.y = (uint8_t*)malloc(self->coded_size);
	self->planes_forward.cr = (uint8_t*)malloc(self->coded_size >> 2);
	self->planes_forward.cb = (uint8_t*)malloc(self->coded_size >> 2);

	self->has_sequence_header = true;
}


void decode_picture(mpeg1_decoder_t *self) {
	bit_buffer_skip(self->bits, 10); // skip temporalReference
	self->picture_type = bit_buffer_read(self->bits, 3);
	bit_buffer_skip(self->bits, 16); // skip vbv_delay

	// Skip B and D frames or unknown coding type
	if (self->picture_type <= 0 || self->picture_type >= PICTURE_TYPE_B) {
		return;
	}

	// full_pel_forward, forward_f_code
	if (self->picture_type == PICTURE_TYPE_PREDICTIVE) {
		self->full_pel_forward = bit_buffer_read(self->bits, 1);
		self->forward_f_code = bit_buffer_read(self->bits, 3);
		if (self->forward_f_code == 0) {
			// Ignore picture with zero self->forward_f_code
			return;
		}
		self->forward_r_size = self->forward_f_code - 1;
		self->forward_f = 1 << self->forward_r_size;
	}

	int code = 0;
	do {
		code = bit_buffer_find_next_start_code(self->bits);
	} while (code == START_EXTENSION || code == START_USER_DATA);


	while (code >= START_SLICE_FIRST && code <= START_SLICE_LAST) {
		decode_slice(self, code & 0x000000FF);
		code = bit_buffer_find_next_start_code(self->bits);
	}

	if (code != -1) {
		// We found the next start code; rewind 32self->bits and let the main loop
		// handle it.
		bit_buffer_rewind(self->bits, 32);
	}

	// If this is a reference picutre then rotate the prediction pointers
	if (
		self->picture_type == PICTURE_TYPE_INTRA ||
		self->picture_type == PICTURE_TYPE_PREDICTIVE
	) {
		mpeg1_planes_t temp = self->planes_forward;
		self->planes_forward = self->planes_current;
		self->planes_current = temp;
	}
}


// Slice Layer

void decode_slice(mpeg1_decoder_t *self, int slice) {
	self->slice_begin = true;
	self->macroblock_address = (slice - 1) * self->mb_width - 1;

	// Reset motion vectors and DC predictors
	self->motion_fw_h = self->motion_fw_h_prev = 0;
	self->motion_fw_v = self->motion_fw_v_prev = 0;
	self->dc_predictor_y  = 128;
	self->dc_predictor_cr = 128;
	self->dc_predictor_cb = 128;

	self->quantizer_scale = bit_buffer_read(self->bits, 5);

	// skip extra self->bits
	while (bit_buffer_read(self->bits, 1)) {
		bit_buffer_skip(self->bits, 8);
	}

	do {
		decode_macroblock(self);
	} while (!bit_buffer_next_bytes_are_start_code(self->bits));
};


// Macroblock Layer

void decode_macroblock(mpeg1_decoder_t *self) {
	// Decode self->macroblock_address_increment
	int increment = 0;
	int x = 0;
	int t = read_huffman(self->bits, MACROBLOCK_ADDRESS_INCREMENT);

	while (t == 34) {
		// macroblock_stuffing
		x = 1;
		t = read_huffman(self->bits, MACROBLOCK_ADDRESS_INCREMENT);
	}
	while (t == 35) {
		// macroblock_escape
		increment += 33;
		x =
		t = read_huffman(self->bits, MACROBLOCK_ADDRESS_INCREMENT);
	}
	increment += t;

	// Process any skipped macroblocks
	if (self->slice_begin) {
		// The first self->macroblock_address_increment of each slice is relative
		// to beginning of the preverious row, not the preverious macroblock
		self->slice_begin = false;
		self->macroblock_address += increment;
	}
	else {
		if (self->macroblock_address + increment >= self->mb_size) {
			// Illegal (too large) self->macroblock_address_increment
			// abort();
			return;
		}
		if (increment > 1) {
			// Skipped macroblocks reset DC predictors
			self->dc_predictor_y  = 128;
			self->dc_predictor_cr = 128;
			self->dc_predictor_cb = 128;

			// Skipped macroblocks in P-pictures reset motion vectors
			if (self->picture_type == PICTURE_TYPE_PREDICTIVE) {
				self->motion_fw_h = self->motion_fw_h_prev = 0;
				self->motion_fw_v = self->motion_fw_v_prev = 0;
			}
		}

		// Predict skipped macroblocks
		while (increment > 1) {
			self->macroblock_address++;
			self->mb_row = (self->macroblock_address / self->mb_width)|0;
			self->mb_col = self->macroblock_address % self->mb_width;
			copy_macroblock(
				self,
				self->motion_fw_h, self->motion_fw_v,
				self->planes_forward.y, self->planes_forward.cr, self->planes_forward.cb
			);
			increment--;
		}
		self->macroblock_address++;
	}

	self->mb_row = (self->macroblock_address / self->mb_width)|0;
	self->mb_col = self->macroblock_address % self->mb_width;

	// Process the current macroblock
	// static const s16 *mbTable = MACROBLOCK_TYPE[self->picture_type];
	// macroblock_type = read_huffman(self->bits, mbTable);
	if (self->picture_type == PICTURE_TYPE_INTRA) {
		self->macroblock_type = read_huffman(self->bits, MACROBLOCK_TYPE_INTRA);
	}
	else if (self->picture_type == PICTURE_TYPE_PREDICTIVE) {
		self->macroblock_type = read_huffman(self->bits, MACROBLOCK_TYPE_PREDICTIVE);
	}
	else {
		// Unhandled picture type
		// abort();
	}
	self->macroblock_intra = (self->macroblock_type & 0x01);
	self->macroblock_motion_fw = (self->macroblock_type & 0x08);

	// Quantizer scale
	if ((self->macroblock_type & 0x10) != 0) {
		self->quantizer_scale = bit_buffer_read(self->bits, 5);
	}

	if (self->macroblock_intra) {
		// Intra-coded macroblocks reset motion vectors
		self->motion_fw_h = self->motion_fw_h_prev = 0;
		self->motion_fw_v = self->motion_fw_v_prev = 0;
	}
	else {
		// Non-intra macroblocks reset DC predictors
		self->dc_predictor_y = 128;
		self->dc_predictor_cr = 128;
		self->dc_predictor_cb = 128;

		decode_motion_vectors(self);
		copy_macroblock(
			self,
			self->motion_fw_h, self->motion_fw_v,
			self->planes_forward.y, self->planes_forward.cr, self->planes_forward.cb
		);
	}

	// Decode blocks
	int cbp = ((self->macroblock_type & 0x02) != 0)
		? read_huffman(self->bits, CODE_BLOCK_PATTERN)
		: (self->macroblock_intra ? 0x3f : 0);

	for (int block = 0, mask = 0x20; block < 6; block++) {
		if ((cbp & mask) != 0) {
			decode_block(self, block);
		}
		mask >>= 1;
	}
};


void decode_motion_vectors(mpeg1_decoder_t *self) {
	int code, d, r = 0;

	// Forward
	if (self->macroblock_motion_fw) {
		// Horizontal forward
		code = read_huffman(self->bits, MOTION);
		if ((code != 0) && (self->forward_f != 1)) {
			r = bit_buffer_read(self->bits, self->forward_r_size);
			d = ((abs(code) - 1) << self->forward_r_size) + r + 1;
			if (code < 0) {
				d = -d;
			}
		}
		else {
			d = code;
		}

		self->motion_fw_h_prev += d;
		if (self->motion_fw_h_prev > (self->forward_f << 4) - 1) {
			self->motion_fw_h_prev -= self->forward_f << 5;
		}
		else if (self->motion_fw_h_prev < ((-self->forward_f) << 4)) {
			self->motion_fw_h_prev += self->forward_f << 5;
		}

		self->motion_fw_h = self->motion_fw_h_prev;
		if (self->full_pel_forward) {
			self->motion_fw_h <<= 1;
		}

		// Vertical forward
		code = read_huffman(self->bits, MOTION);
		if ((code != 0) && (self->forward_f != 1)) {
			r = bit_buffer_read(self->bits, self->forward_r_size);
			d = ((abs(code) - 1) << self->forward_r_size) + r + 1;
			if (code < 0) {
				d = -d;
			}
		}
		else {
			d = code;
		}

		self->motion_fw_v_prev += d;
		if (self->motion_fw_v_prev > (self->forward_f << 4) - 1) {
			self->motion_fw_v_prev -= self->forward_f << 5;
		}
		else if (self->motion_fw_v_prev < ((-self->forward_f) << 4)) {
			self->motion_fw_v_prev += self->forward_f << 5;
		}

		self->motion_fw_v = self->motion_fw_v_prev;
		if (self->full_pel_forward) {
			self->motion_fw_v <<= 1;
		}
	}
	else if (self->picture_type == PICTURE_TYPE_PREDICTIVE) {
		// No motion information in P-picture, reset vectors
		self->motion_fw_h = self->motion_fw_h_prev = 0;
		self->motion_fw_v = self->motion_fw_v_prev = 0;
	}
}


void copy_macroblock(mpeg1_decoder_t *self, int motion_h, int motion_v, uint8_t *s_y, uint8_t *s_cr, uint8_t *s_cb) {
	int
		width, scan,
		H, V,
		src, dest, last;
	bool odd_h, odd_v;

	// We use 32bit writes here
	int *d_y = (int*)self->planes_current.y;
	int *d_cb = (int*)self->planes_current.cb;
	int *d_cr = (int*)self->planes_current.cr;

	// Luminance
	width = self->coded_width;
	scan = width - 16;

	H = motion_h >> 1;
	V = motion_v >> 1;
	odd_h = (motion_h & 1) == 1;
	odd_v = (motion_v & 1) == 1;

	src = ((self->mb_row << 4) + V) * width + (self->mb_col << 4) + H;
	dest = (self->mb_row * width + self->mb_col) << 2;
	last = dest + (width << 2);

	int x, y1, y2, y;
	if (odd_h) {
		if (odd_v) {
			while (dest < last) {
				y1 = s_y[src] + s_y[src+width]; src++;
				for (x = 0; x < 4; x++) {
					y2 = s_y[src] + s_y[src+width]; src++;
					y = (((y1 + y2 + 2) >> 2) & 0xff);

					y1 = s_y[src] + s_y[src+width]; src++;
					y |= (((y1 + y2 + 2) << 6) & 0xff00);

					y2 = s_y[src] + s_y[src+width]; src++;
					y |= (((y1 + y2 + 2) << 14) & 0xff0000);

					y1 = s_y[src] + s_y[src+width]; src++;
					y |= (((y1 + y2 + 2) << 22) & 0xff000000);

					d_y[dest++] = y;
				}
				dest += scan >> 2; src += scan-1;
			}
		}
		else {
			while (dest < last) {
				y1 = s_y[src++];
				for (x = 0; x < 4; x++) {
					y2 = s_y[src++];
					y = (((y1 + y2 + 1) >> 1) & 0xff);

					y1 = s_y[src++];
					y |= (((y1 + y2 + 1) << 7) & 0xff00);

					y2 = s_y[src++];
					y |= (((y1 + y2 + 1) << 15) & 0xff0000);

					y1 = s_y[src++];
					y |= (((y1 + y2 + 1) << 23) & 0xff000000);

					d_y[dest++] = y;
				}
				dest += scan >> 2; src += scan-1;
			}
		}
	}
	else {
		if (odd_v) {
			while (dest < last) {
				for (x = 0; x < 4; x++) {
					y = (((s_y[src] + s_y[src+width] + 1) >> 1) & 0xff); src++;
					y |= (((s_y[src] + s_y[src+width] + 1) << 7) & 0xff00); src++;
					y |= (((s_y[src] + s_y[src+width] + 1) << 15) & 0xff0000); src++;
					y |= (((s_y[src] + s_y[src+width] + 1) << 23) & 0xff000000); src++;

					d_y[dest++] = y;
				}
				dest += scan >> 2; src += scan;
			}
		}
		else {
			while (dest < last) {
				for (x = 0; x < 4; x++) {
					y = s_y[src]; src++;
					y |= s_y[src] << 8; src++;
					y |= s_y[src] << 16; src++;
					y |= s_y[src] << 24; src++;

					d_y[dest++] = y;
				}
				dest += scan >> 2; src += scan;
			}
		}
	}

	// Chrominance

	width = self->half_width;
	scan = width - 8;

	H = (motion_h/2) >> 1;
	V = (motion_v/2) >> 1;
	odd_h = ((motion_h/2) & 1) == 1;
	odd_v = ((motion_v/2) & 1) == 1;

	src = ((self->mb_row << 3) + V) * width + (self->mb_col << 3) + H;
	dest = (self->mb_row * width + self->mb_col) << 1;
	last = dest + (width << 1);

	int cr1, cr2, cr,
		cb1, cb2, cb;
	if (odd_h) {
		if (odd_v) {
			while (dest < last) {
				cr1 = s_cr[src] + s_cr[src+width];
				cb1 = s_cb[src] + s_cb[src+width];
				src++;
				for (x = 0; x < 2; x++) {
					cr2 = s_cr[src] + s_cr[src+width];
					cb2 = s_cb[src] + s_cb[src+width]; src++;
					cr = (((cr1 + cr2 + 2) >> 2) & 0xff);
					cb = (((cb1 + cb2 + 2) >> 2) & 0xff);

					cr1 = s_cr[src] + s_cr[src+width];
					cb1 = s_cb[src] + s_cb[src+width]; src++;
					cr |= (((cr1 + cr2 + 2) << 6) & 0xff00);
					cb |= (((cb1 + cb2 + 2) << 6) & 0xff00);

					cr2 = s_cr[src] + s_cr[src+width];
					cb2 = s_cb[src] + s_cb[src+width]; src++;
					cr |= (((cr1 + cr2 + 2) << 14) & 0xff0000);
					cb |= (((cb1 + cb2 + 2) << 14) & 0xff0000);

					cr1 = s_cr[src] + s_cr[src+width];
					cb1 = s_cb[src] + s_cb[src+width]; src++;
					cr |= (((cr1 + cr2 + 2) << 22) & 0xff000000);
					cb |= (((cb1 + cb2 + 2) << 22) & 0xff000000);

					d_cr[dest] = cr;
					d_cb[dest] = cb;
					dest++;
				}
				dest += scan >> 2; src += scan-1;
			}
		}
		else {
			while (dest < last) {
				cr1 = s_cr[src];
				cb1 = s_cb[src];
				src++;
				for (x = 0; x < 2; x++) {
					cr2 = s_cr[src];
					cb2 = s_cb[src++];
					cr = (((cr1 + cr2 + 1) >> 1) & 0xff);
					cb = (((cb1 + cb2 + 1) >> 1) & 0xff);

					cr1 = s_cr[src];
					cb1 = s_cb[src++];
					cr |= (((cr1 + cr2 + 1) << 7) & 0xff00);
					cb |= (((cb1 + cb2 + 1) << 7) & 0xff00);

					cr2 = s_cr[src];
					cb2 = s_cb[src++];
					cr |= (((cr1 + cr2 + 1) << 15) & 0xff0000);
					cb |= (((cb1 + cb2 + 1) << 15) & 0xff0000);

					cr1 = s_cr[src];
					cb1 = s_cb[src++];
					cr |= (((cr1 + cr2 + 1) << 23) & 0xff000000);
					cb |= (((cb1 + cb2 + 1) << 23) & 0xff000000);

					d_cr[dest] = cr;
					d_cb[dest] = cb;
					dest++;
				}
				dest += scan >> 2; src += scan-1;
			}
		}
	}
	else {
		if (odd_v) {
			while (dest < last) {
				for (x = 0; x < 2; x++) {
					cr = (((s_cr[src] + s_cr[src+width] + 1) >> 1) & 0xff);
					cb = (((s_cb[src] + s_cb[src+width] + 1) >> 1) & 0xff); src++;

					cr |= (((s_cr[src] + s_cr[src+width] + 1) << 7) & 0xff00);
					cb |= (((s_cb[src] + s_cb[src+width] + 1) << 7) & 0xff00); src++;

					cr |= (((s_cr[src] + s_cr[src+width] + 1) << 15) & 0xff0000);
					cb |= (((s_cb[src] + s_cb[src+width] + 1) << 15) & 0xff0000); src++;

					cr |= (((s_cr[src] + s_cr[src+width] + 1) << 23) & 0xff000000);
					cb |= (((s_cb[src] + s_cb[src+width] + 1) << 23) & 0xff000000); src++;

					d_cr[dest] = cr;
					d_cb[dest] = cb;
					dest++;
				}
				dest += scan >> 2; src += scan;
			}
		}
		else {
			while (dest < last) {
				for (x = 0; x < 2; x++) {
					cr = s_cr[src];
					cb = s_cb[src]; src++;

					cr |= s_cr[src] << 8;
					cb |= s_cb[src] << 8; src++;

					cr |= s_cr[src] << 16;
					cb |= s_cb[src] << 16; src++;

					cr |= s_cr[src] << 24;
					cb |= s_cb[src] << 24; src++;

					d_cr[dest] = cr;
					d_cb[dest] = cb;
					dest++;
				}
				dest += scan >> 2; src += scan;
			}
		}
	}
}


// Block layer

void decode_block(mpeg1_decoder_t *self, int block) {

	int n = 0;
	uint8_t *quant_matrix;

	// Decode DC coefficient of intra-coded blocks
	if (self->macroblock_intra) {
		int predictor;
		int dctSize;

		// DC prediction

		if (block < 4) {
			predictor = self->dc_predictor_y;
			dctSize = read_huffman(self->bits, DCT_DC_SIZE_LUMINANCE);
		}
		else {
			predictor = (block == 4 ? self->dc_predictor_cr : self->dc_predictor_cb);
			dctSize = read_huffman(self->bits, DCT_DC_SIZE_CHROMINANCE);
		}

		// Read DC coeff
		if (dctSize > 0) {
			int differential = bit_buffer_read(self->bits, dctSize);
			if ((differential & (1 << (dctSize - 1))) != 0) {
				self->block_data[0] = predictor + differential;
			}
			else {
				self->block_data[0] = predictor + ((-1 << dctSize)|(differential+1));
			}
		}
		else {
			self->block_data[0] = predictor;
		}

		// Save predictor value
		if (block < 4) {
			self->dc_predictor_y = self->block_data[0];
		}
		else if (block == 4) {
			self->dc_predictor_cr = self->block_data[0];
		}
		else {
			self->dc_predictor_cb = self->block_data[0];
		}

		// Dequantize + premultiply
		self->block_data[0] <<= (3 + 5);

		quant_matrix = self->intra_quant_matrix;
		n = 1;
	}
	else {
		quant_matrix = self->non_intra_quant_matrix;
	}

	// Decode AC coefficients (+DC for non-intra)
	int level = 0;
	while (true) {
		int run = 0;
		int coeff = read_huffman(self->bits, DCT_COEFF);

		if ((coeff == 0x0001) && (n > 0) && (bit_buffer_read(self->bits, 1) == 0)) {
			// end_of_block
			break;
		}
		if (coeff == 0xffff) {
			// escape
			run = bit_buffer_read(self->bits, 6);
			level = bit_buffer_read(self->bits, 8);
			if (level == 0) {
				level = bit_buffer_read(self->bits, 8);
			}
			else if (level == 128) {
				level = bit_buffer_read(self->bits, 8) - 256;
			}
			else if (level > 128) {
				level = level - 256;
			}
		}
		else {
			run = coeff >> 8;
			level = coeff & 0xff;
			if (bit_buffer_read(self->bits, 1)) {
				level = -level;
			}
		}

		n += run;
		int dezigZagged = ZIG_ZAG[n];
		n++;

		// Dequantize, oddify, clip
		level <<= 1;
		if (!self->macroblock_intra) {
			level += (level < 0 ? -1 : 1);
		}
		level = (level * self->quantizer_scale * quant_matrix[dezigZagged]) >> 4;
		if ((level & 1) == 0) {
			level -= level > 0 ? 1 : -1;
		}
		if (level > 2047) {
			level = 2047;
		}
		else if (level < -2048) {
			level = -2048;
		}

		// Save premultiplied coefficient
		self->block_data[dezigZagged] = level * PREMULTIPLIER_MATRIX[dezigZagged];
	}

	// Move block to its place
	uint8_t *dest_array;
	int dest_index;
	int scan;

	if (block < 4) {
		dest_array = self->planes_current.y;
		scan = self->coded_width - 8;
		dest_index = (self->mb_row * self->coded_width + self->mb_col) << 4;
		if ((block & 1) != 0) {
			dest_index += 8;
		}
		if ((block & 2) != 0) {
			dest_index += self->coded_width << 3;
		}
	}
	else {
		dest_array = (block == 4) ? self->planes_current.cb : self->planes_current.cr;
		scan = (self->coded_width >> 1) - 8;
		dest_index = ((self->mb_row * self->coded_width) << 2) + (self->mb_col << 3);
	}

	if (self->macroblock_intra) {
		// Overwrite (no prediction)
		if (n == 1) {
			copy_value_to_destination((self->block_data[0] + 128) >> 8, dest_array, dest_index, scan);
			self->block_data[0] = 0;
		}
		else {
			idct(self->block_data);
			copy_block_to_destination(self->block_data, dest_array, dest_index, scan);
			zero_block_data(self);
		}
	}
	else {
		// Add data to the predicted macroblock
		if (n == 1) {
			add_value_to_destination((self->block_data[0] + 128) >> 8, dest_array, dest_index, scan);
			self->block_data[0] = 0;
		}
		else {
			idct(self->block_data);
			add_block_to_destination(self->block_data, dest_array, dest_index, scan);
			zero_block_data(self);
		}
	}

	n = 0;
}


// -----------------------------------------------------------------------------
// Private functions

void zero_block_data(mpeg1_decoder_t *self) {
	for (int i = 0; i < 64; i++) {
		self->block_data[i] = 0;
	}
}

inline uint8_t clamp_to_uint8(int n) {
	return n > 255 
		? 255 
		: (n < 0 ? 0 : n);
}

void copy_block_to_destination(int *block, uint8_t *dest, int index, int scan) {
	for (int n = 0; n < 64; n += 8, index += scan+8) {
		dest[index+0] = clamp_to_uint8(block[n+0]);
		dest[index+1] = clamp_to_uint8(block[n+1]);
		dest[index+2] = clamp_to_uint8(block[n+2]);
		dest[index+3] = clamp_to_uint8(block[n+3]);
		dest[index+4] = clamp_to_uint8(block[n+4]);
		dest[index+5] = clamp_to_uint8(block[n+5]);
		dest[index+6] = clamp_to_uint8(block[n+6]);
		dest[index+7] = clamp_to_uint8(block[n+7]);
	}
}

void add_block_to_destination(int *block, uint8_t *dest, int index, int scan) {
	for (int n = 0; n < 64; n += 8, index += scan+8) {
		dest[index+0] = clamp_to_uint8(dest[index+0] + block[n+0]);
		dest[index+1] = clamp_to_uint8(dest[index+1] + block[n+1]);
		dest[index+2] = clamp_to_uint8(dest[index+2] + block[n+2]);
		dest[index+3] = clamp_to_uint8(dest[index+3] + block[n+3]);
		dest[index+4] = clamp_to_uint8(dest[index+4] + block[n+4]);
		dest[index+5] = clamp_to_uint8(dest[index+5] + block[n+5]);
		dest[index+6] = clamp_to_uint8(dest[index+6] + block[n+6]);
		dest[index+7] = clamp_to_uint8(dest[index+7] + block[n+7]);
	}
}

void copy_value_to_destination(int value, uint8_t *dest, int index, int scan) {
	value = clamp_to_uint8(value);
	for (int n = 0; n < 64; n += 8, index += scan+8) {
		dest[index+0] = value;
		dest[index+1] = value;
		dest[index+2] = value;
		dest[index+3] = value;
		dest[index+4] = value;
		dest[index+5] = value;
		dest[index+6] = value;
		dest[index+7] = value;
	}
}

void add_value_to_destination(int value, uint8_t *dest, int index, int scan) {
	for (int n = 0; n < 64; n += 8, index += scan+8) {
		dest[index+0] = clamp_to_uint8(dest[index+0] + value);
		dest[index+1] = clamp_to_uint8(dest[index+1] + value);
		dest[index+2] = clamp_to_uint8(dest[index+2] + value);
		dest[index+3] = clamp_to_uint8(dest[index+3] + value);
		dest[index+4] = clamp_to_uint8(dest[index+4] + value);
		dest[index+5] = clamp_to_uint8(dest[index+5] + value);
		dest[index+6] = clamp_to_uint8(dest[index+6] + value);
		dest[index+7] = clamp_to_uint8(dest[index+7] + value);
	}
}

void idct(int *block) {
	// See http://vsr.informatik.tu-chemnitz.de/~jan/MPEG/HTML/IDCT.html
	// for more info.

	int
		b1, b3, b4, b6, b7, tmp1, tmp2, m0,
		x0, x1, x2, x3, x4, y3, y4, y5, y6, y7;

	// Transform columns
	for (int i = 0; i < 8; ++i) {
		b1 = block[4*8+i];
		b3 = block[2*8+i] + block[6*8+i];
		b4 = block[5*8+i] - block[3*8+i];
		tmp1 = block[1*8+i] + block[7*8+i];
		tmp2 = block[3*8+i] + block[5*8+i];
		b6 = block[1*8+i] - block[7*8+i];
		b7 = tmp1 + tmp2;
		m0 = block[0*8+i];
		x4 = ((b6*473 - b4*196 + 128) >> 8) - b7;
		x0 = x4 - (((tmp1 - tmp2)*362 + 128) >> 8);
		x1 = m0 - b1;
		x2 = (((block[2*8+i] - block[6*8+i])*362 + 128) >> 8) - b3;
		x3 = m0 + b1;
		y3 = x1 + x2;
		y4 = x3 + b3;
		y5 = x1 - x2;
		y6 = x3 - b3;
		y7 = -x0 - ((b4*473 + b6*196 + 128) >> 8);
		block[0*8+i] = b7 + y4;
		block[1*8+i] = x4 + y3;
		block[2*8+i] = y5 - x0;
		block[3*8+i] = y6 - y7;
		block[4*8+i] = y6 + y7;
		block[5*8+i] = x0 + y5;
		block[6*8+i] = y3 - x4;
		block[7*8+i] = y4 - b7;
	}

	// Transform rows
	for (int i = 0; i < 64; i += 8) {
		b1 = block[4+i];
		b3 = block[2+i] + block[6+i];
		b4 = block[5+i] - block[3+i];
		tmp1 = block[1+i] + block[7+i];
		tmp2 = block[3+i] + block[5+i];
		b6 = block[1+i] - block[7+i];
		b7 = tmp1 + tmp2;
		m0 = block[0+i];
		x4 = ((b6*473 - b4*196 + 128) >> 8) - b7;
		x0 = x4 - (((tmp1 - tmp2)*362 + 128) >> 8);
		x1 = m0 - b1;
		x2 = (((block[2+i] - block[6+i])*362 + 128) >> 8) - b3;
		x3 = m0 + b1;
		y3 = x1 + x2;
		y4 = x3 + b3;
		y5 = x1 - x2;
		y6 = x3 - b3;
		y7 = -x0 - ((b4*473 + b6*196 + 128) >> 8);
		block[0+i] = (b7 + y4 + 128) >> 8;
		block[1+i] = (x4 + y3 + 128) >> 8;
		block[2+i] = (y5 - x0 + 128) >> 8;
		block[3+i] = (y6 - y7 + 128) >> 8;
		block[4+i] = (y6 + y7 + 128) >> 8;
		block[5+i] = (x0 + y5 + 128) >> 8;
		block[6+i] = (y3 - x4 + 128) >> 8;
		block[7+i] = (y4 - b7 + 128) >> 8;
	}
}

int read_huffman(bit_buffer_t *bits, const int *code_table) {
	int state = 0;
	do {
		state = code_table[state + bit_buffer_read(bits, 1)];
	} while (state >= 0 && code_table[state] != 0);
	return code_table[state+2];
}