← Back to branch summary

~ubuntu-branches/debian/experimental/libav/experimental

« back to all changes in this revision

Viewing changes to libavcodec/huffyuvdec.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler
  • Date: 2014-08-10 09:45:02 UTC
  • mfrom: (1.1.28) (2.1.45 sid)
  • Revision ID: package-import@ubuntu.com-20140810094502-p8pds4kq0zpig5oq
Tags: 6:11~alpha1-1
http://bugs.debian.org/749164
* New upstream Release v11
  - Fixes Unchecked conversion from double to enum (Closes: #749164)
* Add some post v11_alpha1 patches from upstream
* All SONAMEs bumped because of internal changes, but external API is
  promised to have not changed

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/huffyuvdec.c
31
31
#include "avcodec.h"
32
32
#include "get_bits.h"
33
33
#include "huffyuv.h"
 
34
#include "huffyuvdsp.h"
34
35
#include "thread.h"
35
36
 
36
37
#define classic_shift_luma_table_size 42
37
38
static const unsigned char classic_shift_luma[classic_shift_luma_table_size + FF_INPUT_BUFFER_PADDING_SIZE] = {
38
 
  34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
39
 
  16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
40
 
  69,68, 0
 
39
    34, 36, 35, 69, 135, 232,   9, 16, 10, 24,  11,  23,  12,  16, 13, 10,
 
40
    14,  8, 15,  8,  16,   8,  17, 20, 16, 10, 207, 206, 205, 236, 11,  8,
 
41
    10, 21,  9, 23,   8,   8, 199, 70, 69, 68,   0
41
42
};
42
43
 
43
44
#define classic_shift_chroma_table_size 59
44
45
static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size + FF_INPUT_BUFFER_PADDING_SIZE] = {
45
 
  66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
46
 
  56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
47
 
  214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
 
46
    66, 36,  37,  38, 39, 40,  41,  75,  76,  77, 110, 239, 144, 81, 82,  83,
 
47
    84, 85, 118, 183, 56, 57,  88,  89,  56,  89, 154,  57,  58, 57, 26, 141,
 
48
    57, 56,  58,  57, 58, 57, 184, 119, 214, 245, 116,  83,  82, 49, 80,  79,
 
49
    78, 77,  44,  75, 41, 40,  39,  38,  37,  36,  34,  0
48
50
};
49
51
 
50
52
static const unsigned char classic_add_luma[256] = {
51
 
    3,  9,  5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
52
 
   73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
53
 
   68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
54
 
   35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
55
 
   37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
56
 
   35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
57
 
   27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
58
 
   15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
59
 
   12, 17, 19, 13,  4,  9,  2, 11,  1,  7,  8,  0, 16,  3, 14,  6,
60
 
   12, 10,  5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
61
 
   18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
62
 
   28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
63
 
   28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
64
 
   62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
65
 
   54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
66
 
   46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13,  7,  8,
 
53
     3,  9,  5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
 
54
    73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
 
55
    68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
 
56
    35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
 
57
    37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
 
58
    35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
 
59
    27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
 
60
    15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
 
61
    12, 17, 19, 13,  4,  9,  2, 11,  1,  7,  8,  0, 16,  3, 14,  6,
 
62
    12, 10,  5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
 
63
    18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
 
64
    28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
 
65
    28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
 
66
    62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
 
67
    54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
 
68
    46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13,  7,  8,
67
69
};
68
70
 
69
71
static const unsigned char classic_add_chroma[256] = {
70
 
    3,  1,  2,  2,  2,  2,  3,  3,  7,  5,  7,  5,  8,  6, 11,  9,
71
 
    7, 13, 11, 10,  9,  8,  7,  5,  9,  7,  6,  4,  7,  5,  8,  7,
72
 
   11,  8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
73
 
   43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
74
 
  143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
75
 
   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
76
 
   17, 14,  5,  6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
77
 
  112,113,114,115,  4,117,118, 92, 94,121,122,  3,124,103,  2,  1,
78
 
    0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
79
 
  135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
80
 
   52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
81
 
   19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10,  9,  8, 36,
82
 
    7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
83
 
   83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
84
 
   14, 16, 17, 18, 20, 21, 12, 14, 15,  9, 10,  6,  9,  6,  5,  8,
85
 
    6, 12,  8, 10,  7,  9,  6,  4,  6,  2,  2,  3,  3,  3,  3,  2,
 
72
     3,    1,   2,   2,   2,   2,   3,   3,   7,   5,   7,   5,   8,   6,  11,   9,
 
73
     7,   13,  11,  10,   9,   8,   7,   5,   9,   7,   6,   4,   7,   5,   8,   7,
 
74
     11,   8,  13,  11,  19,  15,  22,  23,  20,  33,  32,  28,  27,  29,  51,  77,
 
75
     43,  45,  76,  81,  46,  82,  75,  55,  56, 144,  58,  80,  60,  74, 147,  63,
 
76
    143,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
 
77
     80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  27,  30,  21,  22,
 
78
     17,  14,   5,   6, 100,  54,  47,  50,  51,  53, 106, 107, 108, 109, 110, 111,
 
79
    112, 113, 114, 115,   4, 117, 118,  92,  94, 121, 122,   3, 124, 103,   2,   1,
 
80
      0, 129, 130, 131, 120, 119, 126, 125, 136, 137, 138, 139, 140, 141, 142, 134,
 
81
    135, 132, 133, 104,  64, 101,  62,  57, 102,  95,  93,  59,  61,  28,  97,  96,
 
82
     52,  49,  48,  29,  32,  25,  24,  46,  23,  98,  45,  44,  43,  20,  42,  41,
 
83
     19,  18,  99,  40,  15,  39,  38,  16,  13,  12,  11,  37,  10,   9,   8,  36,
 
84
      7, 128, 127, 105, 123, 116,  35,  34,  33, 145,  31,  79,  42, 146,  78,  26,
 
85
     83,  48,  49,  50,  44,  47,  26,  31,  30,  18,  17,  19,  21,  24,  25,  13,
 
86
     14,  16,  17,  18,  20,  21,  12,  14,  15,   9,  10,   6,   9,   6,   5,   8,
 
87
      6,  12,   8,  10,   7,   9,   6,   4,   6,   2,   2,   3,   3,   3,   3,   2,
86
88
};
87
89
 
88
90
static int read_len_table(uint8_t *dst, GetBitContext *gb)
96
98
            repeat = get_bits(gb, 8);
97
99
        if (i + repeat > 256 || get_bits_left(gb) < 0) {
98
100
            av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
99
 
            return -1;
 
101
            return AVERROR_INVALIDDATA;
100
102
        }
101
103
        while (repeat--)
102
104
            dst[i++] = val;
104
106
    return 0;
105
107
}
106
108
 
107
 
static void generate_joint_tables(HYuvContext *s)
 
109
static int generate_joint_tables(HYuvContext *s)
108
110
{
109
111
    uint16_t symbols[1 << VLC_BITS];
110
112
    uint16_t bits[1 << VLC_BITS];
111
113
    uint8_t len[1 << VLC_BITS];
 
114
    int ret;
 
115
 
112
116
    if (s->bitstream_bpp < 24) {
113
117
        int p, i, y, u;
114
118
        for (p = 0; p < 3; p++) {
115
119
            for (i = y = 0; y < 256; y++) {
116
 
                int len0 = s->len[0][y];
 
120
                int len0  = s->len[0][y];
117
121
                int limit = VLC_BITS - len0;
118
 
                if(limit <= 0)
 
122
                if (limit <= 0)
119
123
                    continue;
120
124
                for (u = 0; u < 256; u++) {
121
125
                    int len1 = s->len[p][u];
122
126
                    if (len1 > limit)
123
127
                        continue;
124
 
                    len[i] = len0 + len1;
125
 
                    bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
 
128
                    len[i]     = len0 + len1;
 
129
                    bits[i]    = (s->bits[0][y] << len1) + s->bits[p][u];
126
130
                    symbols[i] = (y << 8) + u;
127
 
                    if(symbols[i] != 0xffff) // reserved to mean "invalid"
 
131
                    if (symbols[i] != 0xffff) // reserved to mean "invalid"
128
132
                        i++;
129
133
                }
130
134
            }
131
135
            ff_free_vlc(&s->vlc[3 + p]);
132
 
            ff_init_vlc_sparse(&s->vlc[3 + p], VLC_BITS, i, len, 1, 1,
133
 
                               bits, 2, 2, symbols, 2, 2, 0);
 
136
            if ((ret = ff_init_vlc_sparse(&s->vlc[3 + p], VLC_BITS, i, len, 1, 1,
 
137
                                          bits, 2, 2, symbols, 2, 2, 0)) < 0)
 
138
                return ret;
134
139
        }
135
140
    } else {
136
 
        uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;
 
141
        uint8_t (*map)[4] = (uint8_t(*)[4]) s->pix_bgr_map;
137
142
        int i, b, g, r, code;
138
143
        int p0 = s->decorrelate;
139
144
        int p1 = !s->decorrelate;
140
 
        // restrict the range to +/-16 because that's pretty much guaranteed to
141
 
        // cover all the combinations that fit in 11 bits total, and it doesn't
142
 
        // matter if we miss a few rare codes.
 
145
        /* Restrict the range to +/-16 because that's pretty much guaranteed
 
146
         * to cover all the combinations that fit in 11 bits total, and it
 
147
         *  does not matter if we miss a few rare codes. */
143
148
        for (i = 0, g = -16; g < 16; g++) {
144
 
            int len0 = s->len[p0][g & 255];
 
149
            int len0   = s->len[p0][g & 255];
145
150
            int limit0 = VLC_BITS - len0;
146
151
            if (limit0 < 2)
147
152
                continue;
148
153
            for (b = -16; b < 16; b++) {
149
 
                int len1 = s->len[p1][b & 255];
 
154
                int len1   = s->len[p1][b & 255];
150
155
                int limit1 = limit0 - len1;
151
156
                if (limit1 < 1)
152
157
                    continue;
155
160
                    int len2 = s->len[2][r & 255];
156
161
                    if (len2 > limit1)
157
162
                        continue;
158
 
                    len[i] = len0 + len1 + len2;
 
163
                    len[i]  = len0 + len1 + len2;
159
164
                    bits[i] = (code << len2) + s->bits[2][r & 255];
160
165
                    if (s->decorrelate) {
161
166
                        map[i][G] = g;
171
176
            }
172
177
        }
173
178
        ff_free_vlc(&s->vlc[3]);
174
 
        init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);
 
179
        if ((ret = init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1,
 
180
                            bits, 2, 2, 0)) < 0)
 
181
            return ret;
175
182
    }
 
183
    return 0;
176
184
}
177
185
 
178
186
static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length)
179
187
{
180
188
    GetBitContext gb;
181
 
    int i;
 
189
    int i, ret;
182
190
 
183
 
    init_get_bits(&gb, src, length * 8);
 
191
    if ((ret = init_get_bits(&gb, src, length * 8)) < 0)
 
192
        return ret;
184
193
 
185
194
    for (i = 0; i < 3; i++) {
186
 
        if (read_len_table(s->len[i], &gb) < 0)
187
 
            return -1;
188
 
        if (ff_huffyuv_generate_bits_table(s->bits[i], s->len[i]) < 0) {
189
 
            return -1;
190
 
        }
 
195
        if ((ret = read_len_table(s->len[i], &gb)) < 0)
 
196
            return ret;
 
197
        if ((ret = ff_huffyuv_generate_bits_table(s->bits[i], s->len[i])) < 0)
 
198
            return ret;
191
199
        ff_free_vlc(&s->vlc[i]);
192
 
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
193
 
                 s->bits[i], 4, 4, 0);
 
200
        if ((ret = init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
 
201
                            s->bits[i], 4, 4, 0)) < 0)
 
202
            return ret;
194
203
    }
195
204
 
196
 
    generate_joint_tables(s);
 
205
    if ((ret = generate_joint_tables(s)) < 0)
 
206
        return ret;
197
207
 
198
208
    return (get_bits_count(&gb) + 7) / 8;
199
209
}
201
211
static int read_old_huffman_tables(HYuvContext *s)
202
212
{
203
213
    GetBitContext gb;
204
 
    int i;
205
 
 
206
 
    init_get_bits(&gb, classic_shift_luma,
207
 
                  classic_shift_luma_table_size * 8);
208
 
    if (read_len_table(s->len[0], &gb) < 0)
209
 
        return -1;
210
 
 
211
 
    init_get_bits(&gb, classic_shift_chroma,
212
 
                  classic_shift_chroma_table_size * 8);
213
 
    if (read_len_table(s->len[1], &gb) < 0)
214
 
        return -1;
215
 
 
216
 
    for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
217
 
    for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
 
214
    int i, ret;
 
215
 
 
216
    if ((ret = init_get_bits(&gb, classic_shift_luma,
 
217
                             classic_shift_luma_table_size * 8)) < 0)
 
218
        return ret;
 
219
    if ((ret = read_len_table(s->len[0], &gb)) < 0)
 
220
        return ret;
 
221
 
 
222
    if ((ret = init_get_bits(&gb, classic_shift_chroma,
 
223
                             classic_shift_chroma_table_size * 8)) < 0)
 
224
        return ret;
 
225
    if ((ret = read_len_table(s->len[1], &gb)) < 0)
 
226
        return ret;
 
227
 
 
228
    for (i = 0; i < 256; i++)
 
229
        s->bits[0][i] = classic_add_luma[i];
 
230
    for (i = 0; i < 256; i++)
 
231
        s->bits[1][i] = classic_add_chroma[i];
218
232
 
219
233
    if (s->bitstream_bpp >= 24) {
220
234
        memcpy(s->bits[1], s->bits[0], 256 * sizeof(uint32_t));
221
 
        memcpy(s->len[1] , s->len [0], 256 * sizeof(uint8_t));
 
235
        memcpy(s->len[1], s->len[0], 256 * sizeof(uint8_t));
222
236
    }
223
237
    memcpy(s->bits[2], s->bits[1], 256 * sizeof(uint32_t));
224
 
    memcpy(s->len[2] , s->len [1], 256 * sizeof(uint8_t));
 
238
    memcpy(s->len[2], s->len[1], 256 * sizeof(uint8_t));
225
239
 
226
240
    for (i = 0; i < 3; i++) {
227
241
        ff_free_vlc(&s->vlc[i]);
228
 
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
229
 
                 s->bits[i], 4, 4, 0);
 
242
        if ((ret = init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
 
243
                            s->bits[i], 4, 4, 0)) < 0)
 
244
            return ret;
230
245
    }
231
246
 
232
 
    generate_joint_tables(s);
 
247
    if ((ret = generate_joint_tables(s)) < 0)
 
248
        return ret;
233
249
 
234
250
    return 0;
235
251
}
237
253
static av_cold int decode_init(AVCodecContext *avctx)
238
254
{
239
255
    HYuvContext *s = avctx->priv_data;
 
256
    int ret;
240
257
 
241
258
    ff_huffyuv_common_init(avctx);
 
259
    ff_huffyuvdsp_init(&s->hdsp);
242
260
    memset(s->vlc, 0, 3 * sizeof(VLC));
243
261
 
244
262
    s->interlaced = s->height > 288;
245
 
 
246
 
    s->bgr32 = 1;
 
263
    s->bgr32      = 1;
247
264
 
248
265
    if (avctx->extradata_size) {
249
266
        if ((avctx->bits_per_coded_sample & 7) &&
258
275
        int method, interlace;
259
276
 
260
277
        if (avctx->extradata_size < 4)
261
 
            return -1;
 
278
            return AVERROR_INVALIDDATA;
262
279
 
263
 
        method = ((uint8_t*)avctx->extradata)[0];
264
 
        s->decorrelate = method & 64 ? 1 : 0;
265
 
        s->predictor = method & 63;
266
 
        s->bitstream_bpp = ((uint8_t*)avctx->extradata)[1];
 
280
        method           = avctx->extradata[0];
 
281
        s->decorrelate   = method & 64 ? 1 : 0;
 
282
        s->predictor     = method & 63;
 
283
        s->bitstream_bpp = avctx->extradata[1];
267
284
        if (s->bitstream_bpp == 0)
268
285
            s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
269
 
        interlace = (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
 
286
        interlace     = (avctx->extradata[2] & 0x30) >> 4;
270
287
        s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 : s->interlaced;
271
 
        s->context = ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
 
288
        s->context    = avctx->extradata[2] & 0x40 ? 1 : 0;
272
289
 
273
 
        if ( read_huffman_tables(s, ((uint8_t*)avctx->extradata) + 4,
274
 
                                 avctx->extradata_size - 4) < 0)
275
 
            return -1;
276
 
    }else{
 
290
        if ((ret = read_huffman_tables(s, avctx->extradata + 4,
 
291
                                       avctx->extradata_size - 4)) < 0)
 
292
            return ret;
 
293
    } else {
277
294
        switch (avctx->bits_per_coded_sample & 7) {
278
295
        case 1:
279
 
            s->predictor = LEFT;
 
296
            s->predictor   = LEFT;
280
297
            s->decorrelate = 0;
281
298
            break;
282
299
        case 2:
283
 
            s->predictor = LEFT;
 
300
            s->predictor   = LEFT;
284
301
            s->decorrelate = 1;
285
302
            break;
286
303
        case 3:
287
 
            s->predictor = PLANE;
 
304
            s->predictor   = PLANE;
288
305
            s->decorrelate = avctx->bits_per_coded_sample >= 24;
289
306
            break;
290
307
        case 4:
291
 
            s->predictor = MEDIAN;
 
308
            s->predictor   = MEDIAN;
292
309
            s->decorrelate = 0;
293
310
            break;
294
311
        default:
295
 
            s->predictor = LEFT; //OLD
 
312
            s->predictor   = LEFT; // OLD
296
313
            s->decorrelate = 0;
297
314
            break;
298
315
        }
299
316
        s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
300
 
        s->context = 0;
 
317
        s->context       = 0;
301
318
 
302
 
        if (read_old_huffman_tables(s) < 0)
303
 
            return -1;
 
319
        if ((ret = read_old_huffman_tables(s)) < 0)
 
320
            return ret;
304
321
    }
305
322
 
306
323
    switch (s->bitstream_bpp) {
308
325
        avctx->pix_fmt = AV_PIX_FMT_YUV420P;
309
326
        break;
310
327
    case 16:
311
 
        if (s->yuy2) {
 
328
        if (s->yuy2)
312
329
            avctx->pix_fmt = AV_PIX_FMT_YUYV422;
313
 
        } else {
 
330
        else
314
331
            avctx->pix_fmt = AV_PIX_FMT_YUV422P;
315
 
        }
316
332
        break;
317
333
    case 24:
318
334
    case 32:
319
 
        if (s->bgr32) {
 
335
        if (s->bgr32)
320
336
            avctx->pix_fmt = AV_PIX_FMT_RGB32;
321
 
        } else {
 
337
        else
322
338
            avctx->pix_fmt = AV_PIX_FMT_BGR24;
323
 
        }
324
339
        break;
325
340
    default:
326
341
        return AVERROR_INVALIDDATA;
327
342
    }
328
343
 
329
 
    ff_huffyuv_alloc_temp(s);
 
344
    if (s->predictor == MEDIAN && avctx->pix_fmt == AV_PIX_FMT_YUV422P &&
 
345
        avctx->width % 4) {
 
346
        av_log(avctx, AV_LOG_ERROR, "width must be multiple of 4 "
 
347
               "for this combination of colorspace and predictor type.\n");
 
348
        return AVERROR_INVALIDDATA;
 
349
    }
 
350
 
 
351
    if ((ret = ff_huffyuv_alloc_temp(s)) < 0)
 
352
        return ret;
330
353
 
331
354
    return 0;
332
355
}
334
357
static av_cold int decode_init_thread_copy(AVCodecContext *avctx)
335
358
{
336
359
    HYuvContext *s = avctx->priv_data;
337
 
    int i;
 
360
    int i, ret;
338
361
 
339
 
    ff_huffyuv_alloc_temp(s);
 
362
    if ((ret = ff_huffyuv_alloc_temp(s)) < 0)
 
363
        return ret;
340
364
 
341
365
    for (i = 0; i < 6; i++)
342
366
        s->vlc[i].table = NULL;
343
367
 
344
368
    if (s->version == 2) {
345
 
        if (read_huffman_tables(s, ((uint8_t*)avctx->extradata) + 4,
346
 
                                avctx->extradata_size) < 0)
347
 
            return -1;
 
369
        if ((ret = read_huffman_tables(s, avctx->extradata + 4,
 
370
                                       avctx->extradata_size)) < 0)
 
371
            return ret;
348
372
    } else {
349
 
        if (read_old_huffman_tables(s) < 0)
350
 
            return -1;
 
373
        if ((ret = read_old_huffman_tables(s)) < 0)
 
374
            return ret;
351
375
    }
352
376
 
353
377
    return 0;
355
379
 
356
380
/* TODO instead of restarting the read when the code isn't in the first level
357
381
 * of the joint table, jump into the 2nd level of the individual table. */
358
 
#define READ_2PIX(dst0, dst1, plane1){\
359
 
    uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
360
 
    if(code != 0xffff){\
361
 
        dst0 = code>>8;\
362
 
        dst1 = code;\
363
 
    }else{\
364
 
        dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
365
 
        dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
366
 
    }\
367
 
}
 
382
#define READ_2PIX(dst0, dst1, plane1)                                   \
 
383
    {                                                                   \
 
384
        uint16_t code = get_vlc2(&s->gb, s->vlc[3 + plane1].table,      \
 
385
                                 VLC_BITS, 1);                          \
 
386
        if (code != 0xffff) {                                           \
 
387
            dst0 = code >> 8;                                           \
 
388
            dst1 = code;                                                \
 
389
        } else {                                                        \
 
390
            dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);      \
 
391
            dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3); \
 
392
        }                                                               \
 
393
    }
368
394
 
369
395
static void decode_422_bitstream(HYuvContext *s, int count)
370
396
{
374
400
 
375
401
    if (count >= (get_bits_left(&s->gb)) / (31 * 4)) {
376
402
        for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
377
 
            READ_2PIX(s->temp[0][2 * i    ], s->temp[1][i], 1);
 
403
            READ_2PIX(s->temp[0][2 * i],     s->temp[1][i], 1);
378
404
            READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
379
405
        }
380
406
    } else {
381
407
        for (i = 0; i < count; i++) {
382
 
            READ_2PIX(s->temp[0][2 * i    ], s->temp[1][i], 1);
 
408
            READ_2PIX(s->temp[0][2 * i],     s->temp[1][i], 1);
383
409
            READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
384
410
        }
385
411
    }
389
415
{
390
416
    int i;
391
417
 
392
 
    count/=2;
 
418
    count /= 2;
393
419
 
394
420
    if (count >= (get_bits_left(&s->gb)) / (31 * 2)) {
395
421
        for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
396
422
            READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
397
423
        }
398
424
    } else {
399
 
        for(i=0; i<count; i++){
 
425
        for (i = 0; i < count; i++) {
400
426
            READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
401
427
        }
402
428
    }
409
435
    for (i = 0; i < count; i++) {
410
436
        int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
411
437
        if (code != -1) {
412
 
            *(uint32_t*)&s->temp[0][4 * i] = s->pix_bgr_map[code];
413
 
        } else if(decorrelate) {
 
438
            *(uint32_t *) &s->temp[0][4 * i] = s->pix_bgr_map[code];
 
439
        } else if (decorrelate) {
414
440
            s->temp[0][4 * i + G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
415
441
            s->temp[0][4 * i + B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) +
416
442
                                    s->temp[0][4 * i + G];
429
455
static void decode_bgr_bitstream(HYuvContext *s, int count)
430
456
{
431
457
    if (s->decorrelate) {
432
 
        if (s->bitstream_bpp==24)
 
458
        if (s->bitstream_bpp == 24)
433
459
            decode_bgr_1(s, count, 1, 0);
434
460
        else
435
461
            decode_bgr_1(s, count, 1, 1);
436
462
    } else {
437
 
        if (s->bitstream_bpp==24)
 
463
        if (s->bitstream_bpp == 24)
438
464
            decode_bgr_1(s, count, 0, 0);
439
465
        else
440
466
            decode_bgr_1(s, count, 0, 1);
446
472
    int h, cy, i;
447
473
    int offset[AV_NUM_DATA_POINTERS];
448
474
 
449
 
    if (s->avctx->draw_horiz_band==NULL)
 
475
    if (s->avctx->draw_horiz_band == NULL)
450
476
        return;
451
477
 
452
 
    h = y - s->last_slice_end;
 
478
    h  = y - s->last_slice_end;
453
479
    y -= h;
454
480
 
455
 
    if (s->bitstream_bpp == 12) {
456
 
        cy = y>>1;
457
 
    } else {
 
481
    if (s->bitstream_bpp == 12)
 
482
        cy = y >> 1;
 
483
    else
458
484
        cy = y;
459
 
    }
460
485
 
461
486
    offset[0] = frame->linesize[0] * y;
462
487
    offset[1] = frame->linesize[1] * cy;
474
499
                        AVPacket *avpkt)
475
500
{
476
501
    const uint8_t *buf = avpkt->data;
477
 
    int buf_size = avpkt->size;
 
502
    int buf_size       = avpkt->size;
478
503
    HYuvContext *s = avctx->priv_data;
479
 
    const int width = s->width;
480
 
    const int width2 = s->width>>1;
 
504
    const int width  = s->width;
 
505
    const int width2 = s->width >> 1;
481
506
    const int height = s->height;
482
507
    int fake_ystride, fake_ustride, fake_vstride;
483
508
    ThreadFrame frame = { .f = data };
484
 
    AVFrame * const p = data;
485
 
    int table_size = 0;
 
509
    AVFrame *const p = data;
 
510
    int table_size = 0, ret;
486
511
 
487
512
    av_fast_malloc(&s->bitstream_buffer,
488
513
                   &s->bitstream_buffer_size,
491
516
        return AVERROR(ENOMEM);
492
517
 
493
518
    memset(s->bitstream_buffer + buf_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
494
 
    s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer,
495
 
                     (const uint32_t*)buf, buf_size / 4);
 
519
    s->bdsp.bswap_buf((uint32_t *) s->bitstream_buffer,
 
520
                      (const uint32_t *) buf, buf_size / 4);
496
521
 
497
 
    if (ff_thread_get_buffer(avctx, &frame, 0) < 0) {
 
522
    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0) {
498
523
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
499
 
        return -1;
 
524
        return ret;
500
525
    }
501
526
 
502
527
    if (s->context) {
503
528
        table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
504
529
        if (table_size < 0)
505
 
            return -1;
 
530
            return table_size;
506
531
    }
507
532
 
508
 
    if ((unsigned)(buf_size-table_size) >= INT_MAX / 8)
509
 
        return -1;
510
 
 
511
 
    init_get_bits(&s->gb, s->bitstream_buffer+table_size,
512
 
                  (buf_size-table_size) * 8);
513
 
 
514
 
    fake_ystride = s->interlaced ? p->linesize[0] * 2  : p->linesize[0];
515
 
    fake_ustride = s->interlaced ? p->linesize[1] * 2  : p->linesize[1];
516
 
    fake_vstride = s->interlaced ? p->linesize[2] * 2  : p->linesize[2];
 
533
    if ((unsigned) (buf_size - table_size) >= INT_MAX / 8)
 
534
        return AVERROR_INVALIDDATA;
 
535
 
 
536
    if ((ret = init_get_bits(&s->gb, s->bitstream_buffer + table_size,
 
537
                             (buf_size - table_size) * 8)) < 0)
 
538
        return ret;
 
539
 
 
540
    fake_ystride = s->interlaced ? p->linesize[0] * 2 : p->linesize[0];
 
541
    fake_ustride = s->interlaced ? p->linesize[1] * 2 : p->linesize[1];
 
542
    fake_vstride = s->interlaced ? p->linesize[2] * 2 : p->linesize[2];
517
543
 
518
544
    s->last_slice_end = 0;
519
545
 
528
554
            p->data[0][1] = get_bits(&s->gb, 8);
529
555
            p->data[0][0] = get_bits(&s->gb, 8);
530
556
 
531
 
            av_log(avctx, AV_LOG_ERROR,
532
 
                   "YUY2 output is not implemented yet\n");
533
 
            return -1;
 
557
            avpriv_report_missing_feature(avctx, "YUY2 output");
 
558
            return AVERROR_PATCHWELCOME;
534
559
        } else {
535
 
 
536
 
            leftv = p->data[2][0] = get_bits(&s->gb, 8);
537
 
            lefty = p->data[0][1] = get_bits(&s->gb, 8);
538
 
            leftu = p->data[1][0] = get_bits(&s->gb, 8);
539
 
                    p->data[0][0] = get_bits(&s->gb, 8);
 
560
            leftv         =
 
561
            p->data[2][0] = get_bits(&s->gb, 8);
 
562
            lefty         =
 
563
            p->data[0][1] = get_bits(&s->gb, 8);
 
564
            leftu         =
 
565
            p->data[1][0] = get_bits(&s->gb, 8);
 
566
            p->data[0][0] = get_bits(&s->gb, 8);
540
567
 
541
568
            switch (s->predictor) {
542
569
            case LEFT:
543
570
            case PLANE:
544
 
                decode_422_bitstream(s, width-2);
545
 
                lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
546
 
                if (!(s->flags&CODEC_FLAG_GRAY)) {
547
 
                    leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
548
 
                    leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
 
571
                decode_422_bitstream(s, width - 2);
 
572
                lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + 2, s->temp[0],
 
573
                                                   width - 2, lefty);
 
574
                if (!(s->flags & CODEC_FLAG_GRAY)) {
 
575
                    leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
 
576
                    leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
549
577
                }
550
578
 
551
579
                for (cy = y = 1; y < s->height; y++, cy++) {
556
584
 
557
585
                        ydst = p->data[0] + p->linesize[0] * y;
558
586
 
559
 
                        lefty = s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
 
587
                        lefty = s->hdsp.add_hfyu_left_pred(ydst, s->temp[0],
 
588
                                                           width, lefty);
560
589
                        if (s->predictor == PLANE) {
561
590
                            if (y > s->interlaced)
562
 
                                s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
 
591
                                s->hdsp.add_bytes(ydst, ydst - fake_ystride, width);
563
592
                        }
564
593
                        y++;
565
 
                        if (y >= s->height) break;
 
594
                        if (y >= s->height)
 
595
                            break;
566
596
                    }
567
597
 
568
598
                    draw_slice(s, p, y);
569
599
 
570
 
                    ydst = p->data[0] + p->linesize[0]*y;
571
 
                    udst = p->data[1] + p->linesize[1]*cy;
572
 
                    vdst = p->data[2] + p->linesize[2]*cy;
 
600
                    ydst = p->data[0] + p->linesize[0] * y;
 
601
                    udst = p->data[1] + p->linesize[1] * cy;
 
602
                    vdst = p->data[2] + p->linesize[2] * cy;
573
603
 
574
604
                    decode_422_bitstream(s, width);
575
 
                    lefty = s->dsp.add_hfyu_left_prediction(ydst, s->temp[0], width, lefty);
 
605
                    lefty = s->hdsp.add_hfyu_left_pred(ydst, s->temp[0],
 
606
                                                       width, lefty);
576
607
                    if (!(s->flags & CODEC_FLAG_GRAY)) {
577
 
                        leftu= s->dsp.add_hfyu_left_prediction(udst, s->temp[1], width2, leftu);
578
 
                        leftv= s->dsp.add_hfyu_left_prediction(vdst, s->temp[2], width2, leftv);
 
608
                        leftu = s->hdsp.add_hfyu_left_pred(udst, s->temp[1], width2, leftu);
 
609
                        leftv = s->hdsp.add_hfyu_left_pred(vdst, s->temp[2], width2, leftv);
579
610
                    }
580
611
                    if (s->predictor == PLANE) {
581
612
                        if (cy > s->interlaced) {
582
 
                            s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
 
613
                            s->hdsp.add_bytes(ydst, ydst - fake_ystride, width);
583
614
                            if (!(s->flags & CODEC_FLAG_GRAY)) {
584
 
                                s->dsp.add_bytes(udst, udst - fake_ustride, width2);
585
 
                                s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
 
615
                                s->hdsp.add_bytes(udst, udst - fake_ustride, width2);
 
616
                                s->hdsp.add_bytes(vdst, vdst - fake_vstride, width2);
586
617
                            }
587
618
                        }
588
619
                    }
593
624
            case MEDIAN:
594
625
                /* first line except first 2 pixels is left predicted */
595
626
                decode_422_bitstream(s, width - 2);
596
 
                lefty= s->dsp.add_hfyu_left_prediction(p->data[0] + 2, s->temp[0], width - 2, lefty);
 
627
                lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + 2, s->temp[0],
 
628
                                                   width - 2, lefty);
597
629
                if (!(s->flags & CODEC_FLAG_GRAY)) {
598
 
                    leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
599
 
                    leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
 
630
                    leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
 
631
                    leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
600
632
                }
601
633
 
602
634
                cy = y = 1;
604
636
                /* second line is left predicted for interlaced case */
605
637
                if (s->interlaced) {
606
638
                    decode_422_bitstream(s, width);
607
 
                    lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
 
639
                    lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + p->linesize[0],
 
640
                                                       s->temp[0], width, lefty);
608
641
                    if (!(s->flags & CODEC_FLAG_GRAY)) {
609
 
                        leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
610
 
                        leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
 
642
                        leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
 
643
                        leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
611
644
                    }
612
 
                    y++; cy++;
 
645
                    y++;
 
646
                    cy++;
613
647
                }
614
648
 
615
649
                /* next 4 pixels are left predicted too */
616
650
                decode_422_bitstream(s, 4);
617
 
                lefty = s->dsp.add_hfyu_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
618
 
                if (!(s->flags&CODEC_FLAG_GRAY)) {
619
 
                    leftu = s->dsp.add_hfyu_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
620
 
                    leftv = s->dsp.add_hfyu_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
 
651
                lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + fake_ystride,
 
652
                                                   s->temp[0], 4, lefty);
 
653
                if (!(s->flags & CODEC_FLAG_GRAY)) {
 
654
                    leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
 
655
                    leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
621
656
                }
622
657
 
623
658
                /* next line except the first 4 pixels is median predicted */
624
659
                lefttopy = p->data[0][3];
625
660
                decode_422_bitstream(s, width - 4);
626
 
                s->dsp.add_hfyu_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
627
 
                if (!(s->flags&CODEC_FLAG_GRAY)) {
 
661
                s->hdsp.add_hfyu_median_pred(p->data[0] + fake_ystride + 4,
 
662
                                             p->data[0] + 4, s->temp[0],
 
663
                                             width - 4, &lefty, &lefttopy);
 
664
                if (!(s->flags & CODEC_FLAG_GRAY)) {
628
665
                    lefttopu = p->data[1][1];
629
666
                    lefttopv = p->data[2][1];
630
 
                    s->dsp.add_hfyu_median_prediction(p->data[1] + fake_ustride+2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
631
 
                    s->dsp.add_hfyu_median_prediction(p->data[2] + fake_vstride+2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
 
667
                    s->hdsp.add_hfyu_median_pred(p->data[1] + fake_ustride + 2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
 
668
                    s->hdsp.add_hfyu_median_pred(p->data[2] + fake_vstride + 2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
632
669
                }
633
 
                y++; cy++;
 
670
                y++;
 
671
                cy++;
634
672
 
635
 
                for (; y<height; y++, cy++) {
 
673
                for (; y < height; y++, cy++) {
636
674
                    uint8_t *ydst, *udst, *vdst;
637
675
 
638
676
                    if (s->bitstream_bpp == 12) {
639
677
                        while (2 * cy > y) {
640
678
                            decode_gray_bitstream(s, width);
641
679
                            ydst = p->data[0] + p->linesize[0] * y;
642
 
                            s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
 
680
                            s->hdsp.add_hfyu_median_pred(ydst, ydst - fake_ystride,
 
681
                                                         s->temp[0], width,
 
682
                                                         &lefty, &lefttopy);
643
683
                            y++;
644
684
                        }
645
 
                        if (y >= height) break;
 
685
                        if (y >= height)
 
686
                            break;
646
687
                    }
647
688
                    draw_slice(s, p, y);
648
689
 
652
693
                    udst = p->data[1] + p->linesize[1] * cy;
653
694
                    vdst = p->data[2] + p->linesize[2] * cy;
654
695
 
655
 
                    s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
 
696
                    s->hdsp.add_hfyu_median_pred(ydst, ydst - fake_ystride,
 
697
                                                 s->temp[0], width,
 
698
                                                 &lefty, &lefttopy);
656
699
                    if (!(s->flags & CODEC_FLAG_GRAY)) {
657
 
                        s->dsp.add_hfyu_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
658
 
                        s->dsp.add_hfyu_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
 
700
                        s->hdsp.add_hfyu_median_pred(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
 
701
                        s->hdsp.add_hfyu_median_pred(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
659
702
                    }
660
703
                }
661
704
 
669
712
        const int last_line = (height - 1) * p->linesize[0];
670
713
 
671
714
        if (s->bitstream_bpp == 32) {
672
 
            lefta = p->data[0][last_line+A] = get_bits(&s->gb, 8);
673
 
            leftr = p->data[0][last_line+R] = get_bits(&s->gb, 8);
674
 
            leftg = p->data[0][last_line+G] = get_bits(&s->gb, 8);
675
 
            leftb = p->data[0][last_line+B] = get_bits(&s->gb, 8);
 
715
            lefta = p->data[0][last_line + A] = get_bits(&s->gb, 8);
 
716
            leftr = p->data[0][last_line + R] = get_bits(&s->gb, 8);
 
717
            leftg = p->data[0][last_line + G] = get_bits(&s->gb, 8);
 
718
            leftb = p->data[0][last_line + B] = get_bits(&s->gb, 8);
676
719
        } else {
677
 
            leftr = p->data[0][last_line+R] = get_bits(&s->gb, 8);
678
 
            leftg = p->data[0][last_line+G] = get_bits(&s->gb, 8);
679
 
            leftb = p->data[0][last_line+B] = get_bits(&s->gb, 8);
680
 
            lefta = p->data[0][last_line+A] = 255;
 
720
            leftr = p->data[0][last_line + R] = get_bits(&s->gb, 8);
 
721
            leftg = p->data[0][last_line + G] = get_bits(&s->gb, 8);
 
722
            leftb = p->data[0][last_line + B] = get_bits(&s->gb, 8);
 
723
            lefta = p->data[0][last_line + A] = 255;
681
724
            skip_bits(&s->gb, 8);
682
725
        }
683
726
 
686
729
            case LEFT:
687
730
            case PLANE:
688
731
                decode_bgr_bitstream(s, width - 1);
689
 
                s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width - 1, &leftr, &leftg, &leftb, &lefta);
 
732
                s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + last_line + 4,
 
733
                                                 s->temp[0], width - 1, &leftr,
 
734
                                                 &leftg, &leftb, &lefta);
690
735
 
691
 
                for (y = s->height - 2; y >= 0; y--) { //Yes it is stored upside down.
 
736
                for (y = s->height - 2; y >= 0; y--) { // Yes it is stored upside down.
692
737
                    decode_bgr_bitstream(s, width);
693
738
 
694
 
                    s->dsp.add_hfyu_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb, &lefta);
 
739
                    s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + p->linesize[0] * y,
 
740
                                                     s->temp[0], width, &leftr,
 
741
                                                     &leftg, &leftb, &lefta);
695
742
                    if (s->predictor == PLANE) {
696
 
                        if (s->bitstream_bpp != 32) lefta = 0;
 
743
                        if (s->bitstream_bpp != 32)
 
744
                            lefta = 0;
697
745
                        if ((y & s->interlaced) == 0 &&
698
746
                            y < s->height - 1 - s->interlaced) {
699
 
                            s->dsp.add_bytes(p->data[0] + p->linesize[0] * y,
700
 
                                             p->data[0] + p->linesize[0] * y +
701
 
                                             fake_ystride, fake_ystride);
 
747
                            s->hdsp.add_bytes(p->data[0] + p->linesize[0] * y,
 
748
                                              p->data[0] + p->linesize[0] * y +
 
749
                                              fake_ystride, fake_ystride);
702
750
                        }
703
751
                    }
704
752
                }
709
757
                av_log(avctx, AV_LOG_ERROR,
710
758
                       "prediction type not supported!\n");
711
759
            }
712
 
        }else{
713
 
            av_log(avctx, AV_LOG_ERROR,
714
 
                   "BGR24 output is not implemented yet\n");
715
 
            return -1;
 
760
        } else {
 
761
            avpriv_report_missing_feature(avctx, "BGR24 output");
 
762
            return AVERROR_PATCHWELCOME;
716
763
        }
717
764
    }
718
765
    emms_c();
730
777
    ff_huffyuv_common_end(s);
731
778
    av_freep(&s->bitstream_buffer);
732
779
 
733
 
    for (i = 0; i < 6; i++) {
 
780
    for (i = 0; i < 6; i++)
734
781
        ff_free_vlc(&s->vlc[i]);
735
 
    }
736
782
 
737
783
    return 0;
738
784
}
739
785
 
740
 
#if CONFIG_HUFFYUV_DECODER
741
786
AVCodec ff_huffyuv_decoder = {
742
787
    .name             = "huffyuv",
743
788
    .long_name        = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
751
796
                        CODEC_CAP_FRAME_THREADS,
752
797
    .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
753
798
};
754
 
#endif
755
799
 
756
800
#if CONFIG_FFVHUFF_DECODER
757
801
AVCodec ff_ffvhuff_decoder = {
767
811
                        CODEC_CAP_FRAME_THREADS,
768
812
    .init_thread_copy = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
769
813
};
770
 
#endif
 
814
#endif /* CONFIG_FFVHUFF_DECODER */