Statistics
| Branch: | Revision:

ffmpeg / libavcodec / huffyuv.c @ 8dbcc9f2

History | View | Annotate | Download (36.6 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
#ifndef INT64_MAX
34
#define INT64_MAX 9223372036854775807LL
35
#endif
36

    
37
#define VLC_BITS 11
38

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

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

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

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

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

    
120
static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
121
    int i;
122

    
123
    for(i=0; i<w-1; i++){
124
        acc+= src[i];
125
        dst[i]= acc;
126
        i++;
127
        acc+= src[i];
128
        dst[i]= acc;
129
    }
130

    
131
    for(; i<w; i++){
132
        acc+= src[i];
133
        dst[i]= acc;
134
    }
135

    
136
    return acc;
137
}
138

    
139
static inline void add_median_prediction(uint8_t *dst, uint8_t *src1, uint8_t *diff, int w, int *left, int *left_top){
140
    int i;
141
    uint8_t l, lt;
142

    
143
    l= *left;
144
    lt= *left_top;
145

    
146
    for(i=0; i<w; i++){
147
        l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
148
        lt= src1[i];
149
        dst[i]= l;
150
    }    
151

    
152
    *left= l;
153
    *left_top= lt;
154
}
155

    
156
static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
157
    int i;
158
    int r,g,b;
159
    r= *red;
160
    g= *green;
161
    b= *blue;
162

    
163
    for(i=0; i<w; i++){
164
        b+= src[4*i+0];
165
        g+= src[4*i+1];
166
        r+= src[4*i+2];
167
        
168
        dst[4*i+0]= b;
169
        dst[4*i+1]= g;
170
        dst[4*i+2]= r;
171
    }
172

    
173
    *red= r;
174
    *green= g;
175
    *blue= b;
176
}
177

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

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

    
212
static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
213
    int len, index;
214
    uint32_t bits=0;
215

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

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

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

    
309
static int read_old_huffman_tables(HYuvContext *s){
310
#if 1
311
    GetBitContext gb;
312
    int i;
313

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

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

    
339
static int decode_init(AVCodecContext *avctx)
340
{
341
    HYuvContext *s = avctx->priv_data;
342
    int width, height;
343

    
344
    s->avctx= avctx;
345
    s->flags= avctx->flags;
346
        
347
    dsputil_init(&s->dsp, avctx);
348
    
349
    width= s->width= avctx->width;
350
    height= s->height= avctx->height;
351
    avctx->coded_frame= &s->picture;
352

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

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

    
436
static void store_table(HYuvContext *s, uint8_t *len){
437
    int i;
438
    int index= s->avctx->extradata_size;
439

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

    
459
static int encode_init(AVCodecContext *avctx)
460
{
461
    HYuvContext *s = avctx->priv_data;
462
    int i, j, width, height;
463

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

    
512
        for(;;){
513
            for(i=0; i<3; i++){
514
                char *next;
515

    
516
                for(j=0; j<256; j++){
517
                    s->stats[i][j]+= strtol(p, &next, 0);
518
                    if(next==p) return -1;
519
                    p=next;
520
                }        
521
            }
522
            if(p[0]==0 || p[1]==0 || p[2]==0) break;
523
        }
524
    }else{
525
        for(i=0; i<3; i++)
526
            for(j=0; j<256; j++){
527
                int d= FFMIN(j, 256-j);
528
                
529
                s->stats[i][j]= 100000000/(d+1);
530
            }
531
    }
532
    
533
    for(i=0; i<3; i++){
534
        generate_len_table(s->len[i], s->stats[i], 256);
535

    
536
        if(generate_bits_table(s->bits[i], s->len[i])<0){
537
            return -1;
538
        }
539
        
540
        store_table(s, s->len[i]);
541
    }
542

    
543
    for(i=0; i<3; i++)
544
        for(j=0; j<256; j++)
545
            s->stats[i][j]= 0;
546
    
547
    s->interlaced= height > 288;
548

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

    
551
    s->picture_number=0;
552

    
553
    return 0;
554
}
555

    
556
static void decode_422_bitstream(HYuvContext *s, int count){
557
    int i;
558

    
559
    count/=2;
560
    
561
    for(i=0; i<count; i++){
562
        s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
563
        s->temp[1][  i  ]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
564
        s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
565
        s->temp[2][  i  ]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
566
    }
567
}
568

    
569
static void decode_gray_bitstream(HYuvContext *s, int count){
570
    int i;
571
    
572
    count/=2;
573
    
574
    for(i=0; i<count; i++){
575
        s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
576
        s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
577
    }
578
}
579

    
580
static void encode_422_bitstream(HYuvContext *s, int count){
581
    int i;
582
    
583
    count/=2;
584
    if(s->flags&CODEC_FLAG_PASS1){
585
        for(i=0; i<count; i++){
586
            s->stats[0][ s->temp[0][2*i  ] ]++;
587
            s->stats[1][ s->temp[1][  i  ] ]++;
588
            s->stats[0][ s->temp[0][2*i+1] ]++;
589
            s->stats[2][ s->temp[2][  i  ] ]++;
590
        }
591
    }else{
592
        for(i=0; i<count; i++){
593
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
594
            put_bits(&s->pb, s->len[1][ s->temp[1][  i  ] ], s->bits[1][ s->temp[1][  i  ] ]);
595
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
596
            put_bits(&s->pb, s->len[2][ s->temp[2][  i  ] ], s->bits[2][ s->temp[2][  i  ] ]);
597
        }
598
    }
599
}
600

    
601
static void encode_gray_bitstream(HYuvContext *s, int count){
602
    int i;
603
    
604
    count/=2;
605
    if(s->flags&CODEC_FLAG_PASS1){
606
        for(i=0; i<count; i++){
607
            s->stats[0][ s->temp[0][2*i  ] ]++;
608
            s->stats[0][ s->temp[0][2*i+1] ]++;
609
        }
610
    }else{
611
        for(i=0; i<count; i++){
612
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
613
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
614
        }
615
    }
616
}
617

    
618
static void decode_bgr_bitstream(HYuvContext *s, int count){
619
    int i;
620

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

    
654
static void draw_slice(HYuvContext *s, int y){
655
    int h, cy;
656
    int offset[4];
657
    
658
    if(s->avctx->draw_horiz_band==NULL) 
659
        return;
660
        
661
    h= y - s->last_slice_end;
662
    y -= h;
663
    
664
    if(s->bitstream_bpp==12){
665
        cy= y>>1;
666
    }else{
667
        cy= y;
668
    }
669

    
670
    offset[0] = s->picture.linesize[0]*y;
671
    offset[1] = s->picture.linesize[1]*cy;
672
    offset[2] = s->picture.linesize[2]*cy;
673
    offset[3] = 0;
674
    emms_c();
675

    
676
    s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
677
    
678
    s->last_slice_end= y + h;
679
}
680

    
681
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
682
    HYuvContext *s = avctx->priv_data;
683
    const int width= s->width;
684
    const int width2= s->width>>1;
685
    const int height= s->height;
686
    int fake_ystride, fake_ustride, fake_vstride;
687
    AVFrame * const p= &s->picture;
688

    
689
    AVFrame *picture = data;
690

    
691
    *data_size = 0;
692

    
693
    /* no supplementary picture */
694
    if (buf_size == 0)
695
        return 0;
696

    
697
    s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4);
698
    
699
    init_get_bits(&s->gb, s->bitstream_buffer, buf_size*8);
700

    
701
    if(p->data[0])
702
        avctx->release_buffer(avctx, p);
703

    
704
    p->reference= 0;
705
    if(avctx->get_buffer(avctx, p) < 0){
706
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
707
        return -1;
708
    }
709

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

    
746
                for(cy=y=1; y<s->height; y++,cy++){
747
                    uint8_t *ydst, *udst, *vdst;
748
                    
749
                    if(s->bitstream_bpp==12){
750
                        decode_gray_bitstream(s, width);
751
                    
752
                        ydst= p->data[0] + p->linesize[0]*y;
753

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

    
810
                /* next 4 pixels are left predicted too */
811
                decode_422_bitstream(s, 4);
812
                lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
813
                if(!(s->flags&CODEC_FLAG_GRAY)){
814
                    leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
815
                    leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
816
                }
817

    
818
                /* next line except the first 4 pixels is median predicted */
819
                lefttopy= p->data[0][3];
820
                decode_422_bitstream(s, width-4);
821
                add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
822
                if(!(s->flags&CODEC_FLAG_GRAY)){
823
                    lefttopu= p->data[1][1];
824
                    lefttopv= p->data[2][1];
825
                    add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
826
                    add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
827
                }
828
                y++; cy++;
829
                
830
                for(; y<height; y++,cy++){
831
                    uint8_t *ydst, *udst, *vdst;
832

    
833
                    if(s->bitstream_bpp==12){
834
                        while(2*cy > y){
835
                            decode_gray_bitstream(s, width);
836
                            ydst= p->data[0] + p->linesize[0]*y;
837
                            add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
838
                            y++;
839
                        }
840
                        if(y>=height) break;
841
                    }
842
                    draw_slice(s, y);
843

    
844
                    decode_422_bitstream(s, width);
845

    
846
                    ydst= p->data[0] + p->linesize[0]*y;
847
                    udst= p->data[1] + p->linesize[1]*cy;
848
                    vdst= p->data[2] + p->linesize[2]*cy;
849

    
850
                    add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
851
                    if(!(s->flags&CODEC_FLAG_GRAY)){
852
                        add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
853
                        add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
854
                    }
855
                }
856

    
857
                draw_slice(s, height);
858
                break;
859
            }
860
        }
861
    }else{
862
        int y;
863
        int leftr, leftg, leftb;
864
        const int last_line= (height-1)*p->linesize[0];
865
        
866
        if(s->bitstream_bpp==32){
867
                   p->data[0][last_line+3]= get_bits(&s->gb, 8);
868
            leftr= p->data[0][last_line+2]= get_bits(&s->gb, 8);
869
            leftg= p->data[0][last_line+1]= get_bits(&s->gb, 8);
870
            leftb= p->data[0][last_line+0]= get_bits(&s->gb, 8);
871
        }else{
872
            leftr= p->data[0][last_line+2]= get_bits(&s->gb, 8);
873
            leftg= p->data[0][last_line+1]= get_bits(&s->gb, 8);
874
            leftb= p->data[0][last_line+0]= get_bits(&s->gb, 8);
875
            skip_bits(&s->gb, 8);
876
        }
877
        
878
        if(s->bgr32){
879
            switch(s->predictor){
880
            case LEFT:
881
            case PLANE:
882
                decode_bgr_bitstream(s, width-1);
883
                add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
884

    
885
                for(y=s->height-2; y>=0; y--){ //yes its stored upside down
886
                    decode_bgr_bitstream(s, width);
887
                    
888
                    add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
889
                    if(s->predictor == PLANE){
890
                        if((y&s->interlaced)==0){
891
                            s->dsp.add_bytes(p->data[0] + p->linesize[0]*y, 
892
                                             p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
893
                        }
894
                    }
895
                }
896
                draw_slice(s, height); // just 1 large slice as this isnt possible in reverse order
897
                break;
898
            default:
899
                av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
900
            }
901
        }else{
902

    
903
            av_log(avctx, AV_LOG_ERROR, "BGR24 output isnt implemenetd yet\n");
904
            return -1;
905
        }
906
    }
907
    emms_c();
908
    
909
    *picture= *p;
910
    *data_size = sizeof(AVFrame);
911
    
912
    return (get_bits_count(&s->gb)+31)/32*4;
913
}
914

    
915
static int decode_end(AVCodecContext *avctx)
916
{
917
    HYuvContext *s = avctx->priv_data;
918
    int i;
919
    
920
    for(i=0; i<3; i++){
921
        free_vlc(&s->vlc[i]);
922
    }
923
    
924
    avcodec_default_free_buffers(avctx);
925

    
926
    return 0;
927
}
928

    
929
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
930
    HYuvContext *s = avctx->priv_data;
931
    AVFrame *pict = data;
932
    const int width= s->width;
933
    const int width2= s->width>>1;
934
    const int height= s->height;
935
    const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
936
    const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
937
    const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
938
    AVFrame * const p= &s->picture;
939
    int i, size;
940

    
941
    init_put_bits(&s->pb, buf, buf_size);
942
    
943
    *p = *pict;
944
    p->pict_type= FF_I_TYPE;
945
    p->key_frame= 1;
946
    
947
    if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
948
        int lefty, leftu, leftv, y, cy;
949

    
950
        put_bits(&s->pb, 8, leftv= p->data[2][0]);
951
        put_bits(&s->pb, 8, lefty= p->data[0][1]);
952
        put_bits(&s->pb, 8, leftu= p->data[1][0]);
953
        put_bits(&s->pb, 8,        p->data[0][0]);
954
        
955
        lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
956
        leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
957
        leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
958
        
959
        encode_422_bitstream(s, width-2);
960
        
961
        if(s->predictor==MEDIAN){
962
            int lefttopy, lefttopu, lefttopv;
963
            cy=y=1;
964
            if(s->interlaced){
965
                lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
966
                leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
967
                leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
968
        
969
                encode_422_bitstream(s, width);
970
                y++; cy++;
971
            }
972
            
973
            lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
974
            leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ystride, 2, leftu);
975
            leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_ystride, 2, leftv);
976
        
977
            encode_422_bitstream(s, 4);
978

    
979
            lefttopy= p->data[0][3];
980
            lefttopu= p->data[1][1];
981
            lefttopv= p->data[2][1];
982
            s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
983
            s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
984
            s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
985
            encode_422_bitstream(s, width-4);
986
            y++; cy++;
987

    
988
            for(; y<height; y++,cy++){
989
                uint8_t *ydst, *udst, *vdst;
990
                    
991
                if(s->bitstream_bpp==12){
992
                    while(2*cy > y){
993
                        ydst= p->data[0] + p->linesize[0]*y;
994
                        s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
995
                        encode_gray_bitstream(s, width);
996
                        y++;
997
                    }
998
                    if(y>=height) break;
999
                }
1000
                ydst= p->data[0] + p->linesize[0]*y;
1001
                udst= p->data[1] + p->linesize[1]*cy;
1002
                vdst= p->data[2] + p->linesize[2]*cy;
1003

    
1004
                s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1005
                s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1006
                s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1007

    
1008
                encode_422_bitstream(s, width);
1009
            }
1010
        }else{
1011
            for(cy=y=1; y<height; y++,cy++){
1012
                uint8_t *ydst, *udst, *vdst;
1013
                
1014
                /* encode a luma only line & y++ */
1015
                if(s->bitstream_bpp==12){
1016
                    ydst= p->data[0] + p->linesize[0]*y;
1017

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

    
1021
                        lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1022
                    }else{
1023
                        lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1024
                    }
1025
                    encode_gray_bitstream(s, width);
1026
                    y++;
1027
                    if(y>=height) break;
1028
                }
1029
                
1030
                ydst= p->data[0] + p->linesize[0]*y;
1031
                udst= p->data[1] + p->linesize[1]*cy;
1032
                vdst= p->data[2] + p->linesize[2]*cy;
1033

    
1034
                if(s->predictor == PLANE && s->interlaced < cy){
1035
                    s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1036
                    s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1037
                    s->dsp.diff_bytes(s->temp[2] + 1250, vdst, vdst - fake_vstride, width2);
1038

    
1039
                    lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1040
                    leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1041
                    leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + 1250, width2, leftv);
1042
                }else{
1043
                    lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1044
                    leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1045
                    leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1046
                }
1047

    
1048
                encode_422_bitstream(s, width);
1049
            }
1050
        }        
1051
    }else{
1052
        av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1053
    }
1054
    emms_c();
1055
    
1056
    size= (get_bit_count(&s->pb)+31)/32;
1057
    
1058
    if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1059
        int j;
1060
        char *p= avctx->stats_out;
1061
        for(i=0; i<3; i++){
1062
            for(j=0; j<256; j++){
1063
                sprintf(p, "%llu ", s->stats[i][j]);
1064
                p+= strlen(p);
1065
                s->stats[i][j]= 0;
1066
            }
1067
            sprintf(p, "\n");
1068
            p++;
1069
        }
1070
    }else{
1071
        flush_put_bits(&s->pb);
1072
        s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1073
    }
1074
    
1075
    s->picture_number++;
1076

    
1077
    return size*4;
1078
}
1079

    
1080
static int encode_end(AVCodecContext *avctx)
1081
{
1082
//    HYuvContext *s = avctx->priv_data;
1083

    
1084
    av_freep(&avctx->extradata);
1085
    av_freep(&avctx->stats_out);
1086
    
1087
    return 0;
1088
}
1089

    
1090
static const AVOption huffyuv_options[] =
1091
{
1092
    AVOPTION_CODEC_INT("prediction_method", "prediction_method", prediction_method, 0, 2, 0),
1093
    AVOPTION_END()
1094
};
1095

    
1096
AVCodec huffyuv_decoder = {
1097
    "huffyuv",
1098
    CODEC_TYPE_VIDEO,
1099
    CODEC_ID_HUFFYUV,
1100
    sizeof(HYuvContext),
1101
    decode_init,
1102
    NULL,
1103
    decode_end,
1104
    decode_frame,
1105
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1106
    NULL
1107
};
1108

    
1109
#ifdef CONFIG_ENCODERS
1110

    
1111
AVCodec huffyuv_encoder = {
1112
    "huffyuv",
1113
    CODEC_TYPE_VIDEO,
1114
    CODEC_ID_HUFFYUV,
1115
    sizeof(HYuvContext),
1116
    encode_init,
1117
    encode_frame,
1118
    encode_end,
1119
    .options = huffyuv_options,
1120
};
1121

    
1122
#endif //CONFIG_ENCODERS