Statistics
| Branch: | Revision:

ffmpeg / libavcodec / huffyuv.c @ 19716d64

History | View | Annotate | Download (44.9 KB)

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

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

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

    
35
#define VLC_BITS 11
36

    
37
#ifdef WORDS_BIGENDIAN
38
#define B 3
39
#define G 2
40
#define R 1
41
#else
42
#define B 0
43
#define G 1
44
#define R 2
45
#endif
46

    
47
typedef enum Predictor{
48
    LEFT= 0,
49
    PLANE,
50
    MEDIAN,
51
} Predictor;
52

    
53
typedef struct HYuvContext{
54
    AVCodecContext *avctx;
55
    Predictor predictor;
56
    GetBitContext gb;
57
    PutBitContext pb;
58
    int interlaced;
59
    int decorrelate;
60
    int bitstream_bpp;
61
    int version;
62
    int yuy2;                               //use yuy2 instead of 422P
63
    int bgr32;                              //use bgr32 instead of bgr24
64
    int width, height;
65
    int flags;
66
    int context;
67
    int picture_number;
68
    int last_slice_end;
69
    uint8_t *temp[3];
70
    uint64_t stats[3][256];
71
    uint8_t len[3][256];
72
    uint32_t bits[3][256];
73
    VLC vlc[6];                             //Y,U,V,YY,YU,YV
74
    uint16_t pix2_map[3][1<<VLC_BITS];
75
    AVFrame picture;
76
    uint8_t *bitstream_buffer;
77
    unsigned int bitstream_buffer_size;
78
    DSPContext dsp;
79
}HYuvContext;
80

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

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

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

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

    
131
static inline int add_left_prediction(uint8_t *dst, uint8_t *src, int w, int acc){
132
    int i;
133

    
134
    for(i=0; i<w-1; i++){
135
        acc+= src[i];
136
        dst[i]= acc;
137
        i++;
138
        acc+= src[i];
139
        dst[i]= acc;
140
    }
141

    
142
    for(; i<w; i++){
143
        acc+= src[i];
144
        dst[i]= acc;
145
    }
146

    
147
    return acc;
148
}
149

    
150
static inline void add_median_prediction(uint8_t *dst, uint8_t *src1, uint8_t *diff, int w, int *left, int *left_top){
151
    int i;
152
    uint8_t l, lt;
153

    
154
    l= *left;
155
    lt= *left_top;
156

    
157
    for(i=0; i<w; i++){
158
        l= mid_pred(l, src1[i], (l + src1[i] - lt)&0xFF) + diff[i];
159
        lt= src1[i];
160
        dst[i]= l;
161
    }
162

    
163
    *left= l;
164
    *left_top= lt;
165
}
166

    
167
static inline void add_left_prediction_bgr32(uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
168
    int i;
169
    int r,g,b;
170
    r= *red;
171
    g= *green;
172
    b= *blue;
173

    
174
    for(i=0; i<w; i++){
175
        b+= src[4*i+B];
176
        g+= src[4*i+G];
177
        r+= src[4*i+R];
178

    
179
        dst[4*i+B]= b;
180
        dst[4*i+G]= g;
181
        dst[4*i+R]= r;
182
    }
183

    
184
    *red= r;
185
    *green= g;
186
    *blue= b;
187
}
188

    
189
static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int left){
190
    int i;
191
    if(w<32){
192
        for(i=0; i<w; i++){
193
            const int temp= src[i];
194
            dst[i]= temp - left;
195
            left= temp;
196
        }
197
        return left;
198
    }else{
199
        for(i=0; i<16; i++){
200
            const int temp= src[i];
201
            dst[i]= temp - left;
202
            left= temp;
203
        }
204
        s->dsp.diff_bytes(dst+16, src+16, src+15, w-16);
205
        return src[w-1];
206
    }
207
}
208

    
209
static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue){
210
    int i;
211
    int r,g,b;
212
    r= *red;
213
    g= *green;
214
    b= *blue;
215
    for(i=0; i<FFMIN(w,4); i++){
216
        const int rt= src[i*4+R];
217
        const int gt= src[i*4+G];
218
        const int bt= src[i*4+B];
219
        dst[i*4+R]= rt - r;
220
        dst[i*4+G]= gt - g;
221
        dst[i*4+B]= bt - b;
222
        r = rt;
223
        g = gt;
224
        b = bt;
225
    }
226
    s->dsp.diff_bytes(dst+16, src+16, src+12, w*4-16);
227
    *red=   src[(w-1)*4+R];
228
    *green= src[(w-1)*4+G];
229
    *blue=  src[(w-1)*4+B];
230
}
231

    
232
static void read_len_table(uint8_t *dst, GetBitContext *gb){
233
    int i, val, repeat;
234

    
235
    for(i=0; i<256;){
236
        repeat= get_bits(gb, 3);
237
        val   = get_bits(gb, 5);
238
        if(repeat==0)
239
            repeat= get_bits(gb, 8);
240
//printf("%d %d\n", val, repeat);
241
        while (repeat--)
242
            dst[i++] = val;
243
    }
244
}
245

    
246
static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
247
    int len, index;
248
    uint32_t bits=0;
249

    
250
    for(len=32; len>0; len--){
251
        for(index=0; index<256; index++){
252
            if(len_table[index]==len)
253
                dst[index]= bits++;
254
        }
255
        if(bits & 1){
256
            av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
257
            return -1;
258
        }
259
        bits >>= 1;
260
    }
261
    return 0;
262
}
263

    
264
#ifdef CONFIG_ENCODERS
265
typedef struct {
266
    uint64_t val;
267
    int name;
268
} heap_elem_t;
269

    
270
static void heap_sift(heap_elem_t *h, int root, int size)
271
{
272
    while(root*2+1 < size) {
273
        int child = root*2+1;
274
        if(child < size-1 && h[child].val > h[child+1].val)
275
            child++;
276
        if(h[root].val > h[child].val) {
277
            FFSWAP(heap_elem_t, h[root], h[child]);
278
            root = child;
279
        } else
280
            break;
281
    }
282
}
283

    
284
static void generate_len_table(uint8_t *dst, uint64_t *stats, int size){
285
    heap_elem_t h[size];
286
    int up[2*size];
287
    int len[2*size];
288
    int offset, i, next;
289

    
290
    for(offset=1; ; offset<<=1){
291
        for(i=0; i<size; i++){
292
            h[i].name = i;
293
            h[i].val = (stats[i] << 8) + offset;
294
        }
295
        for(i=size/2-1; i>=0; i--)
296
            heap_sift(h, i, size);
297

    
298
        for(next=size; next<size*2-1; next++){
299
            // merge the two smallest entries, and put it back in the heap
300
            uint64_t min1v = h[0].val;
301
            up[h[0].name] = next;
302
            h[0].val = INT64_MAX;
303
            heap_sift(h, 0, size);
304
            up[h[0].name] = next;
305
            h[0].name = next;
306
            h[0].val += min1v;
307
            heap_sift(h, 0, size);
308
        }
309

    
310
        len[2*size-2] = 0;
311
        for(i=2*size-3; i>=size; i--)
312
            len[i] = len[up[i]] + 1;
313
        for(i=0; i<size; i++) {
314
            dst[i] = len[up[i]] + 1;
315
            if(dst[i] > 32) break;
316
        }
317
        if(i==size) break;
318
    }
319
}
320
#endif /* CONFIG_ENCODERS */
321

    
322
static void generate_joint_tables(HYuvContext *s){
323
    // TODO modify init_vlc to allow sparse tables, and eliminate pix2_map
324
    // TODO rgb
325
    if(s->bitstream_bpp < 24){
326
        uint16_t bits[1<<VLC_BITS];
327
        uint8_t len[1<<VLC_BITS];
328
        int p, i, y, u;
329
        for(p=0; p<3; p++){
330
            for(i=y=0; y<256; y++){
331
                int len0 = s->len[0][y];
332
                int limit = VLC_BITS - len0;
333
                if(limit > 0){
334
                    for(u=0; u<256; u++){
335
                        int len1 = s->len[p][u];
336
                        if(len1 <= limit){
337
                            len[i] = len0 + len1;
338
                            bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
339
                            s->pix2_map[p][i] = (y<<8) + u;
340
                            i++;
341
                        }
342
                    }
343
                }
344
            }
345
            free_vlc(&s->vlc[3+p]);
346
            init_vlc(&s->vlc[3+p], VLC_BITS, i, len, 1, 1, bits, 2, 2, 0);
347
        }
348
    }
349
}
350

    
351
static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
352
    GetBitContext gb;
353
    int i;
354

    
355
    init_get_bits(&gb, src, length*8);
356

    
357
    for(i=0; i<3; i++){
358
        read_len_table(s->len[i], &gb);
359

    
360
        if(generate_bits_table(s->bits[i], s->len[i])<0){
361
            return -1;
362
        }
363
#if 0
364
for(j=0; j<256; j++){
365
printf("%6X, %2d,  %3d\n", s->bits[i][j], s->len[i][j], j);
366
}
367
#endif
368
        free_vlc(&s->vlc[i]);
369
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
370
    }
371

    
372
    generate_joint_tables(s);
373

    
374
    return (get_bits_count(&gb)+7)/8;
375
}
376

    
377
static int read_old_huffman_tables(HYuvContext *s){
378
#if 1
379
    GetBitContext gb;
380
    int i;
381

    
382
    init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
383
    read_len_table(s->len[0], &gb);
384
    init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
385
    read_len_table(s->len[1], &gb);
386

    
387
    for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
388
    for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
389

    
390
    if(s->bitstream_bpp >= 24){
391
        memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
392
        memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
393
    }
394
    memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
395
    memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
396

    
397
    for(i=0; i<3; i++){
398
        free_vlc(&s->vlc[i]);
399
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
400
    }
401

    
402
    generate_joint_tables(s);
403

    
404
    return 0;
405
#else
406
    av_log(s->avctx, AV_LOG_DEBUG, "v1 huffyuv is not supported \n");
407
    return -1;
408
#endif
409
}
410

    
411
static void alloc_temp(HYuvContext *s){
412
    int i;
413

    
414
    if(s->bitstream_bpp<24){
415
        for(i=0; i<3; i++){
416
            s->temp[i]= av_malloc(s->width + 16);
417
        }
418
    }else{
419
        for(i=0; i<2; i++){
420
            s->temp[i]= av_malloc(4*s->width + 16);
421
        }
422
    }
423
}
424

    
425
static int common_init(AVCodecContext *avctx){
426
    HYuvContext *s = avctx->priv_data;
427

    
428
    s->avctx= avctx;
429
    s->flags= avctx->flags;
430

    
431
    dsputil_init(&s->dsp, avctx);
432

    
433
    s->width= avctx->width;
434
    s->height= avctx->height;
435
    assert(s->width>0 && s->height>0);
436

    
437
    return 0;
438
}
439

    
440
#ifdef CONFIG_DECODERS
441
static int decode_init(AVCodecContext *avctx)
442
{
443
    HYuvContext *s = avctx->priv_data;
444

    
445
    common_init(avctx);
446
    memset(s->vlc, 0, 3*sizeof(VLC));
447

    
448
    avctx->coded_frame= &s->picture;
449
    s->interlaced= s->height > 288;
450

    
451
s->bgr32=1;
452
//if(avctx->extradata)
453
//  printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
454
    if(avctx->extradata_size){
455
        if((avctx->bits_per_sample&7) && avctx->bits_per_sample != 12)
456
            s->version=1; // do such files exist at all?
457
        else
458
            s->version=2;
459
    }else
460
        s->version=0;
461

    
462
    if(s->version==2){
463
        int method, interlace;
464

    
465
        method= ((uint8_t*)avctx->extradata)[0];
466
        s->decorrelate= method&64 ? 1 : 0;
467
        s->predictor= method&63;
468
        s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
469
        if(s->bitstream_bpp==0)
470
            s->bitstream_bpp= avctx->bits_per_sample&~7;
471
        interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
472
        s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
473
        s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
474

    
475
        if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
476
            return -1;
477
    }else{
478
        switch(avctx->bits_per_sample&7){
479
        case 1:
480
            s->predictor= LEFT;
481
            s->decorrelate= 0;
482
            break;
483
        case 2:
484
            s->predictor= LEFT;
485
            s->decorrelate= 1;
486
            break;
487
        case 3:
488
            s->predictor= PLANE;
489
            s->decorrelate= avctx->bits_per_sample >= 24;
490
            break;
491
        case 4:
492
            s->predictor= MEDIAN;
493
            s->decorrelate= 0;
494
            break;
495
        default:
496
            s->predictor= LEFT; //OLD
497
            s->decorrelate= 0;
498
            break;
499
        }
500
        s->bitstream_bpp= avctx->bits_per_sample & ~7;
501
        s->context= 0;
502

    
503
        if(read_old_huffman_tables(s) < 0)
504
            return -1;
505
    }
506

    
507
    switch(s->bitstream_bpp){
508
    case 12:
509
        avctx->pix_fmt = PIX_FMT_YUV420P;
510
        break;
511
    case 16:
512
        if(s->yuy2){
513
            avctx->pix_fmt = PIX_FMT_YUYV422;
514
        }else{
515
            avctx->pix_fmt = PIX_FMT_YUV422P;
516
        }
517
        break;
518
    case 24:
519
    case 32:
520
        if(s->bgr32){
521
            avctx->pix_fmt = PIX_FMT_RGB32;
522
        }else{
523
            avctx->pix_fmt = PIX_FMT_BGR24;
524
        }
525
        break;
526
    default:
527
        assert(0);
528
    }
529

    
530
    alloc_temp(s);
531

    
532
//    av_log(NULL, AV_LOG_DEBUG, "pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
533

    
534
    return 0;
535
}
536
#endif
537

    
538
#ifdef CONFIG_ENCODERS
539
static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
540
    int i;
541
    int index= 0;
542

    
543
    for(i=0; i<256;){
544
        int val= len[i];
545
        int repeat=0;
546

    
547
        for(; i<256 && len[i]==val && repeat<255; i++)
548
            repeat++;
549

    
550
        assert(val < 32 && val >0 && repeat<256 && repeat>0);
551
        if(repeat>7){
552
            buf[index++]= val;
553
            buf[index++]= repeat;
554
        }else{
555
            buf[index++]= val | (repeat<<5);
556
        }
557
    }
558

    
559
    return index;
560
}
561

    
562
static int encode_init(AVCodecContext *avctx)
563
{
564
    HYuvContext *s = avctx->priv_data;
565
    int i, j;
566

    
567
    common_init(avctx);
568

    
569
    avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
570
    avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
571
    s->version=2;
572

    
573
    avctx->coded_frame= &s->picture;
574

    
575
    switch(avctx->pix_fmt){
576
    case PIX_FMT_YUV420P:
577
        s->bitstream_bpp= 12;
578
        break;
579
    case PIX_FMT_YUV422P:
580
        s->bitstream_bpp= 16;
581
        break;
582
    case PIX_FMT_RGB32:
583
        s->bitstream_bpp= 24;
584
        break;
585
    default:
586
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
587
        return -1;
588
    }
589
    avctx->bits_per_sample= s->bitstream_bpp;
590
    s->decorrelate= s->bitstream_bpp >= 24;
591
    s->predictor= avctx->prediction_method;
592
    s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
593
    if(avctx->context_model==1){
594
        s->context= avctx->context_model;
595
        if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
596
            av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
597
            return -1;
598
        }
599
    }else s->context= 0;
600

    
601
    if(avctx->codec->id==CODEC_ID_HUFFYUV){
602
        if(avctx->pix_fmt==PIX_FMT_YUV420P){
603
            av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
604
            return -1;
605
        }
606
        if(avctx->context_model){
607
            av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
608
            return -1;
609
        }
610
        if(s->interlaced != ( s->height > 288 ))
611
            av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
612
    }
613

    
614
    if(s->bitstream_bpp>=24 && s->predictor==MEDIAN){
615
        av_log(avctx, AV_LOG_ERROR, "Error: RGB is incompatible with median predictor\n");
616
        return -1;
617
    }
618

    
619
    ((uint8_t*)avctx->extradata)[0]= s->predictor | (s->decorrelate << 6);
620
    ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
621
    ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
622
    if(s->context)
623
        ((uint8_t*)avctx->extradata)[2]|= 0x40;
624
    ((uint8_t*)avctx->extradata)[3]= 0;
625
    s->avctx->extradata_size= 4;
626

    
627
    if(avctx->stats_in){
628
        char *p= avctx->stats_in;
629

    
630
        for(i=0; i<3; i++)
631
            for(j=0; j<256; j++)
632
                s->stats[i][j]= 1;
633

    
634
        for(;;){
635
            for(i=0; i<3; i++){
636
                char *next;
637

    
638
                for(j=0; j<256; j++){
639
                    s->stats[i][j]+= strtol(p, &next, 0);
640
                    if(next==p) return -1;
641
                    p=next;
642
                }
643
            }
644
            if(p[0]==0 || p[1]==0 || p[2]==0) break;
645
        }
646
    }else{
647
        for(i=0; i<3; i++)
648
            for(j=0; j<256; j++){
649
                int d= FFMIN(j, 256-j);
650

    
651
                s->stats[i][j]= 100000000/(d+1);
652
            }
653
    }
654

    
655
    for(i=0; i<3; i++){
656
        generate_len_table(s->len[i], s->stats[i], 256);
657

    
658
        if(generate_bits_table(s->bits[i], s->len[i])<0){
659
            return -1;
660
        }
661

    
662
        s->avctx->extradata_size+=
663
        store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
664
    }
665

    
666
    if(s->context){
667
        for(i=0; i<3; i++){
668
            int pels = s->width*s->height / (i?40:10);
669
            for(j=0; j<256; j++){
670
                int d= FFMIN(j, 256-j);
671
                s->stats[i][j]= pels/(d+1);
672
            }
673
        }
674
    }else{
675
        for(i=0; i<3; i++)
676
            for(j=0; j<256; j++)
677
                s->stats[i][j]= 0;
678
    }
679

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

    
682
    alloc_temp(s);
683

    
684
    s->picture_number=0;
685

    
686
    return 0;
687
}
688
#endif /* CONFIG_ENCODERS */
689

    
690
/* TODO instead of restarting the read when the code isn't in the first level
691
 * of the joint table, jump into the 2nd level of the individual table. */
692
#define READ_2PIX(dst0, dst1, plane1){\
693
    int code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
694
    if(code >= 0){\
695
        int x = s->pix2_map[plane1][code];\
696
        dst0 = x>>8;\
697
        dst1 = x;\
698
    }else{\
699
        dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
700
        dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
701
    }\
702
}
703

    
704
static void decode_422_bitstream(HYuvContext *s, int count){
705
    int i;
706

    
707
    count/=2;
708

    
709
    for(i=0; i<count; i++){
710
        READ_2PIX(s->temp[0][2*i  ], s->temp[1][i], 1);
711
        READ_2PIX(s->temp[0][2*i+1], s->temp[2][i], 2);
712
    }
713
}
714

    
715
static void decode_gray_bitstream(HYuvContext *s, int count){
716
    int i;
717

    
718
    count/=2;
719

    
720
    for(i=0; i<count; i++){
721
        READ_2PIX(s->temp[0][2*i  ], s->temp[0][2*i+1], 0);
722
    }
723
}
724

    
725
#ifdef CONFIG_ENCODERS
726
static int encode_422_bitstream(HYuvContext *s, int count){
727
    int i;
728

    
729
    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
730
        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
731
        return -1;
732
    }
733

    
734
#define LOAD4\
735
            int y0 = s->temp[0][2*i];\
736
            int y1 = s->temp[0][2*i+1];\
737
            int u0 = s->temp[1][i];\
738
            int v0 = s->temp[2][i];
739

    
740
    count/=2;
741
    if(s->flags&CODEC_FLAG_PASS1){
742
        for(i=0; i<count; i++){
743
            LOAD4;
744
            s->stats[0][y0]++;
745
            s->stats[1][u0]++;
746
            s->stats[0][y1]++;
747
            s->stats[2][v0]++;
748
        }
749
    }
750
    if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
751
        return 0;
752
    if(s->context){
753
        for(i=0; i<count; i++){
754
            LOAD4;
755
            s->stats[0][y0]++;
756
            put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
757
            s->stats[1][u0]++;
758
            put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
759
            s->stats[0][y1]++;
760
            put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
761
            s->stats[2][v0]++;
762
            put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
763
        }
764
    }else{
765
        for(i=0; i<count; i++){
766
            LOAD4;
767
            put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
768
            put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
769
            put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
770
            put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
771
        }
772
    }
773
    return 0;
774
}
775

    
776
static int encode_gray_bitstream(HYuvContext *s, int count){
777
    int i;
778

    
779
    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
780
        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
781
        return -1;
782
    }
783

    
784
#define LOAD2\
785
            int y0 = s->temp[0][2*i];\
786
            int y1 = s->temp[0][2*i+1];
787
#define STAT2\
788
            s->stats[0][y0]++;\
789
            s->stats[0][y1]++;
790
#define WRITE2\
791
            put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
792
            put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
793

    
794
    count/=2;
795
    if(s->flags&CODEC_FLAG_PASS1){
796
        for(i=0; i<count; i++){
797
            LOAD2;
798
            STAT2;
799
        }
800
    }
801
    if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
802
        return 0;
803

    
804
    if(s->context){
805
        for(i=0; i<count; i++){
806
            LOAD2;
807
            STAT2;
808
            WRITE2;
809
        }
810
    }else{
811
        for(i=0; i<count; i++){
812
            LOAD2;
813
            WRITE2;
814
        }
815
    }
816
    return 0;
817
}
818
#endif /* CONFIG_ENCODERS */
819

    
820
static void decode_bgr_bitstream(HYuvContext *s, int count){
821
    int i;
822

    
823
    if(s->decorrelate){
824
        if(s->bitstream_bpp==24){
825
            for(i=0; i<count; i++){
826
                s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
827
                s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
828
                s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
829
            }
830
        }else{
831
            for(i=0; i<count; i++){
832
                s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
833
                s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
834
                s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
835
                                   get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
836
            }
837
        }
838
    }else{
839
        if(s->bitstream_bpp==24){
840
            for(i=0; i<count; i++){
841
                s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
842
                s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
843
                s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
844
            }
845
        }else{
846
            for(i=0; i<count; i++){
847
                s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
848
                s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
849
                s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
850
                                   get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
851
            }
852
        }
853
    }
854
}
855

    
856
static int encode_bgr_bitstream(HYuvContext *s, int count){
857
    int i;
858

    
859
    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 3*4*count){
860
        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
861
        return -1;
862
    }
863

    
864
#define LOAD3\
865
            int g= s->temp[0][4*i+G];\
866
            int b= (s->temp[0][4*i+B] - g) & 0xff;\
867
            int r= (s->temp[0][4*i+R] - g) & 0xff;
868
#define STAT3\
869
            s->stats[0][b]++;\
870
            s->stats[1][g]++;\
871
            s->stats[2][r]++;
872
#define WRITE3\
873
            put_bits(&s->pb, s->len[1][g], s->bits[1][g]);\
874
            put_bits(&s->pb, s->len[0][b], s->bits[0][b]);\
875
            put_bits(&s->pb, s->len[2][r], s->bits[2][r]);
876

    
877
    if((s->flags&CODEC_FLAG_PASS1) && (s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)){
878
        for(i=0; i<count; i++){
879
            LOAD3;
880
            STAT3;
881
        }
882
    }else if(s->context || (s->flags&CODEC_FLAG_PASS1)){
883
        for(i=0; i<count; i++){
884
            LOAD3;
885
            STAT3;
886
            WRITE3;
887
        }
888
    }else{
889
        for(i=0; i<count; i++){
890
            LOAD3;
891
            WRITE3;
892
        }
893
    }
894
    return 0;
895
}
896

    
897
#ifdef CONFIG_DECODERS
898
static void draw_slice(HYuvContext *s, int y){
899
    int h, cy;
900
    int offset[4];
901

    
902
    if(s->avctx->draw_horiz_band==NULL)
903
        return;
904

    
905
    h= y - s->last_slice_end;
906
    y -= h;
907

    
908
    if(s->bitstream_bpp==12){
909
        cy= y>>1;
910
    }else{
911
        cy= y;
912
    }
913

    
914
    offset[0] = s->picture.linesize[0]*y;
915
    offset[1] = s->picture.linesize[1]*cy;
916
    offset[2] = s->picture.linesize[2]*cy;
917
    offset[3] = 0;
918
    emms_c();
919

    
920
    s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
921

    
922
    s->last_slice_end= y + h;
923
}
924

    
925
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
926
    HYuvContext *s = avctx->priv_data;
927
    const int width= s->width;
928
    const int width2= s->width>>1;
929
    const int height= s->height;
930
    int fake_ystride, fake_ustride, fake_vstride;
931
    AVFrame * const p= &s->picture;
932
    int table_size= 0;
933

    
934
    AVFrame *picture = data;
935

    
936
    s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
937

    
938
    s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4);
939

    
940
    if(p->data[0])
941
        avctx->release_buffer(avctx, p);
942

    
943
    p->reference= 0;
944
    if(avctx->get_buffer(avctx, p) < 0){
945
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
946
        return -1;
947
    }
948

    
949
    if(s->context){
950
        table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
951
        if(table_size < 0)
952
            return -1;
953
    }
954

    
955
    if((unsigned)(buf_size-table_size) >= INT_MAX/8)
956
        return -1;
957

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

    
960
    fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
961
    fake_ustride= s->interlaced ? p->linesize[1]*2  : p->linesize[1];
962
    fake_vstride= s->interlaced ? p->linesize[2]*2  : p->linesize[2];
963

    
964
    s->last_slice_end= 0;
965

    
966
    if(s->bitstream_bpp<24){
967
        int y, cy;
968
        int lefty, leftu, leftv;
969
        int lefttopy, lefttopu, lefttopv;
970

    
971
        if(s->yuy2){
972
            p->data[0][3]= get_bits(&s->gb, 8);
973
            p->data[0][2]= get_bits(&s->gb, 8);
974
            p->data[0][1]= get_bits(&s->gb, 8);
975
            p->data[0][0]= get_bits(&s->gb, 8);
976

    
977
            av_log(avctx, AV_LOG_ERROR, "YUY2 output is not implemented yet\n");
978
            return -1;
979
        }else{
980

    
981
            leftv= p->data[2][0]= get_bits(&s->gb, 8);
982
            lefty= p->data[0][1]= get_bits(&s->gb, 8);
983
            leftu= p->data[1][0]= get_bits(&s->gb, 8);
984
                   p->data[0][0]= get_bits(&s->gb, 8);
985

    
986
            switch(s->predictor){
987
            case LEFT:
988
            case PLANE:
989
                decode_422_bitstream(s, width-2);
990
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
991
                if(!(s->flags&CODEC_FLAG_GRAY)){
992
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
993
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
994
                }
995

    
996
                for(cy=y=1; y<s->height; y++,cy++){
997
                    uint8_t *ydst, *udst, *vdst;
998

    
999
                    if(s->bitstream_bpp==12){
1000
                        decode_gray_bitstream(s, width);
1001

    
1002
                        ydst= p->data[0] + p->linesize[0]*y;
1003

    
1004
                        lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1005
                        if(s->predictor == PLANE){
1006
                            if(y>s->interlaced)
1007
                                s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1008
                        }
1009
                        y++;
1010
                        if(y>=s->height) break;
1011
                    }
1012

    
1013
                    draw_slice(s, y);
1014

    
1015
                    ydst= p->data[0] + p->linesize[0]*y;
1016
                    udst= p->data[1] + p->linesize[1]*cy;
1017
                    vdst= p->data[2] + p->linesize[2]*cy;
1018

    
1019
                    decode_422_bitstream(s, width);
1020
                    lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
1021
                    if(!(s->flags&CODEC_FLAG_GRAY)){
1022
                        leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
1023
                        leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
1024
                    }
1025
                    if(s->predictor == PLANE){
1026
                        if(cy>s->interlaced){
1027
                            s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
1028
                            if(!(s->flags&CODEC_FLAG_GRAY)){
1029
                                s->dsp.add_bytes(udst, udst - fake_ustride, width2);
1030
                                s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
1031
                            }
1032
                        }
1033
                    }
1034
                }
1035
                draw_slice(s, height);
1036

    
1037
                break;
1038
            case MEDIAN:
1039
                /* first line except first 2 pixels is left predicted */
1040
                decode_422_bitstream(s, width-2);
1041
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
1042
                if(!(s->flags&CODEC_FLAG_GRAY)){
1043
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
1044
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
1045
                }
1046

    
1047
                cy=y=1;
1048

    
1049
                /* second line is left predicted for interlaced case */
1050
                if(s->interlaced){
1051
                    decode_422_bitstream(s, width);
1052
                    lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
1053
                    if(!(s->flags&CODEC_FLAG_GRAY)){
1054
                        leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1055
                        leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1056
                    }
1057
                    y++; cy++;
1058
                }
1059

    
1060
                /* next 4 pixels are left predicted too */
1061
                decode_422_bitstream(s, 4);
1062
                lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
1063
                if(!(s->flags&CODEC_FLAG_GRAY)){
1064
                    leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1065
                    leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1066
                }
1067

    
1068
                /* next line except the first 4 pixels is median predicted */
1069
                lefttopy= p->data[0][3];
1070
                decode_422_bitstream(s, width-4);
1071
                add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
1072
                if(!(s->flags&CODEC_FLAG_GRAY)){
1073
                    lefttopu= p->data[1][1];
1074
                    lefttopv= p->data[2][1];
1075
                    add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
1076
                    add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
1077
                }
1078
                y++; cy++;
1079

    
1080
                for(; y<height; y++,cy++){
1081
                    uint8_t *ydst, *udst, *vdst;
1082

    
1083
                    if(s->bitstream_bpp==12){
1084
                        while(2*cy > y){
1085
                            decode_gray_bitstream(s, width);
1086
                            ydst= p->data[0] + p->linesize[0]*y;
1087
                            add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1088
                            y++;
1089
                        }
1090
                        if(y>=height) break;
1091
                    }
1092
                    draw_slice(s, y);
1093

    
1094
                    decode_422_bitstream(s, width);
1095

    
1096
                    ydst= p->data[0] + p->linesize[0]*y;
1097
                    udst= p->data[1] + p->linesize[1]*cy;
1098
                    vdst= p->data[2] + p->linesize[2]*cy;
1099

    
1100
                    add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
1101
                    if(!(s->flags&CODEC_FLAG_GRAY)){
1102
                        add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1103
                        add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1104
                    }
1105
                }
1106

    
1107
                draw_slice(s, height);
1108
                break;
1109
            }
1110
        }
1111
    }else{
1112
        int y;
1113
        int leftr, leftg, leftb;
1114
        const int last_line= (height-1)*p->linesize[0];
1115

    
1116
        if(s->bitstream_bpp==32){
1117
            skip_bits(&s->gb, 8);
1118
            leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1119
            leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1120
            leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1121
        }else{
1122
            leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
1123
            leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
1124
            leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
1125
            skip_bits(&s->gb, 8);
1126
        }
1127

    
1128
        if(s->bgr32){
1129
            switch(s->predictor){
1130
            case LEFT:
1131
            case PLANE:
1132
                decode_bgr_bitstream(s, width-1);
1133
                add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
1134

    
1135
                for(y=s->height-2; y>=0; y--){ //yes its stored upside down
1136
                    decode_bgr_bitstream(s, width);
1137

    
1138
                    add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
1139
                    if(s->predictor == PLANE){
1140
                        if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
1141
                            s->dsp.add_bytes(p->data[0] + p->linesize[0]*y,
1142
                                             p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
1143
                        }
1144
                    }
1145
                }
1146
                draw_slice(s, height); // just 1 large slice as this is not possible in reverse order
1147
                break;
1148
            default:
1149
                av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
1150
            }
1151
        }else{
1152

    
1153
            av_log(avctx, AV_LOG_ERROR, "BGR24 output is not implemented yet\n");
1154
            return -1;
1155
        }
1156
    }
1157
    emms_c();
1158

    
1159
    *picture= *p;
1160
    *data_size = sizeof(AVFrame);
1161

    
1162
    return (get_bits_count(&s->gb)+31)/32*4 + table_size;
1163
}
1164
#endif
1165

    
1166
static int common_end(HYuvContext *s){
1167
    int i;
1168

    
1169
    for(i=0; i<3; i++){
1170
        av_freep(&s->temp[i]);
1171
    }
1172
    return 0;
1173
}
1174

    
1175
#ifdef CONFIG_DECODERS
1176
static int decode_end(AVCodecContext *avctx)
1177
{
1178
    HYuvContext *s = avctx->priv_data;
1179
    int i;
1180

    
1181
    common_end(s);
1182
    av_freep(&s->bitstream_buffer);
1183

    
1184
    for(i=0; i<3; i++){
1185
        free_vlc(&s->vlc[i]);
1186
    }
1187

    
1188
    return 0;
1189
}
1190
#endif
1191

    
1192
#ifdef CONFIG_ENCODERS
1193
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1194
    HYuvContext *s = avctx->priv_data;
1195
    AVFrame *pict = data;
1196
    const int width= s->width;
1197
    const int width2= s->width>>1;
1198
    const int height= s->height;
1199
    const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
1200
    const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
1201
    const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
1202
    AVFrame * const p= &s->picture;
1203
    int i, j, size=0;
1204

    
1205
    *p = *pict;
1206
    p->pict_type= FF_I_TYPE;
1207
    p->key_frame= 1;
1208

    
1209
    if(s->context){
1210
        for(i=0; i<3; i++){
1211
            generate_len_table(s->len[i], s->stats[i], 256);
1212
            if(generate_bits_table(s->bits[i], s->len[i])<0)
1213
                return -1;
1214
            size+= store_table(s, s->len[i], &buf[size]);
1215
        }
1216

    
1217
        for(i=0; i<3; i++)
1218
            for(j=0; j<256; j++)
1219
                s->stats[i][j] >>= 1;
1220
    }
1221

    
1222
    init_put_bits(&s->pb, buf+size, buf_size-size);
1223

    
1224
    if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1225
        int lefty, leftu, leftv, y, cy;
1226

    
1227
        put_bits(&s->pb, 8, leftv= p->data[2][0]);
1228
        put_bits(&s->pb, 8, lefty= p->data[0][1]);
1229
        put_bits(&s->pb, 8, leftu= p->data[1][0]);
1230
        put_bits(&s->pb, 8,        p->data[0][0]);
1231

    
1232
        lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
1233
        leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
1234
        leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
1235

    
1236
        encode_422_bitstream(s, width-2);
1237

    
1238
        if(s->predictor==MEDIAN){
1239
            int lefttopy, lefttopu, lefttopv;
1240
            cy=y=1;
1241
            if(s->interlaced){
1242
                lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1243
                leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1244
                leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
1245

    
1246
                encode_422_bitstream(s, width);
1247
                y++; cy++;
1248
            }
1249

    
1250
            lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
1251
            leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1252
            leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
1253

    
1254
            encode_422_bitstream(s, 4);
1255

    
1256
            lefttopy= p->data[0][3];
1257
            lefttopu= p->data[1][1];
1258
            lefttopv= p->data[2][1];
1259
            s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1260
            s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1261
            s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
1262
            encode_422_bitstream(s, width-4);
1263
            y++; cy++;
1264

    
1265
            for(; y<height; y++,cy++){
1266
                uint8_t *ydst, *udst, *vdst;
1267

    
1268
                if(s->bitstream_bpp==12){
1269
                    while(2*cy > y){
1270
                        ydst= p->data[0] + p->linesize[0]*y;
1271
                        s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1272
                        encode_gray_bitstream(s, width);
1273
                        y++;
1274
                    }
1275
                    if(y>=height) break;
1276
                }
1277
                ydst= p->data[0] + p->linesize[0]*y;
1278
                udst= p->data[1] + p->linesize[1]*cy;
1279
                vdst= p->data[2] + p->linesize[2]*cy;
1280

    
1281
                s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1282
                s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1283
                s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1284

    
1285
                encode_422_bitstream(s, width);
1286
            }
1287
        }else{
1288
            for(cy=y=1; y<height; y++,cy++){
1289
                uint8_t *ydst, *udst, *vdst;
1290

    
1291
                /* encode a luma only line & y++ */
1292
                if(s->bitstream_bpp==12){
1293
                    ydst= p->data[0] + p->linesize[0]*y;
1294

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

    
1298
                        lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1299
                    }else{
1300
                        lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1301
                    }
1302
                    encode_gray_bitstream(s, width);
1303
                    y++;
1304
                    if(y>=height) break;
1305
                }
1306

    
1307
                ydst= p->data[0] + p->linesize[0]*y;
1308
                udst= p->data[1] + p->linesize[1]*cy;
1309
                vdst= p->data[2] + p->linesize[2]*cy;
1310

    
1311
                if(s->predictor == PLANE && s->interlaced < cy){
1312
                    s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1313
                    s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1314
                    s->dsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
1315

    
1316
                    lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1317
                    leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1318
                    leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
1319
                }else{
1320
                    lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1321
                    leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1322
                    leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1323
                }
1324

    
1325
                encode_422_bitstream(s, width);
1326
            }
1327
        }
1328
    }else if(avctx->pix_fmt == PIX_FMT_RGB32){
1329
        uint8_t *data = p->data[0] + (height-1)*p->linesize[0];
1330
        const int stride = -p->linesize[0];
1331
        const int fake_stride = -fake_ystride;
1332
        int y;
1333
        int leftr, leftg, leftb;
1334

    
1335
        put_bits(&s->pb, 8, leftr= data[R]);
1336
        put_bits(&s->pb, 8, leftg= data[G]);
1337
        put_bits(&s->pb, 8, leftb= data[B]);
1338
        put_bits(&s->pb, 8, 0);
1339

    
1340
        sub_left_prediction_bgr32(s, s->temp[0], data+4, width-1, &leftr, &leftg, &leftb);
1341
        encode_bgr_bitstream(s, width-1);
1342

    
1343
        for(y=1; y<s->height; y++){
1344
            uint8_t *dst = data + y*stride;
1345
            if(s->predictor == PLANE && s->interlaced < y){
1346
                s->dsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width*4);
1347
                sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width, &leftr, &leftg, &leftb);
1348
            }else{
1349
                sub_left_prediction_bgr32(s, s->temp[0], dst, width, &leftr, &leftg, &leftb);
1350
            }
1351
            encode_bgr_bitstream(s, width);
1352
        }
1353
    }else{
1354
        av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1355
    }
1356
    emms_c();
1357

    
1358
    size+= (put_bits_count(&s->pb)+31)/8;
1359
    size/= 4;
1360

    
1361
    if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1362
        int j;
1363
        char *p= avctx->stats_out;
1364
        char *end= p + 1024*30;
1365
        for(i=0; i<3; i++){
1366
            for(j=0; j<256; j++){
1367
                snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1368
                p+= strlen(p);
1369
                s->stats[i][j]= 0;
1370
            }
1371
            snprintf(p, end-p, "\n");
1372
            p++;
1373
        }
1374
    } else
1375
        avctx->stats_out[0] = '\0';
1376
    if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
1377
        flush_put_bits(&s->pb);
1378
        s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1379
    }
1380

    
1381
    s->picture_number++;
1382

    
1383
    return size*4;
1384
}
1385

    
1386
static int encode_end(AVCodecContext *avctx)
1387
{
1388
    HYuvContext *s = avctx->priv_data;
1389

    
1390
    common_end(s);
1391

    
1392
    av_freep(&avctx->extradata);
1393
    av_freep(&avctx->stats_out);
1394

    
1395
    return 0;
1396
}
1397
#endif /* CONFIG_ENCODERS */
1398

    
1399
#ifdef CONFIG_DECODERS
1400
AVCodec huffyuv_decoder = {
1401
    "huffyuv",
1402
    CODEC_TYPE_VIDEO,
1403
    CODEC_ID_HUFFYUV,
1404
    sizeof(HYuvContext),
1405
    decode_init,
1406
    NULL,
1407
    decode_end,
1408
    decode_frame,
1409
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1410
    NULL
1411
};
1412

    
1413
AVCodec ffvhuff_decoder = {
1414
    "ffvhuff",
1415
    CODEC_TYPE_VIDEO,
1416
    CODEC_ID_FFVHUFF,
1417
    sizeof(HYuvContext),
1418
    decode_init,
1419
    NULL,
1420
    decode_end,
1421
    decode_frame,
1422
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1423
    NULL
1424
};
1425
#endif
1426

    
1427
#ifdef CONFIG_ENCODERS
1428

    
1429
AVCodec huffyuv_encoder = {
1430
    "huffyuv",
1431
    CODEC_TYPE_VIDEO,
1432
    CODEC_ID_HUFFYUV,
1433
    sizeof(HYuvContext),
1434
    encode_init,
1435
    encode_frame,
1436
    encode_end,
1437
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV422P, PIX_FMT_RGB32, -1},
1438
};
1439

    
1440
AVCodec ffvhuff_encoder = {
1441
    "ffvhuff",
1442
    CODEC_TYPE_VIDEO,
1443
    CODEC_ID_FFVHUFF,
1444
    sizeof(HYuvContext),
1445
    encode_init,
1446
    encode_frame,
1447
    encode_end,
1448
    .pix_fmts= (enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_RGB32, -1},
1449
};
1450

    
1451
#endif //CONFIG_ENCODERS