Statistics
| Branch: | Revision:

ffmpeg / libavcodec / huffyuv.c @ f45fcba3

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
    AVFrame picture;
75
    uint8_t *bitstream_buffer;
76
    unsigned int bitstream_buffer_size;
77
    DSPContext dsp;
78
}HYuvContext;
79

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

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

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

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

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

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

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

    
146
    return acc;
147
}
148

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
321
static void generate_joint_tables(HYuvContext *s){
322
    // TODO rgb
323
    if(s->bitstream_bpp < 24){
324
        uint16_t symbols[1<<VLC_BITS];
325
        uint16_t bits[1<<VLC_BITS];
326
        uint8_t len[1<<VLC_BITS];
327
        int p, i, y, u;
328
        for(p=0; p<3; p++){
329
            for(i=y=0; y<256; y++){
330
                int len0 = s->len[0][y];
331
                int limit = VLC_BITS - len0;
332
                if(limit <= 0)
333
                    continue;
334
                for(u=0; u<256; u++){
335
                    int len1 = s->len[p][u];
336
                    if(len1 > limit)
337
                        continue;
338
                    len[i] = len0 + len1;
339
                    bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
340
                    symbols[i] = (y<<8) + u;
341
                    if(symbols[i] != 0xffff) // reserved to mean "invalid"
342
                        i++;
343
                }
344
            }
345
            free_vlc(&s->vlc[3+p]);
346
            init_vlc_sparse(&s->vlc[3+p], VLC_BITS, i, len, 1, 1, bits, 2, 2, symbols, 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
    uint16_t code = get_vlc2(&s->gb, s->vlc[3+plane1].table, VLC_BITS, 1);\
694
    if(code != 0xffff){\
695
        dst0 = code>>8;\
696
        dst1 = code;\
697
    }else{\
698
        dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);\
699
        dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3);\
700
    }\
701
}
702

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

    
706
    count/=2;
707

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

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

    
717
    count/=2;
718

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
933
    AVFrame *picture = data;
934

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

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

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

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

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

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

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

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

    
963
    s->last_slice_end= 0;
964

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

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

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

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

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

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

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

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

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

    
1012
                    draw_slice(s, y);
1013

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

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

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

    
1046
                cy=y=1;
1047

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

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

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

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

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

    
1093
                    decode_422_bitstream(s, width);
1094

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1187
    return 0;
1188
}
1189
#endif
1190

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

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

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

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

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

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

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

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

    
1235
        encode_422_bitstream(s, width-2);
1236

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

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

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

    
1253
            encode_422_bitstream(s, 4);
1254

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    
1380
    s->picture_number++;
1381

    
1382
    return size*4;
1383
}
1384

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

    
1389
    common_end(s);
1390

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

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

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

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

    
1426
#ifdef CONFIG_ENCODERS
1427

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

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

    
1450
#endif //CONFIG_ENCODERS