FFmpeg: libavcodec/ffv1.h Source File

FFmpeg

[フレーム]

libavcodec

ffv1.h

Go to the documentation of this file.

1 /*

2 * FFV1 codec for libavcodec

3 *

5 *

6 * This file is part of FFmpeg.

7 *

8 * FFmpeg is free software; you can redistribute it and/or

9 * modify it under the terms of the GNU Lesser General Public

10 * License as published by the Free Software Foundation; either

11 * version 2.1 of the License, or (at your option) any later version.

12 *

13 * FFmpeg is distributed in the hope that it will be useful,

14 * but WITHOUT ANY WARRANTY; without even the implied warranty of

15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

16 * Lesser General Public License for more details.

17 *

18 * You should have received a copy of the GNU Lesser General Public

19 * License along with FFmpeg; if not, write to the Free Software

20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

21 */

23 #ifndef AVCODEC_FFV1_H

24 #define AVCODEC_FFV1_H

26 /**

27 * @file

28 * FF Video Codec 1 (a lossless codec)

29 */

31 #include "libavutil/avassert.h"

32 #include "libavutil/crc.h"

33 #include "libavutil/opt.h"

34 #include "libavutil/imgutils.h"

35 #include "libavutil/pixdesc.h"

36 #include "libavutil/timer.h"

37 #include "avcodec.h"

38 #include "dsputil.h"

39 #include "get_bits.h"

40 #include "internal.h"

41 #include "mathops.h"

42 #include "put_bits.h"

43 #include "rangecoder.h"

44 #include "thread.h"

46 #ifdef __INTEL_COMPILER

47 #undef av_flatten

48 #define av_flatten

49 #endif

51 #define MAX_PLANES 4

52 #define CONTEXT_SIZE 32

54 #define MAX_QUANT_TABLES 8

55 #define MAX_CONTEXT_INPUTS 5

57 extern const uint8_t ff_log2_run[41];

59 typedef struct VlcState {

60 int16_t drift;

61 uint16_t error_sum;

62 int8_t bias;

63 uint8_t count;

64 } VlcState;

66 typedef struct PlaneContext {

67 int16_t quant_table[MAX_CONTEXT_INPUTS][256];

68 int quant_table_index;

69 int context_count;

70 uint8_t (*state)[CONTEXT_SIZE];

71 VlcState *vlc_state;

72 uint8_t interlace_bit_state[2];

73 } PlaneContext;

75 #define MAX_SLICES 256

77 typedef struct FFV1Context {

78 AVClass *class;

79 AVCodecContext *avctx;

80 RangeCoder c;

81 GetBitContext gb;

82 PutBitContext pb;

83 uint64_t rc_stat[256][2];

84 uint64_t (*rc_stat2[MAX_QUANT_TABLES])[32][2];

85 int version;

86 int minor_version;

87 int width, height;

88 int chroma_planes;

89 int chroma_h_shift, chroma_v_shift;

90 int transparency;

91 int flags;

92 int picture_number;

93 ThreadFrame picture, last_picture;

94 struct FFV1Context *fsrc;

96 AVFrame *cur;

97 int plane_count;

98 int ac; ///< 1=range coder <-> 0=golomb rice

99 int ac_byte_count; ///< number of bytes used for AC coding

100 PlaneContext plane[MAX_PLANES];

101 int16_t quant_table[MAX_CONTEXT_INPUTS][256];

102 int16_t quant_tables[MAX_QUANT_TABLES][MAX_CONTEXT_INPUTS][256];

103 int context_count[MAX_QUANT_TABLES];

104 uint8_t state_transition[256];

105 uint8_t (*initial_states[MAX_QUANT_TABLES])[32];

106 int run_index;

107 int colorspace;

108 int16_t *sample_buffer;

109

110 int ec;

111 int intra;

112 int slice_damaged;

113 int key_frame_ok;

114

115 int bits_per_raw_sample;

116 int packed_at_lsb;

117

118 int gob_count;

119 int quant_table_count;

120

121 DSPContext dsp;

122

123 struct FFV1Context *slice_context[MAX_SLICES];

124 int slice_count;

125 int num_v_slices;

126 int num_h_slices;

127 int slice_width;

128 int slice_height;

129 int slice_x;

130 int slice_y;

131 } FFV1Context;

132

133 int ffv1_common_init(AVCodecContext *avctx);

134 int ffv1_init_slice_state(FFV1Context *f, FFV1Context *fs);

135 int ffv1_init_slices_state(FFV1Context *f);

136 int ffv1_init_slice_contexts(FFV1Context *f);

137 int ffv1_allocate_initial_states(FFV1Context *f);

138 void ffv1_clear_slice_state(FFV1Context *f, FFV1Context *fs);

139 int ffv1_close(AVCodecContext *avctx);

140

141 static av_always_inline int fold(int diff, int bits)

142 {

143 if (bits == 8)

144 diff = (int8_t)diff;

145 else {

146 diff += 1 << (bits - 1);

147 diff &= (1 << bits) - 1;

148 diff -= 1 << (bits - 1);

149 }

150

151 return diff;

152 }

153

154 static inline int predict(int16_t *src, int16_t *last)

155 {

156 const int LT = last[-1];

157 const int T = last[0];

158 const int L = src[-1];

159

160 return mid_pred(L, L + T - LT, T);

161 }

162

163 static inline int get_context(PlaneContext *p, int16_t *src,

164 int16_t *last, int16_t *last2)

165 {

166 const int LT = last[-1];

167 const int T = last[0];

168 const int RT = last[1];

169 const int L = src[-1];

170

171 if (p->quant_table[3][127]) {

172 const int TT = last2[0];

173 const int LL = src[-2];

174 return p->quant_table[0][(L - LT) & 0xFF] +

175 p->quant_table[1][(LT - T) & 0xFF] +

176 p->quant_table[2][(T - RT) & 0xFF] +

177 p->quant_table[3][(LL - L) & 0xFF] +

178 p->quant_table[4][(TT - T) & 0xFF];

179 } else

180 return p->quant_table[0][(L - LT) & 0xFF] +

181 p->quant_table[1][(LT - T) & 0xFF] +

182 p->quant_table[2][(T - RT) & 0xFF];

183 }

184

185 static inline void update_vlc_state(VlcState *const state, const int v)

186 {

187 int drift = state->drift;

188 int count = state->count;

189 state->error_sum += FFABS(v);

190 drift += v;

191

192 if (count == 128) { // FIXME: variable

193 count >>= 1;

194 drift >>= 1;

195 state->error_sum >>= 1;

196 }

197 count++;

198

199 if (drift <= -count) {

200 if (state->bias > -128)

201 state->bias--;

202

203 drift += count;

204 if (drift <= -count)

205 drift = -count + 1;

206 } else if (drift > 0) {

207 if (state->bias < 127)

208 state->bias++;

209

210 drift -= count;

211 if (drift > 0)

212 drift = 0;

213 }

214

215 state->drift = drift;

216 state->count = count;

217 }

218

219 #endif /* AVCODEC_FFV1_H */

Generated on Wed Jul 10 2013 23:47:57 for FFmpeg by doxygen 1.8.2