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 * 35) {

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 if (s->slice_coding_mode == 1) {

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

291 int i;

292 int v = sample[0][x];

293 for (i = bits-1; i>=0; i--) {

294 uint8_t state = 128;

295 put_rac(c, &state, (v>>i) & 1);

296 }

297 }

298 return 0;

299 }

300

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

302 int diff, context;

303

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

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

306

307 if (context < 0) {

308 context = -context;

309 diff = -diff;

310 }

311

312 diff = fold(diff, bits);

313

314 if (s->ac) {

315 if (s->flags & CODEC_FLAG_PASS1) {

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

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

318 } else {

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

320 }

321 } else {

322 if (context == 0)

323 run_mode = 1;

324

325 if (run_mode) {

326 if (diff) {

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

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

329 run_index++;

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

331 }

332

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

334 if (run_index)

335 run_index--;

336 run_count = 0;

337 run_mode = 0;

338 if (diff > 0)

339 diff--;

340 } else {

341 run_count++;

342 }

343 }

344

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

346 run_count, run_index, run_mode, x,

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

348

349 if (run_mode == 0)

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

351 }

352 }

353 if (run_mode) {

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

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

356 run_index++;

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

358 }

359

360 if (run_count)

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

362 }

363 s->run_index = run_index;

364

365 return 0;

366 }

367

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

369 int stride, int plane_index)

370 {

371 int x, y, i, ret;

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

373 int16_t *sample[3];

374 s->run_index = 0;

375

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

377

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

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

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

381

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

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

384 // { START_TIMER

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

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

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

388 if((ret = encode_line(s, w, sample, plane_index, 8)) < 0)

389 return ret;

390 } else {

391 if (s->packed_at_lsb) {

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

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

394 }

395 } else {

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

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

398 }

399 }

400 if((ret = encode_line(s, w, sample, plane_index, s->bits_per_raw_sample)) < 0)

401 return ret;

402 }

403 // STOP_TIMER("encode line") }

404 }

405 return 0;

406 }

407

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

409 {

410 int x, y, p, i;

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

412 int16_t *sample[4][3];

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

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

415 int offset = 1 << bits;

416

417 s->run_index = 0;

418

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

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

421

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

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

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

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

426

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

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

429 if (lbd) {

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

431 b = v & 0xFF;

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

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

434 a = v >> 24;

435 } else {

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

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

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

439 }

440

441 if (s->slice_coding_mode != 1) {

442 b -= g;

443 r -= g;

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

445 b += offset;

446 r += offset;

447 }

448

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

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

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

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

453 }

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

455 int ret;

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

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

458 if (lbd && s->slice_coding_mode == 0)

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

460 else

461 ret = encode_line(s, w, sample[p], (p + 1) / 2, bits + (s->slice_coding_mode != 1));

462 if (ret < 0)

463 return ret;

464 }

465 }

466 return 0;

467 }

468

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

470 {

471 int last = 0;

472 int i;

473 uint8_t state[CONTEXT_SIZE];

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

475

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

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

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

479 last = i;

480 }

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

482 }

483

484 static void write_quant_tables(RangeCoder *c,

485 int16_t quant_table[MAX_CONTEXT_INPUTS][256])

486 {

487 int i;

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

489 write_quant_table(c, quant_table[i]);

490 }

491

492 static void write_header(FFV1Context *f)

493 {

494 uint8_t state[CONTEXT_SIZE];

495 int i, j;

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

497

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

499

500 if (f->version < 2) {

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

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

503 if (f->ac > 1) {

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

505 put_symbol(c, state,

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

507 }

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

509 if (f->version > 0)

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

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

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

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

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

515

516 write_quant_tables(c, f->quant_table);

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

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

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

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

521 put_symbol(c, state,

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

523 put_symbol(c, state,

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

525 put_symbol(c, state,

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

527 0);

528 put_symbol(c, state,

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

530 0);

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

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

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

534 }

535 }

536 }

537 }

538

539 static int write_extradata(FFV1Context *f)

540 {

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

542 uint8_t state[CONTEXT_SIZE];

543 int i, j, k;

544 uint8_t state2[32][CONTEXT_SIZE];

545 unsigned v;

546

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

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

549

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

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

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

553 if (!f->avctx->extradata)

554 return AVERROR(ENOMEM);

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

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

557

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

559 if (f->version > 2) {

560 if (f->version == 3)

561 f->micro_version = 4;

562 put_symbol(c, state, f->micro_version, 0);

563 }

564

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

566 if (f->ac > 1)

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

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

569

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

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

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

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

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

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

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

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

578

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

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

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

582

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

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

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

586 break;

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

588 put_rac(c, state, 1);

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

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

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

592 put_symbol(c, state2[k],

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

594 }

595 } else {

596 put_rac(c, state, 0);

597 }

598 }

599

600 if (f->version > 2) {

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

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

603 }

604

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

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

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

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

609

610 return 0;

611 }

612

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

614 {

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

616

617 do {

618 changed = 0;

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

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

621

622 #define COST(old, new) \

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

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

625

626 #define COST2(old, new) \

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

628

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

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

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

632 int j;

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

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

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

636 if (i != 256 - i2) {

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

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

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

640 }

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

642 if (stt[j] == i)

643 stt[j] = i2;

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

645 stt[j] = i;

646 if (i != 256 - i2) {

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

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

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

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

651 }

652 }

653 print = changed = 1;

654 }

655 }

656 }

657 } while (changed);

658 return print;

659 }

660

661 static av_cold int encode_init(AVCodecContext *avctx)

662 {

663 FFV1Context *s = avctx->priv_data;

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

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

666

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

668 return ret;

669

670 s->version = 0;

671

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

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

674

675 if (avctx->level == 3 || (avctx->level <= 0 && s->version == 2)) {

676 s->version = 3;

677 }

678

679 if (s->ec < 0) {

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

681 }

682

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

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

685 return AVERROR_INVALIDDATA;

686 }

687

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

689

690 s->plane_count = 3;

691 switch(avctx->pix_fmt) {

692 case AV_PIX_FMT_YUV444P9:

693 case AV_PIX_FMT_YUV422P9:

694 case AV_PIX_FMT_YUV420P9:

695 case AV_PIX_FMT_YUVA444P9:

696 case AV_PIX_FMT_YUVA422P9:

697 case AV_PIX_FMT_YUVA420P9:

698 if (!avctx->bits_per_raw_sample)

699 s->bits_per_raw_sample = 9;

700 case AV_PIX_FMT_YUV444P10:

701 case AV_PIX_FMT_YUV420P10:

702 case AV_PIX_FMT_YUV422P10:

703 case AV_PIX_FMT_YUVA444P10:

704 case AV_PIX_FMT_YUVA422P10:

705 case AV_PIX_FMT_YUVA420P10:

706 s->packed_at_lsb = 1;

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

708 s->bits_per_raw_sample = 10;

709 case AV_PIX_FMT_GRAY16:

710 case AV_PIX_FMT_YUV444P16:

711 case AV_PIX_FMT_YUV422P16:

712 case AV_PIX_FMT_YUV420P16:

713 case AV_PIX_FMT_YUVA444P16:

714 case AV_PIX_FMT_YUVA422P16:

715 case AV_PIX_FMT_YUVA420P16:

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

717 s->bits_per_raw_sample = 16;

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

719 s->bits_per_raw_sample = avctx->bits_per_raw_sample;

720 }

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

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

723 return AVERROR_INVALIDDATA;

724 }

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

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

727 s->ac = 2;

728 }

729 if (!s->ac) {

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

731 return AVERROR(ENOSYS);

732 }

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

734 case AV_PIX_FMT_GRAY8:

735 case AV_PIX_FMT_YUV444P:

736 case AV_PIX_FMT_YUV440P:

737 case AV_PIX_FMT_YUV422P:

738 case AV_PIX_FMT_YUV420P:

739 case AV_PIX_FMT_YUV411P:

740 case AV_PIX_FMT_YUV410P:

741 case AV_PIX_FMT_YUVA444P:

742 case AV_PIX_FMT_YUVA422P:

743 case AV_PIX_FMT_YUVA420P:

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

745 s->colorspace = 0;

746 s->transparency = desc->nb_components == 4;

747 break;

748 case AV_PIX_FMT_RGB32:

749 s->colorspace = 1;

750 s->transparency = 1;

751 s->chroma_planes = 1;

752 break;

753 case AV_PIX_FMT_0RGB32:

754 s->colorspace = 1;

755 s->chroma_planes = 1;

756 break;

757 case AV_PIX_FMT_GBRP9:

758 if (!avctx->bits_per_raw_sample)

759 s->bits_per_raw_sample = 9;

760 case AV_PIX_FMT_GBRP10:

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

762 s->bits_per_raw_sample = 10;

763 case AV_PIX_FMT_GBRP12:

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

765 s->bits_per_raw_sample = 12;

766 case AV_PIX_FMT_GBRP14:

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

768 s->bits_per_raw_sample = 14;

769 else if (!s->bits_per_raw_sample)

770 s->bits_per_raw_sample = avctx->bits_per_raw_sample;

771 s->colorspace = 1;

772 s->chroma_planes = 1;

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

774 if (!s->ac) {

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

776 return AVERROR(ENOSYS);

777 }

778 break;

779 default:

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

781 return AVERROR(ENOSYS);

782 }

783 if (s->transparency) {

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

785 }

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

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

788 return AVERROR(EINVAL);

789 }

790

791 if (s->ac > 1)

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

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

794

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

796 s->quant_table_count = 2;

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

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

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

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

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

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

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

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

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

806 } else {

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

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

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

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

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

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

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

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

815 }

816 }

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

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

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

820 sizeof(s->quant_table));

821

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

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

824

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

826 p->quant_table_index = avctx->context_model;

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

828 }

829

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

831 return ret;

832

833 avctx->coded_frame = av_frame_alloc();

834 if (!avctx->coded_frame)

835 return AVERROR(ENOMEM);

836

837 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

838

839 if (!s->transparency)

840 s->plane_count = 2;

841 if (!s->chroma_planes && s->version > 3)

842 s->plane_count--;

843

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

845 s->picture_number = 0;

846

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

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

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

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

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

852 return AVERROR(ENOMEM);

853 }

854 }

855 if (avctx->stats_in) {

856 char *p = avctx->stats_in;

857 uint8_t best_state[256][256];

858 int gob_count = 0;

859 char *next;

860

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

862

863 for (;;) {

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

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

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

867 if (next == p) {

868 av_log(avctx, AV_LOG_ERROR,

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

870 return AVERROR_INVALIDDATA;

871 }

872 p = next;

873 }

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

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

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

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

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

879 if (next == p) {

880 av_log(avctx, AV_LOG_ERROR,

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

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

883 return AVERROR_INVALIDDATA;

884 }

885 p = next;

886 }

887 }

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

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

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

891 return AVERROR_INVALIDDATA;

892 }

893 p = next;

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

895 p++;

896 if (p[0] == 0)

897 break;

898 }

899 sort_stt(s, s->state_transition);

900

901 find_best_state(best_state, s->state_transition);

902

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

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

905 double a=0, b=0;

906 int jp = 0;

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

908 double p = 128;

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

910 if (a+b)

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

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

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

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

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

916 a=b=0;

917 }

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

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

920 if (a+b) {

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

922 }

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

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

925 }

926 }

927 }

928 }

929

930 if (s->version > 1) {

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

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

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

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

935 goto slices_ok;

936 }

937 }

938 av_log(avctx, AV_LOG_ERROR,

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

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

941 avctx->slices);

942 return AVERROR(ENOSYS);

943 slices_ok:

944 if ((ret = write_extradata(s)) < 0)

945 return ret;

946 }

947

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

949 return ret;

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

951 return ret;

952

953 #define STATS_OUT_SIZE 1024 * 1024 * 6

954 if (avctx->flags & CODEC_FLAG_PASS1) {

955 avctx->stats_out = av_mallocz(STATS_OUT_SIZE);

956 if (!avctx->stats_out)

957 return AVERROR(ENOMEM);

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

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

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

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

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

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

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

965 return AVERROR(ENOMEM);

966 }

967 }

968

969 return 0;

970 }

971

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

973 {

974 RangeCoder *c = &fs->c;

975 uint8_t state[CONTEXT_SIZE];

976 int j;

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

978

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

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

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

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

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

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

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

986 }

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

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

989 else

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

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

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

993 if (f->version > 3) {

994 put_rac(c, state, fs->slice_coding_mode == 1);

995 if (fs->slice_coding_mode == 1)

996 ffv1_clear_slice_state(f, fs);

997 put_symbol(c, state, fs->slice_coding_mode, 0);

998 }

999 }

1000

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

1002 {

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

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

1005 int width = fs->slice_width;

1006 int height = fs->slice_height;

1007 int x = fs->slice_x;

1008 int y = fs->slice_y;

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

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

1011 int ret;

1012 RangeCoder c_bak = fs->c;

1013

1014 fs->slice_coding_mode = 0;

1015

1016 retry:

1017 if (c->coded_frame->key_frame)

1018 ffv1_clear_slice_state(f, fs);

1019 if (f->version > 2) {

1020 encode_slice_header(f, fs);

1021 }

1022 if (!fs->ac) {

1023 if (f->version > 2)

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

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

1026 init_put_bits(&fs->pb,

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

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

1029 }

1030

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

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

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

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

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

1036

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

1038

1039 if (f->chroma_planes) {

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

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

1042 }

1043 if (fs->transparency)

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

1045 } else {

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

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

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

1049 ret = encode_rgb_frame(fs, planes, width, height, p->linesize);

1050 }

1051 emms_c();

1052

1053 if (ret < 0) {

1054 av_assert0(fs->slice_coding_mode == 0);

1055 if (fs->version < 4 || !fs->ac) {

1056 av_log(c, AV_LOG_ERROR, "Buffer too small\n");

1057 return ret;

1058 }

1059 av_log(c, AV_LOG_DEBUG, "Coding slice as PCM\n");

1060 fs->slice_coding_mode = 1;

1061 fs->c = c_bak;

1062 goto retry;

1063 }

1064

1065 return 0;

1066 }

1067

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

1069 const AVFrame *pict, int *got_packet)

1070 {

1071 FFV1Context *f = avctx->priv_data;

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

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

1074 int used_count = 0;

1075 uint8_t keystate = 128;

1076 uint8_t *buf_p;

1077 int i, ret;

1078 int64_t maxsize = FF_MIN_BUFFER_SIZE

1079 + avctx->width*avctx->height*35LL*4;

1080

1081 if (f->version > 3)

1082 maxsize = FF_MIN_BUFFER_SIZE + avctx->width*avctx->height*3LL*4;

1083

1084 if ((ret = ff_alloc_packet2(avctx, pkt, maxsize)) < 0)

1085 return ret;

1086

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

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

1089

1090 av_frame_unref(p);

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

1092 return ret;

1093 avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I;

1094

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

1096 put_rac(c, &keystate, 1);

1097 avctx->coded_frame->key_frame = 1;

1098 f->gob_count++;

1099 write_header(f);

1100 } else {

1101 put_rac(c, &keystate, 0);

1102 avctx->coded_frame->key_frame = 0;

1103 }

1104

1105 if (f->ac > 1) {

1106 int i;

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

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

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

1110 }

1111 }

1112

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

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

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

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

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

1118 }

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

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

1121

1122 buf_p = pkt->data;

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

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

1125 int bytes;

1126

1127 if (fs->ac) {

1128 uint8_t state = 129;

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

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

1131 } else {

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

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

1134 }

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

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

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

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

1139 AV_WB24(buf_p + bytes, bytes);

1140 bytes += 3;

1141 }

1142 if (f->ec) {

1143 unsigned v;

1144 buf_p[bytes++] = 0;

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

1146 AV_WL32(buf_p + bytes, v);

1147 bytes += 4;

1148 }

1149 buf_p += bytes;

1150 }

1151

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

1153 int j, k, m;

1154 char *p = avctx->stats_out;

1155 char *end = p + STATS_OUT_SIZE;

1156

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

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

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

1160

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

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

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

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

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

1166 }

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

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

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

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

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

1172 }

1173 }

1174 }

1175

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

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

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

1179 p += strlen(p);

1180 }

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

1182

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

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

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

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

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

1188 p += strlen(p);

1189 }

1190 }

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

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

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

1194

1195 f->picture_number++;

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

1197 pkt->flags |= AV_PKT_FLAG_KEY * avctx->coded_frame->key_frame;

1198 *got_packet = 1;

1199

1200 return 0;

1201 }

1202

1203 static av_cold int encode_close(AVCodecContext *avctx)

1204 {

1205 av_frame_free(&avctx->coded_frame);

1206 ffv1_close(avctx);

1207 return 0;

1208 }

1209

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

1211 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

1212 static const AVOption options[] = {

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

1214 { NULL }

1215 };

1216

1217 static const AVClass ffv1_class = {

1218 .class_name = "ffv1 encoder",

1219 .item_name = av_default_item_name,

1220 .option = options,

1221 .version = LIBAVUTIL_VERSION_INT,

1222 };

1223

1224 static const AVCodecDefault ffv1_defaults[] = {

1225 { "coder", "-1" },

1226 { NULL },

1227 };

1228

1229 AVCodec ff_ffv1_encoder = {

1230 .name = "ffv1",

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

1232 .type = AVMEDIA_TYPE_VIDEO,

1233 .id = AV_CODEC_ID_FFV1,

1234 .priv_data_size = sizeof(FFV1Context),

1235 .init = encode_init,

1236 .encode2 = encode_frame,

1237 .close = encode_close,

1238 .capabilities = CODEC_CAP_SLICE_THREADS,

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

1240 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUV444P,

1241 AV_PIX_FMT_YUVA444P, AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV411P,

1242 AV_PIX_FMT_YUV410P, AV_PIX_FMT_0RGB32, AV_PIX_FMT_RGB32, AV_PIX_FMT_YUV420P16,

1243 AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9,

1244 AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10,

1245 AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,

1246 AV_PIX_FMT_YUVA444P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA420P10,

1247 AV_PIX_FMT_YUVA444P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA420P9,

1248 AV_PIX_FMT_GRAY16, AV_PIX_FMT_GRAY8, AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,

1249 AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,

1250 AV_PIX_FMT_NONE

1251

1252 },

1253 .defaults = ffv1_defaults,

1254 .priv_class = &ffv1_class,

1255 };

Generated on Sat Jan 25 2014 19:51:47 for FFmpeg by doxygen 1.8.2