FFmpeg: libavcodec/ffv1enc.c Source File

FFmpeg

[フレーム]

libavcodec

ffv1enc.c

Go to the documentation of this file.

1 /*

2 * FFV1 encoder

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 /**

24 * @file

25 * FF Video Codec 1 (a lossless codec) encoder

26 */

28 #include "libavutil/attributes.h"

29 #include "libavutil/avassert.h"

30 #include "libavutil/crc.h"

31 #include "libavutil/opt.h"

32 #include "libavutil/imgutils.h"

33 #include "libavutil/pixdesc.h"

34 #include "libavutil/timer.h"

35 #include "avcodec.h"

36 #include "internal.h"

37 #include "put_bits.h"

38 #include "rangecoder.h"

39 #include "golomb.h"

40 #include "mathops.h"

41 #include "ffv1.h"

43 static const int8_t quant5_10bit[256] = {

44 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1,

45 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

46 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

47 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

48 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

49 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

50 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

51 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

52 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

53 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

54 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

55 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

56 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1,

57 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

58 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,

59 -1, -1, -1, -1, -1, -1, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0,

60 };

62 static const int8_t quant5[256] = {

63 0, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

64 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

65 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

66 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

67 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

68 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

69 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

70 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

71 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

72 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

73 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

74 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

75 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

76 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

77 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

78 -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2, -1, -1, -1,

79 };

81 static const int8_t quant9_10bit[256] = {

82 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2,

83 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3,

84 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,

85 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4,

86 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

87 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

88 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

89 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

90 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,

91 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,

92 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,

93 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,

94 -4, -4, -4, -4, -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3,

95 -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3, -3,

96 -3, -3, -3, -3, -3, -3, -2, -2, -2, -2, -2, -2, -2, -2, -2, -2,

97 -2, -2, -2, -2, -1, -1, -1, -1, -1, -1, -1, -1, -0, -0, -0, -0,

98 };

100 static const int8_t quant11[256] = {

101 0, 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4,

102 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,

103 4, 4, 4, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

104 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

105 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

106 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

107 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

108 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,

109 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,

110 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,

111 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,

112 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,

113 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5,

114 -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -5, -4, -4,

115 -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4, -4,

116 -4, -4, -4, -4, -4, -3, -3, -3, -3, -3, -3, -3, -2, -2, -2, -1,

117 };

118

119 static const uint8_t ver2_state[256] = {

120 0, 10, 10, 10, 10, 16, 16, 16, 28, 16, 16, 29, 42, 49, 20, 49,

121 59, 25, 26, 26, 27, 31, 33, 33, 33, 34, 34, 37, 67, 38, 39, 39,

122 40, 40, 41, 79, 43, 44, 45, 45, 48, 48, 64, 50, 51, 52, 88, 52,

123 53, 74, 55, 57, 58, 58, 74, 60, 101, 61, 62, 84, 66, 66, 68, 69,

124 87, 82, 71, 97, 73, 73, 82, 75, 111, 77, 94, 78, 87, 81, 83, 97,

125 85, 83, 94, 86, 99, 89, 90, 99, 111, 92, 93, 134, 95, 98, 105, 98,

126 105, 110, 102, 108, 102, 118, 103, 106, 106, 113, 109, 112, 114, 112, 116, 125,

127 115, 116, 117, 117, 126, 119, 125, 121, 121, 123, 145, 124, 126, 131, 127, 129,

128 165, 130, 132, 138, 133, 135, 145, 136, 137, 139, 146, 141, 143, 142, 144, 148,

129 147, 155, 151, 149, 151, 150, 152, 157, 153, 154, 156, 168, 158, 162, 161, 160,

130 172, 163, 169, 164, 166, 184, 167, 170, 177, 174, 171, 173, 182, 176, 180, 178,

131 175, 189, 179, 181, 186, 183, 192, 185, 200, 187, 191, 188, 190, 197, 193, 196,

132 197, 194, 195, 196, 198, 202, 199, 201, 210, 203, 207, 204, 205, 206, 208, 214,

133 209, 211, 221, 212, 213, 215, 224, 216, 217, 218, 219, 220, 222, 228, 223, 225,

134 226, 224, 227, 229, 240, 230, 231, 232, 233, 234, 235, 236, 238, 239, 237, 242,

135 241, 243, 242, 244, 245, 246, 247, 248, 249, 250, 251, 252, 252, 253, 254, 255,

136 };

137

138 static void find_best_state(uint8_t best_state[256][256],

139 const uint8_t one_state[256])

140 {

141 int i, j, k, m;

142 double l2tab[256];

143

144 for (i = 1; i < 256; i++)

145 l2tab[i] = log2(i / 256.0);

146

147 for (i = 0; i < 256; i++) {

148 double best_len[256];

149 double p = i / 256.0;

150

151 for (j = 0; j < 256; j++)

152 best_len[j] = 1 << 30;

153

154 for (j = FFMAX(i - 10, 1); j < FFMIN(i + 11, 256); j++) {

155 double occ[256] = { 0 };

156 double len = 0;

157 occ[j] = 1.0;

158 for (k = 0; k < 256; k++) {

159 double newocc[256] = { 0 };

160 for (m = 1; m < 256; m++)

161 if (occ[m]) {

162 len -=occ[m]*( p *l2tab[ m]

163 + (1-p)*l2tab[256-m]);

164 }

165 if (len < best_len[k]) {

166 best_len[k] = len;

167 best_state[i][k] = j;

168 }

169 for (m = 0; m < 256; m++)

170 if (occ[m]) {

171 newocc[ one_state[ m]] += occ[m] * p;

172 newocc[256 - one_state[256 - m]] += occ[m] * (1 - p);

173 }

174 memcpy(occ, newocc, sizeof(occ));

175 }

176 }

177 }

178 }

179

180 static av_always_inline av_flatten void put_symbol_inline(RangeCoder *c,

181 uint8_t *state, int v,

182 int is_signed,

183 uint64_t rc_stat[256][2],

184 uint64_t rc_stat2[32][2])

185 {

186 int i;

187

188 #define put_rac(C, S, B) \

189 do { \

190 if (rc_stat) { \

191 rc_stat[*(S)][B]++; \

192 rc_stat2[(S) - state][B]++; \

193 } \

194 put_rac(C, S, B); \

195 } while (0)

196

197 if (v) {

198 const int a = FFABS(v);

199 const int e = av_log2(a);

200 put_rac(c, state + 0, 0);

201 if (e <= 9) {

202 for (i = 0; i < e; i++)

203 put_rac(c, state + 1 + i, 1); // 1..10

204 put_rac(c, state + 1 + i, 0);

205

206 for (i = e - 1; i >= 0; i--)

207 put_rac(c, state + 22 + i, (a >> i) & 1); // 22..31

208

209 if (is_signed)

210 put_rac(c, state + 11 + e, v < 0); // 11..21

211 } else {

212 for (i = 0; i < e; i++)

213 put_rac(c, state + 1 + FFMIN(i, 9), 1); // 1..10

214 put_rac(c, state + 1 + 9, 0);

215

216 for (i = e - 1; i >= 0; i--)

217 put_rac(c, state + 22 + FFMIN(i, 9), (a >> i) & 1); // 22..31

218

219 if (is_signed)

220 put_rac(c, state + 11 + 10, v < 0); // 11..21

221 }

222 } else {

223 put_rac(c, state + 0, 1);

224 }

225 #undef put_rac

226 }

227

228 static av_noinline void put_symbol(RangeCoder *c, uint8_t *state,

229 int v, int is_signed)

230 {

231 put_symbol_inline(c, state, v, is_signed, NULL, NULL);

232 }

233

234

235 static inline void put_vlc_symbol(PutBitContext *pb, VlcState *const state,

236 int v, int bits)

237 {

238 int i, k, code;

239 v = fold(v - state->bias, bits);

240

241 i = state->count;

242 k = 0;

243 while (i < state->error_sum) { // FIXME: optimize

244 k++;

245 i += i;

246 }

247

248 av_assert2(k <= 13);

249

250 #if 0 // JPEG LS

251 if (k == 0 && 2 * state->drift <= -state->count)

252 code = v ^ (-1);

253 else

254 code = v;

255 #else

256 code = v ^ ((2 * state->drift + state->count) >> 31);

257 #endif

258

259 av_dlog(NULL, "v:%d/%d bias:%d error:%d drift:%d count:%d k:%d\n", v, code,

260 state->bias, state->error_sum, state->drift, state->count, k);

261 set_sr_golomb(pb, code, k, 12, bits);

262

263 update_vlc_state(state, v);

264 }

265

266 static av_always_inline int encode_line(FFV1Context *s, int w,

267 int16_t *sample[3],

268 int plane_index, int bits)

269 {

270 PlaneContext *const p = &s->plane[plane_index];

271 RangeCoder *const c = &s->c;

272 int x;

273 int run_index = s->run_index;

274 int run_count = 0;

275 int run_mode = 0;

276

277 if (s->ac) {

278 if (c->bytestream_end - c->bytestream < w * 20) {

279 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

280 return AVERROR_INVALIDDATA;

281 }

282 } else {

283 if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < w * 4) {

284 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");

285 return AVERROR_INVALIDDATA;

286 }

287 }

288

289 for (x = 0; x < w; x++) {

290 int diff, context;

291

292 context = get_context(p, sample[0] + x, sample[1] + x, sample[2] + x);

293 diff = sample[0][x] - predict(sample[0] + x, sample[1] + x);

294

295 if (context < 0) {

296 context = -context;

297 diff = -diff;

298 }

299

300 diff = fold(diff, bits);

301

302 if (s->ac) {

303 if (s->flags & CODEC_FLAG_PASS1) {

304 put_symbol_inline(c, p->state[context], diff, 1, s->rc_stat,

305 s->rc_stat2[p->quant_table_index][context]);

306 } else {

307 put_symbol_inline(c, p->state[context], diff, 1, NULL, NULL);

308 }

309 } else {

310 if (context == 0)

311 run_mode = 1;

312

313 if (run_mode) {

314 if (diff) {

315 while (run_count >= 1 << ff_log2_run[run_index]) {

316 run_count -= 1 << ff_log2_run[run_index];

317 run_index++;

318 put_bits(&s->pb, 1, 1);

319 }

320

321 put_bits(&s->pb, 1 + ff_log2_run[run_index], run_count);

322 if (run_index)

323 run_index--;

324 run_count = 0;

325 run_mode = 0;

326 if (diff > 0)

327 diff--;

328 } else {

329 run_count++;

330 }

331 }

332

333 av_dlog(s->avctx, "count:%d index:%d, mode:%d, x:%d pos:%d\n",

334 run_count, run_index, run_mode, x,

335 (int)put_bits_count(&s->pb));

336

337 if (run_mode == 0)

338 put_vlc_symbol(&s->pb, &p->vlc_state[context], diff, bits);

339 }

340 }

341 if (run_mode) {

342 while (run_count >= 1 << ff_log2_run[run_index]) {

343 run_count -= 1 << ff_log2_run[run_index];

344 run_index++;

345 put_bits(&s->pb, 1, 1);

346 }

347

348 if (run_count)

349 put_bits(&s->pb, 1, 1);

350 }

351 s->run_index = run_index;

352

353 return 0;

354 }

355

356 static void encode_plane(FFV1Context *s, uint8_t *src, int w, int h,

357 int stride, int plane_index)

358 {

359 int x, y, i;

360 const int ring_size = s->avctx->context_model ? 3 : 2;

361 int16_t *sample[3];

362 s->run_index = 0;

363

364 memset(s->sample_buffer, 0, ring_size * (w + 6) * sizeof(*s->sample_buffer));

365

366 for (y = 0; y < h; y++) {

367 for (i = 0; i < ring_size; i++)

368 sample[i] = s->sample_buffer + (w + 6) * ((h + i - y) % ring_size) + 3;

369

370 sample[0][-1]= sample[1][0 ];

371 sample[1][ w]= sample[1][w-1];

372 // { START_TIMER

373 if (s->bits_per_raw_sample <= 8) {

374 for (x = 0; x < w; x++)

375 sample[0][x] = src[x + stride * y];

376 encode_line(s, w, sample, plane_index, 8);

377 } else {

378 if (s->packed_at_lsb) {

379 for (x = 0; x < w; x++) {

380 sample[0][x] = ((uint16_t*)(src + stride*y))[x];

381 }

382 } else {

383 for (x = 0; x < w; x++) {

384 sample[0][x] = ((uint16_t*)(src + stride*y))[x] >> (16 - s->bits_per_raw_sample);

385 }

386 }

387 encode_line(s, w, sample, plane_index, s->bits_per_raw_sample);

388 }

389 // STOP_TIMER("encode line") }

390 }

391 }

392

393 static void encode_rgb_frame(FFV1Context *s, uint8_t *src[3], int w, int h, int stride[3])

394 {

395 int x, y, p, i;

396 const int ring_size = s->avctx->context_model ? 3 : 2;

397 int16_t *sample[4][3];

398 int lbd = s->bits_per_raw_sample <= 8;

399 int bits = s->bits_per_raw_sample > 0 ? s->bits_per_raw_sample : 8;

400 int offset = 1 << bits;

401

402 s->run_index = 0;

403

404 memset(s->sample_buffer, 0, ring_size * MAX_PLANES *

405 (w + 6) * sizeof(*s->sample_buffer));

406

407 for (y = 0; y < h; y++) {

408 for (i = 0; i < ring_size; i++)

409 for (p = 0; p < MAX_PLANES; p++)

410 sample[p][i]= s->sample_buffer + p*ring_size*(w+6) + ((h+i-y)%ring_size)*(w+6) + 3;

411

412 for (x = 0; x < w; x++) {

413 int b, g, r, av_uninit(a);

414 if (lbd) {

415 unsigned v = *((uint32_t*)(src[0] + x*4 + stride[0]*y));

416 b = v & 0xFF;

417 g = (v >> 8) & 0xFF;

418 r = (v >> 16) & 0xFF;

419 a = v >> 24;

420 } else {

421 b = *((uint16_t*)(src[0] + x*2 + stride[0]*y));

422 g = *((uint16_t*)(src[1] + x*2 + stride[1]*y));

423 r = *((uint16_t*)(src[2] + x*2 + stride[2]*y));

424 }

425

426 b -= g;

427 r -= g;

428 g += (b + r) >> 2;

429 b += offset;

430 r += offset;

431

432 sample[0][0][x] = g;

433 sample[1][0][x] = b;

434 sample[2][0][x] = r;

435 sample[3][0][x] = a;

436 }

437 for (p = 0; p < 3 + s->transparency; p++) {

438 sample[p][0][-1] = sample[p][1][0 ];

439 sample[p][1][ w] = sample[p][1][w-1];

440 if (lbd)

441 encode_line(s, w, sample[p], (p + 1) / 2, 9);

442 else

443 encode_line(s, w, sample[p], (p + 1) / 2, bits + 1);

444 }

445 }

446 }

447

448 static void write_quant_table(RangeCoder *c, int16_t *quant_table)

449 {

450 int last = 0;

451 int i;

452 uint8_t state[CONTEXT_SIZE];

453 memset(state, 128, sizeof(state));

454

455 for (i = 1; i < 128; i++)

456 if (quant_table[i] != quant_table[i - 1]) {

457 put_symbol(c, state, i - last - 1, 0);

458 last = i;

459 }

460 put_symbol(c, state, i - last - 1, 0);

461 }

462

463 static void write_quant_tables(RangeCoder *c,

464 int16_t quant_table[MAX_CONTEXT_INPUTS][256])

465 {

466 int i;

467 for (i = 0; i < 5; i++)

468 write_quant_table(c, quant_table[i]);

469 }

470

471 static void write_header(FFV1Context *f)

472 {

473 uint8_t state[CONTEXT_SIZE];

474 int i, j;

475 RangeCoder *const c = &f->slice_context[0]->c;

476

477 memset(state, 128, sizeof(state));

478

479 if (f->version < 2) {

480 put_symbol(c, state, f->version, 0);

481 put_symbol(c, state, f->ac, 0);

482 if (f->ac > 1) {

483 for (i = 1; i < 256; i++)

484 put_symbol(c, state,

485 f->state_transition[i] - c->one_state[i], 1);

486 }

487 put_symbol(c, state, f->colorspace, 0); //YUV cs type

488 if (f->version > 0)

489 put_symbol(c, state, f->bits_per_raw_sample, 0);

490 put_rac(c, state, f->chroma_planes);

491 put_symbol(c, state, f->chroma_h_shift, 0);

492 put_symbol(c, state, f->chroma_v_shift, 0);

493 put_rac(c, state, f->transparency);

494

495 write_quant_tables(c, f->quant_table);

496 } else if (f->version < 3) {

497 put_symbol(c, state, f->slice_count, 0);

498 for (i = 0; i < f->slice_count; i++) {

499 FFV1Context *fs = f->slice_context[i];

500 put_symbol(c, state,

501 (fs->slice_x + 1) * f->num_h_slices / f->width, 0);

502 put_symbol(c, state,

503 (fs->slice_y + 1) * f->num_v_slices / f->height, 0);

504 put_symbol(c, state,

505 (fs->slice_width + 1) * f->num_h_slices / f->width - 1,

506 0);

507 put_symbol(c, state,

508 (fs->slice_height + 1) * f->num_v_slices / f->height - 1,

509 0);

510 for (j = 0; j < f->plane_count; j++) {

511 put_symbol(c, state, f->plane[j].quant_table_index, 0);

512 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);

513 }

514 }

515 }

516 }

517

518 static int write_extradata(FFV1Context *f)

519 {

520 RangeCoder *const c = &f->c;

521 uint8_t state[CONTEXT_SIZE];

522 int i, j, k;

523 uint8_t state2[32][CONTEXT_SIZE];

524 unsigned v;

525

526 memset(state2, 128, sizeof(state2));

527 memset(state, 128, sizeof(state));

528

529 f->avctx->extradata_size = 10000 + 4 +

530 (11 * 11 * 5 * 5 * 5 + 11 * 11 * 11) * 32;

531 f->avctx->extradata = av_malloc(f->avctx->extradata_size);

532 ff_init_range_encoder(c, f->avctx->extradata, f->avctx->extradata_size);

533 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);

534

535 put_symbol(c, state, f->version, 0);

536 if (f->version > 2) {

537 if (f->version == 3)

538 f->minor_version = 3;

539 put_symbol(c, state, f->minor_version, 0);

540 }

541

542 put_symbol(c, state, f->ac, 0);

543 if (f->ac > 1)

544 for (i = 1; i < 256; i++)

545 put_symbol(c, state, f->state_transition[i] - c->one_state[i], 1);

546

547 put_symbol(c, state, f->colorspace, 0); // YUV cs type

548 put_symbol(c, state, f->bits_per_raw_sample, 0);

549 put_rac(c, state, f->chroma_planes);

550 put_symbol(c, state, f->chroma_h_shift, 0);

551 put_symbol(c, state, f->chroma_v_shift, 0);

552 put_rac(c, state, f->transparency);

553 put_symbol(c, state, f->num_h_slices - 1, 0);

554 put_symbol(c, state, f->num_v_slices - 1, 0);

555

556 put_symbol(c, state, f->quant_table_count, 0);

557 for (i = 0; i < f->quant_table_count; i++)

558 write_quant_tables(c, f->quant_tables[i]);

559

560 for (i = 0; i < f->quant_table_count; i++) {

561 for (j = 0; j < f->context_count[i] * CONTEXT_SIZE; j++)

562 if (f->initial_states[i] && f->initial_states[i][0][j] != 128)

563 break;

564 if (j < f->context_count[i] * CONTEXT_SIZE) {

565 put_rac(c, state, 1);

566 for (j = 0; j < f->context_count[i]; j++)

567 for (k = 0; k < CONTEXT_SIZE; k++) {

568 int pred = j ? f->initial_states[i][j - 1][k] : 128;

569 put_symbol(c, state2[k],

570 (int8_t)(f->initial_states[i][j][k] - pred), 1);

571 }

572 } else {

573 put_rac(c, state, 0);

574 }

575 }

576

577 if (f->version > 2) {

578 put_symbol(c, state, f->ec, 0);

579 put_symbol(c, state, f->intra = (f->avctx->gop_size < 2), 0);

580 }

581

582 f->avctx->extradata_size = ff_rac_terminate(c);

583 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, f->avctx->extradata, f->avctx->extradata_size);

584 AV_WL32(f->avctx->extradata + f->avctx->extradata_size, v);

585 f->avctx->extradata_size += 4;

586

587 return 0;

588 }

589

590 static int sort_stt(FFV1Context *s, uint8_t stt[256])

591 {

592 int i, i2, changed, print = 0;

593

594 do {

595 changed = 0;

596 for (i = 12; i < 244; i++) {

597 for (i2 = i + 1; i2 < 245 && i2 < i + 4; i2++) {

598

599 #define COST(old, new) \

600 s->rc_stat[old][0] * -log2((256 - (new)) / 256.0) + \

601 s->rc_stat[old][1] * -log2((new) / 256.0)

602

603 #define COST2(old, new) \

604 COST(old, new) + COST(256 - (old), 256 - (new))

605

606 double size0 = COST2(i, i) + COST2(i2, i2);

607 double sizeX = COST2(i, i2) + COST2(i2, i);

608 if (size0 - sizeX > size0*(1e-14) && i != 128 && i2 != 128) {

609 int j;

610 FFSWAP(int, stt[i], stt[i2]);

611 FFSWAP(int, s->rc_stat[i][0], s->rc_stat[i2][0]);

612 FFSWAP(int, s->rc_stat[i][1], s->rc_stat[i2][1]);

613 if (i != 256 - i2) {

614 FFSWAP(int, stt[256 - i], stt[256 - i2]);

615 FFSWAP(int, s->rc_stat[256 - i][0], s->rc_stat[256 - i2][0]);

616 FFSWAP(int, s->rc_stat[256 - i][1], s->rc_stat[256 - i2][1]);

617 }

618 for (j = 1; j < 256; j++) {

619 if (stt[j] == i)

620 stt[j] = i2;

621 else if (stt[j] == i2)

622 stt[j] = i;

623 if (i != 256 - i2) {

624 if (stt[256 - j] == 256 - i)

625 stt[256 - j] = 256 - i2;

626 else if (stt[256 - j] == 256 - i2)

627 stt[256 - j] = 256 - i;

628 }

629 }

630 print = changed = 1;

631 }

632 }

633 }

634 } while (changed);

635 return print;

636 }

637

638 static av_cold int encode_init(AVCodecContext *avctx)

639 {

640 FFV1Context *s = avctx->priv_data;

641 const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);

642 int i, j, k, m, ret;

643

644 if ((ret = ffv1_common_init(avctx)) < 0)

645 return ret;

646

647 s->version = 0;

648

649 if ((avctx->flags & (CODEC_FLAG_PASS1|CODEC_FLAG_PASS2)) || avctx->slices>1)

650 s->version = FFMAX(s->version, 2);

651

652 if (avctx->level == 3 || (s->version==2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL)) {

653 s->version = 3;

654 }

655

656 if (s->ec < 0) {

657 s->ec = (s->version >= 3);

658 }

659

660 if (s->version >= 2 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {

661 av_log(avctx, AV_LOG_ERROR, "Version 2 needed for requested features but version 2 is experimental and not enabled\n");

662 return AVERROR_INVALIDDATA;

663 }

664

665 s->ac = avctx->coder_type > 0 ? 2 : 0;

666

667 s->plane_count = 3;

668 switch(avctx->pix_fmt) {

669 case AV_PIX_FMT_YUV444P9:

670 case AV_PIX_FMT_YUV422P9:

671 case AV_PIX_FMT_YUV420P9:

672 if (!avctx->bits_per_raw_sample)

673 s->bits_per_raw_sample = 9;

674 case AV_PIX_FMT_YUV444P10:

675 case AV_PIX_FMT_YUV420P10:

676 case AV_PIX_FMT_YUV422P10:

677 s->packed_at_lsb = 1;

678 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

679 s->bits_per_raw_sample = 10;

680 case AV_PIX_FMT_GRAY16:

681 case AV_PIX_FMT_YUV444P16:

682 case AV_PIX_FMT_YUV422P16:

683 case AV_PIX_FMT_YUV420P16:

684 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample) {

685 s->bits_per_raw_sample = 16;

686 } else if (!s->bits_per_raw_sample) {

687 s->bits_per_raw_sample = avctx->bits_per_raw_sample;

688 }

689 if (s->bits_per_raw_sample <= 8) {

690 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample invalid\n");

691 return AVERROR_INVALIDDATA;

692 }

693 if (!s->ac && avctx->coder_type == -1) {

694 av_log(avctx, AV_LOG_INFO, "bits_per_raw_sample > 8, forcing coder 1\n");

695 s->ac = 2;

696 }

697 if (!s->ac) {

698 av_log(avctx, AV_LOG_ERROR, "bits_per_raw_sample of more than 8 needs -coder 1 currently\n");

699 return AVERROR(ENOSYS);

700 }

701 s->version = FFMAX(s->version, 1);

702 case AV_PIX_FMT_GRAY8:

703 case AV_PIX_FMT_YUV444P:

704 case AV_PIX_FMT_YUV440P:

705 case AV_PIX_FMT_YUV422P:

706 case AV_PIX_FMT_YUV420P:

707 case AV_PIX_FMT_YUV411P:

708 case AV_PIX_FMT_YUV410P:

709 s->chroma_planes = desc->nb_components < 3 ? 0 : 1;

710 s->colorspace = 0;

711 break;

712 case AV_PIX_FMT_YUVA444P:

713 case AV_PIX_FMT_YUVA422P:

714 case AV_PIX_FMT_YUVA420P:

715 s->chroma_planes = 1;

716 s->colorspace = 0;

717 s->transparency = 1;

718 break;

719 case AV_PIX_FMT_RGB32:

720 s->colorspace = 1;

721 s->transparency = 1;

722 break;

723 case AV_PIX_FMT_0RGB32:

724 s->colorspace = 1;

725 break;

726 case AV_PIX_FMT_GBRP9:

727 if (!avctx->bits_per_raw_sample)

728 s->bits_per_raw_sample = 9;

729 case AV_PIX_FMT_GBRP10:

730 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

731 s->bits_per_raw_sample = 10;

732 case AV_PIX_FMT_GBRP12:

733 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

734 s->bits_per_raw_sample = 12;

735 case AV_PIX_FMT_GBRP14:

736 if (!avctx->bits_per_raw_sample && !s->bits_per_raw_sample)

737 s->bits_per_raw_sample = 14;

738 else if (!s->bits_per_raw_sample)

739 s->bits_per_raw_sample = avctx->bits_per_raw_sample;

740 s->colorspace = 1;

741 s->chroma_planes = 1;

742 s->version = FFMAX(s->version, 1);

743 break;

744 default:

745 av_log(avctx, AV_LOG_ERROR, "format not supported\n");

746 return AVERROR(ENOSYS);

747 }

748 if (s->transparency) {

749 av_log(avctx, AV_LOG_WARNING, "Storing alpha plane, this will require a recent FFV1 decoder to playback!\n");

750 }

751 if (avctx->context_model > 1U) {

752 av_log(avctx, AV_LOG_ERROR, "Invalid context model %d, valid values are 0 and 1\n", avctx->context_model);

753 return AVERROR(EINVAL);

754 }

755

756 if (s->ac > 1)

757 for (i = 1; i < 256; i++)

758 s->state_transition[i] = ver2_state[i];

759

760 for (i = 0; i < 256; i++) {

761 s->quant_table_count = 2;

762 if (s->bits_per_raw_sample <= 8) {

763 s->quant_tables[0][0][i]= quant11[i];

764 s->quant_tables[0][1][i]= 11*quant11[i];

765 s->quant_tables[0][2][i]= 11*11*quant11[i];

766 s->quant_tables[1][0][i]= quant11[i];

767 s->quant_tables[1][1][i]= 11*quant11[i];

768 s->quant_tables[1][2][i]= 11*11*quant5 [i];

769 s->quant_tables[1][3][i]= 5*11*11*quant5 [i];

770 s->quant_tables[1][4][i]= 5*5*11*11*quant5 [i];

771 } else {

772 s->quant_tables[0][0][i]= quant9_10bit[i];

773 s->quant_tables[0][1][i]= 11*quant9_10bit[i];

774 s->quant_tables[0][2][i]= 11*11*quant9_10bit[i];

775 s->quant_tables[1][0][i]= quant9_10bit[i];

776 s->quant_tables[1][1][i]= 11*quant9_10bit[i];

777 s->quant_tables[1][2][i]= 11*11*quant5_10bit[i];

778 s->quant_tables[1][3][i]= 5*11*11*quant5_10bit[i];

779 s->quant_tables[1][4][i]= 5*5*11*11*quant5_10bit[i];

780 }

781 }

782 s->context_count[0] = (11 * 11 * 11 + 1) / 2;

783 s->context_count[1] = (11 * 11 * 5 * 5 * 5 + 1) / 2;

784 memcpy(s->quant_table, s->quant_tables[avctx->context_model],

785 sizeof(s->quant_table));

786

787 for (i = 0; i < s->plane_count; i++) {

788 PlaneContext *const p = &s->plane[i];

789

790 memcpy(p->quant_table, s->quant_table, sizeof(p->quant_table));

791 p->quant_table_index = avctx->context_model;

792 p->context_count = s->context_count[p->quant_table_index];

793 }

794

795 if ((ret = ffv1_allocate_initial_states(s)) < 0)

796 return ret;

797

798 if (!s->transparency)

799 s->plane_count = 2;

800 avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_h_shift, &s->chroma_v_shift);

801 s->picture_number = 0;

802

803 if (avctx->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {

804 for (i = 0; i < s->quant_table_count; i++) {

805 s->rc_stat2[i] = av_mallocz(s->context_count[i] *

806 sizeof(*s->rc_stat2[i]));

807 if (!s->rc_stat2[i])

808 return AVERROR(ENOMEM);

809 }

810 }

811 if (avctx->stats_in) {

812 char *p = avctx->stats_in;

813 uint8_t best_state[256][256];

814 int gob_count = 0;

815 char *next;

816

817 av_assert0(s->version >= 2);

818

819 for (;;) {

820 for (j = 0; j < 256; j++)

821 for (i = 0; i < 2; i++) {

822 s->rc_stat[j][i] = strtol(p, &next, 0);

823 if (next == p) {

824 av_log(avctx, AV_LOG_ERROR,

825 "2Pass file invalid at %d %d [%s]\n", j, i, p);

826 return AVERROR_INVALIDDATA;

827 }

828 p = next;

829 }

830 for (i = 0; i < s->quant_table_count; i++)

831 for (j = 0; j < s->context_count[i]; j++) {

832 for (k = 0; k < 32; k++)

833 for (m = 0; m < 2; m++) {

834 s->rc_stat2[i][j][k][m] = strtol(p, &next, 0);

835 if (next == p) {

836 av_log(avctx, AV_LOG_ERROR,

837 "2Pass file invalid at %d %d %d %d [%s]\n",

838 i, j, k, m, p);

839 return AVERROR_INVALIDDATA;

840 }

841 p = next;

842 }

843 }

844 gob_count = strtol(p, &next, 0);

845 if (next == p || gob_count <= 0) {

846 av_log(avctx, AV_LOG_ERROR, "2Pass file invalid\n");

847 return AVERROR_INVALIDDATA;

848 }

849 p = next;

850 while (*p == '\n' || *p == ' ')

851 p++;

852 if (p[0] == 0)

853 break;

854 }

855 sort_stt(s, s->state_transition);

856

857 find_best_state(best_state, s->state_transition);

858

859 for (i = 0; i < s->quant_table_count; i++) {

860 for (k = 0; k < 32; k++) {

861 double a=0, b=0;

862 int jp = 0;

863 for (j = 0; j < s->context_count[i]; j++) {

864 double p = 128;

865 if (s->rc_stat2[i][j][k][0] + s->rc_stat2[i][j][k][1] > 200 && j || a+b > 200) {

866 if (a+b)

867 p = 256.0 * b / (a + b);

868 s->initial_states[i][jp][k] =

869 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];

870 for(jp++; jp<j; jp++)

871 s->initial_states[i][jp][k] = s->initial_states[i][jp-1][k];

872 a=b=0;

873 }

874 a += s->rc_stat2[i][j][k][0];

875 b += s->rc_stat2[i][j][k][1];

876 if (a+b) {

877 p = 256.0 * b / (a + b);

878 }

879 s->initial_states[i][j][k] =

880 best_state[av_clip(round(p), 1, 255)][av_clip((a + b) / gob_count, 0, 255)];

881 }

882 }

883 }

884 }

885

886 if (s->version > 1) {

887 s->num_v_slices = (avctx->width > 352 || avctx->height > 288 || !avctx->slices) ? 2 : 1;

888 for (; s->num_v_slices < 9; s->num_v_slices++) {

889 for (s->num_h_slices = s->num_v_slices; s->num_h_slices < 2*s->num_v_slices; s->num_h_slices++) {

890 if (avctx->slices == s->num_h_slices * s->num_v_slices && avctx->slices <= 64 || !avctx->slices)

891 goto slices_ok;

892 }

893 }

894 av_log(avctx, AV_LOG_ERROR,

895 "Unsupported number %d of slices requested, please specify a "

896 "supported number with -slices (ex:4,6,9,12,16, ...)\n",

897 avctx->slices);

898 return AVERROR(ENOSYS);

899 slices_ok:

900 write_extradata(s);

901 }

902

903 if ((ret = ffv1_init_slice_contexts(s)) < 0)

904 return ret;

905 if ((ret = ffv1_init_slices_state(s)) < 0)

906 return ret;

907

908 #define STATS_OUT_SIZE 1024 * 1024 * 6

909 if (avctx->flags & CODEC_FLAG_PASS1) {

910 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);

911 if (!avctx->stats_out)

912 return AVERROR(ENOMEM);

913 for (i = 0; i < s->quant_table_count; i++)

914 for (j = 0; j < s->slice_count; j++) {

915 FFV1Context *sf = s->slice_context[j];

916 av_assert0(!sf->rc_stat2[i]);

917 sf->rc_stat2[i] = av_mallocz(s->context_count[i] *

918 sizeof(*sf->rc_stat2[i]));

919 if (!sf->rc_stat2[i])

920 return AVERROR(ENOMEM);

921 }

922 }

923

924 return 0;

925 }

926

927 static void encode_slice_header(FFV1Context *f, FFV1Context *fs)

928 {

929 RangeCoder *c = &fs->c;

930 uint8_t state[CONTEXT_SIZE];

931 int j;

932 memset(state, 128, sizeof(state));

933

934 put_symbol(c, state, (fs->slice_x +1)*f->num_h_slices / f->width , 0);

935 put_symbol(c, state, (fs->slice_y +1)*f->num_v_slices / f->height , 0);

936 put_symbol(c, state, (fs->slice_width +1)*f->num_h_slices / f->width -1, 0);

937 put_symbol(c, state, (fs->slice_height+1)*f->num_v_slices / f->height-1, 0);

938 for (j=0; j<f->plane_count; j++) {

939 put_symbol(c, state, f->plane[j].quant_table_index, 0);

940 av_assert0(f->plane[j].quant_table_index == f->avctx->context_model);

941 }

942 if (!f->picture.f->interlaced_frame)

943 put_symbol(c, state, 3, 0);

944 else

945 put_symbol(c, state, 1 + !f->picture.f->top_field_first, 0);

946 put_symbol(c, state, f->picture.f->sample_aspect_ratio.num, 0);

947 put_symbol(c, state, f->picture.f->sample_aspect_ratio.den, 0);

948 }

949

950 static int encode_slice(AVCodecContext *c, void *arg)

951 {

952 FFV1Context *fs = *(void **)arg;

953 FFV1Context *f = fs->avctx->priv_data;

954 int width = fs->slice_width;

955 int height = fs->slice_height;

956 int x = fs->slice_x;

957 int y = fs->slice_y;

958 AVFrame *const p = f->picture.f;

959 const int ps = av_pix_fmt_desc_get(c->pix_fmt)->comp[0].step_minus1 + 1;

960

961 if (p->key_frame)

962 ffv1_clear_slice_state(f, fs);

963 if (f->version > 2) {

964 encode_slice_header(f, fs);

965 }

966 if (!fs->ac) {

967 if (f->version > 2)

968 put_rac(&fs->c, (uint8_t[]) { 129 }, 0);

969 fs->ac_byte_count = f->version > 2 || (!x && !y) ? ff_rac_terminate(&fs->c) : 0;

970 init_put_bits(&fs->pb,

971 fs->c.bytestream_start + fs->ac_byte_count,

972 fs->c.bytestream_end - fs->c.bytestream_start - fs->ac_byte_count);

973 }

974

975 if (f->colorspace == 0) {

976 const int chroma_width = FF_CEIL_RSHIFT(width, f->chroma_h_shift);

977 const int chroma_height = FF_CEIL_RSHIFT(height, f->chroma_v_shift);

978 const int cx = x >> f->chroma_h_shift;

979 const int cy = y >> f->chroma_v_shift;

980

981 encode_plane(fs, p->data[0] + ps*x + y*p->linesize[0], width, height, p->linesize[0], 0);

982

983 if (f->chroma_planes) {

984 encode_plane(fs, p->data[1] + ps*cx+cy*p->linesize[1], chroma_width, chroma_height, p->linesize[1], 1);

985 encode_plane(fs, p->data[2] + ps*cx+cy*p->linesize[2], chroma_width, chroma_height, p->linesize[2], 1);

986 }

987 if (fs->transparency)

988 encode_plane(fs, p->data[3] + ps*x + y*p->linesize[3], width, height, p->linesize[3], 2);

989 } else {

990 uint8_t *planes[3] = {p->data[0] + ps*x + y*p->linesize[0],

991 p->data[1] + ps*x + y*p->linesize[1],

992 p->data[2] + ps*x + y*p->linesize[2]};

993 encode_rgb_frame(fs, planes, width, height, p->linesize);

994 }

995 emms_c();

996

997 return 0;

998 }

999

1000 static int encode_frame(AVCodecContext *avctx, AVPacket *pkt,

1001 const AVFrame *pict, int *got_packet)

1002 {

1003 FFV1Context *f = avctx->priv_data;

1004 RangeCoder *const c = &f->slice_context[0]->c;

1005 AVFrame *const p = f->picture.f;

1006 int used_count = 0;

1007 uint8_t keystate = 128;

1008 uint8_t *buf_p;

1009 int i, ret;

1010

1011 if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width*avctx->height*((8*2+1+1)*4)/8

1012 + FF_MIN_BUFFER_SIZE)) < 0)

1013 return ret;

1014

1015 ff_init_range_encoder(c, pkt->data, pkt->size);

1016 ff_build_rac_states(c, 0.05 * (1LL << 32), 256 - 8);

1017

1018 av_frame_unref(p);

1019 if ((ret = av_frame_ref(p, pict)) < 0)

1020 return ret;

1021 p->pict_type = AV_PICTURE_TYPE_I;

1022

1023 if (avctx->gop_size == 0 || f->picture_number % avctx->gop_size == 0) {

1024 put_rac(c, &keystate, 1);

1025 p->key_frame = 1;

1026 f->gob_count++;

1027 write_header(f);

1028 } else {

1029 put_rac(c, &keystate, 0);

1030 p->key_frame = 0;

1031 }

1032

1033 if (f->ac > 1) {

1034 int i;

1035 for (i = 1; i < 256; i++) {

1036 c->one_state[i] = f->state_transition[i];

1037 c->zero_state[256 - i] = 256 - c->one_state[i];

1038 }

1039 }

1040

1041 for (i = 1; i < f->slice_count; i++) {

1042 FFV1Context *fs = f->slice_context[i];

1043 uint8_t *start = pkt->data + (pkt->size - used_count) * (int64_t)i / f->slice_count;

1044 int len = pkt->size / f->slice_count;

1045 ff_init_range_encoder(&fs->c, start, len);

1046 }

1047 avctx->execute(avctx, encode_slice, &f->slice_context[0], NULL,

1048 f->slice_count, sizeof(void *));

1049

1050 buf_p = pkt->data;

1051 for (i = 0; i < f->slice_count; i++) {

1052 FFV1Context *fs = f->slice_context[i];

1053 int bytes;

1054

1055 if (fs->ac) {

1056 uint8_t state = 129;

1057 put_rac(&fs->c, &state, 0);

1058 bytes = ff_rac_terminate(&fs->c);

1059 } else {

1060 flush_put_bits(&fs->pb); // FIXME: nicer padding

1061 bytes = fs->ac_byte_count + (put_bits_count(&fs->pb) + 7) / 8;

1062 }

1063 if (i > 0 || f->version > 2) {

1064 av_assert0(bytes < pkt->size / f->slice_count);

1065 memmove(buf_p, fs->c.bytestream_start, bytes);

1066 av_assert0(bytes < (1 << 24));

1067 AV_WB24(buf_p + bytes, bytes);

1068 bytes += 3;

1069 }

1070 if (f->ec) {

1071 unsigned v;

1072 buf_p[bytes++] = 0;

1073 v = av_crc(av_crc_get_table(AV_CRC_32_IEEE), 0, buf_p, bytes);

1074 AV_WL32(buf_p + bytes, v);

1075 bytes += 4;

1076 }

1077 buf_p += bytes;

1078 }

1079

1080 if ((avctx->flags & CODEC_FLAG_PASS1) && (f->picture_number & 31) == 0) {

1081 int j, k, m;

1082 char *p = avctx->stats_out;

1083 char *end = p + STATS_OUT_SIZE;

1084

1085 memset(f->rc_stat, 0, sizeof(f->rc_stat));

1086 for (i = 0; i < f->quant_table_count; i++)

1087 memset(f->rc_stat2[i], 0, f->context_count[i] * sizeof(*f->rc_stat2[i]));

1088

1089 for (j = 0; j < f->slice_count; j++) {

1090 FFV1Context *fs = f->slice_context[j];

1091 for (i = 0; i < 256; i++) {

1092 f->rc_stat[i][0] += fs->rc_stat[i][0];

1093 f->rc_stat[i][1] += fs->rc_stat[i][1];

1094 }

1095 for (i = 0; i < f->quant_table_count; i++) {

1096 for (k = 0; k < f->context_count[i]; k++)

1097 for (m = 0; m < 32; m++) {

1098 f->rc_stat2[i][k][m][0] += fs->rc_stat2[i][k][m][0];

1099 f->rc_stat2[i][k][m][1] += fs->rc_stat2[i][k][m][1];

1100 }

1101 }

1102 }

1103

1104 for (j = 0; j < 256; j++) {

1105 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",

1106 f->rc_stat[j][0], f->rc_stat[j][1]);

1107 p += strlen(p);

1108 }

1109 snprintf(p, end - p, "\n");

1110

1111 for (i = 0; i < f->quant_table_count; i++) {

1112 for (j = 0; j < f->context_count[i]; j++)

1113 for (m = 0; m < 32; m++) {

1114 snprintf(p, end - p, "%" PRIu64 " %" PRIu64 " ",

1115 f->rc_stat2[i][j][m][0], f->rc_stat2[i][j][m][1]);

1116 p += strlen(p);

1117 }

1118 }

1119 snprintf(p, end - p, "%d\n", f->gob_count);

1120 } else if (avctx->flags & CODEC_FLAG_PASS1)

1121 avctx->stats_out[0] = '0円';

1122

1123 f->picture_number++;

1124 pkt->size = buf_p - pkt->data;

1125 pkt->flags |= AV_PKT_FLAG_KEY * p->key_frame;

1126 *got_packet = 1;

1127

1128 return 0;

1129 }

1130

1131 #define OFFSET(x) offsetof(FFV1Context, x)

1132 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

1133 static const AVOption options[] = {

1134 { "slicecrc", "Protect slices with CRCs", OFFSET(ec), AV_OPT_TYPE_INT, { .i64 = -1 }, -1, 1, VE },

1135 { NULL }

1136 };

1137

1138 static const AVClass ffv1_class = {

1139 .class_name = "ffv1 encoder",

1140 .item_name = av_default_item_name,

1141 .option = options,

1142 .version = LIBAVUTIL_VERSION_INT,

1143 };

1144

1145 static const AVCodecDefault ffv1_defaults[] = {

1146 { "coder", "-1" },

1147 { NULL },

1148 };

1149

1150 AVCodec ff_ffv1_encoder = {

1151 .name = "ffv1",

1152 .type = AVMEDIA_TYPE_VIDEO,

1153 .id = AV_CODEC_ID_FFV1,

1154 .priv_data_size = sizeof(FFV1Context),

1155 .init = encode_init,

1156 .encode2 = encode_frame,

1157 .close = ffv1_close,

1158 .capabilities = CODEC_CAP_SLICE_THREADS,

1159 .pix_fmts = (const enum AVPixelFormat[]) {

1160 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,

1161 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,

1162 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,

1163 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,

1164 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,

1165 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,

1166 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,

1167 AV_PIX_FMT_NONE

1168

1169 },

1170 .long_name = NULL_IF_CONFIG_SMALL("FFmpeg video codec #1"),

1171 .defaults = ffv1_defaults,

1172 .priv_class = &ffv1_class,

1173 };

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