Statistics
| Branch: | Revision:

ffmpeg / libavcodec / huffyuv.c @ ab35de18

History | View | Annotate | Download (36.3 KB)

1
/*
2
 * huffyuv codec for libavcodec
3
 *
4
 * Copyright (c) 2002-2003 Michael Niedermayer <michaelni@gmx.at>
5
 *
6
 * This library is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU Lesser General Public
8
 * License as published by the Free Software Foundation; either
9
 * version 2 of the License, or (at your option) any later version.
10
 *
11
 * This library is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14
 * Lesser General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU Lesser General Public
17
 * License along with this library; if not, write to the Free Software
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 *
20
 * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
21
 * the algorithm used 
22
 */
23
 
24
/**
25
 * @file huffyuv.c
26
 * huffyuv codec for libavcodec.
27
 */
28

    
29
#include "common.h"
30
#include "avcodec.h"
31
#include "dsputil.h"
32

    
33
#define VLC_BITS 11
34

    
35
typedef enum Predictor{
36
    LEFT= 0,
37
    PLANE,
38
    MEDIAN,
39
} Predictor;
40
 
41
typedef struct HYuvContext{
42
    AVCodecContext *avctx;
43
    Predictor predictor;
44
    GetBitContext gb;
45
    PutBitContext pb;
46
    int interlaced;
47
    int decorrelate;
48
    int bitstream_bpp;
49
    int version;
50
    int yuy2;                               //use yuy2 instead of 422P
51
    int bgr32;                              //use bgr32 instead of bgr24
52
    int width, height;
53
    int flags;
54
    int picture_number;
55
    int last_slice_end;
56
    uint8_t __align8 temp[3][2560];
57
    uint64_t stats[3][256];
58
    uint8_t len[3][256];
59
    uint32_t bits[3][256];
60
    VLC vlc[3];
61
    AVFrame picture;
62
    uint8_t __align8 bitstream_buffer[1024*1024*3]; //FIXME dynamic alloc or some other solution
63
    DSPContext dsp; 
64
}HYuvContext;
65

    
66
static const unsigned char classic_shift_luma[] = {
67
  34,36,35,69,135,232,9,16,10,24,11,23,12,16,13,10,14,8,15,8,
68
  16,8,17,20,16,10,207,206,205,236,11,8,10,21,9,23,8,8,199,70,
69
  69,68, 0
70
};
71

    
72
static const unsigned char classic_shift_chroma[] = {
73
  66,36,37,38,39,40,41,75,76,77,110,239,144,81,82,83,84,85,118,183,
74
  56,57,88,89,56,89,154,57,58,57,26,141,57,56,58,57,58,57,184,119,
75
  214,245,116,83,82,49,80,79,78,77,44,75,41,40,39,38,37,36,34, 0
76
};
77

    
78
static const unsigned char classic_add_luma[256] = {
79
    3,  9,  5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
80
   73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
81
   68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
82
   35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
83
   37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
84
   35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
85
   27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
86
   15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
87
   12, 17, 19, 13,  4,  9,  2, 11,  1,  7,  8,  0, 16,  3, 14,  6,
88
   12, 10,  5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
89
   18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
90
   28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
91
   28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
92
   62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
93
   54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
94
   46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13,  7,  8,
95
};
96

    
97
static const unsigned char classic_add_chroma[256] = {
98
    3,  1,  2,  2,  2,  2,  3,  3,  7,  5,  7,  5,  8,  6, 11,  9,
99
    7, 13, 11, 10,  9,  8,  7,  5,  9,  7,  6,  4,  7,  5,  8,  7,
100
   11,  8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
101
   43, 45, 76, 81, 46, 82, 75, 55, 56,144, 58, 80, 60, 74,147, 63,
102
  143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
103
   80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
104
   17, 14,  5,  6,100, 54, 47, 50, 51, 53,106,107,108,109,110,111,
105
  112,113,114,115,  4,117,118, 92, 94,121,122,  3,124,103,  2,  1,
106
    0,129,130,131,120,119,126,125,136,137,138,139,140,141,142,134,
107
  135,132,133,104, 64,101, 62, 57,102, 95, 93, 59, 61, 28, 97, 96,
108
   52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
109
   19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10,  9,  8, 36,
110
    7,128,127,105,123,116, 35, 34, 33,145, 31, 79, 42,146, 78, 26,
111
   83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
112
   14, 16, 17, 18, 20, 21, 12, 14, 15,  9, 10,  6,  9,  6,  5,  8,
113
    6, 12,  8, 10,  7,  9,  6,  4,  6,  2,  2,  3,  3,  3,  3,  2,
114
};
115

    
116
static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
117
    int i;
118

    
119
    for(i=0; i<w-1; i++){
120
        acc+= src[i];
121
        dst[i]= acc;
122
        i++;
123
        acc+= src[i];
124
        dst[i]= acc;
125
    }
126

    
127
    for(; i<w; i++){
128
        acc+= src[i];
129
        dst[i]= acc;
130
    }
131

    
132
    return acc;
133
}
134

    
135
static inline void add_median_prediction(uint8_t *dst, uint8_t *src1, uint8_t *diff, int w, int *left, int *left_top){
136
    int i;
137
    uint8_t l, lt;
138

    
139
    l= *left;
140
    lt= *left_top;
141

    
142
    for(i=0; i<w; i++){
143
        l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
144
        lt= src1[i];
145
        dst[i]= l;
146
    }    
147

    
148
    *left= l;
149
    *left_top= lt;
150
}
151

    
152
static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
153
    int i;
154
    int r,g,b;
155
    r= *red;
156
    g= *green;
157
    b= *blue;
158

    
159
    for(i=0; i<w; i++){
160
        b+= src[4*i+0];
161
        g+= src[4*i+1];
162
        r+= src[4*i+2];
163
        
164
        dst[4*i+0]= b;
165
        dst[4*i+1]= g;
166
        dst[4*i+2]= r;
167
    }
168

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

    
174
static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
175
    int i;
176
    if(w<32){
177
        for(i=0; i<w; i++){
178
            const int temp= src[i];
179
            dst[i]= temp - left;
180
            left= temp;
181
        }
182
        return left;
183
    }else{
184
        for(i=0; i<16; i++){
185
            const int temp= src[i];
186
            dst[i]= temp - left;
187
            left= temp;
188
        }
189
        s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
190
        return src[w-1];
191
    }
192
}
193

    
194
static void read_len_table(uint8_t *dst, GetBitContext *gb){
195
    int i, val, repeat;
196
  
197
    for(i=0; i<256;){
198
        repeat= get_bits(gb, 3);
199
        val   = get_bits(gb, 5);
200
        if(repeat==0)
201
            repeat= get_bits(gb, 8);
202
//printf("%d %d\n", val, repeat);
203
        while (repeat--)
204
            dst[i++] = val;
205
    }
206
}
207

    
208
static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
209
    int len, index;
210
    uint32_t bits=0;
211

    
212
    for(len=32; len>0; len--){
213
        for(index=0; index<256; index++){
214
            if(len_table[index]==len)
215
                dst[index]= bits++;
216
        }
217
        if(bits & 1){
218
            av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
219
            return -1;
220
        }
221
        bits >>= 1;
222
    }
223
    return 0;
224
}
225

    
226
static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
227
    uint64_t counts[2*size];
228
    int up[2*size];
229
    int offset, i, next;
230
    
231
    for(offset=1; ; offset<<=1){
232
        for(i=0; i<size; i++){
233
            counts[i]= stats[i] + offset - 1;
234
        }
235
        
236
        for(next=size; next<size*2; next++){
237
            uint64_t min1, min2;
238
            int min1_i, min2_i;
239
            
240
            min1=min2= INT64_MAX;
241
            min1_i= min2_i=-1;
242
            
243
            for(i=0; i<next; i++){
244
                if(min2 > counts[i]){
245
                    if(min1 > counts[i]){
246
                        min2= min1;
247
                        min2_i= min1_i;
248
                        min1= counts[i];
249
                        min1_i= i;
250
                    }else{
251
                        min2= counts[i];
252
                        min2_i= i;
253
                    }
254
                }
255
            }
256
            
257
            if(min2==INT64_MAX) break;
258
            
259
            counts[next]= min1 + min2;
260
            counts[min1_i]=
261
            counts[min2_i]= INT64_MAX;
262
            up[min1_i]=
263
            up[min2_i]= next;
264
            up[next]= -1;
265
        }
266
        
267
        for(i=0; i<size; i++){
268
            int len;
269
            int index=i;
270
            
271
            for(len=0; up[index] != -1; len++)
272
                index= up[index];
273
                
274
            if(len > 32) break;
275
            
276
            dst[i]= len;
277
        }
278
        if(i==size) break;
279
    }
280
}
281

    
282
static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
283
    GetBitContext gb;
284
    int i;
285
    
286
    init_get_bits(&gb, src, length*8);
287
    
288
    for(i=0; i<3; i++){
289
        read_len_table(s->len[i], &gb);
290
        
291
        if(generate_bits_table(s->bits[i], s->len[i])<0){
292
            return -1;
293
        }
294
#if 0
295
for(j=0; j<256; j++){
296
printf("%6X, %2d,  %3d\n", s->bits[i][j], s->len[i][j], j);
297
}
298
#endif
299
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4);
300
    }
301
    
302
    return 0;
303
}
304

    
305
static int read_old_huffman_tables(HYuvContext *s){
306
#if 1
307
    GetBitContext gb;
308
    int i;
309

    
310
    init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
311
    read_len_table(s->len[0], &gb);
312
    init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
313
    read_len_table(s->len[1], &gb);
314
    
315
    for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
316
    for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
317

    
318
    if(s->bitstream_bpp >= 24){
319
        memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
320
        memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
321
    }
322
    memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
323
    memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
324
    
325
    for(i=0; i<3; i++)
326
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4);
327
    
328
    return 0;
329
#else
330
    fprintf(stderr, "v1 huffyuv is not supported \n");
331
    return -1;
332
#endif
333
}
334

    
335
static int decode_init(AVCodecContext *avctx)
336
{
337
    HYuvContext *s = avctx->priv_data;
338
    int width, height;
339

    
340
    s->avctx= avctx;
341
    s->flags= avctx->flags;
342
        
343
    dsputil_init(&s->dsp, avctx);
344
    
345
    width= s->width= avctx->width;
346
    height= s->height= avctx->height;
347
    avctx->coded_frame= &s->picture;
348

    
349
s->bgr32=1;
350
    assert(width && height);
351
//if(avctx->extradata)
352
//  printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
353
    if(avctx->extradata_size){
354
        if((avctx->bits_per_sample&7) && avctx->bits_per_sample != 12)
355
            s->version=1; // do such files exist at all?
356
        else
357
            s->version=2;
358
    }else
359
        s->version=0;
360
    
361
    if(s->version==2){
362
        int method;
363

    
364
        method= ((uint8_t*)avctx->extradata)[0];
365
        s->decorrelate= method&64 ? 1 : 0;
366
        s->predictor= method&63;
367
        s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
368
        if(s->bitstream_bpp==0) 
369
            s->bitstream_bpp= avctx->bits_per_sample&~7;
370
            
371
        if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
372
            return -1;
373
    }else{
374
        switch(avctx->bits_per_sample&7){
375
        case 1:
376
            s->predictor= LEFT;
377
            s->decorrelate= 0;
378
            break;
379
        case 2:
380
            s->predictor= LEFT;
381
            s->decorrelate= 1;
382
            break;
383
        case 3:
384
            s->predictor= PLANE;
385
            s->decorrelate= avctx->bits_per_sample >= 24;
386
            break;
387
        case 4:
388
            s->predictor= MEDIAN;
389
            s->decorrelate= 0;
390
            break;
391
        default:
392
            s->predictor= LEFT; //OLD
393
            s->decorrelate= 0;
394
            break;
395
        }
396
        s->bitstream_bpp= avctx->bits_per_sample & ~7;
397
        
398
        if(read_old_huffman_tables(s) < 0)
399
            return -1;
400
    }
401
    
402
    s->interlaced= height > 288;
403
    
404
    switch(s->bitstream_bpp){
405
    case 12:
406
        avctx->pix_fmt = PIX_FMT_YUV420P;
407
        break;
408
    case 16:
409
        if(s->yuy2){
410
            avctx->pix_fmt = PIX_FMT_YUV422;
411
        }else{
412
            avctx->pix_fmt = PIX_FMT_YUV422P;
413
        }
414
        break;
415
    case 24:
416
    case 32:
417
        if(s->bgr32){
418
            avctx->pix_fmt = PIX_FMT_RGBA32;
419
        }else{
420
            avctx->pix_fmt = PIX_FMT_BGR24;
421
        }
422
        break;
423
    default:
424
        assert(0);
425
    }
426
    
427
//    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
428
    
429
    return 0;
430
}
431

    
432
static void store_table(HYuvContext *s, uint8_t *len){
433
    int i;
434
    int index= s->avctx->extradata_size;
435

    
436
    for(i=0; i<256;){
437
        int val= len[i];
438
        int repeat=0;
439
        
440
        for(; i<256 && len[i]==val && repeat<255; i++)
441
            repeat++;
442
        
443
        assert(val < 32 && val >0 && repeat<256 && repeat>0);
444
        if(repeat>7){
445
            ((uint8_t*)s->avctx->extradata)[index++]= val;
446
            ((uint8_t*)s->avctx->extradata)[index++]= repeat;
447
        }else{
448
            ((uint8_t*)s->avctx->extradata)[index++]= val | (repeat<<5);
449
        }
450
    }
451
    
452
    s->avctx->extradata_size= index;
453
}
454

    
455
static int encode_init(AVCodecContext *avctx)
456
{
457
    HYuvContext *s = avctx->priv_data;
458
    int i, j, width, height;
459

    
460
    s->avctx= avctx;
461
    s->flags= avctx->flags;
462
        
463
    dsputil_init(&s->dsp, avctx);
464
    
465
    width= s->width= avctx->width;
466
    height= s->height= avctx->height;
467
    
468
    assert(width && height);
469
    
470
    avctx->extradata= av_mallocz(1024*30);
471
    avctx->stats_out= av_mallocz(1024*30);
472
    s->version=2;
473
    
474
    avctx->coded_frame= &s->picture;
475
    
476
    switch(avctx->pix_fmt){
477
    case PIX_FMT_YUV420P:
478
        s->bitstream_bpp= 12;
479
        break;
480
    case PIX_FMT_YUV422P:
481
        s->bitstream_bpp= 16;
482
        break;
483
    default:
484
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
485
        return -1;
486
    }
487
    avctx->bits_per_sample= s->bitstream_bpp;
488
    s->decorrelate= s->bitstream_bpp >= 24;
489
    s->predictor= avctx->prediction_method;
490
    
491
    ((uint8_t*)avctx->extradata)[0]= s->predictor;
492
    ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
493
    ((uint8_t*)avctx->extradata)[2]=
494
    ((uint8_t*)avctx->extradata)[3]= 0;
495
    s->avctx->extradata_size= 4;
496
    
497
    if(avctx->stats_in){
498
        char *p= avctx->stats_in;
499
    
500
        for(i=0; i<3; i++)
501
            for(j=0; j<256; j++)
502
                s->stats[i][j]= 1;
503

    
504
        for(;;){
505
            for(i=0; i<3; i++){
506
                char *next;
507

    
508
                for(j=0; j<256; j++){
509
                    s->stats[i][j]+= strtol(p, &next, 0);
510
                    if(next==p) return -1;
511
                    p=next;
512
                }        
513
            }
514
            if(p[0]==0 || p[1]==0 || p[2]==0) break;
515
        }
516
    }else{
517
        for(i=0; i<3; i++)
518
            for(j=0; j<256; j++){
519
                int d= FFMIN(j, 256-j);
520
                
521
                s->stats[i][j]= 100000000/(d+1);
522
            }
523
    }
524
    
525
    for(i=0; i<3; i++){
526
        generate_len_table(s->len[i], s->stats[i], 256);
527

    
528
        if(generate_bits_table(s->bits[i], s->len[i])<0){
529
            return -1;
530
        }
531
        
532
        store_table(s, s->len[i]);
533
    }
534

    
535
    for(i=0; i<3; i++)
536
        for(j=0; j<256; j++)
537
            s->stats[i][j]= 0;
538
    
539
    s->interlaced= height > 288;
540

    
541
//    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
542

    
543
    s->picture_number=0;
544

    
545
    return 0;
546
}
547

    
548
static void decode_422_bitstream(HYuvContext *s, int count){
549
    int i;
550

    
551
    count/=2;
552
    
553
    for(i=0; i<count; i++){
554
        s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
555
        s->temp[1][  i  ]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
556
        s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
557
        s->temp[2][  i  ]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
558
    }
559
}
560

    
561
static void decode_gray_bitstream(HYuvContext *s, int count){
562
    int i;
563
    
564
    count/=2;
565
    
566
    for(i=0; i<count; i++){
567
        s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
568
        s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
569
    }
570
}
571

    
572
static void encode_422_bitstream(HYuvContext *s, int count){
573
    int i;
574
    
575
    count/=2;
576
    if(s->flags&CODEC_FLAG_PASS1){
577
        for(i=0; i<count; i++){
578
            s->stats[0][ s->temp[0][2*i  ] ]++;
579
            s->stats[1][ s->temp[1][  i  ] ]++;
580
            s->stats[0][ s->temp[0][2*i+1] ]++;
581
            s->stats[2][ s->temp[2][  i  ] ]++;
582
        }
583
    }else{
584
        for(i=0; i<count; i++){
585
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
586
            put_bits(&s->pb, s->len[1][ s->temp[1][  i  ] ], s->bits[1][ s->temp[1][  i  ] ]);
587
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
588
            put_bits(&s->pb, s->len[2][ s->temp[2][  i  ] ], s->bits[2][ s->temp[2][  i  ] ]);
589
        }
590
    }
591
}
592

    
593
static void encode_gray_bitstream(HYuvContext *s, int count){
594
    int i;
595
    
596
    count/=2;
597
    if(s->flags&CODEC_FLAG_PASS1){
598
        for(i=0; i<count; i++){
599
            s->stats[0][ s->temp[0][2*i  ] ]++;
600
            s->stats[0][ s->temp[0][2*i+1] ]++;
601
        }
602
    }else{
603
        for(i=0; i<count; i++){
604
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
605
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
606
        }
607
    }
608
}
609

    
610
static void decode_bgr_bitstream(HYuvContext *s, int count){
611
    int i;
612

    
613
    if(s->decorrelate){
614
        if(s->bitstream_bpp==24){
615
            for(i=0; i<count; i++){
616
                s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
617
                s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+1];
618
                s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+1];
619
            }
620
        }else{
621
            for(i=0; i<count; i++){
622
                s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
623
                s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+1];
624
                s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+1]; 
625
                                   get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
626
            }
627
        }
628
    }else{
629
        if(s->bitstream_bpp==24){
630
            for(i=0; i<count; i++){
631
                s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
632
                s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
633
                s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
634
            }
635
        }else{
636
            for(i=0; i<count; i++){
637
                s->temp[0][4*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
638
                s->temp[0][4*i+1]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
639
                s->temp[0][4*i+2]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
640
                                   get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
641
            }
642
        }
643
    }
644
}
645

    
646
static void draw_slice(HYuvContext *s, int y){
647
    int h, cy;
648
    int offset[4];
649
    
650
    if(s->avctx->draw_horiz_band==NULL) 
651
        return;
652
        
653
    h= y - s->last_slice_end;
654
    y -= h;
655
    
656
    if(s->bitstream_bpp==12){
657
        cy= y>>1;
658
    }else{
659
        cy= y;
660
    }
661

    
662
    offset[0] = s->picture.linesize[0]*y;
663
    offset[1] = s->picture.linesize[1]*cy;
664
    offset[2] = s->picture.linesize[2]*cy;
665
    offset[3] = 0;
666
    emms_c();
667

    
668
    s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
669
    
670
    s->last_slice_end= y + h;
671
}
672

    
673
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
674
    HYuvContext *s = avctx->priv_data;
675
    const int width= s->width;
676
    const int width2= s->width>>1;
677
    const int height= s->height;
678
    int fake_ystride, fake_ustride, fake_vstride;
679
    AVFrame * const p= &s->picture;
680

    
681
    AVFrame *picture = data;
682

    
683
    /* no supplementary picture */
684
    if (buf_size == 0)
685
        return 0;
686

    
687
    s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4);
688
    
689
    init_get_bits(&s->gb, s->bitstream_buffer, buf_size*8);
690

    
691
    if(p->data[0])
692
        avctx->release_buffer(avctx, p);
693

    
694
    p->reference= 0;
695
    if(avctx->get_buffer(avctx, p) < 0){
696
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
697
        return -1;
698
    }
699

    
700
    fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
701
    fake_ustride= s->interlaced ? p->linesize[1]*2  : p->linesize[1];
702
    fake_vstride= s->interlaced ? p->linesize[2]*2  : p->linesize[2];
703
    
704
    s->last_slice_end= 0;
705
        
706
    if(s->bitstream_bpp<24){
707
        int y, cy;
708
        int lefty, leftu, leftv;
709
        int lefttopy, lefttopu, lefttopv;
710
        
711
        if(s->yuy2){
712
            p->data[0][3]= get_bits(&s->gb, 8);
713
            p->data[0][2]= get_bits(&s->gb, 8);
714
            p->data[0][1]= get_bits(&s->gb, 8);
715
            p->data[0][0]= get_bits(&s->gb, 8);
716
            
717
            av_log(avctx, AV_LOG_ERROR, "YUY2 output isnt implemenetd yet\n");
718
            return -1;
719
        }else{
720
        
721
            leftv= p->data[2][0]= get_bits(&s->gb, 8);
722
            lefty= p->data[0][1]= get_bits(&s->gb, 8);
723
            leftu= p->data[1][0]= get_bits(&s->gb, 8);
724
                   p->data[0][0]= get_bits(&s->gb, 8);
725
        
726
            switch(s->predictor){
727
            case LEFT:
728
            case PLANE:
729
                decode_422_bitstream(s, width-2);
730
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
731
                if(!(s->flags&CODEC_FLAG_GRAY)){
732
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
733
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
734
                }
735

    
736
                for(cy=y=1; y<s->height; y++,cy++){
737
                    uint8_t *ydst, *udst, *vdst;
738
                    
739
                    if(s->bitstream_bpp==12){
740
                        decode_gray_bitstream(s, width);
741
                    
742
                        ydst= p->data[0] + p->linesize[0]*y;
743

    
744
                        lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
745
                        if(s->predictor == PLANE){
746
                            if(y>s->interlaced)
747
                                s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
748
                        }
749
                        y++;
750
                        if(y>=s->height) break;
751
                    }
752
                    
753
                    draw_slice(s, y);
754
                    
755
                    ydst= p->data[0] + p->linesize[0]*y;
756
                    udst= p->data[1] + p->linesize[1]*cy;
757
                    vdst= p->data[2] + p->linesize[2]*cy;
758
                    
759
                    decode_422_bitstream(s, width);
760
                    lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
761
                    if(!(s->flags&CODEC_FLAG_GRAY)){
762
                        leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
763
                        leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
764
                    }
765
                    if(s->predictor == PLANE){
766
                        if(cy>s->interlaced){
767
                            s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
768
                            if(!(s->flags&CODEC_FLAG_GRAY)){
769
                                s->dsp.add_bytes(udst, udst - fake_ustride, width2);
770
                                s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
771
                            }
772
                        }
773
                    }
774
                }
775
                draw_slice(s, height);
776
                
777
                break;
778
            case MEDIAN:
779
                /* first line except first 2 pixels is left predicted */
780
                decode_422_bitstream(s, width-2);
781
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
782
                if(!(s->flags&CODEC_FLAG_GRAY)){
783
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
784
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
785
                }
786
                
787
                cy=y=1;
788
                
789
                /* second line is left predicted for interlaced case */
790
                if(s->interlaced){
791
                    decode_422_bitstream(s, width);
792
                    lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
793
                    if(!(s->flags&CODEC_FLAG_GRAY)){
794
                        leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
795
                        leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
796
                    }
797
                    y++; cy++;
798
                }
799

    
800
                /* next 4 pixels are left predicted too */
801
                decode_422_bitstream(s, 4);
802
                lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
803
                if(!(s->flags&CODEC_FLAG_GRAY)){
804
                    leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
805
                    leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
806
                }
807

    
808
                /* next line except the first 4 pixels is median predicted */
809
                lefttopy= p->data[0][3];
810
                decode_422_bitstream(s, width-4);
811
                add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
812
                if(!(s->flags&CODEC_FLAG_GRAY)){
813
                    lefttopu= p->data[1][1];
814
                    lefttopv= p->data[2][1];
815
                    add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
816
                    add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
817
                }
818
                y++; cy++;
819
                
820
                for(; y<height; y++,cy++){
821
                    uint8_t *ydst, *udst, *vdst;
822

    
823
                    if(s->bitstream_bpp==12){
824
                        while(2*cy > y){
825
                            decode_gray_bitstream(s, width);
826
                            ydst= p->data[0] + p->linesize[0]*y;
827
                            add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
828
                            y++;
829
                        }
830
                        if(y>=height) break;
831
                    }
832
                    draw_slice(s, y);
833

    
834
                    decode_422_bitstream(s, width);
835

    
836
                    ydst= p->data[0] + p->linesize[0]*y;
837
                    udst= p->data[1] + p->linesize[1]*cy;
838
                    vdst= p->data[2] + p->linesize[2]*cy;
839

    
840
                    add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
841
                    if(!(s->flags&CODEC_FLAG_GRAY)){
842
                        add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
843
                        add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
844
                    }
845
                }
846

    
847
                draw_slice(s, height);
848
                break;
849
            }
850
        }
851
    }else{
852
        int y;
853
        int leftr, leftg, leftb;
854
        const int last_line= (height-1)*p->linesize[0];
855
        
856
        if(s->bitstream_bpp==32){
857
                   p->data[0][last_line+3]= get_bits(&s->gb, 8);
858
            leftr= p->data[0][last_line+2]= get_bits(&s->gb, 8);
859
            leftg= p->data[0][last_line+1]= get_bits(&s->gb, 8);
860
            leftb= p->data[0][last_line+0]= get_bits(&s->gb, 8);
861
        }else{
862
            leftr= p->data[0][last_line+2]= get_bits(&s->gb, 8);
863
            leftg= p->data[0][last_line+1]= get_bits(&s->gb, 8);
864
            leftb= p->data[0][last_line+0]= get_bits(&s->gb, 8);
865
            skip_bits(&s->gb, 8);
866
        }
867
        
868
        if(s->bgr32){
869
            switch(s->predictor){
870
            case LEFT:
871
            case PLANE:
872
                decode_bgr_bitstream(s, width-1);
873
                add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
874

    
875
                for(y=s->height-2; y>=0; y--){ //yes its stored upside down
876
                    decode_bgr_bitstream(s, width);
877
                    
878
                    add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
879
                    if(s->predictor == PLANE){
880
                        if((y&s->interlaced)==0){
881
                            s->dsp.add_bytes(p->data[0] + p->linesize[0]*y, 
882
                                             p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
883
                        }
884
                    }
885
                }
886
                draw_slice(s, height); // just 1 large slice as this isnt possible in reverse order
887
                break;
888
            default:
889
                av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
890
            }
891
        }else{
892

    
893
            av_log(avctx, AV_LOG_ERROR, "BGR24 output isnt implemenetd yet\n");
894
            return -1;
895
        }
896
    }
897
    emms_c();
898
    
899
    *picture= *p;
900
    *data_size = sizeof(AVFrame);
901
    
902
    return (get_bits_count(&s->gb)+31)/32*4;
903
}
904

    
905
static int decode_end(AVCodecContext *avctx)
906
{
907
    HYuvContext *s = avctx->priv_data;
908
    int i;
909
    
910
    for(i=0; i<3; i++){
911
        free_vlc(&s->vlc[i]);
912
    }
913

    
914
    return 0;
915
}
916

    
917
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
918
    HYuvContext *s = avctx->priv_data;
919
    AVFrame *pict = data;
920
    const int width= s->width;
921
    const int width2= s->width>>1;
922
    const int height= s->height;
923
    const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
924
    const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
925
    const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
926
    AVFrame * const p= &s->picture;
927
    int i, size;
928

    
929
    init_put_bits(&s->pb, buf, buf_size);
930
    
931
    *p = *pict;
932
    p->pict_type= FF_I_TYPE;
933
    p->key_frame= 1;
934
    
935
    if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
936
        int lefty, leftu, leftv, y, cy;
937

    
938
        put_bits(&s->pb, 8, leftv= p->data[2][0]);
939
        put_bits(&s->pb, 8, lefty= p->data[0][1]);
940
        put_bits(&s->pb, 8, leftu= p->data[1][0]);
941
        put_bits(&s->pb, 8,        p->data[0][0]);
942
        
943
        lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
944
        leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
945
        leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
946
        
947
        encode_422_bitstream(s, width-2);
948
        
949
        if(s->predictor==MEDIAN){
950
            int lefttopy, lefttopu, lefttopv;
951
            cy=y=1;
952
            if(s->interlaced){
953
                lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
954
                leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
955
                leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
956
        
957
                encode_422_bitstream(s, width);
958
                y++; cy++;
959
            }
960
            
961
            lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
962
            leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ystride, 2, leftu);
963
            leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_ystride, 2, leftv);
964
        
965
            encode_422_bitstream(s, 4);
966

    
967
            lefttopy= p->data[0][3];
968
            lefttopu= p->data[1][1];
969
            lefttopv= p->data[2][1];
970
            s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
971
            s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
972
            s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
973
            encode_422_bitstream(s, width-4);
974
            y++; cy++;
975

    
976
            for(; y<height; y++,cy++){
977
                uint8_t *ydst, *udst, *vdst;
978
                    
979
                if(s->bitstream_bpp==12){
980
                    while(2*cy > y){
981
                        ydst= p->data[0] + p->linesize[0]*y;
982
                        s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
983
                        encode_gray_bitstream(s, width);
984
                        y++;
985
                    }
986
                    if(y>=height) break;
987
                }
988
                ydst= p->data[0] + p->linesize[0]*y;
989
                udst= p->data[1] + p->linesize[1]*cy;
990
                vdst= p->data[2] + p->linesize[2]*cy;
991

    
992
                s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
993
                s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
994
                s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
995

    
996
                encode_422_bitstream(s, width);
997
            }
998
        }else{
999
            for(cy=y=1; y<height; y++,cy++){
1000
                uint8_t *ydst, *udst, *vdst;
1001
                
1002
                /* encode a luma only line & y++ */
1003
                if(s->bitstream_bpp==12){
1004
                    ydst= p->data[0] + p->linesize[0]*y;
1005

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

    
1009
                        lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1010
                    }else{
1011
                        lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1012
                    }
1013
                    encode_gray_bitstream(s, width);
1014
                    y++;
1015
                    if(y>=height) break;
1016
                }
1017
                
1018
                ydst= p->data[0] + p->linesize[0]*y;
1019
                udst= p->data[1] + p->linesize[1]*cy;
1020
                vdst= p->data[2] + p->linesize[2]*cy;
1021

    
1022
                if(s->predictor == PLANE && s->interlaced < cy){
1023
                    s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1024
                    s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1025
                    s->dsp.diff_bytes(s->temp[2] + 1250, vdst, vdst - fake_vstride, width2);
1026

    
1027
                    lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1028
                    leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1029
                    leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + 1250, width2, leftv);
1030
                }else{
1031
                    lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1032
                    leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1033
                    leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1034
                }
1035

    
1036
                encode_422_bitstream(s, width);
1037
            }
1038
        }        
1039
    }else{
1040
        av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1041
    }
1042
    emms_c();
1043
    
1044
    size= (put_bits_count(&s->pb)+31)/32;
1045
    
1046
    if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1047
        int j;
1048
        char *p= avctx->stats_out;
1049
        for(i=0; i<3; i++){
1050
            for(j=0; j<256; j++){
1051
                sprintf(p, "%llu ", s->stats[i][j]);
1052
                p+= strlen(p);
1053
                s->stats[i][j]= 0;
1054
            }
1055
            sprintf(p, "\n");
1056
            p++;
1057
        }
1058
    }else{
1059
        flush_put_bits(&s->pb);
1060
        s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1061
    }
1062
    
1063
    s->picture_number++;
1064

    
1065
    return size*4;
1066
}
1067

    
1068
static int encode_end(AVCodecContext *avctx)
1069
{
1070
//    HYuvContext *s = avctx->priv_data;
1071

    
1072
    av_freep(&avctx->extradata);
1073
    av_freep(&avctx->stats_out);
1074
    
1075
    return 0;
1076
}
1077

    
1078
static const AVOption huffyuv_options[] =
1079
{
1080
    AVOPTION_CODEC_INT("prediction_method", "prediction_method", prediction_method, 0, 2, 0),
1081
    AVOPTION_END()
1082
};
1083

    
1084
AVCodec huffyuv_decoder = {
1085
    "huffyuv",
1086
    CODEC_TYPE_VIDEO,
1087
    CODEC_ID_HUFFYUV,
1088
    sizeof(HYuvContext),
1089
    decode_init,
1090
    NULL,
1091
    decode_end,
1092
    decode_frame,
1093
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1094
    NULL
1095
};
1096

    
1097
#ifdef CONFIG_ENCODERS
1098

    
1099
AVCodec huffyuv_encoder = {
1100
    "huffyuv",
1101
    CODEC_TYPE_VIDEO,
1102
    CODEC_ID_HUFFYUV,
1103
    sizeof(HYuvContext),
1104
    encode_init,
1105
    encode_frame,
1106
    encode_end,
1107
    .options = huffyuv_options,
1108
};
1109

    
1110
#endif //CONFIG_ENCODERS