Statistics
| Branch: | Revision:

ffmpeg / libavcodec / huffyuv.c @ b2755007

History | View | Annotate | Download (46.9 KB)

1
/*
2
 * huffyuv codec for libavcodec
3
 *
4
 * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
7
 * the algorithm used
8
 *
9
 * This file is part of FFmpeg.
10
 *
11
 * FFmpeg is free software; you can redistribute it and/or
12
 * modify it under the terms of the GNU Lesser General Public
13
 * License as published by the Free Software Foundation; either
14
 * version 2.1 of the License, or (at your option) any later version.
15
 *
16
 * FFmpeg is distributed in the hope that it will be useful,
17
 * 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
 * License along with FFmpeg; if not, write to the Free Software
23
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24
 */
25

    
26
/**
27
 * @file libavcodec/huffyuv.c
28
 * huffyuv codec for libavcodec.
29
 */
30

    
31
#include "avcodec.h"
32
#include "bitstream.h"
33
#include "put_bits.h"
34
#include "dsputil.h"
35

    
36
#define VLC_BITS 11
37

    
38
#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
typedef enum Predictor{
49
    LEFT= 0,
50
    PLANE,
51
    MEDIAN,
52
} Predictor;
53

    
54
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
    int context;
68
    int picture_number;
69
    int last_slice_end;
70
    uint8_t *temp[3];
71
    uint64_t stats[3][256];
72
    uint8_t len[3][256];
73
    uint32_t bits[3][256];
74
    uint32_t pix_bgr_map[1<<VLC_BITS];
75
    VLC vlc[6];                             //Y,U,V,YY,YU,YV
76
    AVFrame picture;
77
    uint8_t *bitstream_buffer;
78
    unsigned int bitstream_buffer_size;
79
    DSPContext dsp;
80
}HYuvContext;
81

    
82
static const unsigned char classic_shift_luma[] = {
83
  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
static const unsigned char classic_shift_chroma[] = {
89
  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
static const unsigned char classic_add_luma[256] = {
95
    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
static const unsigned char classic_add_chroma[256] = {
114
    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
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
        b+= src[4*i+B];
160
        g+= src[4*i+G];
161
        r+= src[4*i+R];
162

    
163
        dst[4*i+B]= b;
164
        dst[4*i+G]= g;
165
        dst[4*i+R]= r;
166
    }
167

    
168
    *red= r;
169
    *green= g;
170
    *blue= b;
171
}
172

    
173
static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
174
    int i;
175
    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
    }
191
}
192

    
193
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
static void read_len_table(uint8_t *dst, GetBitContext *gb){
217
    int i, val, repeat;
218

    
219
    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
        while (repeat--)
226
            dst[i++] = val;
227
    }
228
}
229

    
230
static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
231
    int len, index;
232
    uint32_t bits=0;
233

    
234
    for(len=32; len>0; len--){
235
        for(index=0; index<256; index++){
236
            if(len_table[index]==len)
237
                dst[index]= bits++;
238
        }
239
        if(bits & 1){
240
            av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
241
            return -1;
242
        }
243
        bits >>= 1;
244
    }
245
    return 0;
246
}
247

    
248
#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
249
typedef struct {
250
    uint64_t val;
251
    int name;
252
} HeapElem;
253

    
254
static void heap_sift(HeapElem *h, int root, int size)
255
{
256
    while(root*2+1 < size) {
257
        int child = root*2+1;
258
        if(child < size-1 && h[child].val > h[child+1].val)
259
            child++;
260
        if(h[root].val > h[child].val) {
261
            FFSWAP(HeapElem, h[root], h[child]);
262
            root = child;
263
        } else
264
            break;
265
    }
266
}
267

    
268
static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
269
    HeapElem h[size];
270
    int up[2*size];
271
    int len[2*size];
272
    int offset, i, next;
273

    
274
    for(offset=1; ; offset<<=1){
275
        for(i=0; i<size; i++){
276
            h[i].name = i;
277
            h[i].val = (stats[i] << 8) + offset;
278
        }
279
        for(i=size/2-1; i>=0; i--)
280
            heap_sift(h, i, size);
281

    
282
        for(next=size; next<size*2-1; next++){
283
            // merge the two smallest entries, and put it back in the heap
284
            uint64_t min1v = h[0].val;
285
            up[h[0].name] = next;
286
            h[0].val = INT64_MAX;
287
            heap_sift(h, 0, size);
288
            up[h[0].name] = next;
289
            h[0].name = next;
290
            h[0].val += min1v;
291
            heap_sift(h, 0, size);
292
        }
293

    
294
        len[2*size-2] = 0;
295
        for(i=2*size-3; i>=size; i--)
296
            len[i] = len[up[i]] + 1;
297
        for(i=0; i<size; i++) {
298
            dst[i] = len[up[i]] + 1;
299
            if(dst[i] >= 32) break;
300
        }
301
        if(i==size) break;
302
    }
303
}
304
#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
305

    
306
static void generate_joint_tables(HYuvContext *s){
307
    uint16_t symbols[1<<VLC_BITS];
308
    uint16_t bits[1<<VLC_BITS];
309
    uint8_t len[1<<VLC_BITS];
310
    if(s->bitstream_bpp < 24){
311
        int p, i, y, u;
312
        for(p=0; p<3; p++){
313
            for(i=y=0; y<256; y++){
314
                int len0 = s->len[0][y];
315
                int limit = VLC_BITS - len0;
316
                if(limit <= 0)
317
                    continue;
318
                for(u=0; u<256; u++){
319
                    int len1 = s->len[p][u];
320
                    if(len1 > limit)
321
                        continue;
322
                    len[i] = len0 + len1;
323
                    bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
324
                    symbols[i] = (y<<8) + u;
325
                    if(symbols[i] != 0xffff) // reserved to mean "invalid"
326
                        i++;
327
                }
328
            }
329
            free_vlc(&s->vlc[3+p]);
330
            init_vlc_sparse(&s->vlc[3+p], VLC_BITS, i, len, 1, 1, bits, 2, 2, symbols, 2, 2, 0);
331
        }
332
    }else{
333
        uint8_t (*map)[4] = (uint8_t(*)[4])s->pix_bgr_map;
334
        int i, b, g, r, code;
335
        int p0 = s->decorrelate;
336
        int p1 = !s->decorrelate;
337
        // restrict the range to +/-16 becaues that's pretty much guaranteed to
338
        // cover all the combinations that fit in 11 bits total, and it doesn't
339
        // matter if we miss a few rare codes.
340
        for(i=0, g=-16; g<16; g++){
341
            int len0 = s->len[p0][g&255];
342
            int limit0 = VLC_BITS - len0;
343
            if(limit0 < 2)
344
                continue;
345
            for(b=-16; b<16; b++){
346
                int len1 = s->len[p1][b&255];
347
                int limit1 = limit0 - len1;
348
                if(limit1 < 1)
349
                    continue;
350
                code = (s->bits[p0][g&255] << len1) + s->bits[p1][b&255];
351
                for(r=-16; r<16; r++){
352
                    int len2 = s->len[2][r&255];
353
                    if(len2 > limit1)
354
                        continue;
355
                    len[i] = len0 + len1 + len2;
356
                    bits[i] = (code << len2) + s->bits[2][r&255];
357
                    if(s->decorrelate){
358
                        map[i][G] = g;
359
                        map[i][B] = g+b;
360
                        map[i][R] = g+r;
361
                    }else{
362
                        map[i][B] = g;
363
                        map[i][G] = b;
364
                        map[i][R] = r;
365
                    }
366
                    i++;
367
                }
368
            }
369
        }
370
        free_vlc(&s->vlc[3]);
371
        init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);
372
    }
373
}
374

    
375
static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
376
    GetBitContext gb;
377
    int i;
378

    
379
    init_get_bits(&gb, src, length*8);
380

    
381
    for(i=0; i<3; i++){
382
        read_len_table(s->len[i], &gb);
383

    
384
        if(generate_bits_table(s->bits[i], s->len[i])<0){
385
            return -1;
386
        }
387
#if 0
388
for(j=0; j<256; j++){
389
printf("%6X, %2d,  %3d\n", s->bits[i][j], s->len[i][j], j);
390
}
391
#endif
392
        free_vlc(&s->vlc[i]);
393
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
394
    }
395

    
396
    generate_joint_tables(s);
397

    
398
    return (get_bits_count(&gb)+7)/8;
399
}
400

    
401
static int read_old_huffman_tables(HYuvContext *s){
402
#if 1
403
    GetBitContext gb;
404
    int i;
405

    
406
    init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
407
    read_len_table(s->len[0], &gb);
408
    init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
409
    read_len_table(s->len[1], &gb);
410

    
411
    for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
412
    for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
413

    
414
    if(s->bitstream_bpp >= 24){
415
        memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
416
        memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
417
    }
418
    memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
419
    memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
420

    
421
    for(i=0; i<3; i++){
422
        free_vlc(&s->vlc[i]);
423
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
424
    }
425

    
426
    generate_joint_tables(s);
427

    
428
    return 0;
429
#else
430
    av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
431
    return -1;
432
#endif
433
}
434

    
435
static av_cold void alloc_temp(HYuvContext *s){
436
    int i;
437

    
438
    if(s->bitstream_bpp<24){
439
        for(i=0; i<3; i++){
440
            s->temp[i]= av_malloc(s->width + 16);
441
        }
442
    }else{
443
        for(i=0; i<2; i++){
444
            s->temp[i]= av_malloc(4*s->width + 16);
445
        }
446
    }
447
}
448

    
449
static av_cold int common_init(AVCodecContext *avctx){
450
    HYuvContext *s = avctx->priv_data;
451

    
452
    s->avctx= avctx;
453
    s->flags= avctx->flags;
454

    
455
    dsputil_init(&s->dsp, avctx);
456

    
457
    s->width= avctx->width;
458
    s->height= avctx->height;
459
    assert(s->width>0 && s->height>0);
460

    
461
    return 0;
462
}
463

    
464
#if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
465
static av_cold int decode_init(AVCodecContext *avctx)
466
{
467
    HYuvContext *s = avctx->priv_data;
468

    
469
    common_init(avctx);
470
    memset(s->vlc, 0, 3*sizeof(VLC));
471

    
472
    avctx->coded_frame= &s->picture;
473
    s->interlaced= s->height > 288;
474

    
475
s->bgr32=1;
476
//if(avctx->extradata)
477
//  printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
478
    if(avctx->extradata_size){
479
        if((avctx->bits_per_coded_sample&7) && avctx->bits_per_coded_sample != 12)
480
            s->version=1; // do such files exist at all?
481
        else
482
            s->version=2;
483
    }else
484
        s->version=0;
485

    
486
    if(s->version==2){
487
        int method, interlace;
488

    
489
        method= ((uint8_t*)avctx->extradata)[0];
490
        s->decorrelate= method&64 ? 1 : 0;
491
        s->predictor= method&63;
492
        s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
493
        if(s->bitstream_bpp==0)
494
            s->bitstream_bpp= avctx->bits_per_coded_sample&~7;
495
        interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
496
        s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
497
        s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
498

    
499
        if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
500
            return -1;
501
    }else{
502
        switch(avctx->bits_per_coded_sample&7){
503
        case 1:
504
            s->predictor= LEFT;
505
            s->decorrelate= 0;
506
            break;
507
        case 2:
508
            s->predictor= LEFT;
509
            s->decorrelate= 1;
510
            break;
511
        case 3:
512
            s->predictor= PLANE;
513
            s->decorrelate= avctx->bits_per_coded_sample >= 24;
514
            break;
515
        case 4:
516
            s->predictor= MEDIAN;
517
            s->decorrelate= 0;
518
            break;
519
        default:
520
            s->predictor= LEFT; //OLD
521
            s->decorrelate= 0;
522
            break;
523
        }
524
        s->bitstream_bpp= avctx->bits_per_coded_sample & ~7;
525
        s->context= 0;
526

    
527
        if(read_old_huffman_tables(s) < 0)
528
            return -1;
529
    }
530

    
531
    switch(s->bitstream_bpp){
532
    case 12:
533
        avctx->pix_fmt = PIX_FMT_YUV420P;
534
        break;
535
    case 16:
536
        if(s->yuy2){
537
            avctx->pix_fmt = PIX_FMT_YUYV422;
538
        }else{
539
            avctx->pix_fmt = PIX_FMT_YUV422P;
540
        }
541
        break;
542
    case 24:
543
    case 32:
544
        if(s->bgr32){
545
            avctx->pix_fmt = PIX_FMT_RGB32;
546
        }else{
547
            avctx->pix_fmt = PIX_FMT_BGR24;
548
        }
549
        break;
550
    default:
551
        assert(0);
552
    }
553

    
554
    alloc_temp(s);
555

    
556
//    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);
557

    
558
    return 0;
559
}
560
#endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
561

    
562
#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
563
static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
564
    int i;
565
    int index= 0;
566

    
567
    for(i=0; i<256;){
568
        int val= len[i];
569
        int repeat=0;
570

    
571
        for(; i<256 && len[i]==val && repeat<255; i++)
572
            repeat++;
573

    
574
        assert(val < 32 && val >0 && repeat<256 && repeat>0);
575
        if(repeat>7){
576
            buf[index++]= val;
577
            buf[index++]= repeat;
578
        }else{
579
            buf[index++]= val | (repeat<<5);
580
        }
581
    }
582

    
583
    return index;
584
}
585

    
586
static av_cold int encode_init(AVCodecContext *avctx)
587
{
588
    HYuvContext *s = avctx->priv_data;
589
    int i, j;
590

    
591
    common_init(avctx);
592

    
593
    avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
594
    avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
595
    s->version=2;
596

    
597
    avctx->coded_frame= &s->picture;
598

    
599
    switch(avctx->pix_fmt){
600
    case PIX_FMT_YUV420P:
601
        s->bitstream_bpp= 12;
602
        break;
603
    case PIX_FMT_YUV422P:
604
        s->bitstream_bpp= 16;
605
        break;
606
    case PIX_FMT_RGB32:
607
        s->bitstream_bpp= 24;
608
        break;
609
    default:
610
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
611
        return -1;
612
    }
613
    avctx->bits_per_coded_sample= s->bitstream_bpp;
614
    s->decorrelate= s->bitstream_bpp >= 24;
615
    s->predictor= avctx->prediction_method;
616
    s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
617
    if(avctx->context_model==1){
618
        s->context= avctx->context_model;
619
        if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
620
            av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
621
            return -1;
622
        }
623
    }else s->context= 0;
624

    
625
    if(avctx->codec->id==CODEC_ID_HUFFYUV){
626
        if(avctx->pix_fmt==PIX_FMT_YUV420P){
627
            av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
628
            return -1;
629
        }
630
        if(avctx->context_model){
631
            av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
632
            return -1;
633
        }
634
        if(s->interlaced != ( s->height > 288 ))
635
            av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
636
    }
637

    
638
    if(s->bitstream_bpp>=24 && s->predictor==MEDIAN){
639
        av_log(avctx, AV_LOG_ERROR, "Error: RGB is incompatible with median predictor\n");
640
        return -1;
641
    }
642

    
643
    ((uint8_t*)avctx->extradata)[0]= s->predictor | (s->decorrelate << 6);
644
    ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
645
    ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
646
    if(s->context)
647
        ((uint8_t*)avctx->extradata)[2]|= 0x40;
648
    ((uint8_t*)avctx->extradata)[3]= 0;
649
    s->avctx->extradata_size= 4;
650

    
651
    if(avctx->stats_in){
652
        char *p= avctx->stats_in;
653

    
654
        for(i=0; i<3; i++)
655
            for(j=0; j<256; j++)
656
                s->stats[i][j]= 1;
657

    
658
        for(;;){
659
            for(i=0; i<3; i++){
660
                char *next;
661

    
662
                for(j=0; j<256; j++){
663
                    s->stats[i][j]+= strtol(p, &next, 0);
664
                    if(next==p) return -1;
665
                    p=next;
666
                }
667
            }
668
            if(p[0]==0 || p[1]==0 || p[2]==0) break;
669
        }
670
    }else{
671
        for(i=0; i<3; i++)
672
            for(j=0; j<256; j++){
673
                int d= FFMIN(j, 256-j);
674

    
675
                s->stats[i][j]= 100000000/(d+1);
676
            }
677
    }
678

    
679
    for(i=0; i<3; i++){
680
        generate_len_table(s->len[i], s->stats[i], 256);
681

    
682
        if(generate_bits_table(s->bits[i], s->len[i])<0){
683
            return -1;
684
        }
685

    
686
        s->avctx->extradata_size+=
687
        store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
688
    }
689

    
690
    if(s->context){
691
        for(i=0; i<3; i++){
692
            int pels = s->width*s->height / (i?40:10);
693
            for(j=0; j<256; j++){
694
                int d= FFMIN(j, 256-j);
695
                s->stats[i][j]= pels/(d+1);
696
            }
697
        }
698
    }else{
699
        for(i=0; i<3; i++)
700
            for(j=0; j<256; j++)
701
                s->stats[i][j]= 0;
702
    }
703

    
704
//    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_coded_sample, s->interlaced);
705

    
706
    alloc_temp(s);
707

    
708
    s->picture_number=0;
709

    
710
    return 0;
711
}
712
#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
713

    
714
/* TODO instead of restarting the read when the code isn't in the first level
715
 * of the joint table, jump into the 2nd level of the individual table. */
716
#define READ_2PIX(dst0, dst1, plane1){\
717
    uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
718
    if(code != 0xffff){\
719
        dst0 = code>>8;\
720
        dst1 = code;\
721
    }else{\
722
        dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
723
        dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
724
    }\
725
}
726

    
727
static void decode_422_bitstream(HYuvContext *s, int count){
728
    int i;
729

    
730
    count/=2;
731

    
732
    for(i=0; i<count; i++){
733
        READ_2PIX(s->temp[0][2*i  ], s->temp[1][i], 1);
734
        READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
735
    }
736
}
737

    
738
static void decode_gray_bitstream(HYuvContext *s, int count){
739
    int i;
740

    
741
    count/=2;
742

    
743
    for(i=0; i<count; i++){
744
        READ_2PIX(s->temp[0][2*i  ], s->temp[0][2*i+1], 0);
745
    }
746
}
747

    
748
#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
749
static int encode_422_bitstream(HYuvContext *s, int count){
750
    int i;
751

    
752
    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
753
        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
754
        return -1;
755
    }
756

    
757
#define LOAD4\
758
            int y0 = s->temp[0][2*i];\
759
            int y1 = s->temp[0][2*i+1];\
760
            int u0 = s->temp[1][i];\
761
            int v0 = s->temp[2][i];
762

    
763
    count/=2;
764
    if(s->flags&CODEC_FLAG_PASS1){
765
        for(i=0; i<count; i++){
766
            LOAD4;
767
            s->stats[0][y0]++;
768
            s->stats[1][u0]++;
769
            s->stats[0][y1]++;
770
            s->stats[2][v0]++;
771
        }
772
    }
773
    if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
774
        return 0;
775
    if(s->context){
776
        for(i=0; i<count; i++){
777
            LOAD4;
778
            s->stats[0][y0]++;
779
            put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
780
            s->stats[1][u0]++;
781
            put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
782
            s->stats[0][y1]++;
783
            put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
784
            s->stats[2][v0]++;
785
            put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
786
        }
787
    }else{
788
        for(i=0; i<count; i++){
789
            LOAD4;
790
            put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
791
            put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
792
            put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
793
            put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
794
        }
795
    }
796
    return 0;
797
}
798

    
799
static int encode_gray_bitstream(HYuvContext *s, int count){
800
    int i;
801

    
802
    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
803
        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
804
        return -1;
805
    }
806

    
807
#define LOAD2\
808
            int y0 = s->temp[0][2*i];\
809
            int y1 = s->temp[0][2*i+1];
810
#define STAT2\
811
            s->stats[0][y0]++;\
812
            s->stats[0][y1]++;
813
#define WRITE2\
814
            put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
815
            put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
816

    
817
    count/=2;
818
    if(s->flags&CODEC_FLAG_PASS1){
819
        for(i=0; i<count; i++){
820
            LOAD2;
821
            STAT2;
822
        }
823
    }
824
    if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
825
        return 0;
826

    
827
    if(s->context){
828
        for(i=0; i<count; i++){
829
            LOAD2;
830
            STAT2;
831
            WRITE2;
832
        }
833
    }else{
834
        for(i=0; i<count; i++){
835
            LOAD2;
836
            WRITE2;
837
        }
838
    }
839
    return 0;
840
}
841
#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
842

    
843
static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha){
844
    int i;
845
    for(i=0; i<count; i++){
846
        int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
847
        if(code != -1){
848
            *(uint32_t*)&s->temp[0][4*i] = s->pix_bgr_map[code];
849
        }else if(decorrelate){
850
            s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
851
            s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
852
            s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
853
        }else{
854
            s->temp[0][4*i+B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
855
            s->temp[0][4*i+G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
856
            s->temp[0][4*i+R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
857
        }
858
        if(alpha)
859
            get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
860
    }
861
}
862

    
863
static void decode_bgr_bitstream(HYuvContext *s, int count){
864
    if(s->decorrelate){
865
        if(s->bitstream_bpp==24)
866
            decode_bgr_1(s, count, 1, 0);
867
        else
868
            decode_bgr_1(s, count, 1, 1);
869
    }else{
870
        if(s->bitstream_bpp==24)
871
            decode_bgr_1(s, count, 0, 0);
872
        else
873
            decode_bgr_1(s, count, 0, 1);
874
    }
875
}
876

    
877
static int encode_bgr_bitstream(HYuvContext *s, int count){
878
    int i;
879

    
880
    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3*4*count){
881
        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
882
        return -1;
883
    }
884

    
885
#define LOAD3\
886
            int g= s->temp[0][4*i+G];\
887
            int b= (s->temp[0][4*i+B] - g) & 0xff;\
888
            int r= (s->temp[0][4*i+R] - g) & 0xff;
889
#define STAT3\
890
            s->stats[0][b]++;\
891
            s->stats[1][g]++;\
892
            s->stats[2][r]++;
893
#define WRITE3\
894
            put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
895
            put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
896
            put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
897

    
898
    if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
899
        for(i=0; i<count; i++){
900
            LOAD3;
901
            STAT3;
902
        }
903
    }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
904
        for(i=0; i<count; i++){
905
            LOAD3;
906
            STAT3;
907
            WRITE3;
908
        }
909
    }else{
910
        for(i=0; i<count; i++){
911
            LOAD3;
912
            WRITE3;
913
        }
914
    }
915
    return 0;
916
}
917

    
918
#if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
919
static void draw_slice(HYuvContext *s, int y){
920
    int h, cy;
921
    int offset[4];
922

    
923
    if(s->avctx->draw_horiz_band==NULL)
924
        return;
925

    
926
    h= y - s->last_slice_end;
927
    y -= h;
928

    
929
    if(s->bitstream_bpp==12){
930
        cy= y>>1;
931
    }else{
932
        cy= y;
933
    }
934

    
935
    offset[0] = s->picture.linesize[0]*y;
936
    offset[1] = s->picture.linesize[1]*cy;
937
    offset[2] = s->picture.linesize[2]*cy;
938
    offset[3] = 0;
939
    emms_c();
940

    
941
    s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
942

    
943
    s->last_slice_end= y + h;
944
}
945

    
946
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){
947
    const uint8_t *buf = avpkt->data;
948
    int buf_size = avpkt->size;
949
    HYuvContext *s = avctx->priv_data;
950
    const int width= s->width;
951
    const int width2= s->width>>1;
952
    const int height= s->height;
953
    int fake_ystride, fake_ustride, fake_vstride;
954
    AVFrame * const p= &s->picture;
955
    int table_size= 0;
956

    
957
    AVFrame *picture = data;
958

    
959
    s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
960

    
961
    s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (const uint32_t*)buf, buf_size/4);
962

    
963
    if(p->data[0])
964
        avctx->release_buffer(avctx, p);
965

    
966
    p->reference= 0;
967
    if(avctx->get_buffer(avctx, p) < 0){
968
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
969
        return -1;
970
    }
971

    
972
    if(s->context){
973
        table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
974
        if(table_size < 0)
975
            return -1;
976
    }
977

    
978
    if((unsigned)(buf_size-table_size) >= INT_MAX/8)
979
        return -1;
980

    
981
    init_get_bits(&s->gb, s->bitstream_buffer+table_size, (buf_size-table_size)*8);
982

    
983
    fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
984
    fake_ustride= s->interlaced ? p->linesize[1]*2  : p->linesize[1];
985
    fake_vstride= s->interlaced ? p->linesize[2]*2  : p->linesize[2];
986

    
987
    s->last_slice_end= 0;
988

    
989
    if(s->bitstream_bpp<24){
990
        int y, cy;
991
        int lefty, leftu, leftv;
992
        int lefttopy, lefttopu, lefttopv;
993

    
994
        if(s->yuy2){
995
            p->data[0][3]= get_bits(&s->gb, 8);
996
            p->data[0][2]= get_bits(&s->gb, 8);
997
            p->data[0][1]= get_bits(&s->gb, 8);
998
            p->data[0][0]= get_bits(&s->gb, 8);
999

    
1000
            av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
1001
            return -1;
1002
        }else{
1003

    
1004
            leftv= p->data[2][0]= get_bits(&s->gb, 8);
1005
            lefty= p->data[0][1]= get_bits(&s->gb, 8);
1006
            leftu= p->data[1][0]= get_bits(&s->gb, 8);
1007
                   p->data[0][0]= get_bits(&s->gb, 8);
1008

    
1009
            switch(s->predictor){
1010
            case LEFT:
1011
            case PLANE:
1012
                decode_422_bitstream(s, width-2);
1013
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1014
                if(!(s->flags&CODEC_FLAG_GRAY)){
1015
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1016
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1017
                }
1018

    
1019
                for(cy=y=1; y<s->height; y++,cy++){
1020
                    uint8_t *ydst, *udst, *vdst;
1021

    
1022
                    if(s->bitstream_bpp==12){
1023
                        decode_gray_bitstream(s, width);
1024

    
1025
                        ydst= p->data[0] + p->linesize[0]*y;
1026

    
1027
                        lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1028
                        if(s->predictor == PLANE){
1029
                            if(y>s->interlaced)
1030
                                s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1031
                        }
1032
                        y++;
1033
                        if(y>=s->height) break;
1034
                    }
1035

    
1036
                    draw_slice(s, y);
1037

    
1038
                    ydst= p->data[0] + p->linesize[0]*y;
1039
                    udst= p->data[1] + p->linesize[1]*cy;
1040
                    vdst= p->data[2] + p->linesize[2]*cy;
1041

    
1042
                    decode_422_bitstream(s, width);
1043
                    lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1044
                    if(!(s->flags&CODEC_FLAG_GRAY)){
1045
                        leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
1046
                        leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
1047
                    }
1048
                    if(s->predictor == PLANE){
1049
                        if(cy>s->interlaced){
1050
                            s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1051
                            if(!(s->flags&CODEC_FLAG_GRAY)){
1052
                                s->dsp.add_bytes(udst, udst - fake_ustride, width2);
1053
                                s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
1054
                            }
1055
                        }
1056
                    }
1057
                }
1058
                draw_slice(s, height);
1059

    
1060
                break;
1061
            case MEDIAN:
1062
                /* first line except first 2 pixels is left predicted */
1063
                decode_422_bitstream(s, width-2);
1064
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1065
                if(!(s->flags&CODEC_FLAG_GRAY)){
1066
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1067
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1068
                }
1069

    
1070
                cy=y=1;
1071

    
1072
                /* second line is left predicted for interlaced case */
1073
                if(s->interlaced){
1074
                    decode_422_bitstream(s, width);
1075
                    lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
1076
                    if(!(s->flags&CODEC_FLAG_GRAY)){
1077
                        leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1078
                        leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1079
                    }
1080
                    y++; cy++;
1081
                }
1082

    
1083
                /* next 4 pixels are left predicted too */
1084
                decode_422_bitstream(s, 4);
1085
                lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
1086
                if(!(s->flags&CODEC_FLAG_GRAY)){
1087
                    leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1088
                    leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1089
                }
1090

    
1091
                /* next line except the first 4 pixels is median predicted */
1092
                lefttopy= p->data[0][3];
1093
                decode_422_bitstream(s, width-4);
1094
                s->dsp.add_hfyu_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
1095
                if(!(s->flags&CODEC_FLAG_GRAY)){
1096
                    lefttopu= p->data[1][1];
1097
                    lefttopv= p->data[2][1];
1098
                    s->dsp.add_hfyu_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
1099
                    s->dsp.add_hfyu_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
1100
                }
1101
                y++; cy++;
1102

    
1103
                for(; y<height; y++,cy++){
1104
                    uint8_t *ydst, *udst, *vdst;
1105

    
1106
                    if(s->bitstream_bpp==12){
1107
                        while(2*cy > y){
1108
                            decode_gray_bitstream(s, width);
1109
                            ydst= p->data[0] + p->linesize[0]*y;
1110
                            s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1111
                            y++;
1112
                        }
1113
                        if(y>=height) break;
1114
                    }
1115
                    draw_slice(s, y);
1116

    
1117
                    decode_422_bitstream(s, width);
1118

    
1119
                    ydst= p->data[0] + p->linesize[0]*y;
1120
                    udst= p->data[1] + p->linesize[1]*cy;
1121
                    vdst= p->data[2] + p->linesize[2]*cy;
1122

    
1123
                    s->dsp.add_hfyu_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1124
                    if(!(s->flags&CODEC_FLAG_GRAY)){
1125
                        s->dsp.add_hfyu_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1126
                        s->dsp.add_hfyu_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1127
                    }
1128
                }
1129

    
1130
                draw_slice(s, height);
1131
                break;
1132
            }
1133
        }
1134
    }else{
1135
        int y;
1136
        int leftr, leftg, leftb;
1137
        const int last_line= (height-1)*p->linesize[0];
1138

    
1139
        if(s->bitstream_bpp==32){
1140
            skip_bits(&s->gb, 8);
1141
            leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1142
            leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1143
            leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1144
        }else{
1145
            leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1146
            leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1147
            leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1148
            skip_bits(&s->gb, 8);
1149
        }
1150

    
1151
        if(s->bgr32){
1152
            switch(s->predictor){
1153
            case LEFT:
1154
            case PLANE:
1155
                decode_bgr_bitstream(s, width-1);
1156
                add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
1157

    
1158
                for(y=s->height-2; y>=0; y--){ //Yes it is stored upside down.
1159
                    decode_bgr_bitstream(s, width);
1160

    
1161
                    add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
1162
                    if(s->predictor == PLANE){
1163
                        if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
1164
                            s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
1165
                                             p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
1166
                        }
1167
                    }
1168
                }
1169
                draw_slice(s, height); // just 1 large slice as this is not possible in reverse order
1170
                break;
1171
            default:
1172
                av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
1173
            }
1174
        }else{
1175

    
1176
            av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
1177
            return -1;
1178
        }
1179
    }
1180
    emms_c();
1181

    
1182
    *picture= *p;
1183
    *data_size = sizeof(AVFrame);
1184

    
1185
    return (get_bits_count(&s->gb)+31)/32*4 + table_size;
1186
}
1187
#endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1188

    
1189
static int common_end(HYuvContext *s){
1190
    int i;
1191

    
1192
    for(i=0; i<3; i++){
1193
        av_freep(&s->temp[i]);
1194
    }
1195
    return 0;
1196
}
1197

    
1198
#if CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER
1199
static av_cold int decode_end(AVCodecContext *avctx)
1200
{
1201
    HYuvContext *s = avctx->priv_data;
1202
    int i;
1203

    
1204
    common_end(s);
1205
    av_freep(&s->bitstream_buffer);
1206

    
1207
    for(i=0; i<6; i++){
1208
        free_vlc(&s->vlc[i]);
1209
    }
1210

    
1211
    return 0;
1212
}
1213
#endif /* CONFIG_HUFFYUV_DECODER || CONFIG_FFVHUFF_DECODER */
1214

    
1215
#if CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER
1216
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1217
    HYuvContext *s = avctx->priv_data;
1218
    AVFrame *pict = data;
1219
    const int width= s->width;
1220
    const int width2= s->width>>1;
1221
    const int height= s->height;
1222
    const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
1223
    const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
1224
    const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
1225
    AVFrame * const p= &s->picture;
1226
    int i, j, size=0;
1227

    
1228
    *p = *pict;
1229
    p->pict_type= FF_I_TYPE;
1230
    p->key_frame= 1;
1231

    
1232
    if(s->context){
1233
        for(i=0; i<3; i++){
1234
            generate_len_table(s->len[i], s->stats[i], 256);
1235
            if(generate_bits_table(s->bits[i], s->len[i])<0)
1236
                return -1;
1237
            size+= store_table(s, s->len[i], &buf[size]);
1238
        }
1239

    
1240
        for(i=0; i<3; i++)
1241
            for(j=0; j<256; j++)
1242
                s->stats[i][j] >>= 1;
1243
    }
1244

    
1245
    init_put_bits(&s->pb, buf+size, buf_size-size);
1246

    
1247
    if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1248
        int lefty, leftu, leftv, y, cy;
1249

    
1250
        put_bits(&s->pb, 8, leftv= p->data[2][0]);
1251
        put_bits(&s->pb, 8, lefty= p->data[0][1]);
1252
        put_bits(&s->pb, 8, leftu= p->data[1][0]);
1253
        put_bits(&s->pb, 8,        p->data[0][0]);
1254

    
1255
        lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
1256
        leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
1257
        leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
1258

    
1259
        encode_422_bitstream(s, width-2);
1260

    
1261
        if(s->predictor==MEDIAN){
1262
            int lefttopy, lefttopu, lefttopv;
1263
            cy=y=1;
1264
            if(s->interlaced){
1265
                lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1266
                leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1267
                leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
1268

    
1269
                encode_422_bitstream(s, width);
1270
                y++; cy++;
1271
            }
1272

    
1273
            lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
1274
            leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1275
            leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
1276

    
1277
            encode_422_bitstream(s, 4);
1278

    
1279
            lefttopy= p->data[0][3];
1280
            lefttopu= p->data[1][1];
1281
            lefttopv= p->data[2][1];
1282
            s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1283
            s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1284
            s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
1285
            encode_422_bitstream(s, width-4);
1286
            y++; cy++;
1287

    
1288
            for(; y<height; y++,cy++){
1289
                uint8_t *ydst, *udst, *vdst;
1290

    
1291
                if(s->bitstream_bpp==12){
1292
                    while(2*cy > y){
1293
                        ydst= p->data[0] + p->linesize[0]*y;
1294
                        s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1295
                        encode_gray_bitstream(s, width);
1296
                        y++;
1297
                    }
1298
                    if(y>=height) break;
1299
                }
1300
                ydst= p->data[0] + p->linesize[0]*y;
1301
                udst= p->data[1] + p->linesize[1]*cy;
1302
                vdst= p->data[2] + p->linesize[2]*cy;
1303

    
1304
                s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1305
                s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1306
                s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1307

    
1308
                encode_422_bitstream(s, width);
1309
            }
1310
        }else{
1311
            for(cy=y=1; y<height; y++,cy++){
1312
                uint8_t *ydst, *udst, *vdst;
1313

    
1314
                /* encode a luma only line & y++ */
1315
                if(s->bitstream_bpp==12){
1316
                    ydst= p->data[0] + p->linesize[0]*y;
1317

    
1318
                    if(s->predictor == PLANE && s->interlaced < y){
1319
                        s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1320

    
1321
                        lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1322
                    }else{
1323
                        lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1324
                    }
1325
                    encode_gray_bitstream(s, width);
1326
                    y++;
1327
                    if(y>=height) break;
1328
                }
1329

    
1330
                ydst= p->data[0] + p->linesize[0]*y;
1331
                udst= p->data[1] + p->linesize[1]*cy;
1332
                vdst= p->data[2] + p->linesize[2]*cy;
1333

    
1334
                if(s->predictor == PLANE && s->interlaced < cy){
1335
                    s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1336
                    s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1337
                    s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
1338

    
1339
                    lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1340
                    leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1341
                    leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
1342
                }else{
1343
                    lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1344
                    leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1345
                    leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1346
                }
1347

    
1348
                encode_422_bitstream(s, width);
1349
            }
1350
        }
1351
    }else if(avctx->pix_fmt == PIX_FMT_RGB32){
1352
        uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
1353
        const int stride = -p->linesize[0];
1354
        const int fake_stride = -fake_ystride;
1355
        int y;
1356
        int leftr, leftg, leftb;
1357

    
1358
        put_bits(&s->pb, 8, leftr= data[R]);
1359
        put_bits(&s->pb, 8, leftg= data[G]);
1360
        put_bits(&s->pb, 8, leftb= data[B]);
1361
        put_bits(&s->pb, 8, 0);
1362

    
1363
        sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
1364
        encode_bgr_bitstream(s, width-1);
1365

    
1366
        for(y=1; y<s->height; y++){
1367
            uint8_t *dst = data + y*stride;
1368
            if(s->predictor == PLANE && s->interlaced < y){
1369
                s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
1370
                sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
1371
            }else{
1372
                sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
1373
            }
1374
            encode_bgr_bitstream(s, width);
1375
        }
1376
    }else{
1377
        av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1378
    }
1379
    emms_c();
1380

    
1381
    size+= (put_bits_count(&s->pb)+31)/8;
1382
    put_bits(&s->pb, 16, 0);
1383
    put_bits(&s->pb, 15, 0);
1384
    size/= 4;
1385

    
1386
    if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1387
        int j;
1388
        char *p= avctx->stats_out;
1389
        char *end= p + 1024*30;
1390
        for(i=0; i<3; i++){
1391
            for(j=0; j<256; j++){
1392
                snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1393
                p+= strlen(p);
1394
                s->stats[i][j]= 0;
1395
            }
1396
            snprintf(p, end-p, "\n");
1397
            p++;
1398
        }
1399
    } else
1400
        avctx->stats_out[0] = '\0';
1401
    if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
1402
        flush_put_bits(&s->pb);
1403
        s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1404
    }
1405

    
1406
    s->picture_number++;
1407

    
1408
    return size*4;
1409
}
1410

    
1411
static av_cold int encode_end(AVCodecContext *avctx)
1412
{
1413
    HYuvContext *s = avctx->priv_data;
1414

    
1415
    common_end(s);
1416

    
1417
    av_freep(&avctx->extradata);
1418
    av_freep(&avctx->stats_out);
1419

    
1420
    return 0;
1421
}
1422
#endif /* CONFIG_HUFFYUV_ENCODER || CONFIG_FFVHUFF_ENCODER */
1423

    
1424
#if CONFIG_HUFFYUV_DECODER
1425
AVCodec huffyuv_decoder = {
1426
    "huffyuv",
1427
    CODEC_TYPE_VIDEO,
1428
    CODEC_ID_HUFFYUV,
1429
    sizeof(HYuvContext),
1430
    decode_init,
1431
    NULL,
1432
    decode_end,
1433
    decode_frame,
1434
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1435
    NULL,
1436
    .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1437
};
1438
#endif
1439

    
1440
#if CONFIG_FFVHUFF_DECODER
1441
AVCodec ffvhuff_decoder = {
1442
    "ffvhuff",
1443
    CODEC_TYPE_VIDEO,
1444
    CODEC_ID_FFVHUFF,
1445
    sizeof(HYuvContext),
1446
    decode_init,
1447
    NULL,
1448
    decode_end,
1449
    decode_frame,
1450
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1451
    NULL,
1452
    .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1453
};
1454
#endif
1455

    
1456
#if CONFIG_HUFFYUV_ENCODER
1457
AVCodec huffyuv_encoder = {
1458
    "huffyuv",
1459
    CODEC_TYPE_VIDEO,
1460
    CODEC_ID_HUFFYUV,
1461
    sizeof(HYuvContext),
1462
    encode_init,
1463
    encode_frame,
1464
    encode_end,
1465
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
1466
    .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1467
};
1468
#endif
1469

    
1470
#if CONFIG_FFVHUFF_ENCODER
1471
AVCodec ffvhuff_encoder = {
1472
    "ffvhuff",
1473
    CODEC_TYPE_VIDEO,
1474
    CODEC_ID_FFVHUFF,
1475
    sizeof(HYuvContext),
1476
    encode_init,
1477
    encode_frame,
1478
    encode_end,
1479
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, PIX_FMT_NONE},
1480
    .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1481
};
1482
#endif