FFmpeg: libavcodec/aic.c Source File

FFmpeg

[フレーム]

libavcodec

aic.c

Go to the documentation of this file.

1 /*

2 * Apple Intermediate Codec decoder

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 #include <inttypes.h>

25 #include "avcodec.h"

26 #include "bytestream.h"

27 #include "internal.h"

28 #include "get_bits.h"

29 #include "golomb.h"

30 #include "idctdsp.h"

31 #include "unary.h"

33 #define AIC_HDR_SIZE 24

34 #define AIC_BAND_COEFFS (64 + 32 + 192 + 96)

36 enum AICBands {

37 COEFF_LUMA = 0,

38 COEFF_CHROMA,

39 COEFF_LUMA_EXT,

40 COEFF_CHROMA_EXT,

41 NUM_BANDS

42 };

44 static const int aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };

46 static const int aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };

48 static const uint8_t aic_quant_matrix[64] = {

49 8, 16, 19, 22, 22, 26, 26, 27,

50 16, 16, 22, 22, 26, 27, 27, 29,

51 19, 22, 26, 26, 27, 29, 29, 35,

52 22, 24, 27, 27, 29, 32, 34, 38,

53 26, 27, 29, 29, 32, 35, 38, 46,

54 27, 29, 34, 34, 35, 40, 46, 56,

55 29, 34, 34, 37, 40, 48, 56, 69,

56 34, 37, 38, 40, 48, 58, 69, 83,

57 };

59 static const uint8_t aic_y_scan[64] = {

60 0, 4, 1, 2, 5, 8, 12, 9,

61 6, 3, 7, 10, 13, 14, 11, 15,

62 47, 43, 46, 45, 42, 39, 35, 38,

63 41, 44, 40, 37, 34, 33, 36, 32,

64 16, 20, 17, 18, 21, 24, 28, 25,

65 22, 19, 23, 26, 29, 30, 27, 31,

66 63, 59, 62, 61, 58, 55, 51, 54,

67 57, 60, 56, 53, 50, 49, 52, 48,

68 };

70 static const uint8_t aic_y_ext_scan[192] = {

71 64, 72, 65, 66, 73, 80, 88, 81,

72 74, 67, 75, 82, 89, 90, 83, 91,

73 0, 4, 1, 2, 5, 8, 12, 9,

74 6, 3, 7, 10, 13, 14, 11, 15,

75 16, 20, 17, 18, 21, 24, 28, 25,

76 22, 19, 23, 26, 29, 30, 27, 31,

77 155, 147, 154, 153, 146, 139, 131, 138,

78 145, 152, 144, 137, 130, 129, 136, 128,

79 47, 43, 46, 45, 42, 39, 35, 38,

80 41, 44, 40, 37, 34, 33, 36, 32,

81 63, 59, 62, 61, 58, 55, 51, 54,

82 57, 60, 56, 53, 50, 49, 52, 48,

83 96, 104, 97, 98, 105, 112, 120, 113,

84 106, 99, 107, 114, 121, 122, 115, 123,

85 68, 76, 69, 70, 77, 84, 92, 85,

86 78, 71, 79, 86, 93, 94, 87, 95,

87 100, 108, 101, 102, 109, 116, 124, 117,

88 110, 103, 111, 118, 125, 126, 119, 127,

89 187, 179, 186, 185, 178, 171, 163, 170,

90 177, 184, 176, 169, 162, 161, 168, 160,

91 159, 151, 158, 157, 150, 143, 135, 142,

92 149, 156, 148, 141, 134, 133, 140, 132,

93 191, 183, 190, 189, 182, 175, 167, 174,

94 181, 188, 180, 173, 166, 165, 172, 164,

95 };

97 static const uint8_t aic_c_scan[64] = {

98 0, 4, 1, 2, 5, 8, 12, 9,

99 6, 3, 7, 10, 13, 14, 11, 15,

100 31, 27, 30, 29, 26, 23, 19, 22,

101 25, 28, 24, 21, 18, 17, 20, 16,

102 32, 36, 33, 34, 37, 40, 44, 41,

103 38, 35, 39, 42, 45, 46, 43, 47,

104 63, 59, 62, 61, 58, 55, 51, 54,

105 57, 60, 56, 53, 50, 49, 52, 48,

106 };

107

108 static const uint8_t aic_c_ext_scan[192] = {

109 16, 24, 17, 18, 25, 32, 40, 33,

110 26, 19, 27, 34, 41, 42, 35, 43,

111 0, 4, 1, 2, 5, 8, 12, 9,

112 6, 3, 7, 10, 13, 14, 11, 15,

113 20, 28, 21, 22, 29, 36, 44, 37,

114 30, 23, 31, 38, 45, 46, 39, 47,

115 95, 87, 94, 93, 86, 79, 71, 78,

116 85, 92, 84, 77, 70, 69, 76, 68,

117 63, 59, 62, 61, 58, 55, 51, 54,

118 57, 60, 56, 53, 50, 49, 52, 48,

119 91, 83, 90, 89, 82, 75, 67, 74,

120 81, 88, 80, 73, 66, 65, 72, 64,

121 112, 120, 113, 114, 121, 128, 136, 129,

122 122, 115, 123, 130, 137, 138, 131, 139,

123 96, 100, 97, 98, 101, 104, 108, 105,

124 102, 99, 103, 106, 109, 110, 107, 111,

125 116, 124, 117, 118, 125, 132, 140, 133,

126 126, 119, 127, 134, 141, 142, 135, 143,

127 191, 183, 190, 189, 182, 175, 167, 174,

128 181, 188, 180, 173, 166, 165, 172, 164,

129 159, 155, 158, 157, 154, 151, 147, 150,

130 153, 156, 152, 149, 146, 145, 148, 144,

131 187, 179, 186, 185, 178, 171, 163, 170,

132 177, 184, 176, 169, 162, 161, 168, 160,

133 };

134

135 static const uint8_t * const aic_scan[NUM_BANDS] = {

136 aic_y_scan, aic_c_scan, aic_y_ext_scan, aic_c_ext_scan

137 };

138

139 typedef struct AICContext {

140 AVCodecContext *avctx;

141 AVFrame *frame;

142 IDCTDSPContext idsp;

143 ScanTable scantable;

144

145 int num_x_slices;

146 int slice_width;

147 int mb_width, mb_height;

148 int quant;

149 int interlaced;

150

151 int16_t *slice_data;

152 int16_t *data_ptr[NUM_BANDS];

153

154 DECLARE_ALIGNED(16, int16_t, block)[64];

155 DECLARE_ALIGNED(16, uint8_t, quant_matrix)[64];

156 } AICContext;

157

158 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)

159 {

160 uint32_t frame_size;

161 int width, height;

162

163 if (src[0] != 1) {

164 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);

165 return AVERROR_INVALIDDATA;

166 }

167 if (src[1] != AIC_HDR_SIZE - 2) {

168 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);

169 return AVERROR_INVALIDDATA;

170 }

171 frame_size = AV_RB32(src + 2);

172 width = AV_RB16(src + 6);

173 height = AV_RB16(src + 8);

174 if (frame_size > size) {

175 av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",

176 frame_size, size);

177 return AVERROR_INVALIDDATA;

178 }

179 if (width != ctx->avctx->width || height != ctx->avctx->height) {

180 av_log(ctx->avctx, AV_LOG_ERROR,

181 "Picture dimension changed: old: %d x %d, new: %d x %d\n",

182 ctx->avctx->width, ctx->avctx->height, width, height);

183 return AVERROR_INVALIDDATA;

184 }

185 ctx->quant = src[15];

186 ctx->interlaced = ((src[16] >> 4) == 3);

187

188 return 0;

189 }

190

191 #define GET_CODE(val, type, add_bits) \

192 do { \

193 if (type) \

194 val = get_ue_golomb(gb); \

195 else \

196 val = get_unary(gb, 1, 31); \

197 if (add_bits) \

198 val = (val << add_bits) + get_bits(gb, add_bits); \

199 } while (0)

200

201 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,

202 int band, int slice_width, int force_chroma)

203 {

204 int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;

205 const int num_coeffs = aic_num_band_coeffs[band];

206 const uint8_t *scan = aic_scan[band | force_chroma];

207 int mb, idx;

208 unsigned val;

209

210 has_skips = get_bits1(gb);

211 coeff_type = get_bits1(gb);

212 coeff_bits = get_bits(gb, 3);

213

214 if (has_skips) {

215 skip_type = get_bits1(gb);

216 skip_bits = get_bits(gb, 3);

217

218 for (mb = 0; mb < slice_width; mb++) {

219 idx = -1;

220 do {

221 GET_CODE(val, skip_type, skip_bits);

222 if (val >= 0x10000)

223 return AVERROR_INVALIDDATA;

224 idx += val + 1;

225 if (idx >= num_coeffs)

226 break;

227 GET_CODE(val, coeff_type, coeff_bits);

228 val++;

229 if (val >= 0x10000)

230 return AVERROR_INVALIDDATA;

231 dst[scan[idx]] = val;

232 } while (idx < num_coeffs - 1);

233 dst += num_coeffs;

234 }

235 } else {

236 for (mb = 0; mb < slice_width; mb++) {

237 for (idx = 0; idx < num_coeffs; idx++) {

238 GET_CODE(val, coeff_type, coeff_bits);

239 if (val >= 0x10000)

240 return AVERROR_INVALIDDATA;

241 dst[scan[idx]] = val;

242 }

243 dst += num_coeffs;

244 }

245 }

246 return 0;

247 }

248

249 static void recombine_block(int16_t *dst, const uint8_t *scan,

250 int16_t **base, int16_t **ext)

251 {

252 int i, j;

253

254 for (i = 0; i < 4; i++) {

255 for (j = 0; j < 4; j++)

256 dst[scan[i * 8 + j]] = (*base)[j];

257 for (j = 0; j < 4; j++)

258 dst[scan[i * 8 + j + 4]] = (*ext)[j];

259 *base += 4;

260 *ext += 4;

261 }

262 for (; i < 8; i++) {

263 for (j = 0; j < 8; j++)

264 dst[scan[i * 8 + j]] = (*ext)[j];

265 *ext += 8;

266 }

267 }

268

269 static void recombine_block_il(int16_t *dst, const uint8_t *scan,

270 int16_t **base, int16_t **ext,

271 int block_no)

272 {

273 int i, j;

274

275 if (block_no < 2) {

276 for (i = 0; i < 8; i++) {

277 for (j = 0; j < 4; j++)

278 dst[scan[i * 8 + j]] = (*base)[j];

279 for (j = 0; j < 4; j++)

280 dst[scan[i * 8 + j + 4]] = (*ext)[j];

281 *base += 4;

282 *ext += 4;

283 }

284 } else {

285 for (i = 0; i < 64; i++)

286 dst[scan[i]] = (*ext)[i];

287 *ext += 64;

288 }

289 }

290

291 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)

292 {

293 int i;

294

295 for (i = 0; i < 64; i++) {

296 int val = (uint16_t)block[i];

297 int sign = val & 1;

298

299 block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)

300 + sign;

301 }

302 }

303

304 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,

305 const uint8_t *src, int src_size)

306 {

307 GetBitContext gb;

308 int ret, i, mb, blk;

309 int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);

310 uint8_t *Y, *C[2];

311 uint8_t *dst;

312 int16_t *base_y = ctx->data_ptr[COEFF_LUMA];

313 int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];

314 int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];

315 int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];

316 const int ystride = ctx->frame->linesize[0];

317

318 Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;

319 for (i = 0; i < 2; i++)

320 C[i] = ctx->frame->data[i + 1] + mb_x * 8

321 + mb_y * 8 * ctx->frame->linesize[i + 1];

322 init_get_bits(&gb, src, src_size * 8);

323

324 memset(ctx->slice_data, 0,

325 sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);

326 for (i = 0; i < NUM_BANDS; i++)

327 if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],

328 i, slice_width,

329 !ctx->interlaced)) < 0)

330 return ret;

331

332 for (mb = 0; mb < slice_width; mb++) {

333 for (blk = 0; blk < 4; blk++) {

334 if (!ctx->interlaced)

335 recombine_block(ctx->block, ctx->scantable.permutated,

336 &base_y, &ext_y);

337 else

338 recombine_block_il(ctx->block, ctx->scantable.permutated,

339 &base_y, &ext_y, blk);

340 unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);

341 ctx->idsp.idct(ctx->block);

342

343 if (!ctx->interlaced) {

344 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;

345 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);

346 } else {

347 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;

348 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,

349 ystride * 2);

350 }

351 }

352 Y += 16;

353

354 for (blk = 0; blk < 2; blk++) {

355 recombine_block(ctx->block, ctx->scantable.permutated,

356 &base_c, &ext_c);

357 unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);

358 ctx->idsp.idct(ctx->block);

359 ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],

360 ctx->frame->linesize[blk + 1]);

361 C[blk] += 8;

362 }

363 }

364

365 return 0;

366 }

367

368 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

369 AVPacket *avpkt)

370 {

371 AICContext *ctx = avctx->priv_data;

372 const uint8_t *buf = avpkt->data;

373 int buf_size = avpkt->size;

374 GetByteContext gb;

375 uint32_t off;

376 int x, y, ret;

377 int slice_size;

378

379 ctx->frame = data;

380 ctx->frame->pict_type = AV_PICTURE_TYPE_I;

381 ctx->frame->key_frame = 1;

382

383 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);

384

385 if (buf_size < off) {

386 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");

387 return AVERROR_INVALIDDATA;

388 }

389

390 ret = aic_decode_header(ctx, buf, buf_size);

391 if (ret < 0) {

392 av_log(avctx, AV_LOG_ERROR, "Invalid header\n");

393 return ret;

394 }

395

396 if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)

397 return ret;

398

399 bytestream2_init(&gb, buf + AIC_HDR_SIZE,

400 ctx->num_x_slices * ctx->mb_height * 2);

401

402 for (y = 0; y < ctx->mb_height; y++) {

403 for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {

404 slice_size = bytestream2_get_le16(&gb) * 4;

405 if (slice_size + off > buf_size || !slice_size) {

406 av_log(avctx, AV_LOG_ERROR,

407 "Incorrect slice size %d at %d.%d\n", slice_size, x, y);

408 return AVERROR_INVALIDDATA;

409 }

410

411 ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);

412 if (ret < 0) {

413 av_log(avctx, AV_LOG_ERROR,

414 "Error decoding slice at %d.%d\n", x, y);

415 return ret;

416 }

417

418 off += slice_size;

419 }

420 }

421

422 *got_frame = 1;

423

424 return avpkt->size;

425 }

426

427 static av_cold int aic_decode_init(AVCodecContext *avctx)

428 {

429 AICContext *ctx = avctx->priv_data;

430 int i;

431 uint8_t scan[64];

432

433 ctx->avctx = avctx;

434

435 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

436

437 ff_idctdsp_init(&ctx->idsp, avctx);

438

439 for (i = 0; i < 64; i++)

440 scan[i] = i;

441 ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);

442 for (i = 0; i < 64; i++)

443 ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];

444

445 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;

446 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;

447

448 ctx->num_x_slices = (ctx->mb_width + 15) >> 4;

449 ctx->slice_width = 16;

450 for (i = 1; i < 32; i++) {

451 if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {

452 ctx->slice_width = ctx->mb_width / i;

453 ctx->num_x_slices = i;

454 break;

455 }

456 }

457

458 ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS

459 * sizeof(*ctx->slice_data));

460 if (!ctx->slice_data) {

461 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");

462

463 return AVERROR(ENOMEM);

464 }

465

466 for (i = 0; i < NUM_BANDS; i++)

467 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width

468 * aic_band_off[i];

469

470 return 0;

471 }

472

473 static av_cold int aic_decode_close(AVCodecContext *avctx)

474 {

475 AICContext *ctx = avctx->priv_data;

476

477 av_freep(&ctx->slice_data);

478

479 return 0;

480 }

481

482 AVCodec ff_aic_decoder = {

483 .name = "aic",

484 .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),

485 .type = AVMEDIA_TYPE_VIDEO,

486 .id = AV_CODEC_ID_AIC,

487 .priv_data_size = sizeof(AICContext),

488 .init = aic_decode_init,

489 .close = aic_decode_close,

490 .decode = aic_decode_frame,

491 .capabilities = AV_CODEC_CAP_DR1,

492 };

aic_num_band_coeffs

static const int aic_num_band_coeffs[NUM_BANDS]

Definition: aic.c:44

AICBands

Definition: aic.c:36

IDCTDSPContext::put_signed_pixels_clamped

void(* put_signed_pixels_clamped)(const int16_t *block, uint8_t *pixels, ptrdiff_t line_size)

Definition: idctdsp.h:56

AICContext::data_ptr

int16_t * data_ptr[NUM_BANDS]

Definition: aic.c:152

val

const char const char void * val

Definition: avisynth_c.h:634

GetByteContext

Definition: bytestream.h:33

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:59

AVFrame

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

Definition: frame.h:181

COEFF_LUMA_EXT

Definition: aic.c:39

data

ptrdiff_t const GLvoid * data

Definition: opengl_enc.c:101

AICContext::avctx

AVCodecContext * avctx

Definition: aic.c:140

#define C

ctx

AVFormatContext * ctx

Definition: movenc-test.c:48

AIC_HDR_SIZE

#define AIC_HDR_SIZE

Definition: aic.c:33

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:260

init

static av_cold int init(AVCodecContext *avctx)

Definition: avrndec.c:35

ScanTable

Scantable.

Definition: idctdsp.h:29

AVPacket::size

int size

Definition: avcodec.h:1468

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem.h:53

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:1752

bytestream2_init

static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)

Definition: bytestream.h:133

ScanTable::permutated

uint8_t permutated[64]

Definition: idctdsp.h:31

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:87

blk

#define blk(i)

Definition: sha.c:185

ff_aic_decoder

AVCodec ff_aic_decoder

Definition: aic.c:482

AVCodec

AVCodec.

Definition: avcodec.h:3392

band

Definition: af_biquads.c:76

uint8_t

Definition: audio_convert.c:194

av_cold

#define av_cold

Definition: attributes.h:82

aic_c_scan

static const uint8_t aic_c_scan[64]

Definition: aic.c:97

#define mb

Definition: vf_colormatrix.c:106

#define Y

Definition: vf_boxblur.c:76

AV_RB32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32

Definition: bytestream.h:87

AVPacket::data

uint8_t * data

Definition: avcodec.h:1467

get_bits.h

bitstream reader API header.

size

ptrdiff_t size

Definition: opengl_enc.c:101

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:48

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:28

aic_decode_init

static av_cold int aic_decode_init(AVCodecContext *avctx)

Definition: aic.c:427

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:176

AICContext::mb_width

int mb_width

Definition: aic.c:147

aic_decode_header

static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)

Definition: aic.c:158

aic_y_scan

static const uint8_t aic_y_scan[64]

Definition: aic.c:59

AVERROR

#define AVERROR(e)

Definition: error.h:43

AICContext::idsp

IDCTDSPContext idsp

Definition: aic.c:142

COEFF_CHROMA

Definition: aic.c:38

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:176

AICContext::interlaced

int interlaced

Definition: aic.c:149

aic_decode_close

static av_cold int aic_decode_close(AVCodecContext *avctx)

Definition: aic.c:473

AVCodec::name

const char * name

Name of the codec implementation.

Definition: avcodec.h:3399

aic_decode_coeffs

static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst, int band, int slice_width, int force_chroma)

Definition: aic.c:201

idctdsp.h

bytestream.h

AICContext::block

int16_t block[64]

Definition: aic.c:154

aic_c_ext_scan

static const uint8_t aic_c_ext_scan[192]

Definition: aic.c:108

AICContext::slice_data

int16_t * slice_data

Definition: aic.c:151

aic_scan

static const uint8_t *const aic_scan[NUM_BANDS]

Definition: aic.c:135

AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:266

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:252

FFMIN

#define FFMIN(a, b)

Definition: common.h:96

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:1711

AICContext::quant

int quant

Definition: aic.c:148

COEFF_CHROMA_EXT

Definition: aic.c:40

aic_quant_matrix

static const uint8_t aic_quant_matrix[64]

Definition: aic.c:48

IDCTDSPContext::idct_permutation

uint8_t idct_permutation[64]

IDCT input permutation.

Definition: idctdsp.h:94

src

#define src

Definition: vp9dsp.c:530

AVCodecContext::height

int height

Definition: avcodec.h:1711

aic_band_off

static const int aic_band_off[NUM_BANDS]

Definition: aic.c:46

NUM_BANDS

Definition: aic.c:41

frame_size

int frame_size

Definition: mxfenc.c:1821

aic_decode_slice

static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y, const uint8_t *src, int src_size)

Definition: aic.c:304

avcodec.h

Libavcodec external API header.

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, size in bytes of each picture line.

Definition: frame.h:209

AVCodecContext

main external API structure.

Definition: avcodec.h:1532

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: utils.c:894

buf

void * buf

Definition: avisynth_c.h:553

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:312

height

BYTE int const BYTE int int int height

Definition: avisynth_c.h:676

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:305

unary.h

COEFF_LUMA

Definition: aic.c:37

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:418

unquant_block

static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)

Definition: aic.c:291

IDCTDSPContext

Definition: idctdsp.h:51

AICContext

Definition: aic.c:139

recombine_block

static void recombine_block(int16_t *dst, const uint8_t *scan, int16_t **base, int16_t **ext)

Definition: aic.c:249

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:192

decode

static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)

Definition: ccaption_dec.c:572

AICContext::scantable

ScanTable scantable

Definition: aic.c:143

AV_PIX_FMT_YUV420P

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

Definition: pixfmt.h:63

GetBitContext

Definition: get_bits.h:54

internal.h

common internal api header.

AICContext::mb_height

int mb_height

Definition: aic.c:147

AICContext::frame

AVFrame * frame

Definition: aic.c:141

recombine_block_il

static void recombine_block_il(int16_t *dst, const uint8_t *scan, int16_t **base, int16_t **ext, int block_no)

Definition: aic.c:269

GET_CODE

#define GET_CODE(val, type, add_bits)

Definition: aic.c:191

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:1574

ff_init_scantable

av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)

Definition: idctdsp.c:29

ff_idctdsp_init

av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)

Definition: idctdsp.c:241

AICContext::slice_width

int slice_width

Definition: aic.c:146

aic_decode_frame

static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)

Definition: aic.c:368

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:247

AICContext::num_x_slices

int num_x_slices

Definition: aic.c:145

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AVMEDIA_TYPE_VIDEO

Definition: avutil.h:193

AIC_BAND_COEFFS

#define AIC_BAND_COEFFS

Definition: aic.c:34

av_malloc_array

#define av_malloc_array(a, b)

Definition: tableprint_vlc.h:32

aic_y_ext_scan

static const uint8_t aic_y_ext_scan[192]

Definition: aic.c:70

AV_CODEC_ID_AIC

Definition: avcodec.h:276

golomb.h

exp golomb vlc stuff

AVPacket

This structure stores compressed data.

Definition: avcodec.h:1444

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

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

Definition: avcodec.h:856

AICContext::quant_matrix

uint8_t quant_matrix[64]

Definition: aic.c:155

IDCTDSPContext::idct

void(* idct)(int16_t *block)

Definition: idctdsp.h:63

width

static int width

Definition: demuxing_decoding.c:39

block

static int16_t block[64]

Definition: dct-test.c:112

Generated on Mon Feb 15 2016 15:20:36 for FFmpeg by doxygen 1.8.6