xenia-project/FFmpeg
1
0
Fork 0
mirror of https://github.com/xenia-project/FFmpeg.git synced 2024-12-13 14:25:52 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
2c094d6338
FFmpeg/libavcodec/ffv1.c

919 lines
27 KiB
C
Raw Normal View History

FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
/*
* FFV1 codec for libavcodec
*
* Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
*
* This library 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 of the License, or (at your option) any later version.
*
* This library 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 this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*/
/**
* @file ffv1.c
* FF Video Codec 1 (a experimental lossless codec)
*/
#include "common.h"
#include "avcodec.h"
#include "dsputil.h"
#include "cabac.h"
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
#include "golomb.h"
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
#define MAX_PLANES 4
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
#define CONTEXT_SIZE 32
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
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,
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
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,
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
-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,
};
static const int8_t quant5[256]={
0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
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, 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, 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,-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,-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,-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,-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 quant11[256]={
0, 1, 2, 2, 2, 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, 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, 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, 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,-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,-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,-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,-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,
};
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
static const uint8_t log2_run[32]={
0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
4, 4, 5, 5, 6, 6, 7, 7,
8, 9,10,11,12,13,14,15,
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
};
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
typedef struct VlcState{
int16_t drift;
uint16_t error_sum;
int8_t bias;
uint8_t count;
} VlcState;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
typedef struct PlaneContext{
int context_count;
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
uint8_t (*state)[CONTEXT_SIZE];
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
VlcState *vlc_state;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
uint8_t interlace_bit_state[2];
} PlaneContext;
typedef struct FFV1Context{
AVCodecContext *avctx;
CABACContext c;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
GetBitContext gb;
PutBitContext pb;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
int version;
int width, height;
int chroma_h_shift, chroma_v_shift;
int flags;
int picture_number;
AVFrame picture;
int plane_count;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
int ac; ///< 1-> CABAC 0-> golomb rice
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
PlaneContext plane[MAX_PLANES];
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
int16_t quant_table[5][256];
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
DSPContext dsp;
}FFV1Context;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
static inline int predict(uint8_t *src, uint8_t *last){
const int LT= last[-1];
const int T= last[ 0];
const int L = src[-1];
uint8_t *cm = cropTbl + MAX_NEG_CROP;
const int gradient= cm[L + T - LT];
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
return mid_pred(L, gradient, T);
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
}
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
static inline int get_context(FFV1Context *f, uint8_t *src, uint8_t *last, uint8_t *last2){
const int LT= last[-1];
const int T= last[ 0];
const int RT= last[ 1];
const int L = src[-1];
if(f->quant_table[3][127]){
const int TT= last2[0];
const int LL= src[-2];
return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF]
+f->quant_table[3][(LL-L) & 0xFF] + f->quant_table[4][(TT-T) & 0xFF];
}else
return f->quant_table[0][(L-LT) & 0xFF] + f->quant_table[1][(LT-T) & 0xFF] + f->quant_table[2][(T-RT) & 0xFF];
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
}
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
/**
* put
*/
static inline void put_symbol(CABACContext *c, uint8_t *state, int v, int is_signed){
int i;
if(v){
const int a= ABS(v);
const int e= av_log2(a);
put_cabac(c, state+0, 0);
put_cabac_u(c, state+1, e, 7, 6, 1); //1..7
if(e<7){
for(i=e-1; i>=0; i--){
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
static const int offset[7]= {15+0, 15+0, 15+1, 15+3, 15+6, 15+10, 15+11};
put_cabac(c, state+offset[e]+i, (a>>i)&1); //15..31
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
}
if(is_signed)
put_cabac(c, state+8 + e, v < 0); //8..14
}
}else{
put_cabac(c, state+0, 1);
}
}
static inline int get_symbol(CABACContext *c, uint8_t *state, int is_signed){
int i;
if(get_cabac(c, state+0))
return 0;
else{
const int e= get_cabac_u(c, state+1, 7, 6, 1); //1..7
if(e<7){
int a= 1<<e;
for(i=e-1; i>=0; i--){
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
static const int offset[7]= {15+0, 15+0, 15+1, 15+3, 15+6, 15+10, 15+11};
a += get_cabac(c, state+offset[e]+i)<<i; //14..31
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
}
if(is_signed && get_cabac(c, state+8 + e)) //8..14
return -a;
else
return a;
}else
return -128;
}
}
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
static inline void update_vlc_state(VlcState * const state, const int v){
int drift= state->drift;
int count= state->count;
state->error_sum += ABS(v);
drift += v;
if(count == 128){ //FIXME variable
count >>= 1;
drift >>= 1;
state->error_sum >>= 1;
}
count++;
if(drift <= -count){
if(state->bias > -128) state->bias--;
drift += count;
if(drift <= -count)
drift= -count + 1;
}else if(drift > 0){
if(state->bias < 127) state->bias++;
drift -= count;
if(drift > 0)
drift= 0;
}
state->drift= drift;
state->count= count;
}
static inline void put_vlc_symbol(PutBitContext *pb, VlcState * const state, int v){
int i, k, code;
//printf("final: %d ", v);
v = (int8_t)(v - state->bias);
i= state->count;
k=0;
while(i < state->error_sum){ //FIXME optimize
k++;
i += i;
}
#if 0 // JPEG LS
if(k==0 && 2*state->drift <= - state->count) code= v ^ (-1);
else code= v;
#else
code= v ^ ((2*state->drift + state->count)>>31);
#endif
code = -2*code-1;
code^= (code>>31);
//printf("v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code, state->bias, state->error_sum, state->drift, state->count, k);
set_ur_golomb(pb, code, k, 8, 8);
update_vlc_state(state, v);
}
static inline int get_vlc_symbol(GetBitContext *gb, VlcState * const state){
int k, i, v, ret;
i= state->count;
k=0;
while(i < state->error_sum){ //FIXME optimize
k++;
i += i;
}
v= get_ur_golomb(gb, k, 8, 8);
//printf("v:%d bias:%d error:%d drift:%d count:%d k:%d", v, state->bias, state->error_sum, state->drift, state->count, k);
v++;
if(v&1) v= (v>>1);
else v= -(v>>1);
#if 0 // JPEG LS
if(k==0 && 2*state->drift <= - state->count) v ^= (-1);
#else
v ^= ((2*state->drift + state->count)>>31);
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
#endif
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
ret= (int8_t)(v + state->bias);
update_vlc_state(state, v);
//printf("final: %d\n", ret);
return ret;
}
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
PlaneContext * const p= &s->plane[plane_index];
CABACContext * const c= &s->c;
int x,y;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
uint8_t pred_diff_buffer[4][w+6]; //FIXME rema,e
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
uint8_t *pred_diff[4]= {pred_diff_buffer[0]+3, pred_diff_buffer[1]+3, pred_diff_buffer[2]+3, pred_diff_buffer[3]+3};
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
int run_index=0;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
memset(pred_diff_buffer, 0, sizeof(pred_diff_buffer));
for(y=0; y<h; y++){
uint8_t *temp= pred_diff[0]; //FIXME try a normal buffer
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
int run_count=0;
int run_mode=0;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
pred_diff[0]= pred_diff[1];
pred_diff[1]= pred_diff[2];
pred_diff[2]= pred_diff[3];
pred_diff[3]= temp;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
pred_diff[3][-1]= pred_diff[2][0 ];
pred_diff[2][ w]= pred_diff[2][w-1];
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
for(x=0; x<w; x++){
uint8_t *temp_src= src + x + stride*y;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
int diff, context;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
context= get_context(s, pred_diff[3]+x, pred_diff[2]+x, pred_diff[1]+x);
diff= temp_src[0] - predict(pred_diff[3]+x, pred_diff[2]+x);
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
if(context < 0){
context = -context;
diff= -diff;
}
diff= (int8_t)diff;
if(s->ac)
put_symbol(c, p->state[context], diff, 1);
else{
if(context == 0) run_mode=1;
if(run_mode){
if(diff){
while(run_count >= 1<<log2_run[run_index]){
run_count -= 1<<log2_run[run_index];
run_index++;
put_bits(&s->pb, 1, 1);
}
put_bits(&s->pb, 1 + log2_run[run_index], run_count);
if(run_index) run_index--;
run_count=0;
run_mode=0;
if(diff>0) diff--;
}else{
run_count++;
}
}
// printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, (int)get_bit_count(&s->pb));
if(run_mode == 0)
put_vlc_symbol(&s->pb, &p->vlc_state[context], diff);
}
pred_diff[3][x]= temp_src[0];
}
if(run_mode){
while(run_count >= 1<<log2_run[run_index]){
run_count -= 1<<log2_run[run_index];
run_index++;
put_bits(&s->pb, 1, 1);
}
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
if(run_count)
put_bits(&s->pb, 1, 1);
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
}
}
}
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
static void write_quant_table(CABACContext *c, int16_t *quant_table){
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
int last=0;
int i;
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
uint8_t state[CONTEXT_SIZE]={0};
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
for(i=1; i<128 ; i++){
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
if(quant_table[i] != quant_table[i-1]){
put_symbol(c, state, i-last-1, 0);
last= i;
}
}
put_symbol(c, state, i-last-1, 0);
}
static void write_header(FFV1Context *f){
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
uint8_t state[CONTEXT_SIZE]={0};
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
int i;
CABACContext * const c= &f->c;
put_symbol(c, state, f->version, 0);
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
put_symbol(c, state, f->avctx->coder_type, 0);
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
put_symbol(c, state, 0, 0); //YUV cs type
put_cabac(c, state, 1); //chroma planes
put_symbol(c, state, f->chroma_h_shift, 0);
put_symbol(c, state, f->chroma_v_shift, 0);
put_cabac(c, state, 0); //no transparency plane
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
for(i=0; i<5; i++)
write_quant_table(c, f->quant_table[i]);
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
}
static int common_init(AVCodecContext *avctx){
FFV1Context *s = avctx->priv_data;
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
int width, height;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
s->avctx= avctx;
s->flags= avctx->flags;
dsputil_init(&s->dsp, avctx);
width= s->width= avctx->width;
height= s->height= avctx->height;
assert(width && height);
return 0;
}
static int encode_init(AVCodecContext *avctx)
{
FFV1Context *s = avctx->priv_data;
int i;
common_init(avctx);
s->version=0;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
s->ac= avctx->coder_type;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
s->plane_count=3;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
for(i=0; i<256; i++){
s->quant_table[0][i]= quant11[i];
s->quant_table[1][i]= 11*quant11[i];
if(avctx->context_model==0){
s->quant_table[2][i]= 11*11*quant11[i];
s->quant_table[3][i]=
s->quant_table[4][i]=0;
}else{
s->quant_table[2][i]= 11*11*quant5 [i];
s->quant_table[3][i]= 5*11*11*quant5 [i];
s->quant_table[4][i]= 5*5*11*11*quant5 [i];
}
}
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
for(i=0; i<s->plane_count; i++){
PlaneContext * const p= &s->plane[i];
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
if(avctx->context_model==0){
p->context_count= (11*11*11+1)/2;
}else{
p->context_count= (11*11*5*5*5+1)/2;
}
if(s->ac){
if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
}else{
if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
}
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
}
avctx->coded_frame= &s->picture;
switch(avctx->pix_fmt){
case PIX_FMT_YUV444P:
case PIX_FMT_YUV422P:
case PIX_FMT_YUV420P:
case PIX_FMT_YUV411P:
case PIX_FMT_YUV410P:
avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);
break;
default:
fprintf(stderr, "format not supported\n");
return -1;
}
s->picture_number=0;
return 0;
}
static void clear_state(FFV1Context *f){
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
int i, j;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
for(i=0; i<f->plane_count; i++){
PlaneContext *p= &f->plane[i];
p->interlace_bit_state[0]= 0;
p->interlace_bit_state[1]= 0;
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
for(j=0; j<p->context_count; j++){
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
if(f->ac){
memset(p->state[j], 0, sizeof(uint8_t)*CONTEXT_SIZE);
p->state[j][7] = 2*62;
}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;
}
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
}
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
}
}
static int encode_frame(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){
FFV1Context *f = avctx->priv_data;
CABACContext * const c= &f->c;
AVFrame *pict = data;
const int width= f->width;
const int height= f->height;
AVFrame * const p= &f->picture;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
int used_count= 0;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
if(avctx->strict_std_compliance >= 0){
printf("this codec is under development, files encoded with it wont be decodeable with future versions!!!\n"
"use vstrict=-1 to use it anyway\n");
return -1;
}
ff_init_cabac_encoder(c, buf, buf_size);
ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
*p = *pict;
p->pict_type= FF_I_TYPE;
if(avctx->gop_size==0 || f->picture_number % avctx->gop_size == 0){
put_cabac_bypass(c, 1);
p->key_frame= 1;
write_header(f);
clear_state(f);
}else{
put_cabac_bypass(c, 0);
p->key_frame= 0;
}
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
if(!f->ac){
used_count += put_cabac_terminate(c, 1);
//printf("pos=%d\n", used_count);
init_put_bits(&f->pb, buf + used_count, buf_size - used_count, NULL, NULL);
}
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
if(1){
const int chroma_width = -((-width )>>f->chroma_h_shift);
const int chroma_height= -((-height)>>f->chroma_v_shift);
encode_plane(f, p->data[0], width, height, p->linesize[0], 0);
encode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
encode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 2);
}
emms_c();
f->picture_number++;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
if(f->ac){
return put_cabac_terminate(c, 1);
}else{
flush_put_bits(&f->pb); //nicer padding FIXME
return used_count + (get_bit_count(&f->pb)+7)/8;
}
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
}
static void common_end(FFV1Context *s){
int i;
for(i=0; i<s->plane_count; i++){
PlaneContext *p= &s->plane[i];
av_freep(&p->state);
}
}
static int encode_end(AVCodecContext *avctx)
{
FFV1Context *s = avctx->priv_data;
common_end(s);
return 0;
}
static void decode_plane(FFV1Context *s, uint8_t *src, int w, int h, int stride, int plane_index){
PlaneContext * const p= &s->plane[plane_index];
CABACContext * const c= &s->c;
int x,y;
uint8_t pred_diff_buffer[4][w+6];
uint8_t *pred_diff[4]= {pred_diff_buffer[0]+3, pred_diff_buffer[1]+3, pred_diff_buffer[2]+3, pred_diff_buffer[3]+3};
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
int run_index=0;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
memset(pred_diff_buffer, 0, sizeof(pred_diff_buffer));
for(y=0; y<h; y++){
uint8_t *temp= pred_diff[0]; //FIXME try a normal buffer
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
int run_count=0;
int run_mode=0;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
pred_diff[0]= pred_diff[1];
pred_diff[1]= pred_diff[2];
pred_diff[2]= pred_diff[3];
pred_diff[3]= temp;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
pred_diff[3][-1]= pred_diff[2][0 ];
pred_diff[2][ w]= pred_diff[2][w-1];
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
for(x=0; x<w; x++){
uint8_t *temp_src= src + x + stride*y;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
int diff, context, sign;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
context= get_context(s, pred_diff[3] + x, pred_diff[2] + x, pred_diff[1] + x);
if(context < 0){
context= -context;
sign=1;
}else
sign=0;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
if(s->ac)
diff= get_symbol(c, p->state[context], 1);
else{
if(context == 0 && run_mode==0) run_mode=1;
if(run_mode){
if(run_count==0 && run_mode==1){
if(get_bits1(&s->gb)){
run_count = 1<<log2_run[run_index];
if(x + run_count <= w) run_index++;
}else{
if(log2_run[run_index]) run_count = get_bits(&s->gb, log2_run[run_index]);
else run_count=0;
if(run_index) run_index--;
run_mode=2;
}
}
run_count--;
if(run_count < 0){
run_mode=0;
run_count=0;
diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);
if(diff>=0) diff++;
}else
diff=0;
}else
diff= get_vlc_symbol(&s->gb, &p->vlc_state[context]);
// printf("count:%d index:%d, mode:%d, x:%d y:%d pos:%d\n", run_count, run_index, run_mode, x, y, get_bits_count(&s->gb));
}
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
if(sign) diff= (int8_t)(-diff); //FIXME remove cast
pred_diff[3][x]=
temp_src[0] = predict(pred_diff[3] + x, pred_diff[2] + x) + diff;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
assert(diff>= -128 && diff <= 127);
}
}
}
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
static int read_quant_table(CABACContext *c, int16_t *quant_table, int scale){
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
int v;
int i=0;
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
uint8_t state[CONTEXT_SIZE]={0};
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
for(v=0; i<128 ; v++){
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
int len= get_symbol(c, state, 0) + 1;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
if(len + i > 128) return -1;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
while(len--){
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
quant_table[i] = scale*v;
i++;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
//printf("%2d ",v);
//if(i%16==0) printf("\n");
}
}
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
for(i=1; i<128; i++){
quant_table[256-i]= -quant_table[i];
}
quant_table[128]= -quant_table[127];
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
return 2*v - 1;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
}
static int read_header(FFV1Context *f){
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
uint8_t state[CONTEXT_SIZE]={0};
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
int i, context_count;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
CABACContext * const c= &f->c;
f->version= get_symbol(c, state, 0);
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
f->ac= f->avctx->coder_type= get_symbol(c, state, 0);
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
get_symbol(c, state, 0); //YUV cs type
get_cabac(c, state); //no chroma = false
f->chroma_h_shift= get_symbol(c, state, 0);
f->chroma_v_shift= get_symbol(c, state, 0);
get_cabac(c, state); //transparency plane
f->plane_count= 3;
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
context_count=1;
for(i=0; i<5; i++){
context_count*= read_quant_table(c, f->quant_table[i], context_count);
}
context_count= (context_count+1)/2;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
for(i=0; i<f->plane_count; i++){
PlaneContext * const p= &f->plane[i];
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
p->context_count= context_count;
if(f->ac){
if(!p->state) p->state= av_malloc(CONTEXT_SIZE*p->context_count*sizeof(uint8_t));
}else{
if(!p->vlc_state) p->vlc_state= av_malloc(p->context_count*sizeof(VlcState));
}
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
}
return 0;
}
static int decode_init(AVCodecContext *avctx)
{
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
// FFV1Context *s = avctx->priv_data;
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
common_init(avctx);
#if 0
switch(s->bitstream_bpp){
case 12:
avctx->pix_fmt = PIX_FMT_YUV420P;
break;
case 16:
avctx->pix_fmt = PIX_FMT_YUV422P;
break;
case 24:
case 32:
if(s->bgr32){
avctx->pix_fmt = PIX_FMT_RGBA32;
}else{
avctx->pix_fmt = PIX_FMT_BGR24;
}
break;
default:
assert(0);
}
#endif
return 0;
}
static int decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){
FFV1Context *f = avctx->priv_data;
CABACContext * const c= &f->c;
const int width= f->width;
const int height= f->height;
AVFrame * const p= &f->picture;
int bytes_read;
AVFrame *picture = data;
*data_size = 0;
/* no supplementary picture */
if (buf_size == 0)
return 0;
ff_init_cabac_decoder(c, buf, buf_size);
ff_init_cabac_states(c, ff_h264_lps_range, ff_h264_mps_state, ff_h264_lps_state, 64);
p->reference= 0;
if(avctx->get_buffer(avctx, p) < 0){
fprintf(stderr, "get_buffer() failed\n");
return -1;
}
p->pict_type= FF_I_TYPE; //FIXME I vs. P
if(get_cabac_bypass(c)){
p->key_frame= 1;
read_header(f);
clear_state(f);
}else{
p->key_frame= 0;
}
if(avctx->debug&FF_DEBUG_PICT_INFO)
printf("keyframe:%d\n", p->key_frame);
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
if(!f->ac){
bytes_read = get_cabac_terminate(c);
if(bytes_read ==0) printf("error at end of AC stream\n");
//printf("pos=%d\n", bytes_read);
init_get_bits(&f->gb, buf + bytes_read, buf_size - bytes_read);
}
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
if(1){
const int chroma_width = -((-width )>>f->chroma_h_shift);
const int chroma_height= -((-height)>>f->chroma_v_shift);
decode_plane(f, p->data[0], width, height, p->linesize[0], 0);
decode_plane(f, p->data[1], chroma_width, chroma_height, p->linesize[1], 1);
decode_plane(f, p->data[2], chroma_width, chroma_height, p->linesize[2], 2);
}
emms_c();
f->picture_number++;
*picture= *p;
avctx->release_buffer(avctx, p); //FIXME
*data_size = sizeof(AVFrame);
golomb rice codes use gradients instead of prediction errors as context model store independant quantization tables for each point merge contexts with opposit sign Originally committed as revision 1957 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-13 21:31:28 +00:00
if(f->ac){
bytes_read= get_cabac_terminate(c);
if(bytes_read ==0) printf("error at end of frame\n");
}else{
bytes_read+= (get_bits_count(&f->gb)+7)/8;
}
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
return bytes_read;
}
static int decode_end(AVCodecContext *avctx)
{
FFV1Context *s = avctx->priv_data;
int i;
if(avctx->get_buffer == avcodec_default_get_buffer){
for(i=0; i<4; i++){
av_freep(&s->picture.base[i]);
s->picture.data[i]= NULL;
}
av_freep(&s->picture.opaque);
}
return 0;
}
AVCodec ffv1_decoder = {
"ffv1",
CODEC_TYPE_VIDEO,
CODEC_ID_FFV1,
sizeof(FFV1Context),
decode_init,
NULL,
decode_end,
decode_frame,
reducing memory consumption (reducing number of contexts and other stuff, no noticeable loss in compression rate) Originally committed as revision 1942 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 23:55:16 +00:00
CODEC_CAP_DR1 /*| CODEC_CAP_DRAW_HORIZ_BAND*/,
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
NULL
};
CONFIG_ENCODERS cleanup Originally committed as revision 1984 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-22 11:08:22 +00:00
#ifdef CONFIG_ENCODERS
FFV1 codec (our very simple lossless intra only codec, compresses much better then huffyuv) Originally committed as revision 1939 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-09 02:24:51 +00:00
AVCodec ffv1_encoder = {
"ffv1",
CODEC_TYPE_VIDEO,
CODEC_ID_FFV1,
sizeof(FFV1Context),
encode_init,
encode_frame,
encode_end,
};
CONFIG_ENCODERS cleanup Originally committed as revision 1984 to svn://svn.ffmpeg.org/ffmpeg/trunk
2003-06-22 11:08:22 +00:00
#endif
Reference in New Issue Copy Permalink