Statistics
| Branch: | Revision:

ffmpeg / libavcodec / huffyuv.c @ 09b0499f

History | View | Annotate | Download (41.4 KB)

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

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

    
34
#define VLC_BITS 11
35

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

    
46
typedef enum Predictor{
47
    LEFT= 0,
48
    PLANE,
49
    MEDIAN,
50
} Predictor;
51
 
52
typedef struct HYuvContext{
53
    AVCodecContext *avctx;
54
    Predictor predictor;
55
    GetBitContext gb;
56
    PutBitContext pb;
57
    int interlaced;
58
    int decorrelate;
59
    int bitstream_bpp;
60
    int version;
61
    int yuy2;                               //use yuy2 instead of 422P
62
    int bgr32;                              //use bgr32 instead of bgr24
63
    int width, height;
64
    int flags;
65
    int context;
66
    int picture_number;
67
    int last_slice_end;
68
    uint8_t *temp[3];
69
    uint64_t stats[3][256];
70
    uint8_t len[3][256];
71
    uint32_t bits[3][256];
72
    VLC vlc[3];
73
    AVFrame picture;
74
    uint8_t *bitstream_buffer;
75
    int bitstream_buffer_size;
76
    DSPContext dsp; 
77
}HYuvContext;
78

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

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

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

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

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

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

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

    
145
    return acc;
146
}
147

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

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

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

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

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

    
172
    for(i=0; i<w; i++){
173
        b+= src[4*i+B];
174
        g+= src[4*i+G];
175
        r+= src[4*i+R];
176
        
177
        dst[4*i+B]= b;
178
        dst[4*i+G]= g;
179
        dst[4*i+R]= r;
180
    }
181

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

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

    
207
static void read_len_table(uint8_t *dst, GetBitContext *gb){
208
    int i, val, repeat;
209
  
210
    for(i=0; i<256;){
211
        repeat= get_bits(gb, 3);
212
        val   = get_bits(gb, 5);
213
        if(repeat==0)
214
            repeat= get_bits(gb, 8);
215
//printf("%d %d\n", val, repeat);
216
        while (repeat--)
217
            dst[i++] = val;
218
    }
219
}
220

    
221
static int generate_bits_table(uint32_t *dst, uint8_t *len_table){
222
    int len, index;
223
    uint32_t bits=0;
224

    
225
    for(len=32; len>0; len--){
226
        for(index=0; index<256; index++){
227
            if(len_table[index]==len)
228
                dst[index]= bits++;
229
        }
230
        if(bits & 1){
231
            av_log(NULL, AV_LOG_ERROR, "Error generating huffman table\n");
232
            return -1;
233
        }
234
        bits >>= 1;
235
    }
236
    return 0;
237
}
238

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

    
295
static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
296
    GetBitContext gb;
297
    int i;
298
    
299
    init_get_bits(&gb, src, length*8);
300
    
301
    for(i=0; i<3; i++){
302
        read_len_table(s->len[i], &gb);
303
        
304
        if(generate_bits_table(s->bits[i], s->len[i])<0){
305
            return -1;
306
        }
307
#if 0
308
for(j=0; j<256; j++){
309
printf("%6X, %2d,  %3d\n", s->bits[i][j], s->len[i][j], j);
310
}
311
#endif
312
        free_vlc(&s->vlc[i]);
313
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
314
    }
315
    
316
    return (get_bits_count(&gb)+7)/8;
317
}
318

    
319
static int read_old_huffman_tables(HYuvContext *s){
320
#if 1
321
    GetBitContext gb;
322
    int i;
323

    
324
    init_get_bits(&gb, classic_shift_luma, sizeof(classic_shift_luma)*8);
325
    read_len_table(s->len[0], &gb);
326
    init_get_bits(&gb, classic_shift_chroma, sizeof(classic_shift_chroma)*8);
327
    read_len_table(s->len[1], &gb);
328
    
329
    for(i=0; i<256; i++) s->bits[0][i] = classic_add_luma  [i];
330
    for(i=0; i<256; i++) s->bits[1][i] = classic_add_chroma[i];
331

    
332
    if(s->bitstream_bpp >= 24){
333
        memcpy(s->bits[1], s->bits[0], 256*sizeof(uint32_t));
334
        memcpy(s->len[1] , s->len [0], 256*sizeof(uint8_t));
335
    }
336
    memcpy(s->bits[2], s->bits[1], 256*sizeof(uint32_t));
337
    memcpy(s->len[2] , s->len [1], 256*sizeof(uint8_t));
338
    
339
    for(i=0; i<3; i++){
340
        free_vlc(&s->vlc[i]);
341
        init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1, s->bits[i], 4, 4, 0);
342
    }
343
    
344
    return 0;
345
#else
346
    fprintf(stderr, "v1 huffyuv is not supported \n");
347
    return -1;
348
#endif
349
}
350

    
351
static int common_init(AVCodecContext *avctx){
352
    HYuvContext *s = avctx->priv_data;
353
    int i;
354

    
355
    s->avctx= avctx;
356
    s->flags= avctx->flags;
357
        
358
    dsputil_init(&s->dsp, avctx);
359
    
360
    s->width= avctx->width;
361
    s->height= avctx->height;
362
    assert(s->width>0 && s->height>0);
363
    
364
    for(i=0; i<3; i++){
365
        s->temp[i]= av_malloc(avctx->width + 16);
366
    }
367
    return 0;
368
}
369

    
370
static int decode_init(AVCodecContext *avctx)
371
{
372
    HYuvContext *s = avctx->priv_data;
373

    
374
    common_init(avctx);
375
    memset(s->vlc, 0, 3*sizeof(VLC));
376
    
377
    avctx->coded_frame= &s->picture;
378
    s->interlaced= s->height > 288;
379

    
380
s->bgr32=1;
381
//if(avctx->extradata)
382
//  printf("extradata:%X, extradata_size:%d\n", *(uint32_t*)avctx->extradata, avctx->extradata_size);
383
    if(avctx->extradata_size){
384
        if((avctx->bits_per_sample&7) && avctx->bits_per_sample != 12)
385
            s->version=1; // do such files exist at all?
386
        else
387
            s->version=2;
388
    }else
389
        s->version=0;
390
    
391
    if(s->version==2){
392
        int method, interlace;
393

    
394
        method= ((uint8_t*)avctx->extradata)[0];
395
        s->decorrelate= method&64 ? 1 : 0;
396
        s->predictor= method&63;
397
        s->bitstream_bpp= ((uint8_t*)avctx->extradata)[1];
398
        if(s->bitstream_bpp==0) 
399
            s->bitstream_bpp= avctx->bits_per_sample&~7;
400
        interlace= (((uint8_t*)avctx->extradata)[2] & 0x30) >> 4;
401
        s->interlaced= (interlace==1) ? 1 : (interlace==2) ? 0 : s->interlaced;
402
        s->context= ((uint8_t*)avctx->extradata)[2] & 0x40 ? 1 : 0;
403
            
404
        if(read_huffman_tables(s, ((uint8_t*)avctx->extradata)+4, avctx->extradata_size) < 0)
405
            return -1;
406
    }else{
407
        switch(avctx->bits_per_sample&7){
408
        case 1:
409
            s->predictor= LEFT;
410
            s->decorrelate= 0;
411
            break;
412
        case 2:
413
            s->predictor= LEFT;
414
            s->decorrelate= 1;
415
            break;
416
        case 3:
417
            s->predictor= PLANE;
418
            s->decorrelate= avctx->bits_per_sample >= 24;
419
            break;
420
        case 4:
421
            s->predictor= MEDIAN;
422
            s->decorrelate= 0;
423
            break;
424
        default:
425
            s->predictor= LEFT; //OLD
426
            s->decorrelate= 0;
427
            break;
428
        }
429
        s->bitstream_bpp= avctx->bits_per_sample & ~7;
430
        s->context= 0;
431
        
432
        if(read_old_huffman_tables(s) < 0)
433
            return -1;
434
    }
435
    
436
    switch(s->bitstream_bpp){
437
    case 12:
438
        avctx->pix_fmt = PIX_FMT_YUV420P;
439
        break;
440
    case 16:
441
        if(s->yuy2){
442
            avctx->pix_fmt = PIX_FMT_YUV422;
443
        }else{
444
            avctx->pix_fmt = PIX_FMT_YUV422P;
445
        }
446
        break;
447
    case 24:
448
    case 32:
449
        if(s->bgr32){
450
            avctx->pix_fmt = PIX_FMT_RGBA32;
451
        }else{
452
            avctx->pix_fmt = PIX_FMT_BGR24;
453
        }
454
        break;
455
    default:
456
        assert(0);
457
    }
458
    
459
//    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);
460

    
461
    return 0;
462
}
463

    
464
static int store_table(HYuvContext *s, uint8_t *len, uint8_t *buf){
465
    int i;
466
    int index= 0;
467

    
468
    for(i=0; i<256;){
469
        int val= len[i];
470
        int repeat=0;
471
        
472
        for(; i<256 && len[i]==val && repeat<255; i++)
473
            repeat++;
474
        
475
        assert(val < 32 && val >0 && repeat<256 && repeat>0);
476
        if(repeat>7){
477
            buf[index++]= val;
478
            buf[index++]= repeat;
479
        }else{
480
            buf[index++]= val | (repeat<<5);
481
        }
482
    }
483
    
484
    return index;
485
}
486

    
487
static int encode_init(AVCodecContext *avctx)
488
{
489
    HYuvContext *s = avctx->priv_data;
490
    int i, j;
491

    
492
    common_init(avctx);
493
    
494
    avctx->extradata= av_mallocz(1024*30); // 256*3+4 == 772
495
    avctx->stats_out= av_mallocz(1024*30); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
496
    s->version=2;
497
    
498
    avctx->coded_frame= &s->picture;
499
    
500
    switch(avctx->pix_fmt){
501
    case PIX_FMT_YUV420P:
502
        s->bitstream_bpp= 12;
503
        break;
504
    case PIX_FMT_YUV422P:
505
        s->bitstream_bpp= 16;
506
        break;
507
    default:
508
        av_log(avctx, AV_LOG_ERROR, "format not supported\n");
509
        return -1;
510
    }
511
    avctx->bits_per_sample= s->bitstream_bpp;
512
    s->decorrelate= s->bitstream_bpp >= 24;
513
    s->predictor= avctx->prediction_method;
514
    s->interlaced= avctx->flags&CODEC_FLAG_INTERLACED_ME ? 1 : 0;
515
    if(avctx->context_model==1){
516
        s->context= avctx->context_model;
517
        if(s->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
518
            av_log(avctx, AV_LOG_ERROR, "context=1 is not compatible with 2 pass huffyuv encoding\n");
519
            return -1;
520
        }
521
    }else s->context= 0;
522
    
523
    if(avctx->codec->id==CODEC_ID_HUFFYUV){
524
        if(avctx->pix_fmt==PIX_FMT_YUV420P){
525
            av_log(avctx, AV_LOG_ERROR, "Error: YV12 is not supported by huffyuv; use vcodec=ffvhuff or format=422p\n");
526
            return -1;
527
        }
528
        if(avctx->context_model){
529
            av_log(avctx, AV_LOG_ERROR, "Error: per-frame huffman tables are not supported by huffyuv; use vcodec=ffvhuff\n");
530
            return -1;
531
        }
532
        if(s->interlaced != ( s->height > 288 ))
533
            av_log(avctx, AV_LOG_INFO, "using huffyuv 2.2.0 or newer interlacing flag\n");
534
    }else if(avctx->strict_std_compliance>=0){
535
        av_log(avctx, AV_LOG_ERROR, "This codec is under development; files encoded with it may not be decodeable with future versions!!! Set vstrict=-1 to use it anyway.\n");
536
        return -1;
537
    }
538
    
539
    ((uint8_t*)avctx->extradata)[0]= s->predictor;
540
    ((uint8_t*)avctx->extradata)[1]= s->bitstream_bpp;
541
    ((uint8_t*)avctx->extradata)[2]= s->interlaced ? 0x10 : 0x20;
542
    if(s->context)
543
        ((uint8_t*)avctx->extradata)[2]|= 0x40;
544
    ((uint8_t*)avctx->extradata)[3]= 0;
545
    s->avctx->extradata_size= 4;
546
    
547
    if(avctx->stats_in){
548
        char *p= avctx->stats_in;
549
    
550
        for(i=0; i<3; i++)
551
            for(j=0; j<256; j++)
552
                s->stats[i][j]= 1;
553

    
554
        for(;;){
555
            for(i=0; i<3; i++){
556
                char *next;
557

    
558
                for(j=0; j<256; j++){
559
                    s->stats[i][j]+= strtol(p, &next, 0);
560
                    if(next==p) return -1;
561
                    p=next;
562
                }        
563
            }
564
            if(p[0]==0 || p[1]==0 || p[2]==0) break;
565
        }
566
    }else{
567
        for(i=0; i<3; i++)
568
            for(j=0; j<256; j++){
569
                int d= FFMIN(j, 256-j);
570
                
571
                s->stats[i][j]= 100000000/(d+1);
572
            }
573
    }
574
    
575
    for(i=0; i<3; i++){
576
        generate_len_table(s->len[i], s->stats[i], 256);
577

    
578
        if(generate_bits_table(s->bits[i], s->len[i])<0){
579
            return -1;
580
        }
581
        
582
        s->avctx->extradata_size+=
583
        store_table(s, s->len[i], &((uint8_t*)s->avctx->extradata)[s->avctx->extradata_size]);
584
    }
585

    
586
    if(s->context){
587
        for(i=0; i<3; i++){
588
            int pels = s->width*s->height / (i?40:10);
589
            for(j=0; j<256; j++){
590
                int d= FFMIN(j, 256-j);
591
                s->stats[i][j]= pels/(d+1);
592
            }
593
        }
594
    }else{
595
        for(i=0; i<3; i++)
596
            for(j=0; j<256; j++)
597
                s->stats[i][j]= 0;
598
    }
599
    
600
//    printf("pred:%d bpp:%d hbpp:%d il:%d\n", s->predictor, s->bitstream_bpp, avctx->bits_per_sample, s->interlaced);
601

    
602
    s->picture_number=0;
603

    
604
    return 0;
605
}
606

    
607
static void decode_422_bitstream(HYuvContext *s, int count){
608
    int i;
609

    
610
    count/=2;
611
    
612
    for(i=0; i<count; i++){
613
        s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
614
        s->temp[1][  i  ]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
615
        s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
616
        s->temp[2][  i  ]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
617
    }
618
}
619

    
620
static void decode_gray_bitstream(HYuvContext *s, int count){
621
    int i;
622
    
623
    count/=2;
624
    
625
    for(i=0; i<count; i++){
626
        s->temp[0][2*i  ]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
627
        s->temp[0][2*i+1]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); 
628
    }
629
}
630

    
631
static int encode_422_bitstream(HYuvContext *s, int count){
632
    int i;
633
    
634
    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 2*4*count){
635
        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
636
        return -1;
637
    }
638
    
639
    count/=2;
640
    if(s->flags&CODEC_FLAG_PASS1){
641
        for(i=0; i<count; i++){
642
            s->stats[0][ s->temp[0][2*i  ] ]++;
643
            s->stats[1][ s->temp[1][  i  ] ]++;
644
            s->stats[0][ s->temp[0][2*i+1] ]++;
645
            s->stats[2][ s->temp[2][  i  ] ]++;
646
        }
647
    }
648
    if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
649
        return 0;
650
    if(s->context){
651
        for(i=0; i<count; i++){
652
            s->stats[0][ s->temp[0][2*i  ] ]++;
653
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
654
            s->stats[1][ s->temp[1][  i  ] ]++;
655
            put_bits(&s->pb, s->len[1][ s->temp[1][  i  ] ], s->bits[1][ s->temp[1][  i  ] ]);
656
            s->stats[0][ s->temp[0][2*i+1] ]++;
657
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
658
            s->stats[2][ s->temp[2][  i  ] ]++;
659
            put_bits(&s->pb, s->len[2][ s->temp[2][  i  ] ], s->bits[2][ s->temp[2][  i  ] ]);
660
        }
661
    }else{
662
        for(i=0; i<count; i++){
663
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
664
            put_bits(&s->pb, s->len[1][ s->temp[1][  i  ] ], s->bits[1][ s->temp[1][  i  ] ]);
665
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
666
            put_bits(&s->pb, s->len[2][ s->temp[2][  i  ] ], s->bits[2][ s->temp[2][  i  ] ]);
667
        }
668
    }
669
    return 0;
670
}
671

    
672
static int encode_gray_bitstream(HYuvContext *s, int count){
673
    int i;
674
    
675
    if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < 4*count){
676
        av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
677
        return -1;
678
    }
679

    
680
    count/=2;
681
    if(s->flags&CODEC_FLAG_PASS1){
682
        for(i=0; i<count; i++){
683
            s->stats[0][ s->temp[0][2*i  ] ]++;
684
            s->stats[0][ s->temp[0][2*i+1] ]++;
685
        }
686
    }
687
    if(s->avctx->flags2&CODEC_FLAG2_NO_OUTPUT)
688
        return 0;
689
    
690
    if(s->context){
691
        for(i=0; i<count; i++){
692
            s->stats[0][ s->temp[0][2*i  ] ]++;
693
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
694
            s->stats[0][ s->temp[0][2*i+1] ]++;
695
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
696
        }
697
    }else{
698
        for(i=0; i<count; i++){
699
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i  ] ], s->bits[0][ s->temp[0][2*i  ] ]);
700
            put_bits(&s->pb, s->len[0][ s->temp[0][2*i+1] ], s->bits[0][ s->temp[0][2*i+1] ]);
701
        }
702
    }
703
    return 0;
704
}
705

    
706
static void decode_bgr_bitstream(HYuvContext *s, int count){
707
    int i;
708

    
709
    if(s->decorrelate){
710
        if(s->bitstream_bpp==24){
711
            for(i=0; i<count; i++){
712
                s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
713
                s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
714
                s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G];
715
            }
716
        }else{
717
            for(i=0; i<count; i++){
718
                s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
719
                s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) + s->temp[0][4*i+G];
720
                s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) + s->temp[0][4*i+G]; 
721
                                   get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
722
            }
723
        }
724
    }else{
725
        if(s->bitstream_bpp==24){
726
            for(i=0; i<count; i++){
727
                s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
728
                s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
729
                s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
730
            }
731
        }else{
732
            for(i=0; i<count; i++){
733
                s->temp[0][4*i+B]= get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
734
                s->temp[0][4*i+G]= get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3); 
735
                s->temp[0][4*i+R]= get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); 
736
                                   get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3); //?!
737
            }
738
        }
739
    }
740
}
741

    
742
static void draw_slice(HYuvContext *s, int y){
743
    int h, cy;
744
    int offset[4];
745
    
746
    if(s->avctx->draw_horiz_band==NULL) 
747
        return;
748
        
749
    h= y - s->last_slice_end;
750
    y -= h;
751
    
752
    if(s->bitstream_bpp==12){
753
        cy= y>>1;
754
    }else{
755
        cy= y;
756
    }
757

    
758
    offset[0] = s->picture.linesize[0]*y;
759
    offset[1] = s->picture.linesize[1]*cy;
760
    offset[2] = s->picture.linesize[2]*cy;
761
    offset[3] = 0;
762
    emms_c();
763

    
764
    s->avctx->draw_horiz_band(s->avctx, &s->picture, offset, y, 3, h);
765
    
766
    s->last_slice_end= y + h;
767
}
768

    
769
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
770
    HYuvContext *s = avctx->priv_data;
771
    const int width= s->width;
772
    const int width2= s->width>>1;
773
    const int height= s->height;
774
    int fake_ystride, fake_ustride, fake_vstride;
775
    AVFrame * const p= &s->picture;
776
    int table_size= 0;
777

    
778
    AVFrame *picture = data;
779

    
780
    s->bitstream_buffer= av_fast_realloc(s->bitstream_buffer, &s->bitstream_buffer_size, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
781

    
782
    s->dsp.bswap_buf((uint32_t*)s->bitstream_buffer, (uint32_t*)buf, buf_size/4);
783
    
784
    if(p->data[0])
785
        avctx->release_buffer(avctx, p);
786

    
787
    p->reference= 0;
788
    if(avctx->get_buffer(avctx, p) < 0){
789
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
790
        return -1;
791
    }
792
    
793
    if(s->context){
794
        table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
795
        if(table_size < 0)
796
            return -1;
797
    }
798

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

    
801
    fake_ystride= s->interlaced ? p->linesize[0]*2  : p->linesize[0];
802
    fake_ustride= s->interlaced ? p->linesize[1]*2  : p->linesize[1];
803
    fake_vstride= s->interlaced ? p->linesize[2]*2  : p->linesize[2];
804
    
805
    s->last_slice_end= 0;
806
        
807
    if(s->bitstream_bpp<24){
808
        int y, cy;
809
        int lefty, leftu, leftv;
810
        int lefttopy, lefttopu, lefttopv;
811
        
812
        if(s->yuy2){
813
            p->data[0][3]= get_bits(&s->gb, 8);
814
            p->data[0][2]= get_bits(&s->gb, 8);
815
            p->data[0][1]= get_bits(&s->gb, 8);
816
            p->data[0][0]= get_bits(&s->gb, 8);
817
            
818
            av_log(avctx, AV_LOG_ERROR, "YUY2 output isnt implemenetd yet\n");
819
            return -1;
820
        }else{
821
        
822
            leftv= p->data[2][0]= get_bits(&s->gb, 8);
823
            lefty= p->data[0][1]= get_bits(&s->gb, 8);
824
            leftu= p->data[1][0]= get_bits(&s->gb, 8);
825
                   p->data[0][0]= get_bits(&s->gb, 8);
826
        
827
            switch(s->predictor){
828
            case LEFT:
829
            case PLANE:
830
                decode_422_bitstream(s, width-2);
831
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
832
                if(!(s->flags&CODEC_FLAG_GRAY)){
833
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
834
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
835
                }
836

    
837
                for(cy=y=1; y<s->height; y++,cy++){
838
                    uint8_t *ydst, *udst, *vdst;
839
                    
840
                    if(s->bitstream_bpp==12){
841
                        decode_gray_bitstream(s, width);
842
                    
843
                        ydst= p->data[0] + p->linesize[0]*y;
844

    
845
                        lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
846
                        if(s->predictor == PLANE){
847
                            if(y>s->interlaced)
848
                                s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
849
                        }
850
                        y++;
851
                        if(y>=s->height) break;
852
                    }
853
                    
854
                    draw_slice(s, y);
855
                    
856
                    ydst= p->data[0] + p->linesize[0]*y;
857
                    udst= p->data[1] + p->linesize[1]*cy;
858
                    vdst= p->data[2] + p->linesize[2]*cy;
859
                    
860
                    decode_422_bitstream(s, width);
861
                    lefty= add_left_prediction(ydst, s->temp[0], width, lefty);
862
                    if(!(s->flags&CODEC_FLAG_GRAY)){
863
                        leftu= add_left_prediction(udst, s->temp[1], width2, leftu);
864
                        leftv= add_left_prediction(vdst, s->temp[2], width2, leftv);
865
                    }
866
                    if(s->predictor == PLANE){
867
                        if(cy>s->interlaced){
868
                            s->dsp.add_bytes(ydst, ydst - fake_ystride, width);
869
                            if(!(s->flags&CODEC_FLAG_GRAY)){
870
                                s->dsp.add_bytes(udst, udst - fake_ustride, width2);
871
                                s->dsp.add_bytes(vdst, vdst - fake_vstride, width2);
872
                            }
873
                        }
874
                    }
875
                }
876
                draw_slice(s, height);
877
                
878
                break;
879
            case MEDIAN:
880
                /* first line except first 2 pixels is left predicted */
881
                decode_422_bitstream(s, width-2);
882
                lefty= add_left_prediction(p->data[0] + 2, s->temp[0], width-2, lefty);
883
                if(!(s->flags&CODEC_FLAG_GRAY)){
884
                    leftu= add_left_prediction(p->data[1] + 1, s->temp[1], width2-1, leftu);
885
                    leftv= add_left_prediction(p->data[2] + 1, s->temp[2], width2-1, leftv);
886
                }
887
                
888
                cy=y=1;
889
                
890
                /* second line is left predicted for interlaced case */
891
                if(s->interlaced){
892
                    decode_422_bitstream(s, width);
893
                    lefty= add_left_prediction(p->data[0] + p->linesize[0], s->temp[0], width, lefty);
894
                    if(!(s->flags&CODEC_FLAG_GRAY)){
895
                        leftu= add_left_prediction(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
896
                        leftv= add_left_prediction(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
897
                    }
898
                    y++; cy++;
899
                }
900

    
901
                /* next 4 pixels are left predicted too */
902
                decode_422_bitstream(s, 4);
903
                lefty= add_left_prediction(p->data[0] + fake_ystride, s->temp[0], 4, lefty);
904
                if(!(s->flags&CODEC_FLAG_GRAY)){
905
                    leftu= add_left_prediction(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
906
                    leftv= add_left_prediction(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
907
                }
908

    
909
                /* next line except the first 4 pixels is median predicted */
910
                lefttopy= p->data[0][3];
911
                decode_422_bitstream(s, width-4);
912
                add_median_prediction(p->data[0] + fake_ystride+4, p->data[0]+4, s->temp[0], width-4, &lefty, &lefttopy);
913
                if(!(s->flags&CODEC_FLAG_GRAY)){
914
                    lefttopu= p->data[1][1];
915
                    lefttopv= p->data[2][1];
916
                    add_median_prediction(p->data[1] + fake_ustride+2, p->data[1]+2, s->temp[1], width2-2, &leftu, &lefttopu);
917
                    add_median_prediction(p->data[2] + fake_vstride+2, p->data[2]+2, s->temp[2], width2-2, &leftv, &lefttopv);
918
                }
919
                y++; cy++;
920
                
921
                for(; y<height; y++,cy++){
922
                    uint8_t *ydst, *udst, *vdst;
923

    
924
                    if(s->bitstream_bpp==12){
925
                        while(2*cy > y){
926
                            decode_gray_bitstream(s, width);
927
                            ydst= p->data[0] + p->linesize[0]*y;
928
                            add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
929
                            y++;
930
                        }
931
                        if(y>=height) break;
932
                    }
933
                    draw_slice(s, y);
934

    
935
                    decode_422_bitstream(s, width);
936

    
937
                    ydst= p->data[0] + p->linesize[0]*y;
938
                    udst= p->data[1] + p->linesize[1]*cy;
939
                    vdst= p->data[2] + p->linesize[2]*cy;
940

    
941
                    add_median_prediction(ydst, ydst - fake_ystride, s->temp[0], width, &lefty, &lefttopy);
942
                    if(!(s->flags&CODEC_FLAG_GRAY)){
943
                        add_median_prediction(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
944
                        add_median_prediction(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
945
                    }
946
                }
947

    
948
                draw_slice(s, height);
949
                break;
950
            }
951
        }
952
    }else{
953
        int y;
954
        int leftr, leftg, leftb;
955
        const int last_line= (height-1)*p->linesize[0];
956
        
957
        if(s->bitstream_bpp==32){
958
            skip_bits(&s->gb, 8);
959
            leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
960
            leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
961
            leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
962
        }else{
963
            leftr= p->data[0][last_line+R]= get_bits(&s->gb, 8);
964
            leftg= p->data[0][last_line+G]= get_bits(&s->gb, 8);
965
            leftb= p->data[0][last_line+B]= get_bits(&s->gb, 8);
966
            skip_bits(&s->gb, 8);
967
        }
968
        
969
        if(s->bgr32){
970
            switch(s->predictor){
971
            case LEFT:
972
            case PLANE:
973
                decode_bgr_bitstream(s, width-1);
974
                add_left_prediction_bgr32(p->data[0] + last_line+4, s->temp[0], width-1, &leftr, &leftg, &leftb);
975

    
976
                for(y=s->height-2; y>=0; y--){ //yes its stored upside down
977
                    decode_bgr_bitstream(s, width);
978
                    
979
                    add_left_prediction_bgr32(p->data[0] + p->linesize[0]*y, s->temp[0], width, &leftr, &leftg, &leftb);
980
                    if(s->predictor == PLANE){
981
                        if((y&s->interlaced)==0 && y<s->height-1-s->interlaced){
982
                            s->dsp.add_bytes(p->data[0] + p->linesize[0]*y, 
983
                                             p->data[0] + p->linesize[0]*y + fake_ystride, fake_ystride);
984
                        }
985
                    }
986
                }
987
                draw_slice(s, height); // just 1 large slice as this isnt possible in reverse order
988
                break;
989
            default:
990
                av_log(avctx, AV_LOG_ERROR, "prediction type not supported!\n");
991
            }
992
        }else{
993

    
994
            av_log(avctx, AV_LOG_ERROR, "BGR24 output isnt implemenetd yet\n");
995
            return -1;
996
        }
997
    }
998
    emms_c();
999
    
1000
    *picture= *p;
1001
    *data_size = sizeof(AVFrame);
1002
    
1003
    return (get_bits_count(&s->gb)+31)/32*4;
1004
}
1005

    
1006
static int common_end(HYuvContext *s){
1007
    int i;
1008
    
1009
    for(i=0; i<3; i++){
1010
        av_freep(&s->temp[i]);
1011
    }
1012
    return 0;
1013
}
1014

    
1015
static int decode_end(AVCodecContext *avctx)
1016
{
1017
    HYuvContext *s = avctx->priv_data;
1018
    int i;
1019
    
1020
    common_end(s);
1021
    av_freep(&s->bitstream_buffer);
1022
    
1023
    for(i=0; i<3; i++){
1024
        free_vlc(&s->vlc[i]);
1025
    }
1026

    
1027
    return 0;
1028
}
1029

    
1030
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
1031
    HYuvContext *s = avctx->priv_data;
1032
    AVFrame *pict = data;
1033
    const int width= s->width;
1034
    const int width2= s->width>>1;
1035
    const int height= s->height;
1036
    const int fake_ystride= s->interlaced ? pict->linesize[0]*2  : pict->linesize[0];
1037
    const int fake_ustride= s->interlaced ? pict->linesize[1]*2  : pict->linesize[1];
1038
    const int fake_vstride= s->interlaced ? pict->linesize[2]*2  : pict->linesize[2];
1039
    AVFrame * const p= &s->picture;
1040
    int i, j, size=0;
1041

    
1042
    *p = *pict;
1043
    p->pict_type= FF_I_TYPE;
1044
    p->key_frame= 1;
1045
    
1046
    if(s->context){
1047
        for(i=0; i<3; i++){
1048
            generate_len_table(s->len[i], s->stats[i], 256);
1049
            if(generate_bits_table(s->bits[i], s->len[i])<0)
1050
                return -1;
1051
            size+= store_table(s, s->len[i], &buf[size]);
1052
        }
1053

    
1054
        for(i=0; i<3; i++)
1055
            for(j=0; j<256; j++)
1056
                s->stats[i][j] >>= 1;
1057
    }
1058

    
1059
    init_put_bits(&s->pb, buf+size, buf_size-size);
1060

    
1061
    if(avctx->pix_fmt == PIX_FMT_YUV422P || avctx->pix_fmt == PIX_FMT_YUV420P){
1062
        int lefty, leftu, leftv, y, cy;
1063

    
1064
        put_bits(&s->pb, 8, leftv= p->data[2][0]);
1065
        put_bits(&s->pb, 8, lefty= p->data[0][1]);
1066
        put_bits(&s->pb, 8, leftu= p->data[1][0]);
1067
        put_bits(&s->pb, 8,        p->data[0][0]);
1068
        
1069
        lefty= sub_left_prediction(s, s->temp[0], p->data[0]+2, width-2 , lefty);
1070
        leftu= sub_left_prediction(s, s->temp[1], p->data[1]+1, width2-1, leftu);
1071
        leftv= sub_left_prediction(s, s->temp[2], p->data[2]+1, width2-1, leftv);
1072
        
1073
        encode_422_bitstream(s, width-2);
1074
        
1075
        if(s->predictor==MEDIAN){
1076
            int lefttopy, lefttopu, lefttopv;
1077
            cy=y=1;
1078
            if(s->interlaced){
1079
                lefty= sub_left_prediction(s, s->temp[0], p->data[0]+p->linesize[0], width , lefty);
1080
                leftu= sub_left_prediction(s, s->temp[1], p->data[1]+p->linesize[1], width2, leftu);
1081
                leftv= sub_left_prediction(s, s->temp[2], p->data[2]+p->linesize[2], width2, leftv);
1082
        
1083
                encode_422_bitstream(s, width);
1084
                y++; cy++;
1085
            }
1086
            
1087
            lefty= sub_left_prediction(s, s->temp[0], p->data[0]+fake_ystride, 4, lefty);
1088
            leftu= sub_left_prediction(s, s->temp[1], p->data[1]+fake_ustride, 2, leftu);
1089
            leftv= sub_left_prediction(s, s->temp[2], p->data[2]+fake_vstride, 2, leftv);
1090
        
1091
            encode_422_bitstream(s, 4);
1092

    
1093
            lefttopy= p->data[0][3];
1094
            lefttopu= p->data[1][1];
1095
            lefttopv= p->data[2][1];
1096
            s->dsp.sub_hfyu_median_prediction(s->temp[0], p->data[0]+4, p->data[0] + fake_ystride+4, width-4 , &lefty, &lefttopy);
1097
            s->dsp.sub_hfyu_median_prediction(s->temp[1], p->data[1]+2, p->data[1] + fake_ustride+2, width2-2, &leftu, &lefttopu);
1098
            s->dsp.sub_hfyu_median_prediction(s->temp[2], p->data[2]+2, p->data[2] + fake_vstride+2, width2-2, &leftv, &lefttopv);
1099
            encode_422_bitstream(s, width-4);
1100
            y++; cy++;
1101

    
1102
            for(; y<height; y++,cy++){
1103
                uint8_t *ydst, *udst, *vdst;
1104
                    
1105
                if(s->bitstream_bpp==12){
1106
                    while(2*cy > y){
1107
                        ydst= p->data[0] + p->linesize[0]*y;
1108
                        s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1109
                        encode_gray_bitstream(s, width);
1110
                        y++;
1111
                    }
1112
                    if(y>=height) break;
1113
                }
1114
                ydst= p->data[0] + p->linesize[0]*y;
1115
                udst= p->data[1] + p->linesize[1]*cy;
1116
                vdst= p->data[2] + p->linesize[2]*cy;
1117

    
1118
                s->dsp.sub_hfyu_median_prediction(s->temp[0], ydst - fake_ystride, ydst, width , &lefty, &lefttopy);
1119
                s->dsp.sub_hfyu_median_prediction(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
1120
                s->dsp.sub_hfyu_median_prediction(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
1121

    
1122
                encode_422_bitstream(s, width);
1123
            }
1124
        }else{
1125
            for(cy=y=1; y<height; y++,cy++){
1126
                uint8_t *ydst, *udst, *vdst;
1127
                
1128
                /* encode a luma only line & y++ */
1129
                if(s->bitstream_bpp==12){
1130
                    ydst= p->data[0] + p->linesize[0]*y;
1131

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

    
1135
                        lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1136
                    }else{
1137
                        lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1138
                    }
1139
                    encode_gray_bitstream(s, width);
1140
                    y++;
1141
                    if(y>=height) break;
1142
                }
1143
                
1144
                ydst= p->data[0] + p->linesize[0]*y;
1145
                udst= p->data[1] + p->linesize[1]*cy;
1146
                vdst= p->data[2] + p->linesize[2]*cy;
1147

    
1148
                if(s->predictor == PLANE && s->interlaced < cy){
1149
                    s->dsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
1150
                    s->dsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
1151
                    s->dsp.diff_bytes(s->temp[2] + 1250, vdst, vdst - fake_vstride, width2);
1152

    
1153
                    lefty= sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
1154
                    leftu= sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
1155
                    leftv= sub_left_prediction(s, s->temp[2], s->temp[2] + 1250, width2, leftv);
1156
                }else{
1157
                    lefty= sub_left_prediction(s, s->temp[0], ydst, width , lefty);
1158
                    leftu= sub_left_prediction(s, s->temp[1], udst, width2, leftu);
1159
                    leftv= sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
1160
                }
1161

    
1162
                encode_422_bitstream(s, width);
1163
            }
1164
        }        
1165
    }else{
1166
        av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
1167
    }
1168
    emms_c();
1169
    
1170
    size+= (put_bits_count(&s->pb)+31)/8;
1171
    size/= 4;
1172
    
1173
    if((s->flags&CODEC_FLAG_PASS1) && (s->picture_number&31)==0){
1174
        int j;
1175
        char *p= avctx->stats_out;
1176
        char *end= p + 1024*30;
1177
        for(i=0; i<3; i++){
1178
            for(j=0; j<256; j++){
1179
                snprintf(p, end-p, "%llu ", s->stats[i][j]);
1180
                p+= strlen(p);
1181
                s->stats[i][j]= 0;
1182
            }
1183
            snprintf(p, end-p, "\n");
1184
            p++;
1185
        }
1186
    }
1187
    if(!(s->avctx->flags2 & CODEC_FLAG2_NO_OUTPUT)){
1188
        flush_put_bits(&s->pb);
1189
        s->dsp.bswap_buf((uint32_t*)buf, (uint32_t*)buf, size);
1190
        avctx->stats_out[0] = '\0';
1191
    }
1192
    
1193
    s->picture_number++;
1194

    
1195
    return size*4;
1196
}
1197

    
1198
static int encode_end(AVCodecContext *avctx)
1199
{
1200
    HYuvContext *s = avctx->priv_data;
1201
    
1202
    common_end(s);
1203

    
1204
    av_freep(&avctx->extradata);
1205
    av_freep(&avctx->stats_out);
1206
    
1207
    return 0;
1208
}
1209

    
1210
static const AVOption huffyuv_options[] =
1211
{
1212
    AVOPTION_CODEC_INT("prediction_method", "prediction_method", prediction_method, 0, 2, 0),
1213
    AVOPTION_END()
1214
};
1215

    
1216
static const AVOption ffvhuff_options[] =
1217
{
1218
    AVOPTION_CODEC_INT("prediction_method", "prediction_method", prediction_method, 0, 2, 0),
1219
    AVOPTION_CODEC_INT("context_model", "context_model", context_model, 0, 2, 0),
1220
    AVOPTION_END()
1221
};
1222

    
1223

    
1224
AVCodec huffyuv_decoder = {
1225
    "huffyuv",
1226
    CODEC_TYPE_VIDEO,
1227
    CODEC_ID_HUFFYUV,
1228
    sizeof(HYuvContext),
1229
    decode_init,
1230
    NULL,
1231
    decode_end,
1232
    decode_frame,
1233
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1234
    NULL
1235
};
1236

    
1237
AVCodec ffvhuff_decoder = {
1238
    "ffvhuff",
1239
    CODEC_TYPE_VIDEO,
1240
    CODEC_ID_FFVHUFF,
1241
    sizeof(HYuvContext),
1242
    decode_init,
1243
    NULL,
1244
    decode_end,
1245
    decode_frame,
1246
    CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND,
1247
    NULL
1248
};
1249

    
1250
#ifdef CONFIG_ENCODERS
1251

    
1252
AVCodec huffyuv_encoder = {
1253
    "huffyuv",
1254
    CODEC_TYPE_VIDEO,
1255
    CODEC_ID_HUFFYUV,
1256
    sizeof(HYuvContext),
1257
    encode_init,
1258
    encode_frame,
1259
    encode_end,
1260
    .options = huffyuv_options,
1261
};
1262

    
1263
AVCodec ffvhuff_encoder = {
1264
    "ffvhuff",
1265
    CODEC_TYPE_VIDEO,
1266
    CODEC_ID_FFVHUFF,
1267
    sizeof(HYuvContext),
1268
    encode_init,
1269
    encode_frame,
1270
    encode_end,
1271
    .options = ffvhuff_options,
1272
};
1273

    
1274
#endif //CONFIG_ENCODERS