← Back to branch summary

~ubuntu-branches/ubuntu/trusty/libav/trusty

« back to all changes in this revision

Viewing changes to libavcodec/ffv1.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2011-04-19 15:04:55 UTC
  • mfrom: (1.2.1 upstream)
  • mto: (1.3.4 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20110419150455-c1nac6gjm3t2aa4n
Tags: 4:0.7~b1-1
* New upstream version
* bump SONAME and SHLIBS
* configure flags --disable-stripping was removed upstream
* the MAINTAINERS file was removed upstream
* remove patch disable-configuration-warning.patch
* drop avfilter confflags, it is enable by default in 0.7
* libfaad wrapper has been removed upstream
* also update the *contents* of the lintian overrides

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/ffv1.c
3
3
 *
4
4
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5
5
 *
6
 
 * This file is part of FFmpeg.
 
6
 * This file is part of Libav.
7
7
 *
8
 
 * FFmpeg is free software; you can redistribute it and/or
 
8
 * Libav is free software; you can redistribute it and/or
9
9
 * modify it under the terms of the GNU Lesser General Public
10
10
 * License as published by the Free Software Foundation; either
11
11
 * version 2.1 of the License, or (at your option) any later version.
12
12
 *
13
 
 * FFmpeg is distributed in the hope that it will be useful,
 
13
 * Libav is distributed in the hope that it will be useful,
14
14
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
16
 * Lesser General Public License for more details.
17
17
 *
18
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
 
19
 * License along with Libav; if not, write to the Free Software
20
20
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21
21
 */
22
22
 
32
32
#include "rangecoder.h"
33
33
#include "golomb.h"
34
34
#include "mathops.h"
 
35
#include "libavutil/avassert.h"
35
36
 
36
37
#define MAX_PLANES 4
37
38
#define CONTEXT_SIZE 32
38
39
 
 
40
#define MAX_QUANT_TABLES 8
 
41
#define MAX_CONTEXT_INPUTS 5
 
42
 
39
43
extern const uint8_t ff_log2_run[32];
40
44
 
41
45
static const int8_t quant3[256]={
213
217
} VlcState;
214
218
 
215
219
typedef struct PlaneContext{
 
220
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
 
221
    int quant_table_index;
216
222
    int context_count;
217
223
    uint8_t (*state)[CONTEXT_SIZE];
218
224
    VlcState *vlc_state;
219
225
    uint8_t interlace_bit_state[2];
220
226
} PlaneContext;
221
227
 
 
228
#define MAX_SLICES 256
 
229
 
222
230
typedef struct FFV1Context{
223
231
    AVCodecContext *avctx;
224
232
    RangeCoder c;
225
233
    GetBitContext gb;
226
234
    PutBitContext pb;
 
235
    uint64_t rc_stat[256][2];
 
236
    uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
227
237
    int version;
228
238
    int width, height;
229
239
    int chroma_h_shift, chroma_v_shift;
233
243
    int plane_count;
234
244
    int ac;                              ///< 1=range coder <-> 0=golomb rice
235
245
    PlaneContext plane[MAX_PLANES];
236
 
    int16_t quant_table[5][256];
 
246
    int16_t quant_table[MAX_CONTEXT_INPUTS][256];
 
247
    int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
 
248
    int context_count[MAX_QUANT_TABLES];
237
249
    uint8_t state_transition[256];
 
250
    uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
238
251
    int run_index;
239
252
    int colorspace;
 
253
    int_fast16_t *sample_buffer;
 
254
    int gob_count;
 
255
 
 
256
    int quant_table_count;
240
257
 
241
258
    DSPContext dsp;
 
259
 
 
260
    struct FFV1Context *slice_context[MAX_SLICES];
 
261
    int slice_count;
 
262
    int num_v_slices;
 
263
    int num_h_slices;
 
264
    int slice_width;
 
265
    int slice_height;
 
266
    int slice_x;
 
267
    int slice_y;
242
268
}FFV1Context;
243
269
 
244
270
static av_always_inline int fold(int diff, int bits){
261
287
    return mid_pred(L, L + T - LT, T);
262
288
}
263
289
 
264
 
static inline int get_context(FFV1Context *f, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
 
290
static inline int get_context(PlaneContext *p, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
265
291
    const int LT= last[-1];
266
292
    const int  T= last[ 0];
267
293
    const int RT= last[ 1];
268
294
    const int L =  src[-1];
269
295
 
270
 
    if(f->quant_table[3][127]){
 
296
    if(p->quant_table[3][127]){
271
297
        const int TT= last2[0];
272
298
        const int LL=  src[-2];
273
 
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
274
 
              +f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
 
299
        return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF]
 
300
              +p->quant_table[3][(LL-L) & 0xFF] + p->quant_table[4][(TT-T) & 0xFF];
275
301
    }else
276
 
        return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
277
 
}
278
 
 
279
 
static inline void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed){
 
302
        return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
 
303
}
 
304
 
 
305
static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
 
306
    int i,j,k,m;
 
307
    double l2tab[256];
 
308
 
 
309
    for(i=1; i<256; i++)
 
310
        l2tab[i]= log2(i/256.0);
 
311
 
 
312
    for(i=0; i<256; i++){
 
313
        double best_len[256];
 
314
        double p= i/256.0;
 
315
 
 
316
        for(j=0; j<256; j++)
 
317
            best_len[j]= 1<<30;
 
318
 
 
319
        for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
 
320
            double occ[256]={0};
 
321
            double len=0;
 
322
            occ[j]=1.0;
 
323
            for(k=0; k<256; k++){
 
324
                double newocc[256]={0};
 
325
                for(m=0; m<256; m++){
 
326
                    if(occ[m]){
 
327
                        len -=occ[m]*(     p *l2tab[    m]
 
328
                                      + (1-p)*l2tab[256-m]);
 
329
                    }
 
330
                }
 
331
                if(len < best_len[k]){
 
332
                    best_len[k]= len;
 
333
                    best_state[i][k]= j;
 
334
                }
 
335
                for(m=0; m<256; m++){
 
336
                    if(occ[m]){
 
337
                        newocc[    one_state[    m]] += occ[m]*   p ;
 
338
                        newocc[256-one_state[256-m]] += occ[m]*(1-p);
 
339
                    }
 
340
                }
 
341
                memcpy(occ, newocc, sizeof(occ));
 
342
            }
 
343
        }
 
344
    }
 
345
}
 
346
 
 
347
static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed, uint64_t rc_stat[256][2], uint64_t rc_stat2[32][2]){
280
348
    int i;
281
349
 
 
350
#define put_rac(C,S,B) \
 
351
do{\
 
352
    if(rc_stat){\
 
353
    rc_stat[*(S)][B]++;\
 
354
        rc_stat2[(S)-state][B]++;\
 
355
    }\
 
356
    put_rac(C,S,B);\
 
357
}while(0)
 
358
 
282
359
    if(v){
283
360
        const int a= FFABS(v);
284
361
        const int e= av_log2(a);
311
388
    }else{
312
389
        put_rac(c, state+0, 1);
313
390
    }
 
391
#undef put_rac
314
392
}
315
393
 
316
394
static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
317
 
    put_symbol_inline(c, state, v, is_signed);
 
395
    put_symbol_inline(c, state, v, is_signed, NULL, NULL);
318
396
}
319
397
 
320
398
static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
428
506
}
429
507
 
430
508
#if CONFIG_FFV1_ENCODER
431
 
static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
 
509
static av_always_inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
432
510
    PlaneContext * const p= &s->plane[plane_index];
433
511
    RangeCoder * const c= &s->c;
434
512
    int x;
451
529
    for(x=0; x<w; x++){
452
530
        int diff, context;
453
531
 
454
 
        context= get_context(s, sample[0]+x, sample[1]+x, sample[2]+x);
 
532
        context= get_context(p, sample[0]+x, sample[1]+x, sample[2]+x);
455
533
        diff= sample[0][x] - predict(sample[0]+x, sample[1]+x);
456
534
 
457
535
        if(context < 0){
462
540
        diff= fold(diff, bits);
463
541
 
464
542
        if(s->ac){
465
 
            put_symbol_inline(c, p->state[context], diff, 1);
 
543
            if(s->flags & CODEC_FLAG_PASS1){
 
544
                put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
 
545
            }else{
 
546
                put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
 
547
            }
466
548
        }else{
467
549
            if(context == 0) run_mode=1;
468
550
 
509
591
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
510
592
    int x,y,i;
511
593
    const int ring_size= s->avctx->context_model ? 3 : 2;
512
 
    int_fast16_t sample_buffer[ring_size][w+6], *sample[ring_size];
 
594
    int_fast16_t *sample[3];
513
595
    s->run_index=0;
514
596
 
515
 
    memset(sample_buffer, 0, sizeof(sample_buffer));
 
597
    memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
516
598
 
517
599
    for(y=0; y<h; y++){
518
600
        for(i=0; i<ring_size; i++)
519
 
            sample[i]= sample_buffer[(h+i-y)%ring_size]+3;
 
601
            sample[i]= s->sample_buffer + (w+6)*((h+i-y)%ring_size) + 3;
520
602
 
521
603
        sample[0][-1]= sample[1][0  ];
522
604
        sample[1][ w]= sample[1][w-1];
539
621
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
540
622
    int x, y, p, i;
541
623
    const int ring_size= s->avctx->context_model ? 3 : 2;
542
 
    int_fast16_t sample_buffer[3][ring_size][w+6], *sample[3][ring_size];
 
624
    int_fast16_t *sample[3][3];
543
625
    s->run_index=0;
544
626
 
545
 
    memset(sample_buffer, 0, sizeof(sample_buffer));
 
627
    memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
546
628
 
547
629
    for(y=0; y<h; y++){
548
630
        for(i=0; i<ring_size; i++)
549
631
            for(p=0; p<3; p++)
550
 
                sample[p][i]= sample_buffer[p][(h+i-y)%ring_size]+3;
 
632
                sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;
551
633
 
552
634
        for(x=0; x<w; x++){
553
635
            int v= src[x + stride*y];
590
672
    put_symbol(c, state, i-last-1, 0);
591
673
}
592
674
 
 
675
static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
 
676
    int i;
 
677
    for(i=0; i<5; i++)
 
678
        write_quant_table(c, quant_table[i]);
 
679
}
 
680
 
593
681
static void write_header(FFV1Context *f){
594
682
    uint8_t state[CONTEXT_SIZE];
595
 
    int i;
 
683
    int i, j;
 
684
    RangeCoder * const c= &f->slice_context[0]->c;
 
685
 
 
686
    memset(state, 128, sizeof(state));
 
687
 
 
688
    if(f->version < 2){
 
689
        put_symbol(c, state, f->version, 0);
 
690
        put_symbol(c, state, f->ac, 0);
 
691
        if(f->ac>1){
 
692
            for(i=1; i<256; i++){
 
693
                put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
 
694
            }
 
695
        }
 
696
        put_symbol(c, state, f->colorspace, 0); //YUV cs type
 
697
        if(f->version>0)
 
698
            put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
 
699
        put_rac(c, state, 1); //chroma planes
 
700
            put_symbol(c, state, f->chroma_h_shift, 0);
 
701
            put_symbol(c, state, f->chroma_v_shift, 0);
 
702
        put_rac(c, state, 0); //no transparency plane
 
703
 
 
704
        write_quant_tables(c, f->quant_table);
 
705
    }else{
 
706
        put_symbol(c, state, f->slice_count, 0);
 
707
        for(i=0; i<f->slice_count; i++){
 
708
            FFV1Context *fs= f->slice_context[i];
 
709
            put_symbol(c, state, (fs->slice_x     +1)*f->num_h_slices / f->width   , 0);
 
710
            put_symbol(c, state, (fs->slice_y     +1)*f->num_v_slices / f->height  , 0);
 
711
            put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
 
712
            put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
 
713
            for(j=0; j<f->plane_count; j++){
 
714
                put_symbol(c, state, f->plane[j].quant_table_index, 0);
 
715
                av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
 
716
            }
 
717
        }
 
718
    }
 
719
}
 
720
#endif /* CONFIG_FFV1_ENCODER */
 
721
 
 
722
static av_cold int common_init(AVCodecContext *avctx){
 
723
    FFV1Context *s = avctx->priv_data;
 
724
 
 
725
    s->avctx= avctx;
 
726
    s->flags= avctx->flags;
 
727
 
 
728
    dsputil_init(&s->dsp, avctx);
 
729
 
 
730
    s->width = avctx->width;
 
731
    s->height= avctx->height;
 
732
 
 
733
    assert(s->width && s->height);
 
734
    //defaults
 
735
    s->num_h_slices=1;
 
736
    s->num_v_slices=1;
 
737
 
 
738
 
 
739
    return 0;
 
740
}
 
741
 
 
742
static int init_slice_state(FFV1Context *f){
 
743
    int i, j;
 
744
 
 
745
    for(i=0; i<f->slice_count; i++){
 
746
        FFV1Context *fs= f->slice_context[i];
 
747
        for(j=0; j<f->plane_count; j++){
 
748
            PlaneContext * const p= &fs->plane[j];
 
749
 
 
750
            if(fs->ac){
 
751
                if(!p->    state) p->    state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
 
752
                if(!p->    state)
 
753
                    return AVERROR(ENOMEM);
 
754
            }else{
 
755
                if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 
756
                if(!p->vlc_state)
 
757
                    return AVERROR(ENOMEM);
 
758
            }
 
759
        }
 
760
 
 
761
        if (fs->ac>1){
 
762
            //FIXME only redo if state_transition changed
 
763
            for(j=1; j<256; j++){
 
764
                fs->c.one_state [    j]= fs->state_transition[j];
 
765
                fs->c.zero_state[256-j]= 256-fs->c.one_state [j];
 
766
            }
 
767
        }
 
768
    }
 
769
 
 
770
    return 0;
 
771
}
 
772
 
 
773
static av_cold int init_slice_contexts(FFV1Context *f){
 
774
    int i;
 
775
 
 
776
    f->slice_count= f->num_h_slices * f->num_v_slices;
 
777
 
 
778
    for(i=0; i<f->slice_count; i++){
 
779
        FFV1Context *fs= av_mallocz(sizeof(*fs));
 
780
        int sx= i % f->num_h_slices;
 
781
        int sy= i / f->num_h_slices;
 
782
        int sxs= f->avctx->width * sx    / f->num_h_slices;
 
783
        int sxe= f->avctx->width *(sx+1) / f->num_h_slices;
 
784
        int sys= f->avctx->height* sy    / f->num_v_slices;
 
785
        int sye= f->avctx->height*(sy+1) / f->num_v_slices;
 
786
        f->slice_context[i]= fs;
 
787
        memcpy(fs, f, sizeof(*fs));
 
788
        memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
 
789
 
 
790
        fs->slice_width = sxe - sxs;
 
791
        fs->slice_height= sye - sys;
 
792
        fs->slice_x     = sxs;
 
793
        fs->slice_y     = sys;
 
794
 
 
795
        fs->sample_buffer = av_malloc(9 * (fs->width+6) * sizeof(*fs->sample_buffer));
 
796
        if (!fs->sample_buffer)
 
797
            return AVERROR(ENOMEM);
 
798
    }
 
799
    return 0;
 
800
}
 
801
 
 
802
static int allocate_initial_states(FFV1Context *f){
 
803
    int i;
 
804
 
 
805
    for(i=0; i<f->quant_table_count; i++){
 
806
        f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
 
807
        if(!f->initial_states[i])
 
808
            return AVERROR(ENOMEM);
 
809
        memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
 
810
    }
 
811
    return 0;
 
812
}
 
813
 
 
814
#if CONFIG_FFV1_ENCODER
 
815
static int write_extra_header(FFV1Context *f){
596
816
    RangeCoder * const c= &f->c;
 
817
    uint8_t state[CONTEXT_SIZE];
 
818
    int i, j, k;
 
819
    uint8_t state2[32][CONTEXT_SIZE];
597
820
 
 
821
    memset(state2, 128, sizeof(state2));
598
822
    memset(state, 128, sizeof(state));
599
823
 
 
824
    f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
 
825
    ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
 
826
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 
827
 
600
828
    put_symbol(c, state, f->version, 0);
601
829
    put_symbol(c, state, f->ac, 0);
602
830
    if(f->ac>1){
603
831
        for(i=1; i<256; i++){
604
 
            f->state_transition[i]=ver2_state[i];
605
 
            put_symbol(c, state, ver2_state[i] - c->one_state[i], 1);
 
832
            put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
606
833
        }
607
834
    }
608
835
    put_symbol(c, state, f->colorspace, 0); //YUV cs type
609
 
    if(f->version>0)
610
 
        put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
 
836
    put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
611
837
    put_rac(c, state, 1); //chroma planes
612
838
        put_symbol(c, state, f->chroma_h_shift, 0);
613
839
        put_symbol(c, state, f->chroma_v_shift, 0);
614
840
    put_rac(c, state, 0); //no transparency plane
615
 
 
616
 
    for(i=0; i<5; i++)
617
 
        write_quant_table(c, f->quant_table[i]);
618
 
}
619
 
#endif /* CONFIG_FFV1_ENCODER */
620
 
 
621
 
static av_cold int common_init(AVCodecContext *avctx){
622
 
    FFV1Context *s = avctx->priv_data;
623
 
 
624
 
    s->avctx= avctx;
625
 
    s->flags= avctx->flags;
626
 
 
627
 
    dsputil_init(&s->dsp, avctx);
628
 
 
629
 
    s->width = avctx->width;
630
 
    s->height= avctx->height;
631
 
 
632
 
    assert(s->width && s->height);
 
841
    put_symbol(c, state, f->num_h_slices-1, 0);
 
842
    put_symbol(c, state, f->num_v_slices-1, 0);
 
843
 
 
844
    put_symbol(c, state, f->quant_table_count, 0);
 
845
    for(i=0; i<f->quant_table_count; i++)
 
846
        write_quant_tables(c, f->quant_tables[i]);
 
847
 
 
848
    for(i=0; i<f->quant_table_count; i++){
 
849
        for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
 
850
            if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
 
851
                break;
 
852
        if(j<f->context_count[i]*CONTEXT_SIZE){
 
853
            put_rac(c, state, 1);
 
854
            for(j=0; j<f->context_count[i]; j++){
 
855
                for(k=0; k<CONTEXT_SIZE; k++){
 
856
                    int pred= j ? f->initial_states[i][j-1][k] : 128;
 
857
                    put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
 
858
                }
 
859
            }
 
860
        }else{
 
861
            put_rac(c, state, 0);
 
862
        }
 
863
    }
 
864
 
 
865
    f->avctx->extradata_size= ff_rac_terminate(c);
633
866
 
634
867
    return 0;
635
868
}
636
869
 
637
 
#if CONFIG_FFV1_ENCODER
 
870
static int sort_stt(FFV1Context *s, uint8_t stt[256]){
 
871
    int i,i2,changed,print=0;
 
872
 
 
873
    do{
 
874
        changed=0;
 
875
        for(i=12; i<244; i++){
 
876
            for(i2=i+1; i2<245 && i2<i+4; i2++){
 
877
#define COST(old, new) \
 
878
    s->rc_stat[old][0]*-log2((256-(new))/256.0)\
 
879
   +s->rc_stat[old][1]*-log2(     (new) /256.0)
 
880
 
 
881
#define COST2(old, new) \
 
882
    COST(old, new)\
 
883
   +COST(256-(old), 256-(new))
 
884
 
 
885
                double size0= COST2(i, i ) + COST2(i2, i2);
 
886
                double sizeX= COST2(i, i2) + COST2(i2, i );
 
887
                if(sizeX < size0 && i!=128 && i2!=128){
 
888
                    int j;
 
889
                    FFSWAP(int, stt[    i], stt[    i2]);
 
890
                    FFSWAP(int, s->rc_stat[i    ][0],s->rc_stat[    i2][0]);
 
891
                    FFSWAP(int, s->rc_stat[i    ][1],s->rc_stat[    i2][1]);
 
892
                    if(i != 256-i2){
 
893
                        FFSWAP(int, stt[256-i], stt[256-i2]);
 
894
                        FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
 
895
                        FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
 
896
                    }
 
897
                    for(j=1; j<256; j++){
 
898
                        if     (stt[j] == i ) stt[j] = i2;
 
899
                        else if(stt[j] == i2) stt[j] = i ;
 
900
                        if(i != 256-i2){
 
901
                            if     (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
 
902
                            else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
 
903
                        }
 
904
                    }
 
905
                    print=changed=1;
 
906
                }
 
907
            }
 
908
        }
 
909
    }while(changed);
 
910
    return print;
 
911
}
 
912
 
638
913
static av_cold int encode_init(AVCodecContext *avctx)
639
914
{
640
915
    FFV1Context *s = avctx->priv_data;
641
 
    int i;
 
916
    int i, j, k, m;
642
917
 
643
918
    common_init(avctx);
644
919
 
645
920
    s->version=0;
646
921
    s->ac= avctx->coder_type ? 2:0;
647
922
 
 
923
    if(s->ac>1)
 
924
        for(i=1; i<256; i++)
 
925
            s->state_transition[i]=ver2_state[i];
 
926
 
648
927
    s->plane_count=2;
649
928
    for(i=0; i<256; i++){
 
929
        s->quant_table_count=2;
650
930
        if(avctx->bits_per_raw_sample <=8){
651
 
            s->quant_table[0][i]=           quant11[i];
652
 
            s->quant_table[1][i]=        11*quant11[i];
653
 
            if(avctx->context_model==0){
654
 
                s->quant_table[2][i]=     11*11*quant11[i];
655
 
                s->quant_table[3][i]=
656
 
                s->quant_table[4][i]=0;
657
 
            }else{
658
 
                s->quant_table[2][i]=     11*11*quant5 [i];
659
 
                s->quant_table[3][i]=   5*11*11*quant5 [i];
660
 
                s->quant_table[4][i]= 5*5*11*11*quant5 [i];
661
 
            }
 
931
            s->quant_tables[0][0][i]=           quant11[i];
 
932
            s->quant_tables[0][1][i]=        11*quant11[i];
 
933
            s->quant_tables[0][2][i]=     11*11*quant11[i];
 
934
            s->quant_tables[1][0][i]=           quant11[i];
 
935
            s->quant_tables[1][1][i]=        11*quant11[i];
 
936
            s->quant_tables[1][2][i]=     11*11*quant5 [i];
 
937
            s->quant_tables[1][3][i]=   5*11*11*quant5 [i];
 
938
            s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];
662
939
        }else{
663
 
            s->quant_table[0][i]=           quant9_10bit[i];
664
 
            s->quant_table[1][i]=        11*quant9_10bit[i];
665
 
            if(avctx->context_model==0){
666
 
                s->quant_table[2][i]=     11*11*quant9_10bit[i];
667
 
                s->quant_table[3][i]=
668
 
                s->quant_table[4][i]=0;
669
 
            }else{
670
 
                s->quant_table[2][i]=     11*11*quant5_10bit[i];
671
 
                s->quant_table[3][i]=   5*11*11*quant5_10bit[i];
672
 
                s->quant_table[4][i]= 5*5*11*11*quant5_10bit[i];
673
 
            }
 
940
            s->quant_tables[0][0][i]=           quant9_10bit[i];
 
941
            s->quant_tables[0][1][i]=        11*quant9_10bit[i];
 
942
            s->quant_tables[0][2][i]=     11*11*quant9_10bit[i];
 
943
            s->quant_tables[1][0][i]=           quant9_10bit[i];
 
944
            s->quant_tables[1][1][i]=        11*quant9_10bit[i];
 
945
            s->quant_tables[1][2][i]=     11*11*quant5_10bit[i];
 
946
            s->quant_tables[1][3][i]=   5*11*11*quant5_10bit[i];
 
947
            s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
674
948
        }
675
949
    }
 
950
    s->context_count[0]= (11*11*11+1)/2;
 
951
    s->context_count[1]= (11*11*5*5*5+1)/2;
 
952
    memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
676
953
 
677
954
    for(i=0; i<s->plane_count; i++){
678
955
        PlaneContext * const p= &s->plane[i];
679
956
 
680
 
        if(avctx->context_model==0){
681
 
            p->context_count= (11*11*11+1)/2;
682
 
        }else{
683
 
            p->context_count= (11*11*5*5*5+1)/2;
684
 
        }
685
 
 
686
 
        if(s->ac){
687
 
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
688
 
        }else{
689
 
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
690
 
        }
 
957
        memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
 
958
        p->quant_table_index= avctx->context_model;
 
959
        p->context_count= s->context_count[p->quant_table_index];
691
960
    }
692
961
 
 
962
    if(allocate_initial_states(s) < 0)
 
963
        return AVERROR(ENOMEM);
 
964
 
693
965
    avctx->coded_frame= &s->picture;
694
966
    switch(avctx->pix_fmt){
695
967
    case PIX_FMT_YUV444P16:
703
975
            av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");
704
976
            return -1;
705
977
        }
706
 
        s->version= 1;
 
978
        s->version= FFMAX(s->version, 1);
707
979
    case PIX_FMT_YUV444P:
708
980
    case PIX_FMT_YUV422P:
709
981
    case PIX_FMT_YUV420P:
722
994
 
723
995
    s->picture_number=0;
724
996
 
 
997
    if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
 
998
        for(i=0; i<s->quant_table_count; i++){
 
999
            s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
 
1000
            if(!s->rc_stat2[i])
 
1001
                return AVERROR(ENOMEM);
 
1002
        }
 
1003
    }
 
1004
    if(avctx->stats_in){
 
1005
        char *p= avctx->stats_in;
 
1006
        uint8_t best_state[256][256];
 
1007
        int gob_count=0;
 
1008
        char *next;
 
1009
 
 
1010
        av_assert0(s->version>=2);
 
1011
 
 
1012
        for(;;){
 
1013
            for(j=0; j<256; j++){
 
1014
                for(i=0; i<2; i++){
 
1015
                    s->rc_stat[j][i]= strtol(p, &next, 0);
 
1016
                    if(next==p){
 
1017
                        av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
 
1018
                        return -1;
 
1019
                    }
 
1020
                    p=next;
 
1021
                }
 
1022
            }
 
1023
            for(i=0; i<s->quant_table_count; i++){
 
1024
                for(j=0; j<s->context_count[i]; j++){
 
1025
                    for(k=0; k<32; k++){
 
1026
                        for(m=0; m<2; m++){
 
1027
                            s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
 
1028
                            if(next==p){
 
1029
                                av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
 
1030
                                return -1;
 
1031
                            }
 
1032
                            p=next;
 
1033
                        }
 
1034
                    }
 
1035
                }
 
1036
            }
 
1037
            gob_count= strtol(p, &next, 0);
 
1038
            if(next==p || gob_count <0){
 
1039
                av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
 
1040
                return -1;
 
1041
            }
 
1042
            p=next;
 
1043
            while(*p=='\n' || *p==' ') p++;
 
1044
            if(p[0]==0) break;
 
1045
        }
 
1046
        sort_stt(s, s->state_transition);
 
1047
 
 
1048
        find_best_state(best_state, s->state_transition);
 
1049
 
 
1050
        for(i=0; i<s->quant_table_count; i++){
 
1051
            for(j=0; j<s->context_count[i]; j++){
 
1052
                for(k=0; k<32; k++){
 
1053
                    double p= 128;
 
1054
                    if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
 
1055
                        p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
 
1056
                    }
 
1057
                    s->initial_states[i][j][k]= best_state[av_clip(round(p), 1, 255)][av_clip((s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1])/gob_count, 0, 255)];
 
1058
                }
 
1059
            }
 
1060
        }
 
1061
    }
 
1062
 
 
1063
    if(s->version>1){
 
1064
        s->num_h_slices=2;
 
1065
        s->num_v_slices=2;
 
1066
        write_extra_header(s);
 
1067
    }
 
1068
 
 
1069
    if(init_slice_contexts(s) < 0)
 
1070
        return -1;
 
1071
    if(init_slice_state(s) < 0)
 
1072
        return -1;
 
1073
 
 
1074
#define STATS_OUT_SIZE 1024*1024*6
 
1075
    if(avctx->flags & CODEC_FLAG_PASS1){
 
1076
        avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
 
1077
        for(i=0; i<s->quant_table_count; i++){
 
1078
            for(j=0; j<s->slice_count; j++){
 
1079
                FFV1Context *sf= s->slice_context[j];
 
1080
                av_assert0(!sf->rc_stat2[i]);
 
1081
                sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
 
1082
                if(!sf->rc_stat2[i])
 
1083
                    return AVERROR(ENOMEM);
 
1084
            }
 
1085
        }
 
1086
    }
 
1087
 
725
1088
    return 0;
726
1089
}
727
1090
#endif /* CONFIG_FFV1_ENCODER */
728
1091
 
729
1092
 
730
1093
static void clear_state(FFV1Context *f){
731
 
    int i, j;
732
 
 
733
 
    for(i=0; i<f->plane_count; i++){
734
 
        PlaneContext *p= &f->plane[i];
735
 
 
736
 
        p->interlace_bit_state[0]= 128;
737
 
        p->interlace_bit_state[1]= 128;
738
 
 
739
 
        for(j=0; j<p->context_count; j++){
740
 
            if(f->ac){
741
 
                memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
 
1094
    int i, si, j;
 
1095
 
 
1096
    for(si=0; si<f->slice_count; si++){
 
1097
        FFV1Context *fs= f->slice_context[si];
 
1098
        for(i=0; i<f->plane_count; i++){
 
1099
            PlaneContext *p= &fs->plane[i];
 
1100
 
 
1101
            p->interlace_bit_state[0]= 128;
 
1102
            p->interlace_bit_state[1]= 128;
 
1103
 
 
1104
            if(fs->ac){
 
1105
                if(f->initial_states[p->quant_table_index]){
 
1106
                    memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
 
1107
                }else
 
1108
                memset(p->state, 128, CONTEXT_SIZE*p->context_count);
742
1109
            }else{
743
 
                p->vlc_state[j].drift= 0;
744
 
                p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
745
 
                p->vlc_state[j].bias= 0;
746
 
                p->vlc_state[j].count= 1;
 
1110
            for(j=0; j<p->context_count; j++){
 
1111
                    p->vlc_state[j].drift= 0;
 
1112
                    p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
 
1113
                    p->vlc_state[j].bias= 0;
 
1114
                    p->vlc_state[j].count= 1;
 
1115
            }
747
1116
            }
748
1117
        }
749
1118
    }
750
1119
}
751
1120
 
752
1121
#if CONFIG_FFV1_ENCODER
 
1122
static int encode_slice(AVCodecContext *c, void *arg){
 
1123
    FFV1Context *fs= *(void**)arg;
 
1124
    FFV1Context *f= fs->avctx->priv_data;
 
1125
    int width = fs->slice_width;
 
1126
    int height= fs->slice_height;
 
1127
    int x= fs->slice_x;
 
1128
    int y= fs->slice_y;
 
1129
    AVFrame * const p= &f->picture;
 
1130
 
 
1131
    if(f->colorspace==0){
 
1132
        const int chroma_width = -((-width )>>f->chroma_h_shift);
 
1133
        const int chroma_height= -((-height)>>f->chroma_v_shift);
 
1134
        const int cx= x>>f->chroma_h_shift;
 
1135
        const int cy= y>>f->chroma_v_shift;
 
1136
 
 
1137
        encode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
 
1138
 
 
1139
        encode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
 
1140
        encode_plane(fs, p->data[2] + cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);
 
1141
    }else{
 
1142
        encode_rgb_frame(fs, (uint32_t*)(p->data[0]) + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
 
1143
    }
 
1144
    emms_c();
 
1145
 
 
1146
    return 0;
 
1147
}
 
1148
 
753
1149
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
754
1150
    FFV1Context *f = avctx->priv_data;
755
 
    RangeCoder * const c= &f->c;
 
1151
    RangeCoder * const c= &f->slice_context[0]->c;
756
1152
    AVFrame *pict = data;
757
 
    const int width= f->width;
758
 
    const int height= f->height;
759
1153
    AVFrame * const p= &f->picture;
760
1154
    int used_count= 0;
761
1155
    uint8_t keystate=128;
 
1156
    uint8_t *buf_p;
 
1157
    int i;
762
1158
 
763
1159
    ff_init_range_encoder(c, buf, buf_size);
764
1160
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
769
1165
    if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
770
1166
        put_rac(c, &keystate, 1);
771
1167
        p->key_frame= 1;
 
1168
        f->gob_count++;
772
1169
        write_header(f);
773
1170
        clear_state(f);
774
1171
    }else{
779
1176
    if(!f->ac){
780
1177
        used_count += ff_rac_terminate(c);
781
1178
//printf("pos=%d\n", used_count);
782
 
        init_put_bits(&f->pb, buf + used_count, buf_size - used_count);
 
1179
        init_put_bits(&f->slice_context[0]->pb, buf + used_count, buf_size - used_count);
783
1180
    }else if (f->ac>1){
784
1181
        int i;
785
1182
        for(i=1; i<256; i++){
788
1185
        }
789
1186
    }
790
1187
 
791
 
    if(f->colorspace==0){
792
 
        const int chroma_width = -((-width )>>f->chroma_h_shift);
793
 
        const int chroma_height= -((-height)>>f->chroma_v_shift);
794
 
 
795
 
        encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
796
 
 
797
 
        encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
798
 
        encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
799
 
    }else{
800
 
        encode_rgb_frame(f, (uint32_t*)(p->data[0]), width, height, p->linesize[0]/4);
801
 
    }
802
 
    emms_c();
 
1188
    for(i=1; i<f->slice_count; i++){
 
1189
        FFV1Context *fs= f->slice_context[i];
 
1190
        uint8_t *start= buf + (buf_size-used_count)*i/f->slice_count;
 
1191
        int len= buf_size/f->slice_count;
 
1192
 
 
1193
        if(fs->ac){
 
1194
            ff_init_range_encoder(&fs->c, start, len);
 
1195
        }else{
 
1196
            init_put_bits(&fs->pb, start, len);
 
1197
        }
 
1198
    }
 
1199
    avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
 
1200
 
 
1201
    buf_p=buf;
 
1202
    for(i=0; i<f->slice_count; i++){
 
1203
        FFV1Context *fs= f->slice_context[i];
 
1204
        int bytes;
 
1205
 
 
1206
        if(fs->ac){
 
1207
            uint8_t state=128;
 
1208
            put_rac(&fs->c, &state, 0);
 
1209
            bytes= ff_rac_terminate(&fs->c);
 
1210
        }else{
 
1211
            flush_put_bits(&fs->pb); //nicer padding FIXME
 
1212
            bytes= used_count + (put_bits_count(&fs->pb)+7)/8;
 
1213
            used_count= 0;
 
1214
        }
 
1215
        if(i>0){
 
1216
            av_assert0(bytes < buf_size/f->slice_count);
 
1217
            memmove(buf_p, fs->ac ? fs->c.bytestream_start : fs->pb.buf, bytes);
 
1218
            av_assert0(bytes < (1<<24));
 
1219
            AV_WB24(buf_p+bytes, bytes);
 
1220
            bytes+=3;
 
1221
        }
 
1222
        buf_p += bytes;
 
1223
    }
 
1224
 
 
1225
    if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
 
1226
        int j, k, m;
 
1227
        char *p= avctx->stats_out;
 
1228
        char *end= p + STATS_OUT_SIZE;
 
1229
 
 
1230
        memset(f->rc_stat, 0, sizeof(f->rc_stat));
 
1231
        for(i=0; i<f->quant_table_count; i++)
 
1232
            memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
 
1233
 
 
1234
        for(j=0; j<f->slice_count; j++){
 
1235
            FFV1Context *fs= f->slice_context[j];
 
1236
            for(i=0; i<256; i++){
 
1237
                f->rc_stat[i][0] += fs->rc_stat[i][0];
 
1238
                f->rc_stat[i][1] += fs->rc_stat[i][1];
 
1239
            }
 
1240
            for(i=0; i<f->quant_table_count; i++){
 
1241
                for(k=0; k<f->context_count[i]; k++){
 
1242
                    for(m=0; m<32; m++){
 
1243
                        f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
 
1244
                        f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
 
1245
                    }
 
1246
                }
 
1247
            }
 
1248
        }
 
1249
 
 
1250
        for(j=0; j<256; j++){
 
1251
            snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
 
1252
            p+= strlen(p);
 
1253
        }
 
1254
        snprintf(p, end-p, "\n");
 
1255
 
 
1256
        for(i=0; i<f->quant_table_count; i++){
 
1257
            for(j=0; j<f->context_count[i]; j++){
 
1258
                for(m=0; m<32; m++){
 
1259
                    snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
 
1260
                    p+= strlen(p);
 
1261
                }
 
1262
            }
 
1263
        }
 
1264
        snprintf(p, end-p, "%d\n", f->gob_count);
 
1265
    } else if(avctx->flags&CODEC_FLAG_PASS1)
 
1266
        avctx->stats_out[0] = '\0';
803
1267
 
804
1268
    f->picture_number++;
805
 
 
806
 
    if(f->ac){
807
 
        return ff_rac_terminate(c);
808
 
    }else{
809
 
        flush_put_bits(&f->pb); //nicer padding FIXME
810
 
        return used_count + (put_bits_count(&f->pb)+7)/8;
811
 
    }
 
1269
    return buf_p-buf;
812
1270
}
813
1271
#endif /* CONFIG_FFV1_ENCODER */
814
1272
 
815
1273
static av_cold int common_end(AVCodecContext *avctx){
816
1274
    FFV1Context *s = avctx->priv_data;
817
 
    int i;
818
 
 
819
 
    for(i=0; i<s->plane_count; i++){
820
 
        PlaneContext *p= &s->plane[i];
821
 
 
822
 
        av_freep(&p->state);
823
 
        av_freep(&p->vlc_state);
 
1275
    int i, j;
 
1276
 
 
1277
    if (avctx->codec->decode && s->picture.data[0])
 
1278
        avctx->release_buffer(avctx, &s->picture);
 
1279
 
 
1280
    for(j=0; j<s->slice_count; j++){
 
1281
        FFV1Context *fs= s->slice_context[j];
 
1282
        for(i=0; i<s->plane_count; i++){
 
1283
            PlaneContext *p= &fs->plane[i];
 
1284
 
 
1285
            av_freep(&p->state);
 
1286
            av_freep(&p->vlc_state);
 
1287
        }
 
1288
        av_freep(&fs->sample_buffer);
 
1289
    }
 
1290
 
 
1291
    av_freep(&avctx->stats_out);
 
1292
    for(j=0; j<s->quant_table_count; j++){
 
1293
        av_freep(&s->initial_states[j]);
 
1294
        for(i=0; i<s->slice_count; i++){
 
1295
            FFV1Context *sf= s->slice_context[i];
 
1296
            av_freep(&sf->rc_stat2[j]);
 
1297
        }
 
1298
        av_freep(&s->rc_stat2[j]);
 
1299
    }
 
1300
 
 
1301
    for(i=0; i<s->slice_count; i++){
 
1302
        av_freep(&s->slice_context[i]);
824
1303
    }
825
1304
 
826
1305
    return 0;
837
1316
    for(x=0; x<w; x++){
838
1317
        int diff, context, sign;
839
1318
 
840
 
        context= get_context(s, sample[1] + x, sample[0] + x, sample[1] + x);
 
1319
        context= get_context(p, sample[1] + x, sample[0] + x, sample[1] + x);
841
1320
        if(context < 0){
842
1321
            context= -context;
843
1322
            sign=1;
844
1323
        }else
845
1324
            sign=0;
846
1325
 
 
1326
        av_assert2(context < p->context_count);
847
1327
 
848
1328
        if(s->ac){
849
1329
            diff= get_symbol_inline(c, p->state[context], 1);
885
1365
 
886
1366
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
887
1367
    int x, y;
888
 
    int_fast16_t sample_buffer[2][w+6];
889
1368
    int_fast16_t *sample[2];
890
 
    sample[0]=sample_buffer[0]+3;
891
 
    sample[1]=sample_buffer[1]+3;
 
1369
    sample[0]=s->sample_buffer    +3;
 
1370
    sample[1]=s->sample_buffer+w+6+3;
892
1371
 
893
1372
    s->run_index=0;
894
1373
 
895
 
    memset(sample_buffer, 0, sizeof(sample_buffer));
 
1374
    memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
896
1375
 
897
1376
    for(y=0; y<h; y++){
898
1377
        int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
921
1400
 
922
1401
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
923
1402
    int x, y, p;
924
 
    int_fast16_t sample_buffer[3][2][w+6];
925
1403
    int_fast16_t *sample[3][2];
926
1404
    for(x=0; x<3; x++){
927
 
        sample[x][0] = sample_buffer[x][0]+3;
928
 
        sample[x][1] = sample_buffer[x][1]+3;
 
1405
        sample[x][0] = s->sample_buffer +  x*2   *(w+6) + 3;
 
1406
        sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
929
1407
    }
930
1408
 
931
1409
    s->run_index=0;
932
1410
 
933
 
    memset(sample_buffer, 0, sizeof(sample_buffer));
 
1411
    memset(s->sample_buffer, 0, 6*(w+6)*sizeof(*s->sample_buffer));
934
1412
 
935
1413
    for(y=0; y<h; y++){
936
1414
        for(p=0; p<3; p++){
957
1435
            b += g;
958
1436
            r += g;
959
1437
 
960
 
            src[x + stride*y]= b + (g<<8) + (r<<16);
 
1438
            src[x + stride*y]= b + (g<<8) + (r<<16) + (0xFF<<24);
961
1439
        }
962
1440
    }
963
1441
}
964
1442
 
 
1443
static int decode_slice(AVCodecContext *c, void *arg){
 
1444
    FFV1Context *fs= *(void**)arg;
 
1445
    FFV1Context *f= fs->avctx->priv_data;
 
1446
    int width = fs->slice_width;
 
1447
    int height= fs->slice_height;
 
1448
    int x= fs->slice_x;
 
1449
    int y= fs->slice_y;
 
1450
    AVFrame * const p= &f->picture;
 
1451
 
 
1452
    av_assert1(width && height);
 
1453
    if(f->colorspace==0){
 
1454
        const int chroma_width = -((-width )>>f->chroma_h_shift);
 
1455
        const int chroma_height= -((-height)>>f->chroma_v_shift);
 
1456
        const int cx= x>>f->chroma_h_shift;
 
1457
        const int cy= y>>f->chroma_v_shift;
 
1458
        decode_plane(fs, p->data[0] + x + y*p->linesize[0], width, height, p->linesize[0], 0);
 
1459
 
 
1460
        decode_plane(fs, p->data[1] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);
 
1461
        decode_plane(fs, p->data[2] + cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[2], 1);
 
1462
    }else{
 
1463
        decode_rgb_frame(fs, (uint32_t*)p->data[0] + x + y*(p->linesize[0]/4), width, height, p->linesize[0]/4);
 
1464
    }
 
1465
 
 
1466
    emms_c();
 
1467
 
 
1468
    return 0;
 
1469
}
 
1470
 
965
1471
static int read_quant_table(RangeCoder *c, int16_t *quant_table, int scale){
966
1472
    int v;
967
1473
    int i=0;
990
1496
    return 2*v - 1;
991
1497
}
992
1498
 
993
 
static int read_header(FFV1Context *f){
 
1499
static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
 
1500
    int i;
 
1501
    int context_count=1;
 
1502
 
 
1503
    for(i=0; i<5; i++){
 
1504
        context_count*= read_quant_table(c, quant_table[i], context_count);
 
1505
        if(context_count > 32768U){
 
1506
            return -1;
 
1507
        }
 
1508
    }
 
1509
    return (context_count+1)/2;
 
1510
}
 
1511
 
 
1512
static int read_extra_header(FFV1Context *f){
 
1513
    RangeCoder * const c= &f->c;
994
1514
    uint8_t state[CONTEXT_SIZE];
995
 
    int i, context_count;
996
 
    RangeCoder * const c= &f->c;
 
1515
    int i, j, k;
 
1516
    uint8_t state2[32][CONTEXT_SIZE];
997
1517
 
 
1518
    memset(state2, 128, sizeof(state2));
998
1519
    memset(state, 128, sizeof(state));
999
1520
 
 
1521
    ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
 
1522
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
 
1523
 
1000
1524
    f->version= get_symbol(c, state, 0);
1001
1525
    f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
1002
1526
    if(f->ac>1){
1005
1529
        }
1006
1530
    }
1007
1531
    f->colorspace= get_symbol(c, state, 0); //YUV cs type
1008
 
    if(f->version>0)
1009
 
        f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
 
1532
    f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
1010
1533
    get_rac(c, state); //no chroma = false
1011
1534
    f->chroma_h_shift= get_symbol(c, state, 0);
1012
1535
    f->chroma_v_shift= get_symbol(c, state, 0);
1013
1536
    get_rac(c, state); //transparency plane
1014
1537
    f->plane_count= 2;
 
1538
    f->num_h_slices= 1 + get_symbol(c, state, 0);
 
1539
    f->num_v_slices= 1 + get_symbol(c, state, 0);
 
1540
    if(f->num_h_slices > (unsigned)f->width || f->num_v_slices > (unsigned)f->height){
 
1541
        av_log(f->avctx, AV_LOG_ERROR, "too many slices\n");
 
1542
        return -1;
 
1543
    }
 
1544
 
 
1545
    f->quant_table_count= get_symbol(c, state, 0);
 
1546
    if(f->quant_table_count > (unsigned)MAX_QUANT_TABLES)
 
1547
        return -1;
 
1548
    for(i=0; i<f->quant_table_count; i++){
 
1549
        if((f->context_count[i]= read_quant_tables(c, f->quant_tables[i])) < 0){
 
1550
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
 
1551
            return -1;
 
1552
        }
 
1553
    }
 
1554
 
 
1555
    if(allocate_initial_states(f) < 0)
 
1556
        return AVERROR(ENOMEM);
 
1557
 
 
1558
    for(i=0; i<f->quant_table_count; i++){
 
1559
        if(get_rac(c, state)){
 
1560
            for(j=0; j<f->context_count[i]; j++){
 
1561
                for(k=0; k<CONTEXT_SIZE; k++){
 
1562
                    int pred= j ? f->initial_states[i][j-1][k] : 128;
 
1563
                    f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
 
1564
                }
 
1565
            }
 
1566
        }
 
1567
    }
 
1568
 
 
1569
    return 0;
 
1570
}
 
1571
 
 
1572
static int read_header(FFV1Context *f){
 
1573
    uint8_t state[CONTEXT_SIZE];
 
1574
    int i, j, context_count;
 
1575
    RangeCoder * const c= &f->slice_context[0]->c;
 
1576
 
 
1577
    memset(state, 128, sizeof(state));
 
1578
 
 
1579
    if(f->version < 2){
 
1580
        f->version= get_symbol(c, state, 0);
 
1581
        f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
 
1582
        if(f->ac>1){
 
1583
            for(i=1; i<256; i++){
 
1584
                f->state_transition[i]= get_symbol(c, state, 1) + c->one_state[i];
 
1585
            }
 
1586
        }
 
1587
        f->colorspace= get_symbol(c, state, 0); //YUV cs type
 
1588
        if(f->version>0)
 
1589
            f->avctx->bits_per_raw_sample= get_symbol(c, state, 0);
 
1590
        get_rac(c, state); //no chroma = false
 
1591
        f->chroma_h_shift= get_symbol(c, state, 0);
 
1592
        f->chroma_v_shift= get_symbol(c, state, 0);
 
1593
        get_rac(c, state); //transparency plane
 
1594
        f->plane_count= 2;
 
1595
    }
1015
1596
 
1016
1597
    if(f->colorspace==0){
1017
1598
        if(f->avctx->bits_per_raw_sample<=8){
1047
1628
    }
1048
1629
 
1049
1630
//printf("%d %d %d\n", f->chroma_h_shift, f->chroma_v_shift,f->avctx->pix_fmt);
1050
 
 
1051
 
    context_count=1;
1052
 
    for(i=0; i<5; i++){
1053
 
        context_count*= read_quant_table(c, f->quant_table[i], context_count);
1054
 
        if(context_count < 0 || context_count > 32768){
1055
 
            av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
 
1631
    if(f->version < 2){
 
1632
        context_count= read_quant_tables(c, f->quant_table);
 
1633
        if(context_count < 0){
 
1634
                av_log(f->avctx, AV_LOG_ERROR, "read_quant_table error\n");
 
1635
                return -1;
 
1636
        }
 
1637
    }else{
 
1638
        f->slice_count= get_symbol(c, state, 0);
 
1639
        if(f->slice_count > (unsigned)MAX_SLICES)
1056
1640
            return -1;
 
1641
    }
 
1642
 
 
1643
    for(j=0; j<f->slice_count; j++){
 
1644
        FFV1Context *fs= f->slice_context[j];
 
1645
        fs->ac= f->ac;
 
1646
 
 
1647
        if(f->version >= 2){
 
1648
            fs->slice_x     = get_symbol(c, state, 0)   *f->width ;
 
1649
            fs->slice_y     = get_symbol(c, state, 0)   *f->height;
 
1650
            fs->slice_width =(get_symbol(c, state, 0)+1)*f->width  + fs->slice_x;
 
1651
            fs->slice_height=(get_symbol(c, state, 0)+1)*f->height + fs->slice_y;
 
1652
 
 
1653
            fs->slice_x /= f->num_h_slices;
 
1654
            fs->slice_y /= f->num_v_slices;
 
1655
            fs->slice_width  = fs->slice_width /f->num_h_slices - fs->slice_x;
 
1656
            fs->slice_height = fs->slice_height/f->num_v_slices - fs->slice_y;
 
1657
            if((unsigned)fs->slice_width > f->width || (unsigned)fs->slice_height > f->height)
 
1658
                return -1;
 
1659
            if(    (unsigned)fs->slice_x + (uint64_t)fs->slice_width  > f->width
 
1660
                || (unsigned)fs->slice_y + (uint64_t)fs->slice_height > f->height)
 
1661
                return -1;
1057
1662
        }
1058
 
    }
1059
 
    context_count= (context_count+1)/2;
1060
 
 
1061
 
    for(i=0; i<f->plane_count; i++){
1062
 
        PlaneContext * const p= &f->plane[i];
1063
 
 
1064
 
        p->context_count= context_count;
1065
 
 
1066
 
        if(f->ac){
1067
 
            if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
1068
 
        }else{
1069
 
            if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
 
1663
 
 
1664
        for(i=0; i<f->plane_count; i++){
 
1665
            PlaneContext * const p= &fs->plane[i];
 
1666
 
 
1667
            if(f->version >= 2){
 
1668
                int idx=get_symbol(c, state, 0);
 
1669
                if(idx > (unsigned)f->quant_table_count){
 
1670
                    av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
 
1671
                    return -1;
 
1672
                }
 
1673
                p->quant_table_index= idx;
 
1674
                memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
 
1675
                context_count= f->context_count[idx];
 
1676
            }else{
 
1677
                memcpy(p->quant_table, f->quant_table, sizeof(p->quant_table));
 
1678
            }
 
1679
 
 
1680
            if(p->context_count < context_count){
 
1681
                av_freep(&p->state);
 
1682
                av_freep(&p->vlc_state);
 
1683
            }
 
1684
            p->context_count= context_count;
1070
1685
        }
1071
1686
    }
1072
1687
 
1075
1690
 
1076
1691
static av_cold int decode_init(AVCodecContext *avctx)
1077
1692
{
1078
 
//    FFV1Context *s = avctx->priv_data;
 
1693
    FFV1Context *f = avctx->priv_data;
1079
1694
 
1080
1695
    common_init(avctx);
1081
1696
 
 
1697
    if(avctx->extradata && read_extra_header(f) < 0)
 
1698
        return -1;
 
1699
 
 
1700
    if(init_slice_contexts(f) < 0)
 
1701
        return -1;
 
1702
 
1082
1703
    return 0;
1083
1704
}
1084
1705
 
1086
1707
    const uint8_t *buf = avpkt->data;
1087
1708
    int buf_size = avpkt->size;
1088
1709
    FFV1Context *f = avctx->priv_data;
1089
 
    RangeCoder * const c= &f->c;
1090
 
    const int width= f->width;
1091
 
    const int height= f->height;
 
1710
    RangeCoder * const c= &f->slice_context[0]->c;
1092
1711
    AVFrame * const p= &f->picture;
1093
 
    int bytes_read;
 
1712
    int bytes_read, i;
1094
1713
    uint8_t keystate= 128;
 
1714
    const uint8_t *buf_p;
1095
1715
 
1096
1716
    AVFrame *picture = data;
1097
1717
 
 
1718
    /* release previously stored data */
 
1719
    if (p->data[0])
 
1720
        avctx->release_buffer(avctx, p);
 
1721
 
1098
1722
    ff_init_range_decoder(c, buf, buf_size);
1099
1723
    ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
1100
1724
 
1104
1728
        p->key_frame= 1;
1105
1729
        if(read_header(f) < 0)
1106
1730
            return -1;
 
1731
        if(init_slice_state(f) < 0)
 
1732
            return -1;
 
1733
 
1107
1734
        clear_state(f);
1108
1735
    }else{
1109
1736
        p->key_frame= 0;
1116
1743
        }
1117
1744
    }
1118
1745
 
1119
 
    if(!f->plane[0].state && !f->plane[0].vlc_state)
1120
 
        return -1;
1121
 
 
1122
1746
    p->reference= 0;
1123
1747
    if(avctx->get_buffer(avctx, p) < 0){
1124
1748
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1132
1756
        bytes_read = c->bytestream - c->bytestream_start - 1;
1133
1757
        if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
1134
1758
//printf("pos=%d\n", bytes_read);
1135
 
        init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
 
1759
        init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, buf_size - bytes_read);
1136
1760
    } else {
1137
1761
        bytes_read = 0; /* avoid warning */
1138
1762
    }
1139
1763
 
1140
 
    if(f->colorspace==0){
1141
 
        const int chroma_width = -((-width )>>f->chroma_h_shift);
1142
 
        const int chroma_height= -((-height)>>f->chroma_v_shift);
1143
 
        decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
1144
 
 
1145
 
        decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
1146
 
        decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 1);
1147
 
    }else{
1148
 
        decode_rgb_frame(f, (uint32_t*)p->data[0], width, height, p->linesize[0]/4);
 
1764
    buf_p= buf + buf_size;
 
1765
    for(i=f->slice_count-1; i>0; i--){
 
1766
        FFV1Context *fs= f->slice_context[i];
 
1767
        int v= AV_RB24(buf_p-3)+3;
 
1768
        if(buf_p - buf <= v){
 
1769
            av_log(avctx, AV_LOG_ERROR, "Slice pointer chain broken\n");
 
1770
            return -1;
 
1771
        }
 
1772
        buf_p -= v;
 
1773
        if(fs->ac){
 
1774
            ff_init_range_decoder(&fs->c, buf_p, v);
 
1775
        }else{
 
1776
            init_get_bits(&fs->gb, buf_p, v);
 
1777
        }
1149
1778
    }
1150
1779
 
1151
 
    emms_c();
1152
 
 
 
1780
    avctx->execute(avctx, decode_slice, &f->slice_context[0], NULL, f->slice_count, sizeof(void*));
1153
1781
    f->picture_number++;
1154
1782
 
1155
1783
    *picture= *p;
1156
 
 
1157
 
    avctx->release_buffer(avctx, p); //FIXME
1158
 
 
1159
1784
    *data_size = sizeof(AVFrame);
1160
1785
 
1161
 
    if(f->ac){
1162
 
        bytes_read= c->bytestream - c->bytestream_start - 1;
1163
 
        if(bytes_read ==0) av_log(f->avctx, AV_LOG_ERROR, "error at end of frame\n");
1164
 
    }else{
1165
 
        bytes_read+= (get_bits_count(&f->gb)+7)/8;
1166
 
    }
1167
 
 
1168
 
    return bytes_read;
 
1786
    return buf_size;
1169
1787
}
1170
1788
 
1171
 
AVCodec ffv1_decoder = {
 
1789
AVCodec ff_ffv1_decoder = {
1172
1790
    "ffv1",
1173
1791
    AVMEDIA_TYPE_VIDEO,
1174
1792
    CODEC_ID_FFV1,
1183
1801
};
1184
1802
 
1185
1803
#if CONFIG_FFV1_ENCODER
1186
 
AVCodec ffv1_encoder = {
 
1804
AVCodec ff_ffv1_encoder = {
1187
1805
    "ffv1",
1188
1806
    AVMEDIA_TYPE_VIDEO,
1189
1807
    CODEC_ID_FFV1,