libavcodec/vp3.c:1229: error: Buffer Overrun L2
  Offset: [0, 3] Size: 3.

libavcodec/vp3.c:1166:54: <Offset trace>
1164.      * blocks encoding in these modes can only predict from other blocks
1165.      * that were encoded with these 1 of these 2 modes. */
1166.     static const unsigned char compatible_frame[9] = {
                                                           ^
1167.         1,    /* MODE_INTER_NO_MV */
1168.         0,    /* MODE_INTRA */

libavcodec/vp3.c:1166:54: Assignment
1164.      * blocks encoding in these modes can only predict from other blocks
1165.      * that were encoded with these 1 of these 2 modes. */
1166.     static const unsigned char compatible_frame[9] = {
                                                           ^
1167.         1,    /* MODE_INTER_NO_MV */
1168.         0,    /* MODE_INTRA */

libavcodec/vp3.c:1112:1: <Length trace>
1110. #define DC_COEFF(u) s->all_fragments[u].dc
1111. 
1112. static void reverse_dc_prediction(Vp3DecodeContext *s,
      ^
1113.                                   int first_fragment,
1114.                                   int fragment_width,

libavcodec/vp3.c:1112:1: Array declaration
1110. #define DC_COEFF(u) s->all_fragments[u].dc
1111. 
1112. static void reverse_dc_prediction(Vp3DecodeContext *s,
      ^
1113.                                   int first_fragment,
1114.                                   int fragment_width,

libavcodec/vp3.c:1229:36: Array access: Offset: [0, 3] Size: 3
1227.                     /* if there were no fragments to predict from, use last
1228.                      * DC saved */
1229.                     predicted_dc = last_dc[current_frame_type];
                                         ^
1230.                 } else {
1231. 

static void reverse_dc_prediction(Vp3DecodeContext *s,
                                  int first_fragment,
                                  int fragment_width,
                                  int fragment_height)
{
#define PUL 8
#define PU 4
#define PUR 2
#define PL 1
    int x, y;
    int i = first_fragment;
    int predicted_dc;
    int vl, vul, vu, vur;
    int l, ul, u, ur;
    static const int predictor_transform[16][4] = {
        {  0,  0,  0,  0},
        {  0,  0,  0,128},
        {  0,  0,128,  0},
        {  0,  0, 53, 75},
        {  0,128,  0,  0},
        {  0, 64,  0, 64},
        {  0,128,  0,  0},
        {  0,  0, 53, 75},
        {128,  0,  0,  0},
        {  0,  0,  0,128},
        { 64,  0, 64,  0},
        {  0,  0, 53, 75},
        {  0,128,  0,  0},
       {-104,116,  0,116},
        { 24, 80, 24,  0},
       {-104,116,  0,116}
    };
    static const unsigned char compatible_frame[9] = {
        1,
        0,
        1,
        1,
        1,
        2,
        2,
        1,
        3
    };
    int current_frame_type;
    short last_dc[3];
    int transform = 0;
    vul = vu = vur = vl = 0;
    last_dc[0] = last_dc[1] = last_dc[2] = 0;
    for (y = 0; y < fragment_height; y++) {
        for (x = 0; x < fragment_width; x++, i++) {
            if (s->all_fragments[i].coding_method != MODE_COPY) {
                current_frame_type =
                    compatible_frame[s->all_fragments[i].coding_method];
                transform= 0;
                if(x){
                    l= i-1;
                    vl = DC_COEFF(l);
                    if(COMPATIBLE_FRAME(l))
                        transform |= PL;
                }
                if(y){
                    u= i-fragment_width;
                    vu = DC_COEFF(u);
                    if(COMPATIBLE_FRAME(u))
                        transform |= PU;
                    if(x){
                        ul= i-fragment_width-1;
                        vul = DC_COEFF(ul);
                        if(COMPATIBLE_FRAME(ul))
                            transform |= PUL;
                    }
                    if(x + 1 < fragment_width){
                        ur= i-fragment_width+1;
                        vur = DC_COEFF(ur);
                        if(COMPATIBLE_FRAME(ur))
                            transform |= PUR;
                    }
                }
                if (transform == 0) {
                    predicted_dc = last_dc[current_frame_type];
                } else {
                    predicted_dc =
                        (predictor_transform[transform][0] * vul) +
                        (predictor_transform[transform][1] * vu) +
                        (predictor_transform[transform][2] * vur) +
                        (predictor_transform[transform][3] * vl);
                    predicted_dc /= 128;
                    if ((transform == 15) || (transform == 13)) {
                        if (FFABS(predicted_dc - vu) > 128)
                            predicted_dc = vu;
                        else if (FFABS(predicted_dc - vl) > 128)
                            predicted_dc = vl;
                        else if (FFABS(predicted_dc - vul) > 128)
                            predicted_dc = vul;
                    }
                }
                DC_COEFF(i) += predicted_dc;
                last_dc[current_frame_type] = DC_COEFF(i);
            }
        }
    }
}
['static void reverse_dc_prediction(Vp3DecodeContext *s,\n                                  int first_fragment,\n                                  int fragment_width,\n                                  int fragment_height)\n{\n#define PUL 8\n#define PU 4\n#define PUR 2\n#define PL 1\n    int x, y;\n    int i = first_fragment;\n    int predicted_dc;\n    int vl, vul, vu, vur;\n    int l, ul, u, ur;\n    static const int predictor_transform[16][4] = {\n        {  0,  0,  0,  0},\n        {  0,  0,  0,128},\n        {  0,  0,128,  0},\n        {  0,  0, 53, 75},\n        {  0,128,  0,  0},\n        {  0, 64,  0, 64},\n        {  0,128,  0,  0},\n        {  0,  0, 53, 75},\n        {128,  0,  0,  0},\n        {  0,  0,  0,128},\n        { 64,  0, 64,  0},\n        {  0,  0, 53, 75},\n        {  0,128,  0,  0},\n       {-104,116,  0,116},\n        { 24, 80, 24,  0},\n       {-104,116,  0,116}\n    };\n    static const unsigned char compatible_frame[9] = {\n        1,\n        0,\n        1,\n        1,\n        1,\n        2,\n        2,\n        1,\n        3\n    };\n    int current_frame_type;\n    short last_dc[3];\n    int transform = 0;\n    vul = vu = vur = vl = 0;\n    last_dc[0] = last_dc[1] = last_dc[2] = 0;\n    for (y = 0; y < fragment_height; y++) {\n        for (x = 0; x < fragment_width; x++, i++) {\n            if (s->all_fragments[i].coding_method != MODE_COPY) {\n                current_frame_type =\n                    compatible_frame[s->all_fragments[i].coding_method];\n                transform= 0;\n                if(x){\n                    l= i-1;\n                    vl = DC_COEFF(l);\n                    if(COMPATIBLE_FRAME(l))\n                        transform |= PL;\n                }\n                if(y){\n                    u= i-fragment_width;\n                    vu = DC_COEFF(u);\n                    if(COMPATIBLE_FRAME(u))\n                        transform |= PU;\n                    if(x){\n                        ul= i-fragment_width-1;\n                        vul = DC_COEFF(ul);\n                        if(COMPATIBLE_FRAME(ul))\n                            transform |= PUL;\n                    }\n                    if(x + 1 < fragment_width){\n                        ur= i-fragment_width+1;\n                        vur = DC_COEFF(ur);\n                        if(COMPATIBLE_FRAME(ur))\n                            transform |= PUR;\n                    }\n                }\n                if (transform == 0) {\n                    predicted_dc = last_dc[current_frame_type];\n                } else {\n                    predicted_dc =\n                        (predictor_transform[transform][0] * vul) +\n                        (predictor_transform[transform][1] * vu) +\n                        (predictor_transform[transform][2] * vur) +\n                        (predictor_transform[transform][3] * vl);\n                    predicted_dc /= 128;\n                    if ((transform == 15) || (transform == 13)) {\n                        if (FFABS(predicted_dc - vu) > 128)\n                            predicted_dc = vu;\n                        else if (FFABS(predicted_dc - vl) > 128)\n                            predicted_dc = vl;\n                        else if (FFABS(predicted_dc - vul) > 128)\n                            predicted_dc = vul;\n                    }\n                }\n                DC_COEFF(i) += predicted_dc;\n                last_dc[current_frame_type] = DC_COEFF(i);\n            }\n        }\n    }\n}']