Statistics
| Branch: | Revision:

ffmpeg / libavcodec / huffyuv.c @ e30004fa

History | View | Annotate | Download (47.8 KB)

1 11f18faf Michael Niedermayer
/*
2
 * huffyuv codec for libavcodec
3
 *
4 aaa1e4cd Michael Niedermayer
 * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
5 11f18faf Michael Niedermayer
 *
6 7b94177e Diego Biurrun
 * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
7
 * the algorithm used
8
 *
9 b78e7197 Diego Biurrun
 * This file is part of FFmpeg.
10
 *
11
 * FFmpeg is free software; you can redistribute it and/or
12 11f18faf Michael Niedermayer
 * modify it under the terms of the GNU Lesser General Public
13
 * License as published by the Free Software Foundation; either
14 b78e7197 Diego Biurrun
 * version 2.1 of the License, or (at your option) any later version.
15 11f18faf Michael Niedermayer
 *
16 b78e7197 Diego Biurrun
 * FFmpeg is distributed in the hope that it will be useful,
17 11f18faf Michael Niedermayer
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19
 * Lesser General Public License for more details.
20
 *
21
 * You should have received a copy of the GNU Lesser General Public
22 b78e7197 Diego Biurrun
 * License along with FFmpeg; if not, write to the Free Software
23 5509bffa Diego Biurrun
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 11f18faf Michael Niedermayer
 */
25 115329f1 Diego Biurrun
26 983e3246 Michael Niedermayer
/**
27 bad5537e Diego Biurrun
 * @file libavcodec/huffyuv.c
28 983e3246 Michael Niedermayer
 * huffyuv codec for libavcodec.
29
 */
30 11f18faf Michael Niedermayer
31
#include "avcodec.h"
32 9106a698 Stefano Sabatini
#include "get_bits.h"
33 b2755007 Stefano Sabatini
#include "put_bits.h"
34 11f18faf Michael Niedermayer
#include "dsputil.h"
35
36
#define VLC_BITS 11
37 1e491e29 Michael Niedermayer
38 3ad7dd8c Michael Niedermayer
#ifdef WORDS_BIGENDIAN
39
#define B 3
40
#define G 2
41
#define R 1
42
#else
43
#define B 0
44
#define G 1
45
#define R 2
46
#endif
47
48 11f18faf Michael Niedermayer
typedef enum Predictor{
49
    LEFT= 0,
50
    PLANE,
51
    MEDIAN,
52
} Predictor;
53 115329f1 Diego Biurrun
54 11f18faf Michael Niedermayer
typedef struct HYuvContext{
55
    AVCodecContext *avctx;
56
    Predictor predictor;
57
    GetBitContext gb;
58
    PutBitContext pb;
59
    int interlaced;
60
    int decorrelate;
61
    int bitstream_bpp;
62
    int version;
63
    int yuy2;                               //use yuy2 instead of 422P
64
    int bgr32;                              //use bgr32 instead of bgr24
65
    int width, height;
66
    int flags;
67 11087086 Loren Merritt
    int context;
68 11f18faf Michael Niedermayer
    int picture_number;
69 7c5ab7b8 Michael Niedermayer
    int last_slice_end;
70 0ecca7a4 Michael Niedermayer
    uint8_t *temp[3];
71 11f18faf Michael Niedermayer
    uint64_t stats[3][256];
72
    uint8_t len[3][256];
73
    uint32_t bits[3][256];
74 8be6dac8 Loren Merritt
    uint32_t pix_bgr_map[1<<VLC_BITS];
75 19716d64 Loren Merritt
    VLC vlc[6];                             //Y,U,V,YY,YU,YV
76 492cd3a9 Michael Niedermayer
    AVFrame picture;
77 0ecca7a4 Michael Niedermayer
    uint8_t *bitstream_buffer;
78 f038fe8b Diego Biurrun
    unsigned int bitstream_buffer_size;
79 115329f1 Diego Biurrun
    DSPContext dsp;
80 11f18faf Michael Niedermayer
}HYuvContext;
81
82 24def10e Zdenek Kabelac
static const unsigned char classic_shift_luma[] = {
83 676b385c Michael Niedermayer
  34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
84
  16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
85
  69,68, 0
86
};
87
88 24def10e Zdenek Kabelac
static const unsigned char classic_shift_chroma[] = {
89 676b385c Michael Niedermayer
  66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
90
  56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
91
  214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
92
};
93
94 24def10e Zdenek Kabelac
static const unsigned char classic_add_luma[256] = {
95 676b385c Michael Niedermayer
    3,  9,  5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
96
   73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
97
   68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
98
   35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
99
   37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
100
   35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
101
   27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
102
   15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
103
   12, 17, 19, 13,  4,  9,  2, 11,  1,  7,  8,  0, 16,  3, 14,  6,
104
   12, 10,  5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
105
   18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
106
   28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
107
   28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
108
   62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
109
   54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
110
   46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13,  7,  8,
111
};
112
113 24def10e Zdenek Kabelac
static const unsigned char classic_add_chroma[256] = {
114 676b385c Michael Niedermayer
    3,  1,  2,  2,  2,  2,  3,  3,  7,  5,  7,  5,  8,  6, 11,  9,
115
    7, 13, 11, 10,  9,  8,  7,  5,  9,  7,  6,  4,  7,  5,  8,  7,
116
   11,  8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
117
   43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
118
  143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
119
   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
120
   17, 14,  5,  6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
121
  112,113,114,115,  4,117,118, 92, 94,121,122,  3,124,103,  2,  1,
122
    0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
123
  135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
124
   52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
125
   19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10,  9,  8, 36,
126
    7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
127
   83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
128
   14, 16, 17, 18, 20, 21, 12, 14, 15,  9, 10,  6,  9,  6,  5,  8,
129
    6, 12,  8, 10,  7,  9,  6,  4,  6,  2,  2,  3,  3,  3,  3,  2,
130
};
131
132 11f18faf Michael Niedermayer
static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
133
    int i;
134
135
    for(i=0; i<w-1; i++){
136
        acc+= src[i];
137
        dst[i]= acc;
138
        i++;
139
        acc+= src[i];
140
        dst[i]= acc;
141
    }
142
143
    for(; i<w; i++){
144
        acc+= src[i];
145
        dst[i]= acc;
146
    }
147
148
    return acc;
149
}
150
151
static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
152
    int i;
153
    int r,g,b;
154
    r= *red;
155
    g= *green;
156
    b= *blue;
157
158
    for(i=0; i<w; i++){
159 3ad7dd8c Michael Niedermayer
        b+= src[4*i+B];
160
        g+= src[4*i+G];
161
        r+= src[4*i+R];
162 115329f1 Diego Biurrun
163 3ad7dd8c Michael Niedermayer
        dst[4*i+B]= b;
164
        dst[4*i+G]= g;
165
        dst[4*i+R]= r;
166 11f18faf Michael Niedermayer
    }
167
168
    *red= r;
169
    *green= g;
170
    *blue= b;
171
}
172
173 7c5ab7b8 Michael Niedermayer
static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
174 11f18faf Michael Niedermayer
    int i;
175 7c5ab7b8 Michael Niedermayer
    if(w<32){
176
        for(i=0; i<w; i++){
177
            const int temp= src[i];
178
            dst[i]= temp - left;
179
            left= temp;
180
        }
181
        return left;
182
    }else{
183
        for(i=0; i<16; i++){
184
            const int temp= src[i];
185
            dst[i]= temp - left;
186
            left= temp;
187
        }
188
        s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
189
        return src[w-1];
190 11f18faf Michael Niedermayer
    }
191
}
192 2a250222 Michael Niedermayer
193 d2bfaf8a Loren Merritt
static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
194
    int i;
195
    int r,g,b;
196
    r= *red;
197
    g= *green;
198
    b= *blue;
199
    for(i=0; i<FFMIN(w,4); i++){
200
        const int rt= src[i*4+R];
201
        const int gt= src[i*4+G];
202
        const int bt= src[i*4+B];
203
        dst[i*4+R]= rt - r;
204
        dst[i*4+G]= gt - g;
205
        dst[i*4+B]= bt - b;
206
        r = rt;
207
        g = gt;
208
        b = bt;
209
    }
210
    s->dsp.diff_bytes(dst+16, src+16, src+12, w*4-16);
211
    *red=   src[(w-1)*4+R];
212
    *green= src[(w-1)*4+G];
213
    *blue=  src[(w-1)*4+B];
214
}
215
216 e30004fa Loren Merritt
static int read_len_table(uint8_t *dst, GetBitContext *gb){
217 11f18faf Michael Niedermayer
    int i, val, repeat;
218 115329f1 Diego Biurrun
219 11f18faf Michael Niedermayer
    for(i=0; i<256;){
220
        repeat= get_bits(gb, 3);
221
        val   = get_bits(gb, 5);
222
        if(repeat==0)
223
            repeat= get_bits(gb, 8);
224
//printf("%d %d\n", val, repeat);
225 e30004fa Loren Merritt
        if(i+repeat > 256) {
226
            av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
227
            return -1;
228
        }
229 11f18faf Michael Niedermayer
        while (repeat--)
230
            dst[i++] = val;
231
    }
232 e30004fa Loren Merritt
    return 0;
233 11f18faf Michael Niedermayer
}
234
235
static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
236
    int len, index;
237
    uint32_t bits=0;
238
239
    for(len=32; len>0; len--){
240
        for(index=0; index<256; index++){
241 14b74d38 Michael Niedermayer
            if(len_table[index]==len)
242
                dst[index]= bits++;
243 11f18faf Michael Niedermayer
        }
244 14b74d38 Michael Niedermayer
        if(bits & 1){
245 9b879566 Michel Bardiaux
            av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
246 14b74d38 Michael Niedermayer
            return -1;
247
        }
248
        bits >>= 1;
249 11f18faf Michael Niedermayer
    }
250
    return 0;
251
}
252
253 b250f9c6 Aurelien Jacobs
#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
254 98ef8c32 Loren Merritt
typedef struct {
255
    uint64_t val;
256
    int name;
257 fe5c7e58 Michael Niedermayer
} HeapElem;
258 98ef8c32 Loren Merritt
259 fe5c7e58 Michael Niedermayer
static void heap_sift(HeapElem *h, int root, int size)
260 98ef8c32 Loren Merritt
{
261
    while(root*2+1 < size) {
262
        int child = root*2+1;
263
        if(child < size-1 && h[child].val > h[child+1].val)
264
            child++;
265
        if(h[root].val > h[child].val) {
266 fe5c7e58 Michael Niedermayer
            FFSWAP(HeapElem, h[root], h[child]);
267 98ef8c32 Loren Merritt
            root = child;
268
        } else
269
            break;
270
    }
271
}
272
273 11f18faf Michael Niedermayer
static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
274 fe5c7e58 Michael Niedermayer
    HeapElem h[size];
275 11f18faf Michael Niedermayer
    int up[2*size];
276 98ef8c32 Loren Merritt
    int len[2*size];
277 11f18faf Michael Niedermayer
    int offset, i, next;
278 115329f1 Diego Biurrun
279 11f18faf Michael Niedermayer
    for(offset=1; ; offset<<=1){
280
        for(i=0; i<size; i++){
281 98ef8c32 Loren Merritt
            h[i].name = i;
282
            h[i].val = (stats[i] << 8) + offset;
283 11f18faf Michael Niedermayer
        }
284 98ef8c32 Loren Merritt
        for(i=size/2-1; i>=0; i--)
285
            heap_sift(h, i, size);
286
287
        for(next=size; next<size*2-1; next++){
288
            // merge the two smallest entries, and put it back in the heap
289
            uint64_t min1v = h[0].val;
290
            up[h[0].name] = next;
291
            h[0].val = INT64_MAX;
292
            heap_sift(h, 0, size);
293
            up[h[0].name] = next;
294
            h[0].name = next;
295
            h[0].val += min1v;
296
            heap_sift(h, 0, size);
297 11f18faf Michael Niedermayer
        }
298 115329f1 Diego Biurrun
299 98ef8c32 Loren Merritt
        len[2*size-2] = 0;
300
        for(i=2*size-3; i>=size; i--)
301
            len[i] = len[up[i]] + 1;
302
        for(i=0; i<size; i++) {
303
            dst[i] = len[up[i]] + 1;
304 2bf4aa2e Loren Merritt
            if(dst[i] >= 32) break;
305 11f18faf Michael Niedermayer
        }
306
        if(i==size) break;
307
    }
308
}
309 b250f9c6 Aurelien Jacobs
#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
310 11f18faf Michael Niedermayer
311 19716d64 Loren Merritt
static void generate_joint_tables(HYuvContext *s){
312 8be6dac8 Loren Merritt
    uint16_t symbols[1<<VLC_BITS];
313
    uint16_t bits[1<<VLC_BITS];
314
    uint8_t len[1<<VLC_BITS];
315 19716d64 Loren Merritt
    if(s->bitstream_bpp < 24){
316
        int p, i, y, u;
317
        for(p=0; p<3; p++){
318
            for(i=y=0; y<256; y++){
319
                int len0 = s->len[0][y];
320
                int limit = VLC_BITS - len0;
321 f45fcba3 Loren Merritt
                if(limit <= 0)
322
                    continue;
323
                for(u=0; u<256; u++){
324
                    int len1 = s->len[p][u];
325
                    if(len1 > limit)
326
                        continue;
327
                    len[i] = len0 + len1;
328
                    bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
329
                    symbols[i] = (y<<8) + u;
330
                    if(symbols[i] != 0xffff) // reserved to mean "invalid"
331
                        i++;
332 19716d64 Loren Merritt
                }
333
            }
334
            free_vlc(&s->vlc[3+p]);
335 acc0e0c8 Loren Merritt
            init_vlc_sparse(&s->vlc[3+p], VLC_BITS, i, len, 1, 1, bits, 2, 2, symbols, 2, 2, 0);
336 19716d64 Loren Merritt
        }
337 8be6dac8 Loren Merritt
    }else{
338
        uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;
339
        int i, b, g, r, code;
340
        int p0 = s->decorrelate;
341
        int p1 = !s->decorrelate;
342
        // restrict the range to +/-16 becaues that's pretty much guaranteed to
343
        // cover all the combinations that fit in 11 bits total, and it doesn't
344
        // matter if we miss a few rare codes.
345
        for(i=0, g=-16; g<16; g++){
346
            int len0 = s->len[p0][g&255];
347
            int limit0 = VLC_BITS - len0;
348
            if(limit0 < 2)
349
                continue;
350
            for(b=-16; b<16; b++){
351
                int len1 = s->len[p1][b&255];
352
                int limit1 = limit0 - len1;
353
                if(limit1 < 1)
354
                    continue;
355
                code = (s->bits[p0][g&255] << len1) + s->bits[p1][b&255];
356
                for(r=-16; r<16; r++){
357
                    int len2 = s->len[2][r&255];
358
                    if(len2 > limit1)
359
                        continue;
360
                    len[i] = len0 + len1 + len2;
361
                    bits[i] = (code << len2) + s->bits[2][r&255];
362
                    if(s->decorrelate){
363
                        map[i][G] = g;
364
                        map[i][B] = g+b;
365
                        map[i][R] = g+r;
366
                    }else{
367
                        map[i][B] = g;
368
                        map[i][G] = b;
369
                        map[i][R] = r;
370
                    }
371
                    i++;
372
                }
373
            }
374
        }
375
        free_vlc(&s->vlc[3]);
376
        init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);
377 19716d64 Loren Merritt
    }
378
}
379
380 11f18faf Michael Niedermayer
static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
381
    GetBitContext gb;
382
    int i;
383 115329f1 Diego Biurrun
384 68f593b4 Michael Niedermayer
    init_get_bits(&gb, src, length*8);
385 115329f1 Diego Biurrun
386 11f18faf Michael Niedermayer
    for(i=0; i<3; i++){
387 e30004fa Loren Merritt
        if(read_len_table(s->len[i], &gb)<0)
388
            return -1;
389 11f18faf Michael Niedermayer
        if(generate_bits_table(s->bits[i], s->len[i])<0){
390
            return -1;
391
        }
392
#if 0
393
for(j=0; j<256; j++){
394
printf("%6X, %2d,  %3d\n", s->bits[i][j], s->len[i][j], j);
395
}
396
#endif
397 11087086 Loren Merritt
        free_vlc(&s->vlc[i]);
398 073c2593 Burkhard Plaum
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
399 11f18faf Michael Niedermayer
    }
400 115329f1 Diego Biurrun
401 19716d64 Loren Merritt
    generate_joint_tables(s);
402
403 11087086 Loren Merritt
    return (get_bits_count(&gb)+7)/8;
404 11f18faf Michael Niedermayer
}
405
406
static int read_old_huffman_tables(HYuvContext *s){
407 676b385c Michael Niedermayer
#if 1
408 11f18faf Michael Niedermayer
    GetBitContext gb;
409
    int i;
410
411 68f593b4 Michael Niedermayer
    init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
412 e30004fa Loren Merritt
    if(read_len_table(s->len[0], &gb)<0)
413
        return -1;
414 68f593b4 Michael Niedermayer
    init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
415 e30004fa Loren Merritt
    if(read_len_table(s->len[1], &gb)<0)
416
        return -1;
417 115329f1 Diego Biurrun
418 11f18faf Michael Niedermayer
    for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
419
    for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
420
421
    if(s->bitstream_bpp >= 24){
422
        memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
423
        memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
424
    }
425
    memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
426
    memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
427 115329f1 Diego Biurrun
428 11087086 Loren Merritt
    for(i=0; i<3; i++){
429
        free_vlc(&s->vlc[i]);
430 073c2593 Burkhard Plaum
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
431 11087086 Loren Merritt
    }
432 115329f1 Diego Biurrun
433 19716d64 Loren Merritt
    generate_joint_tables(s);
434
435 11f18faf Michael Niedermayer
    return 0;
436
#else
437 267f7edc Steve L'Homme
    av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
438 11f18faf Michael Niedermayer
    return -1;
439
#endif
440
}
441
442 5ef251e5 Daniel Verkamp
static av_cold void alloc_temp(HYuvContext *s){
443 ae2f1d46 Michael Niedermayer
    int i;
444 115329f1 Diego Biurrun
445 ae2f1d46 Michael Niedermayer
    if(s->bitstream_bpp<24){
446
        for(i=0; i<3; i++){
447
            s->temp[i]= av_malloc(s->width + 16);
448
        }
449
    }else{
450 d2bfaf8a Loren Merritt
        for(i=0; i<2; i++){
451
            s->temp[i]= av_malloc(4*s->width + 16);
452
        }
453 ae2f1d46 Michael Niedermayer
    }
454
}
455
456 5ef251e5 Daniel Verkamp
static av_cold int common_init(AVCodecContext *avctx){
457 11f18faf Michael Niedermayer
    HYuvContext *s = avctx->priv_data;
458
459
    s->avctx= avctx;
460
    s->flags= avctx->flags;
461 115329f1 Diego Biurrun
462 1d98dca3 Michael Niedermayer
    dsputil_init(&s->dsp, avctx);
463 115329f1 Diego Biurrun
464 0ecca7a4 Michael Niedermayer
    s->width= avctx->width;
465
    s->height= avctx->height;
466
    assert(s->width>0 && s->height>0);
467 115329f1 Diego Biurrun
468 0ecca7a4 Michael Niedermayer
    return 0;
469
}
470
471 b250f9c6 Aurelien Jacobs
#if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
472 98a6fff9 Zuxy Meng
static av_cold int decode_init(AVCodecContext *avctx)
473 0ecca7a4 Michael Niedermayer
{
474
    HYuvContext *s = avctx->priv_data;
475
476
    common_init(avctx);
477 11087086 Loren Merritt
    memset(s->vlc, 0, 3*sizeof(VLC));
478 115329f1 Diego Biurrun
479 492cd3a9 Michael Niedermayer
    avctx->coded_frame= &s->picture;
480 0ecca7a4 Michael Niedermayer
    s->interlaced= s->height > 288;
481 1e491e29 Michael Niedermayer
482 11f18faf Michael Niedermayer
s->bgr32=1;
483
//if(avctx->extradata)
484
//  printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
485
    if(avctx->extradata_size){
486 dd1c8f3e Luca Abeni
        if((avctx->bits_per_coded_sample&7) && avctx->bits_per_coded_sample != 12)
487 11f18faf Michael Niedermayer
            s->version=1; // do such files exist at all?
488
        else
489
            s->version=2;
490
    }else
491
        s->version=0;
492 115329f1 Diego Biurrun
493 11f18faf Michael Niedermayer
    if(s->version==2){
494 42dd22c4 Loren Merritt
        int method, interlace;
495 11f18faf Michael Niedermayer
496
        method= ((uint8_t*)avctx->extradata)[0];
497
        s->decorrelate= method&64 ? 1 : 0;
498
        s->predictor= method&63;
499
        s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
500 115329f1 Diego Biurrun
        if(s->bitstream_bpp==0)
501 dd1c8f3e Luca Abeni
            s->bitstream_bpp= avctx->bits_per_coded_sample&~7;
502 42dd22c4 Loren Merritt
        interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
503
        s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
504 11087086 Loren Merritt
        s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
505 115329f1 Diego Biurrun
506 11f18faf Michael Niedermayer
        if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
507
            return -1;
508
    }else{
509 dd1c8f3e Luca Abeni
        switch(avctx->bits_per_coded_sample&7){
510 11f18faf Michael Niedermayer
        case 1:
511
            s->predictor= LEFT;
512
            s->decorrelate= 0;
513
            break;
514
        case 2:
515
            s->predictor= LEFT;
516
            s->decorrelate= 1;
517
            break;
518
        case 3:
519
            s->predictor= PLANE;
520 dd1c8f3e Luca Abeni
            s->decorrelate= avctx->bits_per_coded_sample >= 24;
521 11f18faf Michael Niedermayer
            break;
522
        case 4:
523
            s->predictor= MEDIAN;
524
            s->decorrelate= 0;
525
            break;
526
        default:
527
            s->predictor= LEFT; //OLD
528
            s->decorrelate= 0;
529
            break;
530
        }
531 dd1c8f3e Luca Abeni
        s->bitstream_bpp= avctx->bits_per_coded_sample & ~7;
532 11087086 Loren Merritt
        s->context= 0;
533 115329f1 Diego Biurrun
534 11f18faf Michael Niedermayer
        if(read_old_huffman_tables(s) < 0)
535
            return -1;
536
    }
537 115329f1 Diego Biurrun
538 11f18faf Michael Niedermayer
    switch(s->bitstream_bpp){
539
    case 12:
540
        avctx->pix_fmt = PIX_FMT_YUV420P;
541
        break;
542
    case 16:
543
        if(s->yuy2){
544 71e445fc Diego Biurrun
            avctx->pix_fmt = PIX_FMT_YUYV422;
545 11f18faf Michael Niedermayer
        }else{
546
            avctx->pix_fmt = PIX_FMT_YUV422P;
547
        }
548
        break;
549
    case 24:
550
    case 32:
551
        if(s->bgr32){
552 71e445fc Diego Biurrun
            avctx->pix_fmt = PIX_FMT_RGB32;
553 11f18faf Michael Niedermayer
        }else{
554
            avctx->pix_fmt = PIX_FMT_BGR24;
555
        }
556
        break;
557
    default:
558
        assert(0);
559
    }
560 115329f1 Diego Biurrun
561 ae2f1d46 Michael Niedermayer
    alloc_temp(s);
562 115329f1 Diego Biurrun
563 dd1c8f3e Luca Abeni
//    av_log(NULL, AV_LOG_DEBUG, "pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_coded_sample, s->interlaced);
564 07140e39 Michael Niedermayer
565 11f18faf Michael Niedermayer
    return 0;
566
}
567 b250f9c6 Aurelien Jacobs
#endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
568 11f18faf Michael Niedermayer
569 b250f9c6 Aurelien Jacobs
#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
570 11087086 Loren Merritt
static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
571 11f18faf Michael Niedermayer
    int i;
572 11087086 Loren Merritt
    int index= 0;
573 11f18faf Michael Niedermayer
574
    for(i=0; i<256;){
575
        int val= len[i];
576 a003ee9a Michael Niedermayer
        int repeat=0;
577 115329f1 Diego Biurrun
578 a003ee9a Michael Niedermayer
        for(; i<256 && len[i]==val && repeat<255; i++)
579
            repeat++;
580 115329f1 Diego Biurrun
581 a003ee9a Michael Niedermayer
        assert(val < 32 && val >0 && repeat<256 && repeat>0);
582 11f18faf Michael Niedermayer
        if(repeat>7){
583 11087086 Loren Merritt
            buf[index++]= val;
584
            buf[index++]= repeat;
585 11f18faf Michael Niedermayer
        }else{
586 11087086 Loren Merritt
            buf[index++]= val | (repeat<<5);
587 11f18faf Michael Niedermayer
        }
588
    }
589 115329f1 Diego Biurrun
590 11087086 Loren Merritt
    return index;
591 11f18faf Michael Niedermayer
}
592
593 98a6fff9 Zuxy Meng
static av_cold int encode_init(AVCodecContext *avctx)
594 11f18faf Michael Niedermayer
{
595
    HYuvContext *s = avctx->priv_data;
596 0ecca7a4 Michael Niedermayer
    int i, j;
597 11f18faf Michael Niedermayer
598 0ecca7a4 Michael Niedermayer
    common_init(avctx);
599 115329f1 Diego Biurrun
600 0ecca7a4 Michael Niedermayer
    avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
601
    avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
602 11f18faf Michael Niedermayer
    s->version=2;
603 115329f1 Diego Biurrun
604 492cd3a9 Michael Niedermayer
    avctx->coded_frame= &s->picture;
605 115329f1 Diego Biurrun
606 11f18faf Michael Niedermayer
    switch(avctx->pix_fmt){
607 152ba68c Michael Niedermayer
    case PIX_FMT_YUV420P:
608
        s->bitstream_bpp= 12;
609
        break;
610 11f18faf Michael Niedermayer
    case PIX_FMT_YUV422P:
611
        s->bitstream_bpp= 16;
612
        break;
613 d2bfaf8a Loren Merritt
    case PIX_FMT_RGB32:
614
        s->bitstream_bpp= 24;
615
        break;
616 11f18faf Michael Niedermayer
    default:
617 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
618 11f18faf Michael Niedermayer
        return -1;
619
    }
620 dd1c8f3e Luca Abeni
    avctx->bits_per_coded_sample= s->bitstream_bpp;
621 11f18faf Michael Niedermayer
    s->decorrelate= s->bitstream_bpp >= 24;
622
    s->predictor= avctx->prediction_method;
623 ee598f7b Loren Merritt
    s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
624 11087086 Loren Merritt
    if(avctx->context_model==1){
625
        s->context= avctx->context_model;
626
        if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
627
            av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
628
            return -1;
629
        }
630
    }else s->context= 0;
631 115329f1 Diego Biurrun
632 f37b9768 Loren Merritt
    if(avctx->codec->id==CODEC_ID_HUFFYUV){
633
        if(avctx->pix_fmt==PIX_FMT_YUV420P){
634
            av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
635
            return -1;
636
        }
637
        if(avctx->context_model){
638
            av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
639
            return -1;
640
        }
641 0ecca7a4 Michael Niedermayer
        if(s->interlaced != ( s->height > 288 ))
642 f37b9768 Loren Merritt
            av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
643
    }
644 115329f1 Diego Biurrun
645 d2bfaf8a Loren Merritt
    if(s->bitstream_bpp>=24 && s->predictor==MEDIAN){
646
        av_log(avctx, AV_LOG_ERROR, "Error: RGB is incompatible with median predictor\n");
647
        return -1;
648
    }
649
650
    ((uint8_t*)avctx->extradata)[0]= s->predictor | (s->decorrelate << 6);
651 11f18faf Michael Niedermayer
    ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
652 42dd22c4 Loren Merritt
    ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
653 11087086 Loren Merritt
    if(s->context)
654
        ((uint8_t*)avctx->extradata)[2]|= 0x40;
655 11f18faf Michael Niedermayer
    ((uint8_t*)avctx->extradata)[3]= 0;
656
    s->avctx->extradata_size= 4;
657 115329f1 Diego Biurrun
658 11f18faf Michael Niedermayer
    if(avctx->stats_in){
659
        char *p= avctx->stats_in;
660 115329f1 Diego Biurrun
661 11f18faf Michael Niedermayer
        for(i=0; i<3; i++)
662
            for(j=0; j<256; j++)
663
                s->stats[i][j]= 1;
664
665
        for(;;){
666
            for(i=0; i<3; i++){
667
                char *next;
668
669
                for(j=0; j<256; j++){
670
                    s->stats[i][j]+= strtol(p, &next, 0);
671
                    if(next==p) return -1;
672
                    p=next;
673 115329f1 Diego Biurrun
                }
674 11f18faf Michael Niedermayer
            }
675
            if(p[0]==0 || p[1]==0 || p[2]==0) break;
676
        }
677
    }else{
678
        for(i=0; i<3; i++)
679
            for(j=0; j<256; j++){
680
                int d= FFMIN(j, 256-j);
681 115329f1 Diego Biurrun
682 11f18faf Michael Niedermayer
                s->stats[i][j]= 100000000/(d+1);
683
            }
684
    }
685 115329f1 Diego Biurrun
686 11f18faf Michael Niedermayer
    for(i=0; i<3; i++){
687
        generate_len_table(s->len[i], s->stats[i], 256);
688
689
        if(generate_bits_table(s->bits[i], s->len[i])<0){
690
            return -1;
691
        }
692 115329f1 Diego Biurrun
693 11087086 Loren Merritt
        s->avctx->extradata_size+=
694
        store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
695 11f18faf Michael Niedermayer
    }
696
697 11087086 Loren Merritt
    if(s->context){
698
        for(i=0; i<3; i++){
699 0ecca7a4 Michael Niedermayer
            int pels = s->width*s->height / (i?40:10);
700 11087086 Loren Merritt
            for(j=0; j<256; j++){
701
                int d= FFMIN(j, 256-j);
702
                s->stats[i][j]= pels/(d+1);
703
            }
704
        }
705
    }else{
706
        for(i=0; i<3; i++)
707
            for(j=0; j<256; j++)
708
                s->stats[i][j]= 0;
709
    }
710 115329f1 Diego Biurrun
711 dd1c8f3e Luca Abeni
//    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_coded_sample, s->interlaced);
712 5fd74135 Michael Niedermayer
713 ae2f1d46 Michael Niedermayer
    alloc_temp(s);
714
715 11f18faf Michael Niedermayer
    s->picture_number=0;
716 5fd74135 Michael Niedermayer
717 11f18faf Michael Niedermayer
    return 0;
718
}
719 b250f9c6 Aurelien Jacobs
#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
720 11f18faf Michael Niedermayer
721 19716d64 Loren Merritt
/* TODO instead of restarting the read when the code isn't in the first level
722
 * of the joint table, jump into the 2nd level of the individual table. */
723
#define READ_2PIX(dst0, dst1, plane1){\
724 acc0e0c8 Loren Merritt
    uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
725
    if(code != 0xffff){\
726
        dst0 = code>>8;\
727
        dst1 = code;\
728 19716d64 Loren Merritt
    }else{\
729
        dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
730
        dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
731
    }\
732
}
733
734 11f18faf Michael Niedermayer
static void decode_422_bitstream(HYuvContext *s, int count){
735
    int i;
736 5fd74135 Michael Niedermayer
737 11f18faf Michael Niedermayer
    count/=2;
738 115329f1 Diego Biurrun
739 37458d7e Michael Niedermayer
    if(count >= (s->gb.size_in_bits - get_bits_count(&s->gb))/(31*4)){
740
        for(i=0; i<count && get_bits_count(&s->gb) < s->gb.size_in_bits; i++){
741
            READ_2PIX(s->temp[0][2*i  ], s->temp[1][i], 1);
742
            READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
743
        }
744
    }else{
745 fb6ecd72 Michael Niedermayer
        for(i=0; i<count; i++){
746
            READ_2PIX(s->temp[0][2*i  ], s->temp[1][i], 1);
747
            READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
748
        }
749 37458d7e Michael Niedermayer
    }
750 11f18faf Michael Niedermayer
}
751
752 152ba68c Michael Niedermayer
static void decode_gray_bitstream(HYuvContext *s, int count){
753
    int i;
754 115329f1 Diego Biurrun
755 152ba68c Michael Niedermayer
    count/=2;
756 115329f1 Diego Biurrun
757 37458d7e Michael Niedermayer
    if(count >= (s->gb.size_in_bits - get_bits_count(&s->gb))/(31*2)){
758
        for(i=0; i<count && get_bits_count(&s->gb) < s->gb.size_in_bits; i++){
759
            READ_2PIX(s->temp[0][2*i  ], s->temp[0][2*i+1], 0);
760
        }
761
    }else{
762 fb6ecd72 Michael Niedermayer
        for(i=0; i<count; i++){
763
            READ_2PIX(s->temp[0][2*i  ], s->temp[0][2*i+1], 0);
764
        }
765 37458d7e Michael Niedermayer
    }
766 152ba68c Michael Niedermayer
}
767
768 b250f9c6 Aurelien Jacobs
#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
769 aa5cfdfb Jeff Downs
static int encode_422_bitstream(HYuvContext *s, int offset, int count){
770 11f18faf Michael Niedermayer
    int i;
771 aa5cfdfb Jeff Downs
    const uint8_t *y = s->temp[0] + offset;
772
    const uint8_t *u = s->temp[1] + offset/2;
773
    const uint8_t *v = s->temp[2] + offset/2;
774 115329f1 Diego Biurrun
775 0ecca7a4 Michael Niedermayer
    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
776
        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
777
        return -1;
778
    }
779 115329f1 Diego Biurrun
780 bf1a5a46 Loren Merritt
#define LOAD4\
781 aa5cfdfb Jeff Downs
            int y0 = y[2*i];\
782
            int y1 = y[2*i+1];\
783
            int u0 = u[i];\
784
            int v0 = v[i];
785 bf1a5a46 Loren Merritt
786 11f18faf Michael Niedermayer
    count/=2;
787
    if(s->flags&CODEC_FLAG_PASS1){
788
        for(i=0; i<count; i++){
789 bf1a5a46 Loren Merritt
            LOAD4;
790
            s->stats[0][y0]++;
791
            s->stats[1][u0]++;
792
            s->stats[0][y1]++;
793
            s->stats[2][v0]++;
794 11f18faf Michael Niedermayer
        }
795 09b0499f Michael Niedermayer
    }
796
    if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
797
        return 0;
798
    if(s->context){
799 11087086 Loren Merritt
        for(i=0; i<count; i++){
800 bf1a5a46 Loren Merritt
            LOAD4;
801
            s->stats[0][y0]++;
802
            put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
803
            s->stats[1][u0]++;
804
            put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
805
            s->stats[0][y1]++;
806
            put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
807
            s->stats[2][v0]++;
808
            put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
809 11087086 Loren Merritt
        }
810 11f18faf Michael Niedermayer
    }else{
811
        for(i=0; i<count; i++){
812 bf1a5a46 Loren Merritt
            LOAD4;
813
            put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
814
            put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
815
            put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
816
            put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
817 11f18faf Michael Niedermayer
        }
818
    }
819 0ecca7a4 Michael Niedermayer
    return 0;
820 11f18faf Michael Niedermayer
}
821
822 0ecca7a4 Michael Niedermayer
static int encode_gray_bitstream(HYuvContext *s, int count){
823 152ba68c Michael Niedermayer
    int i;
824 115329f1 Diego Biurrun
825 0ecca7a4 Michael Niedermayer
    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
826
        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
827
        return -1;
828
    }
829
830 bf1a5a46 Loren Merritt
#define LOAD2\
831
            int y0 = s->temp[0][2*i];\
832
            int y1 = s->temp[0][2*i+1];
833
#define STAT2\
834
            s->stats[0][y0]++;\
835
            s->stats[0][y1]++;
836
#define WRITE2\
837
            put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
838
            put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
839
840 152ba68c Michael Niedermayer
    count/=2;
841
    if(s->flags&CODEC_FLAG_PASS1){
842
        for(i=0; i<count; i++){
843 bf1a5a46 Loren Merritt
            LOAD2;
844
            STAT2;
845 152ba68c Michael Niedermayer
        }
846 09b0499f Michael Niedermayer
    }
847
    if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
848
        return 0;
849 115329f1 Diego Biurrun
850 09b0499f Michael Niedermayer
    if(s->context){
851 11087086 Loren Merritt
        for(i=0; i<count; i++){
852 bf1a5a46 Loren Merritt
            LOAD2;
853
            STAT2;
854
            WRITE2;
855 11087086 Loren Merritt
        }
856 152ba68c Michael Niedermayer
    }else{
857
        for(i=0; i<count; i++){
858 bf1a5a46 Loren Merritt
            LOAD2;
859
            WRITE2;
860 152ba68c Michael Niedermayer
        }
861
    }
862 0ecca7a4 Michael Niedermayer
    return 0;
863 152ba68c Michael Niedermayer
}
864 b250f9c6 Aurelien Jacobs
#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
865 152ba68c Michael Niedermayer
866 8be6dac8 Loren Merritt
static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha){
867 11f18faf Michael Niedermayer
    int i;
868 8be6dac8 Loren Merritt
    for(i=0; i<count; i++){
869
        int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
870
        if(code != -1){
871
            *(uint32_t*)&s->temp[0][4*i] = s->pix_bgr_map[code];
872
        }else if(decorrelate){
873
            s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
874
            s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
875
            s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
876 11f18faf Michael Niedermayer
        }else{
877 8be6dac8 Loren Merritt
            s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
878
            s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
879
            s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
880 11f18faf Michael Niedermayer
        }
881 8be6dac8 Loren Merritt
        if(alpha)
882
            get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
883
    }
884
}
885
886
static void decode_bgr_bitstream(HYuvContext *s, int count){
887
    if(s->decorrelate){
888
        if(s->bitstream_bpp==24)
889
            decode_bgr_1(s, count, 1, 0);
890
        else
891
            decode_bgr_1(s, count, 1, 1);
892 11f18faf Michael Niedermayer
    }else{
893 8be6dac8 Loren Merritt
        if(s->bitstream_bpp==24)
894
            decode_bgr_1(s, count, 0, 0);
895
        else
896
            decode_bgr_1(s, count, 0, 1);
897 11f18faf Michael Niedermayer
    }
898
}
899
900 d2bfaf8a Loren Merritt
static int encode_bgr_bitstream(HYuvContext *s, int count){
901
    int i;
902
903
    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3*4*count){
904
        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
905
        return -1;
906
    }
907
908 bf1a5a46 Loren Merritt
#define LOAD3\
909
            int g= s->temp[0][4*i+G];\
910
            int b= (s->temp[0][4*i+B] - g) & 0xff;\
911 d2bfaf8a Loren Merritt
            int r= (s->temp[0][4*i+R] - g) & 0xff;
912 bf1a5a46 Loren Merritt
#define STAT3\
913
            s->stats[0][b]++;\
914
            s->stats[1][g]++;\
915 d2bfaf8a Loren Merritt
            s->stats[2][r]++;
916 bf1a5a46 Loren Merritt
#define WRITE3\
917
            put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
918
            put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
919
            put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
920
921
    if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
922
        for(i=0; i<count; i++){
923
            LOAD3;
924
            STAT3;
925 d2bfaf8a Loren Merritt
        }
926
    }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
927
        for(i=0; i<count; i++){
928 bf1a5a46 Loren Merritt
            LOAD3;
929
            STAT3;
930
            WRITE3;
931 d2bfaf8a Loren Merritt
        }
932
    }else{
933
        for(i=0; i<count; i++){
934 bf1a5a46 Loren Merritt
            LOAD3;
935
            WRITE3;
936 d2bfaf8a Loren Merritt
        }
937
    }
938
    return 0;
939
}
940
941 b250f9c6 Aurelien Jacobs
#if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
942 7c5ab7b8 Michael Niedermayer
static void draw_slice(HYuvContext *s, int y){
943
    int h, cy;
944 7a06ff14 Michael Niedermayer
    int offset[4];
945 115329f1 Diego Biurrun
946
    if(s->avctx->draw_horiz_band==NULL)
947 7c5ab7b8 Michael Niedermayer
        return;
948 115329f1 Diego Biurrun
949 7c5ab7b8 Michael Niedermayer
    h= y - s->last_slice_end;
950
    y -= h;
951 115329f1 Diego Biurrun
952 7c5ab7b8 Michael Niedermayer
    if(s->bitstream_bpp==12){
953
        cy= y>>1;
954
    }else{
955
        cy= y;
956
    }
957 7a06ff14 Michael Niedermayer
958
    offset[0] = s->picture.linesize[0]*y;
959
    offset[1] = s->picture.linesize[1]*cy;
960
    offset[2] = s->picture.linesize[2]*cy;
961
    offset[3] = 0;
962 7c5ab7b8 Michael Niedermayer
    emms_c();
963
964 3bb07d61 Michael Niedermayer
    s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
965 115329f1 Diego Biurrun
966 7c5ab7b8 Michael Niedermayer
    s->last_slice_end= y + h;
967
}
968
969 7a00bbad Thilo Borgmann
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
970
    const uint8_t *buf = avpkt->data;
971
    int buf_size = avpkt->size;
972 11f18faf Michael Niedermayer
    HYuvContext *s = avctx->priv_data;
973
    const int width= s->width;
974
    const int width2= s->width>>1;
975
    const int height= s->height;
976 22f3e8be Michael Niedermayer
    int fake_ystride, fake_ustride, fake_vstride;
977 492cd3a9 Michael Niedermayer
    AVFrame * const p= &s->picture;
978 11087086 Loren Merritt
    int table_size= 0;
979 11f18faf Michael Niedermayer
980 492cd3a9 Michael Niedermayer
    AVFrame *picture = data;
981 11f18faf Michael Niedermayer
982 238ef6da Reimar Döffinger
    av_fast_malloc(&s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
983
    if (!s->bitstream_buffer)
984
        return AVERROR(ENOMEM);
985 11f18faf Michael Niedermayer
986 fb2cf1bc Michael Niedermayer
    s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (const uint32_t*)buf, buf_size/4);
987 115329f1 Diego Biurrun
988 e20c4069 Michael Niedermayer
    if(p->data[0])
989
        avctx->release_buffer(avctx, p);
990
991 1e491e29 Michael Niedermayer
    p->reference= 0;
992
    if(avctx->get_buffer(avctx, p) < 0){
993 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
994 1e491e29 Michael Niedermayer
        return -1;
995 22f3e8be Michael Niedermayer
    }
996 115329f1 Diego Biurrun
997 11087086 Loren Merritt
    if(s->context){
998
        table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
999
        if(table_size < 0)
1000
            return -1;
1001
    }
1002
1003 e70e7a4b Michael Niedermayer
    if((unsigned)(buf_size-table_size) >= INT_MAX/8)
1004
        return -1;
1005
1006 11087086 Loren Merritt
    init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
1007 1e491e29 Michael Niedermayer
1008
    fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
1009
    fake_ustride= s->interlaced ? p->linesize[1]*2  : p->linesize[1];
1010
    fake_vstride= s->interlaced ? p->linesize[2]*2  : p->linesize[2];
1011 115329f1 Diego Biurrun
1012 7c5ab7b8 Michael Niedermayer
    s->last_slice_end= 0;
1013 115329f1 Diego Biurrun
1014 11f18faf Michael Niedermayer
    if(s->bitstream_bpp<24){
1015 152ba68c Michael Niedermayer
        int y, cy;
1016 11f18faf Michael Niedermayer
        int lefty, leftu, leftv;
1017
        int lefttopy, lefttopu, lefttopv;
1018 115329f1 Diego Biurrun
1019 11f18faf Michael Niedermayer
        if(s->yuy2){
1020 1e491e29 Michael Niedermayer
            p->data[0][3]= get_bits(&s->gb, 8);
1021
            p->data[0][2]= get_bits(&s->gb, 8);
1022
            p->data[0][1]= get_bits(&s->gb, 8);
1023
            p->data[0][0]= get_bits(&s->gb, 8);
1024 115329f1 Diego Biurrun
1025 160d679c Mike Melanson
            av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
1026 11f18faf Michael Niedermayer
            return -1;
1027
        }else{
1028 115329f1 Diego Biurrun
1029 1e491e29 Michael Niedermayer
            leftv= p->data[2][0]= get_bits(&s->gb, 8);
1030
            lefty= p->data[0][1]= get_bits(&s->gb, 8);
1031
            leftu= p->data[1][0]= get_bits(&s->gb, 8);
1032
                   p->data[0][0]= get_bits(&s->gb, 8);
1033 115329f1 Diego Biurrun
1034 11f18faf Michael Niedermayer
            switch(s->predictor){
1035
            case LEFT:
1036
            case PLANE:
1037
                decode_422_bitstream(s, width-2);
1038 1e491e29 Michael Niedermayer
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1039 11f18faf Michael Niedermayer
                if(!(s->flags&CODEC_FLAG_GRAY)){
1040 1e491e29 Michael Niedermayer
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1041
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1042 11f18faf Michael Niedermayer
                }
1043
1044 152ba68c Michael Niedermayer
                for(cy=y=1; y<s->height; y++,cy++){
1045 11f18faf Michael Niedermayer
                    uint8_t *ydst, *udst, *vdst;
1046 115329f1 Diego Biurrun
1047 152ba68c Michael Niedermayer
                    if(s->bitstream_bpp==12){
1048
                        decode_gray_bitstream(s, width);
1049 115329f1 Diego Biurrun
1050 1e491e29 Michael Niedermayer
                        ydst= p->data[0] + p->linesize[0]*y;
1051 152ba68c Michael Niedermayer
1052
                        lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1053
                        if(s->predictor == PLANE){
1054
                            if(y>s->interlaced)
1055
                                s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1056
                        }
1057
                        y++;
1058
                        if(y>=s->height) break;
1059
                    }
1060 115329f1 Diego Biurrun
1061 7c5ab7b8 Michael Niedermayer
                    draw_slice(s, y);
1062 115329f1 Diego Biurrun
1063 1e491e29 Michael Niedermayer
                    ydst= p->data[0] + p->linesize[0]*y;
1064
                    udst= p->data[1] + p->linesize[1]*cy;
1065
                    vdst= p->data[2] + p->linesize[2]*cy;
1066 115329f1 Diego Biurrun
1067 152ba68c Michael Niedermayer
                    decode_422_bitstream(s, width);
1068 11f18faf Michael Niedermayer
                    lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1069
                    if(!(s->flags&CODEC_FLAG_GRAY)){
1070
                        leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
1071
                        leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
1072
                    }
1073
                    if(s->predictor == PLANE){
1074 152ba68c Michael Niedermayer
                        if(cy>s->interlaced){
1075 11f18faf Michael Niedermayer
                            s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1076
                            if(!(s->flags&CODEC_FLAG_GRAY)){
1077
                                s->dsp.add_bytes(udst, udst - fake_ustride, width2);
1078
                                s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
1079
                            }
1080
                        }
1081
                    }
1082
                }
1083 7c5ab7b8 Michael Niedermayer
                draw_slice(s, height);
1084 115329f1 Diego Biurrun
1085 11f18faf Michael Niedermayer
                break;
1086
            case MEDIAN:
1087
                /* first line except first 2 pixels is left predicted */
1088
                decode_422_bitstream(s, width-2);
1089 1e491e29 Michael Niedermayer
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1090 11f18faf Michael Niedermayer
                if(!(s->flags&CODEC_FLAG_GRAY)){
1091 1e491e29 Michael Niedermayer
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1092
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1093 11f18faf Michael Niedermayer
                }
1094 115329f1 Diego Biurrun
1095 152ba68c Michael Niedermayer
                cy=y=1;
1096 115329f1 Diego Biurrun
1097 11f18faf Michael Niedermayer
                /* second line is left predicted for interlaced case */
1098
                if(s->interlaced){
1099
                    decode_422_bitstream(s, width);
1100 1e491e29 Michael Niedermayer
                    lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
1101 11f18faf Michael Niedermayer
                    if(!(s->flags&CODEC_FLAG_GRAY)){
1102 1e491e29 Michael Niedermayer
                        leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1103
                        leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1104 11f18faf Michael Niedermayer
                    }
1105 152ba68c Michael Niedermayer
                    y++; cy++;
1106 11f18faf Michael Niedermayer
                }
1107
1108
                /* next 4 pixels are left predicted too */
1109
                decode_422_bitstream(s, 4);
1110 1e491e29 Michael Niedermayer
                lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
1111 11f18faf Michael Niedermayer
                if(!(s->flags&CODEC_FLAG_GRAY)){
1112 1e491e29 Michael Niedermayer
                    leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1113
                    leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1114 11f18faf Michael Niedermayer
                }
1115
1116
                /* next line except the first 4 pixels is median predicted */
1117 1e491e29 Michael Niedermayer
                lefttopy= p->data[0][3];
1118 11f18faf Michael Niedermayer
                decode_422_bitstream(s, width-4);
1119 3daa434a Loren Merritt
                s->dsp.add_hfyu_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
1120 11f18faf Michael Niedermayer
                if(!(s->flags&CODEC_FLAG_GRAY)){
1121 1e491e29 Michael Niedermayer
                    lefttopu= p->data[1][1];
1122
                    lefttopv= p->data[2][1];
1123 3daa434a Loren Merritt
                    s->dsp.add_hfyu_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
1124
                    s->dsp.add_hfyu_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
1125 11f18faf Michael Niedermayer
                }
1126 152ba68c Michael Niedermayer
                y++; cy++;
1127 115329f1 Diego Biurrun
1128 152ba68c Michael Niedermayer
                for(; y<height; y++,cy++){
1129 11f18faf Michael Niedermayer
                    uint8_t *ydst, *udst, *vdst;
1130 152ba68c Michael Niedermayer
1131
                    if(s->bitstream_bpp==12){
1132
                        while(2*cy > y){
1133
                            decode_gray_bitstream(s, width);
1134 1e491e29 Michael Niedermayer
                            ydst= p->data[0] + p->linesize[0]*y;
1135 3daa434a Loren Merritt
                            s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1136 152ba68c Michael Niedermayer
                            y++;
1137
                        }
1138
                        if(y>=height) break;
1139
                    }
1140 7c5ab7b8 Michael Niedermayer
                    draw_slice(s, y);
1141 152ba68c Michael Niedermayer
1142 11f18faf Michael Niedermayer
                    decode_422_bitstream(s, width);
1143 152ba68c Michael Niedermayer
1144 1e491e29 Michael Niedermayer
                    ydst= p->data[0] + p->linesize[0]*y;
1145
                    udst= p->data[1] + p->linesize[1]*cy;
1146
                    vdst= p->data[2] + p->linesize[2]*cy;
1147 11f18faf Michael Niedermayer
1148 3daa434a Loren Merritt
                    s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1149 11f18faf Michael Niedermayer
                    if(!(s->flags&CODEC_FLAG_GRAY)){
1150 3daa434a Loren Merritt
                        s->dsp.add_hfyu_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1151
                        s->dsp.add_hfyu_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1152 11f18faf Michael Niedermayer
                    }
1153
                }
1154 7c5ab7b8 Michael Niedermayer
1155
                draw_slice(s, height);
1156 11f18faf Michael Niedermayer
                break;
1157
            }
1158
        }
1159
    }else{
1160
        int y;
1161
        int leftr, leftg, leftb;
1162 1e491e29 Michael Niedermayer
        const int last_line= (height-1)*p->linesize[0];
1163 115329f1 Diego Biurrun
1164 11f18faf Michael Niedermayer
        if(s->bitstream_bpp==32){
1165 0722ccdb Michael Niedermayer
            skip_bits(&s->gb, 8);
1166
            leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1167
            leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1168
            leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1169 11f18faf Michael Niedermayer
        }else{
1170 0722ccdb Michael Niedermayer
            leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1171
            leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1172
            leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1173 11f18faf Michael Niedermayer
            skip_bits(&s->gb, 8);
1174
        }
1175 115329f1 Diego Biurrun
1176 11f18faf Michael Niedermayer
        if(s->bgr32){
1177
            switch(s->predictor){
1178
            case LEFT:
1179
            case PLANE:
1180
                decode_bgr_bitstream(s, width-1);
1181 1e491e29 Michael Niedermayer
                add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
1182 11f18faf Michael Niedermayer
1183 90b5b51e Diego Biurrun
                for(y=s->height-2; y>=0; y--){ //Yes it is stored upside down.
1184 11f18faf Michael Niedermayer
                    decode_bgr_bitstream(s, width);
1185 115329f1 Diego Biurrun
1186 1e491e29 Michael Niedermayer
                    add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
1187 11f18faf Michael Niedermayer
                    if(s->predictor == PLANE){
1188 fc0be57f Michael Niedermayer
                        if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
1189 115329f1 Diego Biurrun
                            s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
1190 1e491e29 Michael Niedermayer
                                             p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
1191 11f18faf Michael Niedermayer
                        }
1192
                    }
1193
                }
1194 160d679c Mike Melanson
                draw_slice(s, height); // just 1 large slice as this is not possible in reverse order
1195 11f18faf Michael Niedermayer
                break;
1196
            default:
1197 9b879566 Michel Bardiaux
                av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
1198 11f18faf Michael Niedermayer
            }
1199
        }else{
1200
1201 160d679c Mike Melanson
            av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
1202 11f18faf Michael Niedermayer
            return -1;
1203
        }
1204
    }
1205
    emms_c();
1206 115329f1 Diego Biurrun
1207 1e491e29 Michael Niedermayer
    *picture= *p;
1208 492cd3a9 Michael Niedermayer
    *data_size = sizeof(AVFrame);
1209 115329f1 Diego Biurrun
1210 1adc29ee Michael Niedermayer
    return (get_bits_count(&s->gb)+31)/32*4 + table_size;
1211 11f18faf Michael Niedermayer
}
1212 b250f9c6 Aurelien Jacobs
#endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1213 11f18faf Michael Niedermayer
1214 0ecca7a4 Michael Niedermayer
static int common_end(HYuvContext *s){
1215
    int i;
1216 115329f1 Diego Biurrun
1217 0ecca7a4 Michael Niedermayer
    for(i=0; i<3; i++){
1218
        av_freep(&s->temp[i]);
1219
    }
1220
    return 0;
1221
}
1222
1223 b250f9c6 Aurelien Jacobs
#if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
1224 98a6fff9 Zuxy Meng
static av_cold int decode_end(AVCodecContext *avctx)
1225 11f18faf Michael Niedermayer
{
1226
    HYuvContext *s = avctx->priv_data;
1227
    int i;
1228 115329f1 Diego Biurrun
1229 0ecca7a4 Michael Niedermayer
    common_end(s);
1230
    av_freep(&s->bitstream_buffer);
1231 115329f1 Diego Biurrun
1232 7b62bb2b Oliver Pfister
    for(i=0; i<6; i++){
1233 11f18faf Michael Niedermayer
        free_vlc(&s->vlc[i]);
1234
    }
1235 1e491e29 Michael Niedermayer
1236 11f18faf Michael Niedermayer
    return 0;
1237
}
1238 b250f9c6 Aurelien Jacobs
#endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1239 11f18faf Michael Niedermayer
1240 b250f9c6 Aurelien Jacobs
#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
1241 11f18faf Michael Niedermayer
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1242
    HYuvContext *s = avctx->priv_data;
1243 492cd3a9 Michael Niedermayer
    AVFrame *pict = data;
1244 11f18faf Michael Niedermayer
    const int width= s->width;
1245
    const int width2= s->width>>1;
1246
    const int height= s->height;
1247
    const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
1248
    const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
1249
    const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
1250 492cd3a9 Michael Niedermayer
    AVFrame * const p= &s->picture;
1251 11087086 Loren Merritt
    int i, j, size=0;
1252 11f18faf Michael Niedermayer
1253 1e491e29 Michael Niedermayer
    *p = *pict;
1254 aaa1e4cd Michael Niedermayer
    p->pict_type= FF_I_TYPE;
1255
    p->key_frame= 1;
1256 115329f1 Diego Biurrun
1257 11087086 Loren Merritt
    if(s->context){
1258
        for(i=0; i<3; i++){
1259
            generate_len_table(s->len[i], s->stats[i], 256);
1260
            if(generate_bits_table(s->bits[i], s->len[i])<0)
1261
                return -1;
1262
            size+= store_table(s, s->len[i], &buf[size]);
1263
        }
1264
1265
        for(i=0; i<3; i++)
1266
            for(j=0; j<256; j++)
1267
                s->stats[i][j] >>= 1;
1268
    }
1269
1270
    init_put_bits(&s->pb, buf+size, buf_size-size);
1271
1272 152ba68c Michael Niedermayer
    if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1273
        int lefty, leftu, leftv, y, cy;
1274 11f18faf Michael Niedermayer
1275 1e491e29 Michael Niedermayer
        put_bits(&s->pb, 8, leftv= p->data[2][0]);
1276
        put_bits(&s->pb, 8, lefty= p->data[0][1]);
1277
        put_bits(&s->pb, 8, leftu= p->data[1][0]);
1278
        put_bits(&s->pb, 8,        p->data[0][0]);
1279 115329f1 Diego Biurrun
1280 fdb699de Jeff Downs
        lefty= sub_left_prediction(s, s->temp[0], p->data[0], width , 0);
1281
        leftu= sub_left_prediction(s, s->temp[1], p->data[1], width2, 0);
1282
        leftv= sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);
1283 115329f1 Diego Biurrun
1284 fdb699de Jeff Downs
        encode_422_bitstream(s, 2, width-2);
1285 115329f1 Diego Biurrun
1286 11f18faf Michael Niedermayer
        if(s->predictor==MEDIAN){
1287
            int lefttopy, lefttopu, lefttopv;
1288 152ba68c Michael Niedermayer
            cy=y=1;
1289 11f18faf Michael Niedermayer
            if(s->interlaced){
1290 1e491e29 Michael Niedermayer
                lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1291
                leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1292
                leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
1293 115329f1 Diego Biurrun
1294 aa5cfdfb Jeff Downs
                encode_422_bitstream(s, 0, width);
1295 152ba68c Michael Niedermayer
                y++; cy++;
1296 11f18faf Michael Niedermayer
            }
1297 115329f1 Diego Biurrun
1298 1e491e29 Michael Niedermayer
            lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
1299 07140e39 Michael Niedermayer
            leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1300
            leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
1301 115329f1 Diego Biurrun
1302 aa5cfdfb Jeff Downs
            encode_422_bitstream(s, 0, 4);
1303 152ba68c Michael Niedermayer
1304 1e491e29 Michael Niedermayer
            lefttopy= p->data[0][3];
1305
            lefttopu= p->data[1][1];
1306
            lefttopv= p->data[2][1];
1307 84705403 Michael Niedermayer
            s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1308
            s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1309
            s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
1310 aa5cfdfb Jeff Downs
            encode_422_bitstream(s, 0, width-4);
1311 152ba68c Michael Niedermayer
            y++; cy++;
1312 11f18faf Michael Niedermayer
1313 152ba68c Michael Niedermayer
            for(; y<height; y++,cy++){
1314 11f18faf Michael Niedermayer
                uint8_t *ydst, *udst, *vdst;
1315 115329f1 Diego Biurrun
1316 152ba68c Michael Niedermayer
                if(s->bitstream_bpp==12){
1317
                    while(2*cy > y){
1318 1e491e29 Michael Niedermayer
                        ydst= p->data[0] + p->linesize[0]*y;
1319 84705403 Michael Niedermayer
                        s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1320 152ba68c Michael Niedermayer
                        encode_gray_bitstream(s, width);
1321
                        y++;
1322
                    }
1323
                    if(y>=height) break;
1324
                }
1325 1e491e29 Michael Niedermayer
                ydst= p->data[0] + p->linesize[0]*y;
1326
                udst= p->data[1] + p->linesize[1]*cy;
1327
                vdst= p->data[2] + p->linesize[2]*cy;
1328 11f18faf Michael Niedermayer
1329 84705403 Michael Niedermayer
                s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1330
                s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1331
                s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1332 11f18faf Michael Niedermayer
1333 aa5cfdfb Jeff Downs
                encode_422_bitstream(s, 0, width);
1334 11f18faf Michael Niedermayer
            }
1335
        }else{
1336 152ba68c Michael Niedermayer
            for(cy=y=1; y<height; y++,cy++){
1337 11f18faf Michael Niedermayer
                uint8_t *ydst, *udst, *vdst;
1338 115329f1 Diego Biurrun
1339 152ba68c Michael Niedermayer
                /* encode a luma only line & y++ */
1340
                if(s->bitstream_bpp==12){
1341 1e491e29 Michael Niedermayer
                    ydst= p->data[0] + p->linesize[0]*y;
1342 152ba68c Michael Niedermayer
1343
                    if(s->predictor == PLANE && s->interlaced < y){
1344 7c5ab7b8 Michael Niedermayer
                        s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1345 152ba68c Michael Niedermayer
1346 7c5ab7b8 Michael Niedermayer
                        lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1347 152ba68c Michael Niedermayer
                    }else{
1348 7c5ab7b8 Michael Niedermayer
                        lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1349 152ba68c Michael Niedermayer
                    }
1350
                    encode_gray_bitstream(s, width);
1351
                    y++;
1352
                    if(y>=height) break;
1353
                }
1354 115329f1 Diego Biurrun
1355 1e491e29 Michael Niedermayer
                ydst= p->data[0] + p->linesize[0]*y;
1356
                udst= p->data[1] + p->linesize[1]*cy;
1357
                vdst= p->data[2] + p->linesize[2]*cy;
1358 11f18faf Michael Niedermayer
1359 152ba68c Michael Niedermayer
                if(s->predictor == PLANE && s->interlaced < cy){
1360 7c5ab7b8 Michael Niedermayer
                    s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1361
                    s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1362 ae2f1d46 Michael Niedermayer
                    s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
1363 11f18faf Michael Niedermayer
1364 7c5ab7b8 Michael Niedermayer
                    lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1365
                    leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1366 ae2f1d46 Michael Niedermayer
                    leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
1367 11f18faf Michael Niedermayer
                }else{
1368 7c5ab7b8 Michael Niedermayer
                    lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1369
                    leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1370
                    leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1371 11f18faf Michael Niedermayer
                }
1372
1373 aa5cfdfb Jeff Downs
                encode_422_bitstream(s, 0, width);
1374 11f18faf Michael Niedermayer
            }
1375 115329f1 Diego Biurrun
        }
1376 d2bfaf8a Loren Merritt
    }else if(avctx->pix_fmt == PIX_FMT_RGB32){
1377
        uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
1378
        const int stride = -p->linesize[0];
1379
        const int fake_stride = -fake_ystride;
1380
        int y;
1381
        int leftr, leftg, leftb;
1382
1383
        put_bits(&s->pb, 8, leftr= data[R]);
1384
        put_bits(&s->pb, 8, leftg= data[G]);
1385
        put_bits(&s->pb, 8, leftb= data[B]);
1386
        put_bits(&s->pb, 8, 0);
1387
1388
        sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
1389
        encode_bgr_bitstream(s, width-1);
1390
1391
        for(y=1; y<s->height; y++){
1392
            uint8_t *dst = data + y*stride;
1393
            if(s->predictor == PLANE && s->interlaced < y){
1394
                s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
1395
                sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
1396
            }else{
1397
                sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
1398
            }
1399
            encode_bgr_bitstream(s, width);
1400
        }
1401 11f18faf Michael Niedermayer
    }else{
1402 9b879566 Michel Bardiaux
        av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1403 11f18faf Michael Niedermayer
    }
1404
    emms_c();
1405 115329f1 Diego Biurrun
1406 11087086 Loren Merritt
    size+= (put_bits_count(&s->pb)+31)/8;
1407 300a3d0d Michael Niedermayer
    put_bits(&s->pb, 16, 0);
1408
    put_bits(&s->pb, 15, 0);
1409 11087086 Loren Merritt
    size/= 4;
1410 115329f1 Diego Biurrun
1411 11f18faf Michael Niedermayer
    if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1412
        int j;
1413
        char *p= avctx->stats_out;
1414 2fc8ea24 Michael Niedermayer
        char *end= p + 1024*30;
1415 11f18faf Michael Niedermayer
        for(i=0; i<3; i++){
1416
            for(j=0; j<256; j++){
1417 4733abcb Måns Rullgård
                snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1418 11f18faf Michael Niedermayer
                p+= strlen(p);
1419
                s->stats[i][j]= 0;
1420
            }
1421 2fc8ea24 Michael Niedermayer
            snprintf(p, end-p, "\n");
1422 11f18faf Michael Niedermayer
            p++;
1423
        }
1424 390f9f31 Loren Merritt
    } else
1425
        avctx->stats_out[0] = '\0';
1426 09b0499f Michael Niedermayer
    if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
1427 152ba68c Michael Niedermayer
        flush_put_bits(&s->pb);
1428 3d2e8cce Michael Niedermayer
        s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1429 11f18faf Michael Niedermayer
    }
1430 115329f1 Diego Biurrun
1431 11f18faf Michael Niedermayer
    s->picture_number++;
1432 1e491e29 Michael Niedermayer
1433 11f18faf Michael Niedermayer
    return size*4;
1434
}
1435
1436 98a6fff9 Zuxy Meng
static av_cold int encode_end(AVCodecContext *avctx)
1437 11f18faf Michael Niedermayer
{
1438 0ecca7a4 Michael Niedermayer
    HYuvContext *s = avctx->priv_data;
1439 115329f1 Diego Biurrun
1440 0ecca7a4 Michael Niedermayer
    common_end(s);
1441 11f18faf Michael Niedermayer
1442
    av_freep(&avctx->extradata);
1443
    av_freep(&avctx->stats_out);
1444 115329f1 Diego Biurrun
1445 11f18faf Michael Niedermayer
    return 0;
1446
}
1447 b250f9c6 Aurelien Jacobs
#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
1448 11f18faf Michael Niedermayer
1449 b250f9c6 Aurelien Jacobs
#if CONFIG_HUFFYUV_DECODER
1450 11f18faf Michael Niedermayer
AVCodec huffyuv_decoder = {
1451
    "huffyuv",
1452
    CODEC_TYPE_VIDEO,
1453
    CODEC_ID_HUFFYUV,
1454
    sizeof(HYuvContext),
1455
    decode_init,
1456
    NULL,
1457
    decode_end,
1458
    decode_frame,
1459 7c5ab7b8 Michael Niedermayer
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1460 bcdb2378 Stefano Sabatini
    NULL,
1461 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1462 11f18faf Michael Niedermayer
};
1463 2a43a093 Diego Biurrun
#endif
1464 11f18faf Michael Niedermayer
1465 b250f9c6 Aurelien Jacobs
#if CONFIG_FFVHUFF_DECODER
1466 f37b9768 Loren Merritt
AVCodec ffvhuff_decoder = {
1467
    "ffvhuff",
1468
    CODEC_TYPE_VIDEO,
1469
    CODEC_ID_FFVHUFF,
1470
    sizeof(HYuvContext),
1471
    decode_init,
1472
    NULL,
1473
    decode_end,
1474
    decode_frame,
1475
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1476 bcdb2378 Stefano Sabatini
    NULL,
1477 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1478 f37b9768 Loren Merritt
};
1479 62bb489b Måns Rullgård
#endif
1480 f37b9768 Loren Merritt
1481 b250f9c6 Aurelien Jacobs
#if CONFIG_HUFFYUV_ENCODER
1482 11f18faf Michael Niedermayer
AVCodec huffyuv_encoder = {
1483
    "huffyuv",
1484
    CODEC_TYPE_VIDEO,
1485
    CODEC_ID_HUFFYUV,
1486
    sizeof(HYuvContext),
1487
    encode_init,
1488
    encode_frame,
1489
    encode_end,
1490 eacced45 Carl Eugen Hoyos
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
1491 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1492 11f18faf Michael Niedermayer
};
1493 f544a5fc Diego Biurrun
#endif
1494 5fd74135 Michael Niedermayer
1495 b250f9c6 Aurelien Jacobs
#if CONFIG_FFVHUFF_ENCODER
1496 f37b9768 Loren Merritt
AVCodec ffvhuff_encoder = {
1497
    "ffvhuff",
1498
    CODEC_TYPE_VIDEO,
1499
    CODEC_ID_FFVHUFF,
1500
    sizeof(HYuvContext),
1501
    encode_init,
1502
    encode_frame,
1503
    encode_end,
1504 eacced45 Carl Eugen Hoyos
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
1505 fe4bf374 Stefano Sabatini
    .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1506 f37b9768 Loren Merritt
};
1507 f544a5fc Diego Biurrun
#endif