FFmpeg: libavcodec/mjpegenc.c Source File

FFmpeg

[フレーム]

libavcodec

mjpegenc.c

Go to the documentation of this file.

1 /*

2 * MJPEG encoder

6 *

7 * Support for external huffman table, various fixes (AVID workaround),

8 * aspecting, new decode_frame mechanism and apple mjpeg-b support

9 * by Alex Beregszaszi

10 *

11 * This file is part of FFmpeg.

12 *

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

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

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

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

17 *

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

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

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

21 * Lesser General Public License for more details.

22 *

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

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

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

26 */

28 /**

29 * @file

30 * MJPEG encoder.

31 */

33 #include "config_components.h"

35 #include "libavutil/mem.h"

37 #include "avcodec.h"

38 #include "codec_internal.h"

39 #include "jpegtables.h"

40 #include "mjpegenc_common.h"

41 #include "mjpegenc_huffman.h"

42 #include "mpegvideo.h"

43 #include "mjpeg.h"

44 #include "mjpegenc.h"

45 #include "mpegvideoenc.h"

46 #include "profiles.h"

48 /**

49 * Buffer of JPEG frame data.

50 *

51 * Optimal Huffman table generation requires the frame data to be loaded into

52 * a buffer so that the tables can be computed.

53 * There are at most mb_width*mb_height*12*64 of these per frame.

54 */

55 typedef struct MJpegHuffmanCode {

56 // 0=DC lum, 1=DC chrom, 2=AC lum, 3=AC chrom

57 uint8_t table_id; ///< The Huffman table id associated with the data.

58 uint8_t code; ///< The exponent.

59 uint16_t mant; ///< The mantissa.

60 } MJpegHuffmanCode;

62 /* The following is the private context of MJPEG/AMV decoder.

63 * Note that when using slice threading only the main thread's

64 * MPVEncContext is followed by a MjpegContext; the other threads

65 * can access this shared context via MPVEncContext.mjpeg. */

66 typedef struct MJPEGEncContext {

67 MPVMainEncContext mpeg;

68 MJpegContext mjpeg;

69 } MJPEGEncContext;

71 static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256],

72 uint8_t *uni_ac_vlc_len)

73 {

74 for (int i = 0; i < 128; i++) {

75 int level = i - 64;

76 if (!level)

77 continue;

78 for (int run = 0; run < 64; run++) {

79 int len, code, nbits;

80 int alevel = FFABS(level);

82 len = (run >> 4) * huff_size_ac[0xf0];

84 nbits= av_log2_16bit(alevel) + 1;

85 code = ((15&run) << 4) | nbits;

87 len += huff_size_ac[code] + nbits;

89 uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len;

90 // We ignore EOB as its just a constant which does not change generally

91 }

92 }

93 }

95 static void mjpeg_encode_picture_header(MPVEncContext *const s)

96 {

97 ff_mjpeg_encode_picture_header(s->c.avctx, &s->pb, s->c.cur_pic.ptr->f, s->mjpeg_ctx,

98 s->c.intra_scantable.permutated, 0,

99 s->c.intra_matrix, s->c.chroma_intra_matrix,

100 s->c.slice_context_count > 1);

101

102 s->esc_pos = put_bytes_count(&s->pb, 0);

103 for (int i = 1; i < s->c.slice_context_count; i++)

104 s->c.enc_contexts[i]->esc_pos = 0;

105 }

106

107 static int mjpeg_amv_encode_picture_header(MPVMainEncContext *const m)

108 {

109 MJPEGEncContext *const m2 = (MJPEGEncContext*)m;

110 MPVEncContext *const s = &m->s;

111 av_assert2(s->mjpeg_ctx == &m2->mjpeg);

112 /* s->huffman == HUFFMAN_TABLE_OPTIMAL can only be true for MJPEG. */

113 if (!CONFIG_MJPEG_ENCODER || m2->mjpeg.huffman != HUFFMAN_TABLE_OPTIMAL)

114 mjpeg_encode_picture_header(s);

115

116 return 0;

117 }

118

119 #if CONFIG_MJPEG_ENCODER

120 /**

121 * Encodes and outputs the entire frame in the JPEG format.

122 *

123 * @param main The MPVMainEncContext.

124 */

125 static void mjpeg_encode_picture_frame(MPVMainEncContext *const main)

126 {

127 MPVEncContext *const s = &main->s;

128 int nbits, code, table_id;

129 MJpegContext *m = s->mjpeg_ctx;

130 uint8_t *huff_size[4] = { m->huff_size_dc_luminance,

131 m->huff_size_dc_chrominance,

132 m->huff_size_ac_luminance,

133 m->huff_size_ac_chrominance };

134 uint16_t *huff_code[4] = { m->huff_code_dc_luminance,

135 m->huff_code_dc_chrominance,

136 m->huff_code_ac_luminance,

137 m->huff_code_ac_chrominance };

138 size_t total_bits = 0;

139 size_t bytes_needed;

140

141 main->header_bits = get_bits_diff(s);

142 // Estimate the total size first

143 for (int i = 0; i < m->huff_ncode; i++) {

144 table_id = m->huff_buffer[i].table_id;

145 code = m->huff_buffer[i].code;

146 nbits = code & 0xf;

147

148 total_bits += huff_size[table_id][code] + nbits;

149 }

150

151 bytes_needed = (total_bits + 7) / 8;

152 ff_mpv_reallocate_putbitbuffer(s, bytes_needed, bytes_needed);

153

154 for (int i = 0; i < m->huff_ncode; i++) {

155 table_id = m->huff_buffer[i].table_id;

156 code = m->huff_buffer[i].code;

157 nbits = code & 0xf;

158

159 put_bits(&s->pb, huff_size[table_id][code], huff_code[table_id][code]);

160 if (nbits != 0) {

161 put_sbits(&s->pb, nbits, m->huff_buffer[i].mant);

162 }

163 }

164

165 m->huff_ncode = 0;

166 s->i_tex_bits = get_bits_diff(s);

167 }

168

169 /**

170 * Builds all 4 optimal Huffman tables.

171 *

172 * Uses the data stored in the JPEG buffer to compute the tables.

173 * Stores the Huffman tables in the bits_* and val_* arrays in the MJpegContext.

174 *

175 * @param m MJpegContext containing the JPEG buffer.

176 */

177 static void mjpeg_build_optimal_huffman(MJpegContext *m)

178 {

179 MJpegEncHuffmanContext dc_luminance_ctx;

180 MJpegEncHuffmanContext dc_chrominance_ctx;

181 MJpegEncHuffmanContext ac_luminance_ctx;

182 MJpegEncHuffmanContext ac_chrominance_ctx;

183 MJpegEncHuffmanContext *ctx[4] = { &dc_luminance_ctx,

184 &dc_chrominance_ctx,

185 &ac_luminance_ctx,

186 &ac_chrominance_ctx };

187 for (int i = 0; i < 4; i++)

188 ff_mjpeg_encode_huffman_init(ctx[i]);

189

190 for (int i = 0; i < m->huff_ncode; i++) {

191 int table_id = m->huff_buffer[i].table_id;

192 int code = m->huff_buffer[i].code;

193

194 ff_mjpeg_encode_huffman_increment(ctx[table_id], code);

195 }

196

197 ff_mjpeg_encode_huffman_close(&dc_luminance_ctx,

198 m->bits_dc_luminance,

199 m->val_dc_luminance, 12);

200 ff_mjpeg_encode_huffman_close(&dc_chrominance_ctx,

201 m->bits_dc_chrominance,

202 m->val_dc_chrominance, 12);

203 ff_mjpeg_encode_huffman_close(&ac_luminance_ctx,

204 m->bits_ac_luminance,

205 m->val_ac_luminance, 256);

206 ff_mjpeg_encode_huffman_close(&ac_chrominance_ctx,

207 m->bits_ac_chrominance,

208 m->val_ac_chrominance, 256);

209

210 ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance,

211 m->huff_code_dc_luminance,

212 m->bits_dc_luminance,

213 m->val_dc_luminance);

214 ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance,

215 m->huff_code_dc_chrominance,

216 m->bits_dc_chrominance,

217 m->val_dc_chrominance);

218 ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance,

219 m->huff_code_ac_luminance,

220 m->bits_ac_luminance,

221 m->val_ac_luminance);

222 ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance,

223 m->huff_code_ac_chrominance,

224 m->bits_ac_chrominance,

225 m->val_ac_chrominance);

226 }

227 #endif

228

229 /**

230 * Writes the complete JPEG frame when optimal huffman tables are enabled,

231 * otherwise writes the stuffing.

232 *

233 * Header + values + stuffing.

234 *

235 * @param s The MPVEncContext.

236 * @return int Error code, 0 if successful.

237 */

238 int ff_mjpeg_encode_stuffing(MPVEncContext *const s)

239 {

240 MJpegContext *const m = s->mjpeg_ctx;

241 PutBitContext *pbc = &s->pb;

242 int mb_y = s->c.mb_y - !s->c.mb_x;

243 int ret;

244

245 #if CONFIG_MJPEG_ENCODER

246 if (m->huffman == HUFFMAN_TABLE_OPTIMAL) {

247 /* HUFFMAN_TABLE_OPTIMAL is incompatible with slice threading,

248 * therefore the following cast is allowed. */

249 MPVMainEncContext *const main = (MPVMainEncContext*)s;

250

251 mjpeg_build_optimal_huffman(m);

252

253 // Replace the VLCs with the optimal ones.

254 // The default ones may be used for trellis during quantization.

255 init_uni_ac_vlc(m->huff_size_ac_luminance, m->uni_ac_vlc_len);

256 init_uni_ac_vlc(m->huff_size_ac_chrominance, m->uni_chroma_ac_vlc_len);

257 s->intra_ac_vlc_length =

258 s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;

259 s->intra_chroma_ac_vlc_length =

260 s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;

261

262 mjpeg_encode_picture_header(s);

263 mjpeg_encode_picture_frame(main);

264 }

265 #endif

266

267 ret = ff_mpv_reallocate_putbitbuffer(s, put_bits_count(&s->pb) / 8 + 100,

268 put_bits_count(&s->pb) / 4 + 1000);

269 if (ret < 0) {

270 av_log(s->c.avctx, AV_LOG_ERROR, "Buffer reallocation failed\n");

271 goto fail;

272 }

273

274 ff_mjpeg_escape_FF(pbc, s->esc_pos);

275

276 if (s->c.slice_context_count > 1 && mb_y < s->c.mb_height - 1)

277 put_marker(pbc, RST0 + (mb_y&7));

278 s->esc_pos = put_bytes_count(pbc, 0);

279

280 fail:

281 for (int i = 0; i < 3; i++)

282 s->c.last_dc[i] = 128 << s->c.intra_dc_precision;

283

284 return ret;

285 }

286

287 static int alloc_huffman(MJPEGEncContext *const m2)

288 {

289 MJpegContext *const m = &m2->mjpeg;

290 MPVEncContext *const s = &m2->mpeg.s;

291 static const char blocks_per_mb[] = {

292 [CHROMA_420] = 6, [CHROMA_422] = 8, [CHROMA_444] = 12

293 };

294 size_t num_blocks;

295

296 // Make sure we have enough space to hold this frame.

297 num_blocks = s->c.mb_num * blocks_per_mb[s->c.chroma_format];

298

299 m->huff_buffer = av_malloc_array(num_blocks,

300 64 /* codes per MB */ * sizeof(MJpegHuffmanCode));

301 if (!m->huff_buffer)

302 return AVERROR(ENOMEM);

303 return 0;

304 }

305

306 static av_cold int mjpeg_encode_close(AVCodecContext *avctx)

307 {

308 MJPEGEncContext *const mjpeg = avctx->priv_data;

309 av_freep(&mjpeg->mjpeg.huff_buffer);

310 ff_mpv_encode_end(avctx);

311 return 0;

312 }

313

314 /**

315 * Add code and table_id to the JPEG buffer.

316 *

317 * @param s The MJpegContext which contains the JPEG buffer.

318 * @param table_id Which Huffman table the code belongs to.

319 * @param code The encoded exponent of the coefficients and the run-bits.

320 */

321 static inline void mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)

322 {

323 MJpegHuffmanCode *c = &s->huff_buffer[s->huff_ncode++];

324 c->table_id = table_id;

325 c->code = code;

326 }

327

328 /**

329 * Add the coefficient's data to the JPEG buffer.

330 *

331 * @param s The MJpegContext which contains the JPEG buffer.

332 * @param table_id Which Huffman table the code belongs to.

333 * @param val The coefficient.

334 * @param run The run-bits.

335 */

336 static void mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)

337 {

338 int mant, code;

339

340 if (val == 0) {

341 av_assert0(run == 0);

342 mjpeg_encode_code(s, table_id, 0);

343 } else {

344 mant = val;

345 if (val < 0) {

346 val = -val;

347 mant--;

348 }

349

350 code = (run << 4) | (av_log2_16bit(val) + 1);

351

352 s->huff_buffer[s->huff_ncode].mant = mant;

353 mjpeg_encode_code(s, table_id, code);

354 }

355 }

356

357 /**

358 * Add the block's data into the JPEG buffer.

359 *

360 * @param s The MPVEncContext that contains the JPEG buffer.

361 * @param block The block.

362 * @param n The block's index or number.

363 */

364 static void record_block(MPVEncContext *const s, int16_t block[], int n)

365 {

366 int i, j, table_id;

367 int component, dc, last_index, val, run;

368 MJpegContext *m = s->mjpeg_ctx;

369

370 /* DC coef */

371 component = (n <= 3 ? 0 : (n&1) + 1);

372 table_id = (n <= 3 ? 0 : 1);

373 dc = block[0]; /* overflow is impossible */

374 val = dc - s->c.last_dc[component];

375

376 mjpeg_encode_coef(m, table_id, val, 0);

377

378 s->c.last_dc[component] = dc;

379

380 /* AC coefs */

381

382 run = 0;

383 last_index = s->c.block_last_index[n];

384 table_id |= 2;

385

386 for(i=1;i<=last_index;i++) {

387 j = s->c.intra_scantable.permutated[i];

388 val = block[j];

389

390 if (val == 0) {

391 run++;

392 } else {

393 while (run >= 16) {

394 mjpeg_encode_code(m, table_id, 0xf0);

395 run -= 16;

396 }

397 mjpeg_encode_coef(m, table_id, val, run);

398 run = 0;

399 }

400 }

401

402 /* output EOB only if not already 64 values */

403 if (last_index < 63 || run != 0)

404 mjpeg_encode_code(m, table_id, 0);

405 }

406

407 static void encode_block(MPVEncContext *const s, int16_t block[], int n)

408 {

409 int mant, nbits, code, i, j;

410 int component, dc, run, last_index, val;

411 const MJpegContext *const m = s->mjpeg_ctx;

412 const uint16_t *huff_code_ac;

413 const uint8_t *huff_size_ac;

414

415 /* DC coef */

416 component = (n <= 3 ? 0 : (n&1) + 1);

417 dc = block[0]; /* overflow is impossible */

418 val = dc - s->c.last_dc[component];

419 if (n < 4) {

420 ff_mjpeg_encode_dc(&s->pb, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance);

421 huff_size_ac = m->huff_size_ac_luminance;

422 huff_code_ac = m->huff_code_ac_luminance;

423 } else {

424 ff_mjpeg_encode_dc(&s->pb, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance);

425 huff_size_ac = m->huff_size_ac_chrominance;

426 huff_code_ac = m->huff_code_ac_chrominance;

427 }

428 s->c.last_dc[component] = dc;

429

430 /* AC coefs */

431

432 run = 0;

433 last_index = s->c.block_last_index[n];

434 for(i=1;i<=last_index;i++) {

435 j = s->c.intra_scantable.permutated[i];

436 val = block[j];

437 if (val == 0) {

438 run++;

439 } else {

440 while (run >= 16) {

441 put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);

442 run -= 16;

443 }

444 mant = val;

445 if (val < 0) {

446 val = -val;

447 mant--;

448 }

449

450 nbits= av_log2_16bit(val) + 1;

451 code = (run << 4) | nbits;

452

453 put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);

454

455 put_sbits(&s->pb, nbits, mant);

456 run = 0;

457 }

458 }

459

460 /* output EOB only if not already 64 values */

461 if (last_index < 63 || run != 0)

462 put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);

463 }

464

465 static void mjpeg_record_mb(MPVEncContext *const s, int16_t block[][64],

466 int unused_x, int unused_y)

467 {

468 if (s->c.chroma_format == CHROMA_444) {

469 record_block(s, block[0], 0);

470 record_block(s, block[2], 2);

471 record_block(s, block[4], 4);

472 record_block(s, block[8], 8);

473 record_block(s, block[5], 5);

474 record_block(s, block[9], 9);

475

476 if (16*s->c.mb_x+8 < s->c.width) {

477 record_block(s, block[1], 1);

478 record_block(s, block[3], 3);

479 record_block(s, block[6], 6);

480 record_block(s, block[10], 10);

481 record_block(s, block[7], 7);

482 record_block(s, block[11], 11);

483 }

484 } else {

485 for (int i = 0; i < 5; i++)

486 record_block(s, block[i], i);

487 if (s->c.chroma_format == CHROMA_420) {

488 record_block(s, block[5], 5);

489 } else {

490 record_block(s, block[6], 6);

491 record_block(s, block[5], 5);

492 record_block(s, block[7], 7);

493 }

494 }

495 }

496

497 static void mjpeg_encode_mb(MPVEncContext *const s, int16_t block[][64],

498 int unused_x, int unused_y)

499 {

500 if (s->c.chroma_format == CHROMA_444) {

501 encode_block(s, block[0], 0);

502 encode_block(s, block[2], 2);

503 encode_block(s, block[4], 4);

504 encode_block(s, block[8], 8);

505 encode_block(s, block[5], 5);

506 encode_block(s, block[9], 9);

507

508 if (16 * s->c.mb_x + 8 < s->c.width) {

509 encode_block(s, block[1], 1);

510 encode_block(s, block[3], 3);

511 encode_block(s, block[6], 6);

512 encode_block(s, block[10], 10);

513 encode_block(s, block[7], 7);

514 encode_block(s, block[11], 11);

515 }

516 } else {

517 for (int i = 0; i < 5; i++)

518 encode_block(s, block[i], i);

519 if (s->c.chroma_format == CHROMA_420) {

520 encode_block(s, block[5], 5);

521 } else {

522 encode_block(s, block[6], 6);

523 encode_block(s, block[5], 5);

524 encode_block(s, block[7], 7);

525 }

526 }

527

528 s->i_tex_bits += get_bits_diff(s);

529 }

530

531 static av_cold int mjpeg_encode_init(AVCodecContext *avctx)

532 {

533 MJPEGEncContext *const m2 = avctx->priv_data;

534 MJpegContext *const m = &m2->mjpeg;

535 MPVEncContext *const s = &m2->mpeg.s;

536 int ret;

537

538 s->mjpeg_ctx = m;

539 m2->mpeg.encode_picture_header = mjpeg_amv_encode_picture_header;

540 // May be overridden below

541 s->encode_mb = mjpeg_encode_mb;

542

543 if (s->mpv_flags & FF_MPV_FLAG_QP_RD) {

544 // Used to produce garbage with MJPEG.

545 av_log(avctx, AV_LOG_ERROR,

546 "QP RD is no longer compatible with MJPEG or AMV\n");

547 return AVERROR(EINVAL);

548 }

549

550 /* The following check is automatically true for AMV,

551 * but it doesn't hurt either. */

552 ret = ff_mjpeg_encode_check_pix_fmt(avctx);

553 if (ret < 0)

554 return ret;

555

556 if (avctx->width > 65500 || avctx->height > 65500) {

557 av_log(avctx, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");

558 return AVERROR(EINVAL);

559 }

560

561 // Build default Huffman tables.

562 // These may be overwritten later with more optimal Huffman tables, but

563 // they are needed at least right now for some processes like trellis.

564 ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance,

565 m->huff_code_dc_luminance,

566 ff_mjpeg_bits_dc_luminance,

567 ff_mjpeg_val_dc);

568 ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance,

569 m->huff_code_dc_chrominance,

570 ff_mjpeg_bits_dc_chrominance,

571 ff_mjpeg_val_dc);

572 ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance,

573 m->huff_code_ac_luminance,

574 ff_mjpeg_bits_ac_luminance,

575 ff_mjpeg_val_ac_luminance);

576 ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance,

577 m->huff_code_ac_chrominance,

578 ff_mjpeg_bits_ac_chrominance,

579 ff_mjpeg_val_ac_chrominance);

580

581 init_uni_ac_vlc(m->huff_size_ac_luminance, m->uni_ac_vlc_len);

582 init_uni_ac_vlc(m->huff_size_ac_chrominance, m->uni_chroma_ac_vlc_len);

583

584 s->min_qcoeff = -1023;

585 s->max_qcoeff = 1023;

586

587 s->intra_ac_vlc_length =

588 s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;

589 s->intra_chroma_ac_vlc_length =

590 s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;

591

592 ret = ff_mpv_encode_init(avctx);

593 if (ret < 0)

594 return ret;

595

596 // Buffers start out empty.

597 m->huff_ncode = 0;

598

599 if (s->c.slice_context_count > 1)

600 m->huffman = HUFFMAN_TABLE_DEFAULT;

601

602 if (m->huffman == HUFFMAN_TABLE_OPTIMAL) {

603 // If we are here, we have only one slice_context. So no loop necessary.

604 s->encode_mb = mjpeg_record_mb;

605 return alloc_huffman(m2);

606 }

607

608 return 0;

609 }

610

611 #if CONFIG_AMV_ENCODER

612 // maximum over s->mjpeg_vsample[i]

613 #define V_MAX 2

614 static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,

615 const AVFrame *pic_arg, int *got_packet)

616 {

617 MPVEncContext *const s = avctx->priv_data;

618 AVFrame *pic;

619 int i, ret;

620 int chroma_v_shift = 1; /* AMV is 420-only */

621

622 if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {

623 av_log(avctx, AV_LOG_ERROR,

624 "Heights which are not a multiple of 16 might fail with some decoders, "

625 "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height);

626 av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos "

627 "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");

628 return AVERROR_EXPERIMENTAL;

629 }

630

631 pic = av_frame_clone(pic_arg);

632 if (!pic)

633 return AVERROR(ENOMEM);

634 //picture should be flipped upside-down

635 for(i=0; i < 3; i++) {

636 int vsample = i ? 2 >> chroma_v_shift : 2;

637 pic->data[i] += pic->linesize[i] * (vsample * s->c.height / V_MAX - 1);

638 pic->linesize[i] *= -1;

639 }

640 ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet);

641 av_frame_free(&pic);

642 return ret;

643 }

644 #endif

645

646 #define OFFSET(x) offsetof(MJPEGEncContext, mjpeg.x)

647 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM

648 static const AVOption options[] = {

649 #define AMV_OPTIONS_OFFSET 4

650 { "huffman", "Huffman table strategy", OFFSET(huffman), AV_OPT_TYPE_INT, { .i64 = HUFFMAN_TABLE_OPTIMAL }, 0, NB_HUFFMAN_TABLE_OPTION - 1, VE, .unit = "huffman" },

651 { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_DEFAULT }, INT_MIN, INT_MAX, VE, .unit = "huffman" },

652 { "optimal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_OPTIMAL }, INT_MIN, INT_MAX, VE, .unit = "huffman" },

653 { "force_duplicated_matrix", "Always write luma and chroma matrix for mjpeg, useful for rtp streaming.", OFFSET(force_duplicated_matrix), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, VE },

654 FF_MPV_COMMON_OPTS

655 { NULL},

656 };

657

658 #if CONFIG_MJPEG_ENCODER

659 static const AVClass mjpeg_class = {

660 .class_name = "mjpeg encoder",

661 .item_name = av_default_item_name,

662 .option = options,

663 .version = LIBAVUTIL_VERSION_INT,

664 };

665

666 static int mjpeg_get_supported_config(const AVCodecContext *avctx,

667 const AVCodec *codec,

668 enum AVCodecConfig config,

669 unsigned flags, const void **out,

670 int *out_num)

671 {

672 if (config == AV_CODEC_CONFIG_COLOR_RANGE) {

673 static const enum AVColorRange mjpeg_ranges[] = {

674 AVCOL_RANGE_MPEG, AVCOL_RANGE_JPEG, AVCOL_RANGE_UNSPECIFIED,

675 };

676 int strict = avctx ? avctx->strict_std_compliance : 0;

677 int index = strict > FF_COMPLIANCE_UNOFFICIAL ? 1 : 0;

678 *out = &mjpeg_ranges[index];

679 *out_num = FF_ARRAY_ELEMS(mjpeg_ranges) - index - 1;

680 return 0;

681 }

682

683 return ff_default_get_supported_config(avctx, codec, config, flags, out, out_num);

684 }

685

686 const FFCodec ff_mjpeg_encoder = {

687 .p.name = "mjpeg",

688 CODEC_LONG_NAME("MJPEG (Motion JPEG)"),

689 .p.type = AVMEDIA_TYPE_VIDEO,

690 .p.id = AV_CODEC_ID_MJPEG,

691 .priv_data_size = sizeof(MJPEGEncContext),

692 .init = mjpeg_encode_init,

693 FF_CODEC_ENCODE_CB(ff_mpv_encode_picture),

694 .close = mjpeg_encode_close,

695 .p.capabilities = AV_CODEC_CAP_DR1 |

696 AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS |

697 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,

698 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_ICC_PROFILES,

699 CODEC_PIXFMTS(AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P,

700 AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P),

701 .p.priv_class = &mjpeg_class,

702 .p.profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),

703 .get_supported_config = mjpeg_get_supported_config,

704 };

705 #endif

706

707 #if CONFIG_AMV_ENCODER

708 static const AVClass amv_class = {

709 .class_name = "amv encoder",

710 .item_name = av_default_item_name,

711 .option = options + AMV_OPTIONS_OFFSET,

712 .version = LIBAVUTIL_VERSION_INT,

713 };

714

715 const FFCodec ff_amv_encoder = {

716 .p.name = "amv",

717 CODEC_LONG_NAME("AMV Video"),

718 .p.type = AVMEDIA_TYPE_VIDEO,

719 .p.id = AV_CODEC_ID_AMV,

720 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,

721 .priv_data_size = sizeof(MJPEGEncContext),

722 .init = mjpeg_encode_init,

723 FF_CODEC_ENCODE_CB(amv_encode_picture),

724 .close = mjpeg_encode_close,

725 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

726 CODEC_PIXFMTS(AV_PIX_FMT_YUVJ420P),

727 .color_ranges = AVCOL_RANGE_JPEG,

728 .p.priv_class = &amv_class,

729 };

730 #endif

flags

const SwsFlags flags[]

Definition: swscale.c:61

CODEC_PIXFMTS

#define CODEC_PIXFMTS(...)

Definition: codec_internal.h:392

AVCodec

AVCodec.

Definition: codec.h:172

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

ff_mjpeg_encode_dc

void ff_mjpeg_encode_dc(PutBitContext *pb, int val, const uint8_t huff_size[], const uint16_t huff_code[])

Definition: mjpegenc_common.c:468

jpegtables.h

AVERROR_EXPERIMENTAL

#define AVERROR_EXPERIMENTAL

Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.

Definition: error.h:74

mjpeg.h

level

uint8_t level

Definition: svq3.c:208

MPVEncContext

Definition: mpegvideoenc.h:46

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

The codec allows calling the close function for deallocation even if the init function returned a fai...

Definition: codec_internal.h:42

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

mjpeg_encode_coef

static void mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)

Add the coefficient's data to the JPEG buffer.

Definition: mjpegenc.c:336

MJPEGEncContext::mjpeg

MJpegContext mjpeg

Definition: mjpegenc.c:68

out

FILE * out

Definition: movenc.c:55

mjpegenc_common.h

ff_mjpeg_encoder

const FFCodec ff_mjpeg_encoder

MJpegContext::uni_ac_vlc_len

uint8_t uni_ac_vlc_len[64 *64 *2]

Storage for AC luminance VLC.

Definition: mjpegenc.h:60

mpegvideoenc.h

MJpegHuffmanCode

Buffer of JPEG frame data.

Definition: mjpegenc.c:55

put_sbits

static void put_sbits(PutBitContext *pb, int n, int32_t value)

Definition: put_bits.h:291

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:64

mjpeg_encode_init

static av_cold int mjpeg_encode_init(AVCodecContext *avctx)

Definition: mjpegenc.c:531

av_log2_16bit

int av_log2_16bit(unsigned v)

Definition: intmath.c:31

ff_mjpeg_encode_huffman_close

void ff_mjpeg_encode_huffman_close(MJpegEncHuffmanContext *s, uint8_t bits[17], uint8_t val[], int max_nval)

Produces a Huffman encoding with a given input.

Definition: mjpegenc_huffman.c:159

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

MJpegContext::bits_ac_chrominance

uint8_t bits_ac_chrominance[17]

AC chrominance Huffman bits.

Definition: mjpegenc.h:73

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:224

AVCOL_RANGE_JPEG

@ AVCOL_RANGE_JPEG

Full range content.

Definition: pixfmt.h:777

AV_CODEC_CONFIG_COLOR_RANGE

@ AV_CODEC_CONFIG_COLOR_RANGE

AVColorRange, terminated by AVCOL_RANGE_UNSPECIFIED.

Definition: avcodec.h:2536

AVOption

AVOption.

Definition: opt.h:429

put_bytes_count

static int put_bytes_count(const PutBitContext *s, int round_up)

Definition: put_bits.h:110

MJpegContext::val_dc_chrominance

uint8_t val_dc_chrominance[12]

DC chrominance Huffman values.

Definition: mjpegenc.h:68

MJpegContext::huffman

int huffman

Definition: mjpegenc.h:45

MJpegHuffmanCode::mant

uint16_t mant

The mantissa.

Definition: mjpegenc.c:59

ff_mjpeg_val_dc

const uint8_t ff_mjpeg_val_dc[]

Definition: jpegtabs.h:34

FFCodec

Definition: codec_internal.h:127

MJpegContext::huff_code_dc_chrominance

uint16_t huff_code_dc_chrominance[12]

DC chrominance Huffman table codes.

Definition: mjpegenc.h:52

mpegvideo.h

MJpegHuffmanCode::table_id

uint8_t table_id

The Huffman table id associated with the data.

Definition: mjpegenc.c:57

ff_mjpeg_encode_huffman_init

void ff_mjpeg_encode_huffman_init(MJpegEncHuffmanContext *s)

Definition: mjpegenc_huffman.c:146

record_block

static void record_block(MPVEncContext *const s, int16_t block[], int n)

Add the block's data into the JPEG buffer.

Definition: mjpegenc.c:364

ff_mjpeg_bits_ac_chrominance

const uint8_t ff_mjpeg_bits_ac_chrominance[]

Definition: jpegtabs.h:66

MJpegContext::huff_size_dc_chrominance

uint8_t huff_size_dc_chrominance[12]

DC chrominance Huffman table size.

Definition: mjpegenc.h:51

mjpeg_record_mb

static void mjpeg_record_mb(MPVEncContext *const s, int16_t block[][64], int unused_x, int unused_y)

Definition: mjpegenc.c:465

tf_sess_config.config

config

Definition: tf_sess_config.py:33

MPVMainEncContext::encode_picture_header

int(* encode_picture_header)(struct MPVMainEncContext *m)

Definition: mpegvideoenc.h:248

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:448

ff_mpv_encode_picture

int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)

Definition: mpegvideo_enc.c:1941

FF_MPV_COMMON_OPTS

#define FF_MPV_COMMON_OPTS

Definition: mpegvideoenc.h:336

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

MJpegContext::uni_chroma_ac_vlc_len

uint8_t uni_chroma_ac_vlc_len[64 *64 *2]

Storage for AC chrominance VLC.

Definition: mjpegenc.h:62

fail

#define fail()

Definition: checkasm.h:207

AMV_OPTIONS_OFFSET

#define AMV_OPTIONS_OFFSET

mjpeg_encode_picture_header

static void mjpeg_encode_picture_header(MPVEncContext *const s)

Definition: mjpegenc.c:95

val

static double val(void *priv, double ch)

Definition: aeval.c:77

ff_amv_encoder

const FFCodec ff_amv_encoder

FF_CODEC_ENCODE_CB

#define FF_CODEC_ENCODE_CB(func)

Definition: codec_internal.h:359

ff_mjpeg_profiles

const AVProfile ff_mjpeg_profiles[]

Definition: profiles.c:191

pkt

AVPacket * pkt

Definition: movenc.c:60

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:106

main

int main

Definition: dovi_rpuenc.c:38

MJpegContext::bits_dc_luminance

uint8_t bits_dc_luminance[17]

DC luminance Huffman bits.

Definition: mjpegenc.h:65

AV_PIX_FMT_YUVJ422P

@ AV_PIX_FMT_YUVJ422P

planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...

Definition: pixfmt.h:86

#define s(width, name)

Definition: cbs_vp9.c:198

CHROMA_422

#define CHROMA_422

Definition: mpegvideo.h:265

MJpegContext::val_dc_luminance

uint8_t val_dc_luminance[12]

DC luminance Huffman values.

Definition: mjpegenc.h:66

HUFFMAN_TABLE_OPTIMAL

@ HUFFMAN_TABLE_OPTIMAL

Compute and use optimal Huffman tables.

Definition: mjpegenc.h:85

encode_block

static void encode_block(MPVEncContext *const s, int16_t block[], int n)

Definition: mjpegenc.c:407

AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE

This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...

Definition: codec.h:144

MJpegEncHuffmanContext

Definition: mjpegenc_huffman.h:32

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:41

ctx

AVFormatContext * ctx

Definition: movenc.c:49

RST0

@ RST0

Definition: mjpeg.h:61

MJpegContext::val_ac_chrominance

uint8_t val_ac_chrominance[256]

AC chrominance Huffman values.

Definition: mjpegenc.h:74

av_frame_clone

AVFrame * av_frame_clone(const AVFrame *src)

Create a new frame that references the same data as src.

Definition: frame.c:483

mjpeg_encode_code

static void mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)

Add code and table_id to the JPEG buffer.

Definition: mjpegenc.c:321

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)

Definition: pixfmt.h:73

PutBitContext

Definition: put_bits.h:50

NB_HUFFMAN_TABLE_OPTION

@ NB_HUFFMAN_TABLE_OPTION

Definition: mjpegenc.h:86

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:332

AV_PIX_FMT_YUVJ444P

@ AV_PIX_FMT_YUVJ444P

planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...

Definition: pixfmt.h:87

FFABS

#define FFABS(a)

Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...

Definition: common.h:74

AV_CODEC_CAP_FRAME_THREADS

#define AV_CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: codec.h:95

LIBAVUTIL_VERSION_INT

#define LIBAVUTIL_VERSION_INT

Definition: version.h:85

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

NULL

#define NULL

Definition: coverity.c:32

run

uint8_t run

Definition: svq3.c:207

AV_PIX_FMT_YUVJ420P

@ AV_PIX_FMT_YUVJ420P

planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...

Definition: pixfmt.h:85

av_default_item_name

const char * av_default_item_name(void *ptr)

Return the context name.

Definition: log.c:241

profiles.h

options

Definition: swscale.c:43

ff_mpv_encode_end

av_cold int ff_mpv_encode_end(AVCodecContext *avctx)

Definition: mpegvideo_enc.c:1121

ff_mpv_reallocate_putbitbuffer

int ff_mpv_reallocate_putbitbuffer(MPVEncContext *const s, size_t threshold, size_t size_increase)

Definition: mpegvideo_enc.c:2956

ff_mjpeg_val_ac_chrominance

const uint8_t ff_mjpeg_val_ac_chrominance[]

Definition: jpegtabs.h:69

MPVMainEncContext

Definition: mpegvideoenc.h:199

AVCOL_RANGE_UNSPECIFIED

@ AVCOL_RANGE_UNSPECIFIED

Definition: pixfmt.h:743

index

int index

Definition: gxfenc.c:90

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

MJpegContext::huff_ncode

size_t huff_ncode

Number of current entries in the buffer.

Definition: mjpegenc.h:76

MJPEGEncContext

Definition: mjpegenc.c:66

HUFFMAN_TABLE_DEFAULT

@ HUFFMAN_TABLE_DEFAULT

Use the default Huffman tables.

Definition: mjpegenc.h:84

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:550

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

OFFSET

#define OFFSET(x)

Definition: mjpegenc.c:646

ff_mjpeg_val_ac_luminance

const uint8_t ff_mjpeg_val_ac_luminance[]

Definition: jpegtabs.h:42

Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]

Definition: snow.txt:400

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:94

codec_internal.h

ff_mjpeg_encode_huffman_increment

static void ff_mjpeg_encode_huffman_increment(MJpegEncHuffmanContext *s, uint8_t val)

Definition: mjpegenc_huffman.h:38

options

static const AVOption options[]

Definition: mjpegenc.c:648

ff_mjpeg_bits_ac_luminance

const uint8_t ff_mjpeg_bits_ac_luminance[]

Definition: jpegtabs.h:40

MJpegContext::huff_buffer

struct MJpegHuffmanCode * huff_buffer

Buffer for Huffman code values.

Definition: mjpegenc.h:77

FF_MPV_FLAG_QP_RD

#define FF_MPV_FLAG_QP_RD

Definition: mpegvideoenc.h:310

mjpegenc_huffman.h

AV_CODEC_CAP_SLICE_THREADS

#define AV_CODEC_CAP_SLICE_THREADS

Codec supports slice-based (or partition-based) multithreading.

Definition: codec.h:99

#define VE

Definition: mjpegenc.c:647

MJpegContext::huff_code_ac_luminance

uint16_t huff_code_ac_luminance[256]

AC luminance Huffman table codes.

Definition: mjpegenc.h:55

FF_COMPLIANCE_UNOFFICIAL

#define FF_COMPLIANCE_UNOFFICIAL

Allow unofficial extensions.

Definition: defs.h:61

UNI_AC_ENC_INDEX

#define UNI_AC_ENC_INDEX(run, level)

Definition: mpegvideoenc.h:286

MJPEGEncContext::mpeg

MPVMainEncContext mpeg

Definition: mjpegenc.c:67

CHROMA_444

#define CHROMA_444

Definition: mpegvideo.h:266

ff_mjpeg_build_huffman_codes

void ff_mjpeg_build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code, const uint8_t *bits_table, const uint8_t *val_table)

Definition: mjpegenc_common.c:441

AV_CODEC_ID_MJPEG

@ AV_CODEC_ID_MJPEG

Definition: codec_id.h:59

MJpegContext::huff_code_ac_chrominance

uint16_t huff_code_ac_chrominance[256]

AC chrominance Huffman table codes.

Definition: mjpegenc.h:57

get_bits_diff

static int get_bits_diff(MPVEncContext *s)

Definition: mpegvideoenc.h:409

av_assert2

#define av_assert2(cond)

assert() equivalent, that does lie in speed critical code.

Definition: avassert.h:68

ff_default_get_supported_config

int ff_default_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec, enum AVCodecConfig config, unsigned flags, const void **out_configs, int *out_num_configs)

Definition: avcodec.c:759

CHROMA_420

#define CHROMA_420

Definition: mpegvideo.h:264

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

code

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code

Definition: filter_design.txt:178

put_bits_count

static int put_bits_count(PutBitContext *s)

Definition: put_bits.h:90

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:32

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

ff_mjpeg_encode_check_pix_fmt

int ff_mjpeg_encode_check_pix_fmt(AVCodecContext *avctx)

Definition: mjpegenc_common.c:490

len

int len

Definition: vorbis_enc_data.h:426

AVCodecContext::height

int height

Definition: avcodec.h:592

AVCOL_RANGE_MPEG

@ AVCOL_RANGE_MPEG

Narrow or limited range content.

Definition: pixfmt.h:760

FF_CODEC_CAP_ICC_PROFILES

#define FF_CODEC_CAP_ICC_PROFILES

Codec supports embedded ICC profiles (AV_FRAME_DATA_ICC_PROFILE).

Definition: codec_internal.h:81

avcodec.h

ret

Definition: filter_design.txt:187

MJpegContext::bits_dc_chrominance

uint8_t bits_dc_chrominance[17]

DC chrominance Huffman bits.

Definition: mjpegenc.h:67

AVClass::class_name

const char * class_name

The name of the class; usually it is the same name as the context structure type to which the AVClass...

Definition: log.h:81

MJpegContext::huff_size_dc_luminance

uint8_t huff_size_dc_luminance[12]

DC luminance Huffman table size.

Definition: mjpegenc.h:49

AVCodecContext::strict_std_compliance

int strict_std_compliance

strictly follow the standard (MPEG-4, ...).

Definition: avcodec.h:1357

Code::code

int code

LZW code.

Definition: lzwenc.c:46

alloc_huffman

static int alloc_huffman(MJPEGEncContext *const m2)

Definition: mjpegenc.c:287

AV_CODEC_ID_AMV

@ AV_CODEC_ID_AMV

Definition: codec_id.h:159

AVCodecContext

main external API structure.

Definition: avcodec.h:431

init_uni_ac_vlc

static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256], uint8_t *uni_ac_vlc_len)

Definition: mjpegenc.c:71

AV_OPT_TYPE_INT

@ AV_OPT_TYPE_INT

Underlying C type is int.

Definition: opt.h:259

ff_mjpeg_encode_stuffing

int ff_mjpeg_encode_stuffing(MPVEncContext *const s)

Writes the complete JPEG frame when optimal huffman tables are enabled, otherwise writes the stuffing...

Definition: mjpegenc.c:238

ff_mjpeg_escape_FF

void ff_mjpeg_escape_FF(PutBitContext *pb, int start)

Definition: mjpegenc_common.c:385

mjpeg_encode_close

static av_cold int mjpeg_encode_close(AVCodecContext *avctx)

Definition: mjpegenc.c:306

MJpegContext

Holds JPEG frame data and Huffman table data.

Definition: mjpegenc.h:44

put_marker

static void put_marker(PutBitContext *p, enum JpegMarker code)

Definition: mjpegenc.h:89

MJpegContext::huff_size_ac_chrominance

uint8_t huff_size_ac_chrominance[256]

AC chrominance Huffman table size.

Definition: mjpegenc.h:56

AV_PIX_FMT_YUV444P

@ AV_PIX_FMT_YUV444P

planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)

Definition: pixfmt.h:78

ff_mjpeg_bits_dc_chrominance

const uint8_t ff_mjpeg_bits_dc_chrominance[]

Definition: jpegtabs.h:37

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:200

AV_PIX_FMT_YUV422P

@ AV_PIX_FMT_YUV422P

planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)

Definition: pixfmt.h:77

ff_mjpeg_encode_picture_header

void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb, const AVFrame *frame, const struct MJpegContext *m, const uint8_t intra_matrix_permutation[64], int pred, const uint16_t luma_intra_matrix[64], const uint16_t chroma_intra_matrix[64], int use_slices)

Definition: mjpegenc_common.c:275

mem.h

ff_mpv_encode_init

av_cold int ff_mpv_encode_init(AVCodecContext *avctx)

Definition: mpegvideo_enc.c:558

ff_mjpeg_bits_dc_luminance

const FF_VISIBILITY_PUSH_HIDDEN uint8_t ff_mjpeg_bits_dc_luminance[]

Definition: jpegtabs.h:32

AVPacket

This structure stores compressed data.

Definition: packet.h:565

AVCodecContext::priv_data