*
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
*
- * This file is part of FFmpeg.
+ * This file is part of Libav.
*
- * FFmpeg is free software; you can redistribute it and/or
+ * Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
- * FFmpeg is distributed in the hope that it will be useful,
+ * Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
+ * License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#define CONTEXT_SIZE 32
#define MAX_QUANT_TABLES 8
+#define MAX_CONTEXT_INPUTS 5
-extern const uint8_t ff_log2_run[32];
-
-static const int8_t quant3[256]={
- 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
- 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
--1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
--1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
--1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
--1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
--1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
--1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
--1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
--1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, 0,
-};
+extern const uint8_t ff_log2_run[41];
static const int8_t quant5_10bit[256]={
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,-1,
};
-static const int8_t quant7[256]={
- 0, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
--3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
--3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
--3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
--3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
--3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-3,
--3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-2,-2,-2,
--2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,
--2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-2,-1,-1,
-};
-static const int8_t quant9[256]={
- 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3,
- 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
--4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
--4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
--4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
--4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
--4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
--4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
--4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,
--3,-3,-3,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-2,-1,-1,
-};
+
static const int8_t quant9_10bit[256]={
0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,
-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,-4,
-4,-4,-4,-4,-4,-3,-3,-3,-3,-3,-3,-3,-2,-2,-2,-1,
};
-static const int8_t quant13[256]={
- 0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,
- 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
- 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
- 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
--6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
--6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
--6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
--6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,
--6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-6,-5,
--5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
--5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,-5,
--4,-4,-4,-4,-4,-4,-4,-4,-4,-3,-3,-3,-3,-2,-2,-1,
-};
static const uint8_t ver2_state[256]= {
0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,
} VlcState;
typedef struct PlaneContext{
- int16_t quant_table[5][256];
+ int16_t quant_table[MAX_CONTEXT_INPUTS][256];
+ int quant_table_index;
int context_count;
uint8_t (*state)[CONTEXT_SIZE];
VlcState *vlc_state;
RangeCoder c;
GetBitContext gb;
PutBitContext pb;
+ uint64_t rc_stat[256][2];
+ uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];
int version;
int width, height;
int chroma_h_shift, chroma_v_shift;
int plane_count;
int ac; ///< 1=range coder <-> 0=golomb rice
PlaneContext plane[MAX_PLANES];
- int16_t quant_table[5][256];
- int16_t quant_tables[MAX_QUANT_TABLES][5][256];
+ int16_t quant_table[MAX_CONTEXT_INPUTS][256];
+ int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];
int context_count[MAX_QUANT_TABLES];
uint8_t state_transition[256];
+ uint8_t (*initial_states[MAX_QUANT_TABLES])[32];
int run_index;
int colorspace;
- int_fast16_t *sample_buffer;
+ int16_t *sample_buffer;
+ int gob_count;
int quant_table_count;
return diff;
}
-static inline int predict(int_fast16_t *src, int_fast16_t *last){
+static inline int predict(int16_t *src, int16_t *last)
+{
const int LT= last[-1];
const int T= last[ 0];
const int L = src[-1];
return mid_pred(L, L + T - LT, T);
}
-static inline int get_context(PlaneContext *p, int_fast16_t *src, int_fast16_t *last, int_fast16_t *last2){
+static inline int get_context(PlaneContext *p, int16_t *src,
+ int16_t *last, int16_t *last2)
+{
const int LT= last[-1];
const int T= last[ 0];
const int RT= last[ 1];
return p->quant_table[0][(L-LT) & 0xFF] + p->quant_table[1][(LT-T) & 0xFF] + p->quant_table[2][(T-RT) & 0xFF];
}
-static inline void put_symbol_inline(RangeCoder *c, uint8_t *state, int v, int is_signed){
+static void find_best_state(uint8_t best_state[256][256], const uint8_t one_state[256]){
+ int i,j,k,m;
+ double l2tab[256];
+
+ for(i=1; i<256; i++)
+ l2tab[i]= log2(i/256.0);
+
+ for(i=0; i<256; i++){
+ double best_len[256];
+ double p= i/256.0;
+
+ for(j=0; j<256; j++)
+ best_len[j]= 1<<30;
+
+ for(j=FFMAX(i-10,1); j<FFMIN(i+11,256); j++){
+ double occ[256]={0};
+ double len=0;
+ occ[j]=1.0;
+ for(k=0; k<256; k++){
+ double newocc[256]={0};
+ for(m=0; m<256; m++){
+ if(occ[m]){
+ len -=occ[m]*( p *l2tab[ m]
+ + (1-p)*l2tab[256-m]);
+ }
+ }
+ if(len < best_len[k]){
+ best_len[k]= len;
+ best_state[i][k]= j;
+ }
+ for(m=0; m<256; m++){
+ if(occ[m]){
+ newocc[ one_state[ m]] += occ[m]* p ;
+ newocc[256-one_state[256-m]] += occ[m]*(1-p);
+ }
+ }
+ memcpy(occ, newocc, sizeof(occ));
+ }
+ }
+ }
+}
+
+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]){
int i;
+#define put_rac(C,S,B) \
+do{\
+ if(rc_stat){\
+ rc_stat[*(S)][B]++;\
+ rc_stat2[(S)-state][B]++;\
+ }\
+ put_rac(C,S,B);\
+}while(0)
+
if(v){
const int a= FFABS(v);
const int e= av_log2(a);
}else{
put_rac(c, state+0, 1);
}
+#undef put_rac
}
static void av_noinline put_symbol(RangeCoder *c, uint8_t *state, int v, int is_signed){
- put_symbol_inline(c, state, v, is_signed);
+ put_symbol_inline(c, state, v, is_signed, NULL, NULL);
}
static inline av_flatten int get_symbol_inline(RangeCoder *c, uint8_t *state, int is_signed){
}
#if CONFIG_FFV1_ENCODER
-static inline int encode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
+static av_always_inline int encode_line(FFV1Context *s, int w,
+ int16_t *sample[2],
+ int plane_index, int bits)
+{
PlaneContext * const p= &s->plane[plane_index];
RangeCoder * const c= &s->c;
int x;
diff= fold(diff, bits);
if(s->ac){
- put_symbol_inline(c, p->state[context], diff, 1);
+ if(s->flags & CODEC_FLAG_PASS1){
+ put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat, s->rc_stat2[p->quant_table_index][context]);
+ }else{
+ put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);
+ }
}else{
if(context == 0) run_mode=1;
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
int x,y,i;
const int ring_size= s->avctx->context_model ? 3 : 2;
- int_fast16_t *sample[3];
+ int16_t *sample[3];
s->run_index=0;
memset(s->sample_buffer, 0, ring_size*(w+6)*sizeof(*s->sample_buffer));
static void encode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
int x, y, p, i;
const int ring_size= s->avctx->context_model ? 3 : 2;
- int_fast16_t *sample[3][3];
+ int16_t *sample[3][3];
s->run_index=0;
memset(s->sample_buffer, 0, ring_size*3*(w+6)*sizeof(*s->sample_buffer));
put_symbol(c, state, i-last-1, 0);
}
-static void write_quant_tables(RangeCoder *c, int16_t quant_table[5][256]){
+static void write_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
int i;
for(i=0; i<5; i++)
write_quant_table(c, quant_table[i]);
put_symbol(c, state, f->ac, 0);
if(f->ac>1){
for(i=1; i<256; i++){
- f->state_transition[i]=ver2_state[i];
- put_symbol(c, state, ver2_state[i] - c->one_state[i], 1);
+ put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
}
}
put_symbol(c, state, f->colorspace, 0); //YUV cs type
put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);
put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);
put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);
- for(j=0; j<f->plane_count; j++)
- put_symbol(c, state, f->avctx->context_model, 0);
+ for(j=0; j<f->plane_count; j++){
+ put_symbol(c, state, f->plane[j].quant_table_index, 0);
+ av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);
+ }
}
}
}
return 0;
}
-#if CONFIG_FFV1_ENCODER
-static int write_extra_header(FFV1Context *f){
- RangeCoder * const c= &f->c;
- uint8_t state[CONTEXT_SIZE];
- int i;
- memset(state, 128, sizeof(state));
-
- f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000);
- ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
- ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
-
- put_symbol(c, state, f->version, 0);
- put_symbol(c, state, f->ac, 0);
- if(f->ac>1){
- for(i=1; i<256; i++){
- f->state_transition[i]=ver2_state[i];
- put_symbol(c, state, ver2_state[i] - c->one_state[i], 1);
- }
- }
- put_symbol(c, state, f->colorspace, 0); //YUV cs type
- put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
- put_rac(c, state, 1); //chroma planes
- put_symbol(c, state, f->chroma_h_shift, 0);
- put_symbol(c, state, f->chroma_v_shift, 0);
- put_rac(c, state, 0); //no transparency plane
- put_symbol(c, state, f->num_h_slices-1, 0);
- put_symbol(c, state, f->num_v_slices-1, 0);
-
- put_symbol(c, state, f->quant_table_count, 0);
- for(i=0; i<f->quant_table_count; i++)
- write_quant_tables(c, f->quant_tables[i]);
-
- f->avctx->extradata_size= ff_rac_terminate(c);
-
- return 0;
-}
-
static int init_slice_state(FFV1Context *f){
int i, j;
int sye= f->avctx->height*(sy+1) / f->num_v_slices;
f->slice_context[i]= fs;
memcpy(fs, f, sizeof(*fs));
+ memset(fs->rc_stat2, 0, sizeof(fs->rc_stat2));
fs->slice_width = sxe - sxs;
fs->slice_height= sye - sys;
fs->slice_x = sxs;
fs->slice_y = sys;
- fs->sample_buffer = av_malloc(6 * (fs->width+6) * sizeof(*fs->sample_buffer));
+ fs->sample_buffer = av_malloc(9 * (fs->width+6) * sizeof(*fs->sample_buffer));
if (!fs->sample_buffer)
return AVERROR(ENOMEM);
}
return 0;
}
+static int allocate_initial_states(FFV1Context *f){
+ int i;
+
+ for(i=0; i<f->quant_table_count; i++){
+ f->initial_states[i]= av_malloc(f->context_count[i]*sizeof(*f->initial_states[i]));
+ if(!f->initial_states[i])
+ return AVERROR(ENOMEM);
+ memset(f->initial_states[i], 128, f->context_count[i]*sizeof(*f->initial_states[i]));
+ }
+ return 0;
+}
+
+#if CONFIG_FFV1_ENCODER
+static int write_extra_header(FFV1Context *f){
+ RangeCoder * const c= &f->c;
+ uint8_t state[CONTEXT_SIZE];
+ int i, j, k;
+ uint8_t state2[32][CONTEXT_SIZE];
+
+ memset(state2, 128, sizeof(state2));
+ memset(state, 128, sizeof(state));
+
+ f->avctx->extradata= av_malloc(f->avctx->extradata_size= 10000 + (11*11*5*5*5+11*11*11)*32);
+ ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);
+ ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
+
+ put_symbol(c, state, f->version, 0);
+ put_symbol(c, state, f->ac, 0);
+ if(f->ac>1){
+ for(i=1; i<256; i++){
+ put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);
+ }
+ }
+ put_symbol(c, state, f->colorspace, 0); //YUV cs type
+ put_symbol(c, state, f->avctx->bits_per_raw_sample, 0);
+ put_rac(c, state, 1); //chroma planes
+ put_symbol(c, state, f->chroma_h_shift, 0);
+ put_symbol(c, state, f->chroma_v_shift, 0);
+ put_rac(c, state, 0); //no transparency plane
+ put_symbol(c, state, f->num_h_slices-1, 0);
+ put_symbol(c, state, f->num_v_slices-1, 0);
+
+ put_symbol(c, state, f->quant_table_count, 0);
+ for(i=0; i<f->quant_table_count; i++)
+ write_quant_tables(c, f->quant_tables[i]);
+
+ for(i=0; i<f->quant_table_count; i++){
+ for(j=0; j<f->context_count[i]*CONTEXT_SIZE; j++)
+ if(f->initial_states[i] && f->initial_states[i][0][j] != 128)
+ break;
+ if(j<f->context_count[i]*CONTEXT_SIZE){
+ put_rac(c, state, 1);
+ for(j=0; j<f->context_count[i]; j++){
+ for(k=0; k<CONTEXT_SIZE; k++){
+ int pred= j ? f->initial_states[i][j-1][k] : 128;
+ put_symbol(c, state2[k], (int8_t)(f->initial_states[i][j][k]-pred), 1);
+ }
+ }
+ }else{
+ put_rac(c, state, 0);
+ }
+ }
+
+ f->avctx->extradata_size= ff_rac_terminate(c);
+
+ return 0;
+}
+
+static int sort_stt(FFV1Context *s, uint8_t stt[256]){
+ int i,i2,changed,print=0;
+
+ do{
+ changed=0;
+ for(i=12; i<244; i++){
+ for(i2=i+1; i2<245 && i2<i+4; i2++){
+#define COST(old, new) \
+ s->rc_stat[old][0]*-log2((256-(new))/256.0)\
+ +s->rc_stat[old][1]*-log2( (new) /256.0)
+
+#define COST2(old, new) \
+ COST(old, new)\
+ +COST(256-(old), 256-(new))
+
+ double size0= COST2(i, i ) + COST2(i2, i2);
+ double sizeX= COST2(i, i2) + COST2(i2, i );
+ if(sizeX < size0 && i!=128 && i2!=128){
+ int j;
+ FFSWAP(int, stt[ i], stt[ i2]);
+ FFSWAP(int, s->rc_stat[i ][0],s->rc_stat[ i2][0]);
+ FFSWAP(int, s->rc_stat[i ][1],s->rc_stat[ i2][1]);
+ if(i != 256-i2){
+ FFSWAP(int, stt[256-i], stt[256-i2]);
+ FFSWAP(int, s->rc_stat[256-i][0],s->rc_stat[256-i2][0]);
+ FFSWAP(int, s->rc_stat[256-i][1],s->rc_stat[256-i2][1]);
+ }
+ for(j=1; j<256; j++){
+ if (stt[j] == i ) stt[j] = i2;
+ else if(stt[j] == i2) stt[j] = i ;
+ if(i != 256-i2){
+ if (stt[256-j] == 256-i ) stt[256-j] = 256-i2;
+ else if(stt[256-j] == 256-i2) stt[256-j] = 256-i ;
+ }
+ }
+ print=changed=1;
+ }
+ }
+ }
+ }while(changed);
+ return print;
+}
+
static av_cold int encode_init(AVCodecContext *avctx)
{
FFV1Context *s = avctx->priv_data;
- int i;
+ int i, j, k, m;
common_init(avctx);
s->version=0;
s->ac= avctx->coder_type ? 2:0;
+ if(s->ac>1)
+ for(i=1; i<256; i++)
+ s->state_transition[i]=ver2_state[i];
+
s->plane_count=2;
for(i=0; i<256; i++){
s->quant_table_count=2;
s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];
}
}
+ s->context_count[0]= (11*11*11+1)/2;
+ s->context_count[1]= (11*11*5*5*5+1)/2;
memcpy(s->quant_table, s->quant_tables[avctx->context_model], sizeof(s->quant_table));
for(i=0; i<s->plane_count; i++){
PlaneContext * const p= &s->plane[i];
memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));
- if(avctx->context_model==0){
- p->context_count= (11*11*11+1)/2;
- }else{
- p->context_count= (11*11*5*5*5+1)/2;
- }
+ p->quant_table_index= avctx->context_model;
+ p->context_count= s->context_count[p->quant_table_index];
}
+ if(allocate_initial_states(s) < 0)
+ return AVERROR(ENOMEM);
+
avctx->coded_frame= &s->picture;
switch(avctx->pix_fmt){
case PIX_FMT_YUV444P16:
s->picture_number=0;
+ if(avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)){
+ for(i=0; i<s->quant_table_count; i++){
+ s->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*s->rc_stat2[i]));
+ if(!s->rc_stat2[i])
+ return AVERROR(ENOMEM);
+ }
+ }
+ if(avctx->stats_in){
+ char *p= avctx->stats_in;
+ uint8_t best_state[256][256];
+ int gob_count=0;
+ char *next;
+
+ av_assert0(s->version>=2);
+
+ for(;;){
+ for(j=0; j<256; j++){
+ for(i=0; i<2; i++){
+ s->rc_stat[j][i]= strtol(p, &next, 0);
+ if(next==p){
+ av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d [%s]\n", j,i,p);
+ return -1;
+ }
+ p=next;
+ }
+ }
+ for(i=0; i<s->quant_table_count; i++){
+ for(j=0; j<s->context_count[i]; j++){
+ for(k=0; k<32; k++){
+ for(m=0; m<2; m++){
+ s->rc_stat2[i][j][k][m]= strtol(p, &next, 0);
+ if(next==p){
+ av_log(avctx, AV_LOG_ERROR, "2Pass file invalid at %d %d %d %d [%s]\n", i,j,k,m,p);
+ return -1;
+ }
+ p=next;
+ }
+ }
+ }
+ }
+ gob_count= strtol(p, &next, 0);
+ if(next==p || gob_count <0){
+ av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");
+ return -1;
+ }
+ p=next;
+ while(*p=='\n' || *p==' ') p++;
+ if(p[0]==0) break;
+ }
+ sort_stt(s, s->state_transition);
+
+ find_best_state(best_state, s->state_transition);
+
+ for(i=0; i<s->quant_table_count; i++){
+ for(j=0; j<s->context_count[i]; j++){
+ for(k=0; k<32; k++){
+ double p= 128;
+ if(s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]){
+ p=256.0*s->rc_stat2[i][j][k][1] / (s->rc_stat2[i][j][k][0]+s->rc_stat2[i][j][k][1]);
+ }
+ 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)];
+ }
+ }
+ }
+ }
+
if(s->version>1){
s->num_h_slices=2;
s->num_v_slices=2;
if(init_slice_state(s) < 0)
return -1;
+#define STATS_OUT_SIZE 1024*1024*6
+ if(avctx->flags & CODEC_FLAG_PASS1){
+ avctx->stats_out= av_mallocz(STATS_OUT_SIZE);
+ for(i=0; i<s->quant_table_count; i++){
+ for(j=0; j<s->slice_count; j++){
+ FFV1Context *sf= s->slice_context[j];
+ av_assert0(!sf->rc_stat2[i]);
+ sf->rc_stat2[i]= av_mallocz(s->context_count[i]*sizeof(*sf->rc_stat2[i]));
+ if(!sf->rc_stat2[i])
+ return AVERROR(ENOMEM);
+ }
+ }
+ }
+
return 0;
}
#endif /* CONFIG_FFV1_ENCODER */
p->interlace_bit_state[0]= 128;
p->interlace_bit_state[1]= 128;
+ if(fs->ac){
+ if(f->initial_states[p->quant_table_index]){
+ memcpy(p->state, f->initial_states[p->quant_table_index], CONTEXT_SIZE*p->context_count);
+ }else
+ memset(p->state, 128, CONTEXT_SIZE*p->context_count);
+ }else{
for(j=0; j<p->context_count; j++){
- if(fs->ac){
- memset(p->state[j], 128, sizeof(uint8_t)*CONTEXT_SIZE);
- }else{
p->vlc_state[j].drift= 0;
p->vlc_state[j].error_sum= 4; //FFMAX((RANGE + 32)/64, 2);
p->vlc_state[j].bias= 0;
p->vlc_state[j].count= 1;
- }
+ }
}
}
}
ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
*p = *pict;
- p->pict_type= FF_I_TYPE;
+ p->pict_type= AV_PICTURE_TYPE_I;
if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
put_rac(c, &keystate, 1);
p->key_frame= 1;
+ f->gob_count++;
write_header(f);
clear_state(f);
}else{
buf_p += bytes;
}
+ if((avctx->flags&CODEC_FLAG_PASS1) && (f->picture_number&31)==0){
+ int j, k, m;
+ char *p= avctx->stats_out;
+ char *end= p + STATS_OUT_SIZE;
+
+ memset(f->rc_stat, 0, sizeof(f->rc_stat));
+ for(i=0; i<f->quant_table_count; i++)
+ memset(f->rc_stat2[i], 0, f->context_count[i]*sizeof(*f->rc_stat2[i]));
+
+ for(j=0; j<f->slice_count; j++){
+ FFV1Context *fs= f->slice_context[j];
+ for(i=0; i<256; i++){
+ f->rc_stat[i][0] += fs->rc_stat[i][0];
+ f->rc_stat[i][1] += fs->rc_stat[i][1];
+ }
+ for(i=0; i<f->quant_table_count; i++){
+ for(k=0; k<f->context_count[i]; k++){
+ for(m=0; m<32; m++){
+ f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];
+ f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];
+ }
+ }
+ }
+ }
+
+ for(j=0; j<256; j++){
+ snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat[j][0], f->rc_stat[j][1]);
+ p+= strlen(p);
+ }
+ snprintf(p, end-p, "\n");
+
+ for(i=0; i<f->quant_table_count; i++){
+ for(j=0; j<f->context_count[i]; j++){
+ for(m=0; m<32; m++){
+ snprintf(p, end-p, "%"PRIu64" %"PRIu64" ", f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);
+ p+= strlen(p);
+ }
+ }
+ }
+ snprintf(p, end-p, "%d\n", f->gob_count);
+ } else if(avctx->flags&CODEC_FLAG_PASS1)
+ avctx->stats_out[0] = '\0';
+
f->picture_number++;
return buf_p-buf;
}
FFV1Context *s = avctx->priv_data;
int i, j;
+ if (avctx->codec->decode && s->picture.data[0])
+ avctx->release_buffer(avctx, &s->picture);
+
for(j=0; j<s->slice_count; j++){
FFV1Context *fs= s->slice_context[j];
for(i=0; i<s->plane_count; i++){
av_freep(&fs->sample_buffer);
}
+ av_freep(&avctx->stats_out);
+ for(j=0; j<s->quant_table_count; j++){
+ av_freep(&s->initial_states[j]);
+ for(i=0; i<s->slice_count; i++){
+ FFV1Context *sf= s->slice_context[i];
+ av_freep(&sf->rc_stat2[j]);
+ }
+ av_freep(&s->rc_stat2[j]);
+ }
+
+ for(i=0; i<s->slice_count; i++){
+ av_freep(&s->slice_context[i]);
+ }
+
return 0;
}
-static av_always_inline void decode_line(FFV1Context *s, int w, int_fast16_t *sample[2], int plane_index, int bits){
+static av_always_inline void decode_line(FFV1Context *s, int w,
+ int16_t *sample[2],
+ int plane_index, int bits)
+{
PlaneContext * const p= &s->plane[plane_index];
RangeCoder * const c= &s->c;
int x;
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
int x, y;
- int_fast16_t *sample[2];
+ int16_t *sample[2];
sample[0]=s->sample_buffer +3;
sample[1]=s->sample_buffer+w+6+3;
memset(s->sample_buffer, 0, 2*(w+6)*sizeof(*s->sample_buffer));
for(y=0; y<h; y++){
- int_fast16_t *temp= sample[0]; //FIXME try a normal buffer
+ int16_t *temp = sample[0]; //FIXME try a normal buffer
sample[0]= sample[1];
sample[1]= temp;
static void decode_rgb_frame(FFV1Context *s, uint32_t *src, int w, int h, int stride){
int x, y, p;
- int_fast16_t *sample[3][2];
+ int16_t *sample[3][2];
for(x=0; x<3; x++){
sample[x][0] = s->sample_buffer + x*2 *(w+6) + 3;
sample[x][1] = s->sample_buffer + (x*2+1)*(w+6) + 3;
for(y=0; y<h; y++){
for(p=0; p<3; p++){
- int_fast16_t *temp= sample[p][0]; //FIXME try a normal buffer
+ int16_t *temp = sample[p][0]; //FIXME try a normal buffer
sample[p][0]= sample[p][1];
sample[p][1]= temp;
return 2*v - 1;
}
-static int read_quant_tables(RangeCoder *c, int16_t quant_table[5][256]){
+static int read_quant_tables(RangeCoder *c, int16_t quant_table[MAX_CONTEXT_INPUTS][256]){
int i;
int context_count=1;
static int read_extra_header(FFV1Context *f){
RangeCoder * const c= &f->c;
uint8_t state[CONTEXT_SIZE];
- int i;
+ int i, j, k;
+ uint8_t state2[32][CONTEXT_SIZE];
+ memset(state2, 128, sizeof(state2));
memset(state, 128, sizeof(state));
ff_init_range_decoder(c, f->avctx->extradata, f->avctx->extradata_size);
}
}
+ if(allocate_initial_states(f) < 0)
+ return AVERROR(ENOMEM);
+
+ for(i=0; i<f->quant_table_count; i++){
+ if(get_rac(c, state)){
+ for(j=0; j<f->context_count[i]; j++){
+ for(k=0; k<CONTEXT_SIZE; k++){
+ int pred= j ? f->initial_states[i][j-1][k] : 128;
+ f->initial_states[i][j][k]= (pred+get_symbol(c, state2[k], 1))&0xFF;
+ }
+ }
+ }
+ }
+
return 0;
}
av_log(f->avctx, AV_LOG_ERROR, "quant_table_index out of range\n");
return -1;
}
+ p->quant_table_index= idx;
memcpy(p->quant_table, f->quant_tables[idx], sizeof(p->quant_table));
context_count= f->context_count[idx];
}else{
AVFrame *picture = data;
+ /* release previously stored data */
+ if (p->data[0])
+ avctx->release_buffer(avctx, p);
+
ff_init_range_decoder(c, buf, buf_size);
ff_build_rac_states(c, 0.05*(1LL<<32), 256-8);
- p->pict_type= FF_I_TYPE; //FIXME I vs. P
+ p->pict_type= AV_PICTURE_TYPE_I; //FIXME I vs. P
if(get_rac(c, &keystate)){
p->key_frame= 1;
if(read_header(f) < 0)
bytes_read = c->bytestream - c->bytestream_start - 1;
if(bytes_read ==0) av_log(avctx, AV_LOG_ERROR, "error at end of AC stream\n"); //FIXME
//printf("pos=%d\n", bytes_read);
- init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, buf_size - bytes_read);
+ init_get_bits(&f->slice_context[0]->gb, buf + bytes_read, (buf_size - bytes_read) * 8);
} else {
bytes_read = 0; /* avoid warning */
}
if(fs->ac){
ff_init_range_decoder(&fs->c, buf_p, v);
}else{
- init_get_bits(&fs->gb, buf_p, v);
+ init_get_bits(&fs->gb, buf_p, v * 8);
}
}
f->picture_number++;
*picture= *p;
-
- avctx->release_buffer(avctx, p); //FIXME
-
*data_size = sizeof(AVFrame);
return buf_size;
}
-AVCodec ffv1_decoder = {
- "ffv1",
- AVMEDIA_TYPE_VIDEO,
- CODEC_ID_FFV1,
- sizeof(FFV1Context),
- decode_init,
- NULL,
- common_end,
- decode_frame,
- CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
- NULL,
+AVCodec ff_ffv1_decoder = {
+ .name = "ffv1",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = CODEC_ID_FFV1,
+ .priv_data_size = sizeof(FFV1Context),
+ .init = decode_init,
+ .close = common_end,
+ .decode = decode_frame,
+ .capabilities = CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/ | CODEC_CAP_SLICE_THREADS,
.long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
};
#if CONFIG_FFV1_ENCODER
-AVCodec ffv1_encoder = {
- "ffv1",
- AVMEDIA_TYPE_VIDEO,
- CODEC_ID_FFV1,
- sizeof(FFV1Context),
- encode_init,
- encode_frame,
- common_end,
+AVCodec ff_ffv1_encoder = {
+ .name = "ffv1",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = CODEC_ID_FFV1,
+ .priv_data_size = sizeof(FFV1Context),
+ .init = encode_init,
+ .encode = encode_frame,
+ .close = common_end,
+ .capabilities = CODEC_CAP_SLICE_THREADS,
.pix_fmts= (const enum PixelFormat[]){PIX_FMT_YUV420P, PIX_FMT_YUV444P, PIX_FMT_YUV422P, PIX_FMT_YUV411P, PIX_FMT_YUV410P, PIX_FMT_RGB32, PIX_FMT_YUV420P16, PIX_FMT_YUV422P16, PIX_FMT_YUV444P16, PIX_FMT_NONE},
.long_name= NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),
};