FFmpeg: libavcodec/svq1dec.c Source File

FFmpeg

[フレーム]

libavcodec

svq1dec.c

Go to the documentation of this file.

1 /*

2 * SVQ1 decoder

3 * ported to MPlayer by Arpi <arpi@thot.banki.hu>

4 * ported to libavcodec by Nick Kurshev <nickols_k@mail.ru>

5 *

8 *

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 * Sorenson Vector Quantizer #1 (SVQ1) video codec.

31 * For more information of the SVQ1 algorithm, visit:

32 * http://www.pcisys.net/~melanson/codecs/

33 */

35 #include "libavutil/crc.h"

36 #include "libavutil/mem.h"

37 #include "libavutil/thread.h"

39 #include "avcodec.h"

40 #include "codec_internal.h"

41 #include "decode.h"

42 #include "get_bits.h"

43 #include "h263data.h"

44 #include "hpeldsp.h"

45 #include "mathops.h"

46 #include "svq1.h"

48 #define SVQ1_BLOCK_TYPE_VLC_BITS 3

49 static VLCElem svq1_block_type[8];

50 static VLCElem svq1_motion_component[176];

51 static const VLCElem *svq1_intra_multistage[6];

52 static const VLCElem *svq1_inter_multistage[6];

53 static VLCElem svq1_intra_mean[632];

54 static VLCElem svq1_inter_mean[1434];

56 /* motion vector (prediction) */

57 typedef struct svq1_pmv_s {

58 int x;

59 int y;

60 } svq1_pmv;

62 typedef struct SVQ1Context {

63 HpelDSPContext hdsp;

64 GetBitContext gb;

65 AVFrame *prev;

67 uint8_t *pkt_swapped;

68 int pkt_swapped_allocated;

70 svq1_pmv *pmv;

71 int pmv_allocated;

73 int width;

74 int height;

75 int frame_code;

76 int nonref; // 1 if the current frame won't be referenced

78 int last_tempref;

79 } SVQ1Context;

81 static const uint8_t string_table[256] = {

82 0x00, 0xD5, 0x7F, 0xAA, 0xFE, 0x2B, 0x81, 0x54,

83 0x29, 0xFC, 0x56, 0x83, 0xD7, 0x02, 0xA8, 0x7D,

84 0x52, 0x87, 0x2D, 0xF8, 0xAC, 0x79, 0xD3, 0x06,

85 0x7B, 0xAE, 0x04, 0xD1, 0x85, 0x50, 0xFA, 0x2F,

86 0xA4, 0x71, 0xDB, 0x0E, 0x5A, 0x8F, 0x25, 0xF0,

87 0x8D, 0x58, 0xF2, 0x27, 0x73, 0xA6, 0x0C, 0xD9,

88 0xF6, 0x23, 0x89, 0x5C, 0x08, 0xDD, 0x77, 0xA2,

89 0xDF, 0x0A, 0xA0, 0x75, 0x21, 0xF4, 0x5E, 0x8B,

90 0x9D, 0x48, 0xE2, 0x37, 0x63, 0xB6, 0x1C, 0xC9,

91 0xB4, 0x61, 0xCB, 0x1E, 0x4A, 0x9F, 0x35, 0xE0,

92 0xCF, 0x1A, 0xB0, 0x65, 0x31, 0xE4, 0x4E, 0x9B,

93 0xE6, 0x33, 0x99, 0x4C, 0x18, 0xCD, 0x67, 0xB2,

94 0x39, 0xEC, 0x46, 0x93, 0xC7, 0x12, 0xB8, 0x6D,

95 0x10, 0xC5, 0x6F, 0xBA, 0xEE, 0x3B, 0x91, 0x44,

96 0x6B, 0xBE, 0x14, 0xC1, 0x95, 0x40, 0xEA, 0x3F,

97 0x42, 0x97, 0x3D, 0xE8, 0xBC, 0x69, 0xC3, 0x16,

98 0xEF, 0x3A, 0x90, 0x45, 0x11, 0xC4, 0x6E, 0xBB,

99 0xC6, 0x13, 0xB9, 0x6C, 0x38, 0xED, 0x47, 0x92,

100 0xBD, 0x68, 0xC2, 0x17, 0x43, 0x96, 0x3C, 0xE9,

101 0x94, 0x41, 0xEB, 0x3E, 0x6A, 0xBF, 0x15, 0xC0,

102 0x4B, 0x9E, 0x34, 0xE1, 0xB5, 0x60, 0xCA, 0x1F,

103 0x62, 0xB7, 0x1D, 0xC8, 0x9C, 0x49, 0xE3, 0x36,

104 0x19, 0xCC, 0x66, 0xB3, 0xE7, 0x32, 0x98, 0x4D,

105 0x30, 0xE5, 0x4F, 0x9A, 0xCE, 0x1B, 0xB1, 0x64,

106 0x72, 0xA7, 0x0D, 0xD8, 0x8C, 0x59, 0xF3, 0x26,

107 0x5B, 0x8E, 0x24, 0xF1, 0xA5, 0x70, 0xDA, 0x0F,

108 0x20, 0xF5, 0x5F, 0x8A, 0xDE, 0x0B, 0xA1, 0x74,

109 0x09, 0xDC, 0x76, 0xA3, 0xF7, 0x22, 0x88, 0x5D,

110 0xD6, 0x03, 0xA9, 0x7C, 0x28, 0xFD, 0x57, 0x82,

111 0xFF, 0x2A, 0x80, 0x55, 0x01, 0xD4, 0x7E, 0xAB,

112 0x84, 0x51, 0xFB, 0x2E, 0x7A, 0xAF, 0x05, 0xD0,

113 0xAD, 0x78, 0xD2, 0x07, 0x53, 0x86, 0x2C, 0xF9

114 };

115

116 #define SVQ1_PROCESS_VECTOR() \

117 for (; level > 0; i++) { \

118 /* process next depth */ \

119 if (i == m) { \

120 m = n; \

121 if (--level == 0) \

122 break; \

123 } \

124 /* divide block if next bit set */ \

125 if (!get_bits1(bitbuf)) \

126 break; \

127 /* add child nodes */ \

128 list[n++] = list[i]; \

129 list[n++] = list[i] + (((level & 1) ? pitch : 1) << ((level >> 1) + 1));\

130 }

131

132 #define SVQ1_ADD_CODEBOOK() \

133 /* add codebook entries to vector */ \

134 for (j = 0; j < stages; j++) { \

135 n3 = codebook[entries[j]] ^ 0x80808080; \

136 n1 += (n3 & 0xFF00FF00) >> 8; \

137 n2 += n3 & 0x00FF00FF; \

138 } \

139 \

140 /* clip to [0..255] */ \

141 if (n1 & 0xFF00FF00) { \

142 n3 = (n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \

143 n1 += 0x7F007F00; \

144 n1 |= (~n1 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \

145 n1 &= n3 & 0x00FF00FF; \

146 } \

147 \

148 if (n2 & 0xFF00FF00) { \

149 n3 = (n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \

150 n2 += 0x7F007F00; \

151 n2 |= (~n2 >> 15 & 0x00010001 | 0x01000100) - 0x00010001; \

152 n2 &= n3 & 0x00FF00FF; \

153 }

154

155 #define SVQ1_CALC_CODEBOOK_ENTRIES(cbook) \

156 codebook = (const uint32_t *)cbook[level]; \

157 if (stages > 0) \

158 bit_cache = get_bits(bitbuf, 4 * stages); \

159 /* calculate codebook entries for this vector */ \

160 for (j = 0; j < stages; j++) { \

161 entries[j] = (((bit_cache >> (4 * (stages - j - 1))) & 0xF) + \

162 16 * j) << (level + 1); \

163 } \

164 mean -= stages * 128; \

165 n4 = (mean << 16) + mean;

166

167 static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels,

168 ptrdiff_t pitch)

169 {

170 uint32_t bit_cache;

171 uint8_t *list[63];

172 uint32_t *dst;

173 const uint32_t *codebook;

174 int entries[6];

175 int i, j, m, n;

176 int stages;

177 unsigned mean;

178 unsigned x, y, width, height, level;

179 uint32_t n1, n2, n3, n4;

180

181 /* initialize list for breadth first processing of vectors */

182 list[0] = pixels;

183

184 /* recursively process vector */

185 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {

186 SVQ1_PROCESS_VECTOR();

187

188 /* destination address and vector size */

189 dst = (uint32_t *)list[i];

190 width = 1 << ((4 + level) / 2);

191 height = 1 << ((3 + level) / 2);

192

193 /* get number of stages (-1 skips vector, 0 for mean only) */

194 stages = get_vlc2(bitbuf, svq1_intra_multistage[level], 4, 2) - 1;

195

196 if (stages == -1) {

197 for (y = 0; y < height; y++)

198 memset(&dst[y * (pitch / 4)], 0, width);

199 continue; /* skip vector */

200 }

201

202 if ((stages > 0 && level >= 4)) {

203 ff_dlog(NULL,

204 "Error (svq1_decode_block_intra): invalid vector: stages=%i level=%i\n",

205 stages, level);

206 return AVERROR_INVALIDDATA; /* invalid vector */

207 }

208 av_assert0(stages >= 0);

209

210 mean = get_vlc2(bitbuf, svq1_intra_mean, 8, 3);

211

212 if (stages == 0) {

213 for (y = 0; y < height; y++)

214 memset(&dst[y * (pitch / 4)], mean, width);

215 } else {

216 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_intra_codebooks);

217

218 for (y = 0; y < height; y++) {

219 for (x = 0; x < width / 4; x++, codebook++) {

220 n1 = n4;

221 n2 = n4;

222 SVQ1_ADD_CODEBOOK()

223 /* store result */

224 dst[x] = n1 << 8 | n2;

225 }

226 dst += pitch / 4;

227 }

228 }

229 }

230

231 return 0;

232 }

233

234 static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels,

235 ptrdiff_t pitch, int buggy)

236 {

237 uint32_t bit_cache;

238 uint8_t *list[63];

239 uint32_t *dst;

240 const uint32_t *codebook;

241 int entries[6];

242 int i, j, m, n;

243 int stages;

244 unsigned mean;

245 int x, y, width, height, level;

246 uint32_t n1, n2, n3, n4;

247

248 /* initialize list for breadth first processing of vectors */

249 list[0] = pixels;

250

251 /* recursively process vector */

252 for (i = 0, m = 1, n = 1, level = 5; i < n; i++) {

253 SVQ1_PROCESS_VECTOR();

254

255 /* destination address and vector size */

256 dst = (uint32_t *)list[i];

257 width = 1 << ((4 + level) / 2);

258 height = 1 << ((3 + level) / 2);

259

260 /* get number of stages (-1 skips vector, 0 for mean only) */

261 stages = get_vlc2(bitbuf, svq1_inter_multistage[level], 3, 2) - 1;

262

263 if (stages == -1)

264 continue; /* skip vector */

265

266 if ((stages > 0 && level >= 4)) {

267 ff_dlog(NULL,

268 "Error (svq1_decode_block_non_intra): invalid vector: stages=%i level=%i\n",

269 stages, level);

270 return AVERROR_INVALIDDATA; /* invalid vector */

271 }

272 av_assert0(stages >= 0);

273

274 mean = get_vlc2(bitbuf, svq1_inter_mean, 9, 3) - 256;

275

276 if (buggy) {

277 if (mean == -128)

278 mean = 128;

279 else if (mean == 128)

280 mean = -128;

281 }

282

283 SVQ1_CALC_CODEBOOK_ENTRIES(ff_svq1_inter_codebooks);

284

285 for (y = 0; y < height; y++) {

286 for (x = 0; x < width / 4; x++) {

287 n3 = dst[x];

288 /* add mean value to vector */

289 n1 = n4 + ((n3 & 0xFF00FF00) >> 8);

290 n2 = n4 + (n3 & 0x00FF00FF);

291 SVQ1_ADD_CODEBOOK()

292 /* store result */

293 dst[x] = n1 << 8 | n2;

294 if (codebook != NULL)

295 codebook++;

296 }

297 dst += pitch / 4;

298 }

299 }

300 return 0;

301 }

302

303 static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv,

304 svq1_pmv **pmv)

305 {

306 int diff;

307 int i;

308

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

310 /* get motion code */

311 diff = get_vlc2(bitbuf, svq1_motion_component, 7, 2);

312 if (diff < 0)

313 return AVERROR_INVALIDDATA;

314 else if (diff) {

315 if (get_bits1(bitbuf))

316 diff = -diff;

317 }

318

319 /* add median of motion vector predictors and clip result */

320 if (i == 1)

321 mv->y = sign_extend(diff + mid_pred(pmv[0]->y, pmv[1]->y, pmv[2]->y), 6);

322 else

323 mv->x = sign_extend(diff + mid_pred(pmv[0]->x, pmv[1]->x, pmv[2]->x), 6);

324 }

325

326 return 0;

327 }

328

329 static void svq1_skip_block(uint8_t *current, uint8_t *previous,

330 ptrdiff_t pitch, int x, int y)

331 {

332 uint8_t *src;

333 uint8_t *dst;

334 int i;

335

336 src = &previous[x + y * pitch];

337 dst = current;

338

339 for (i = 0; i < 16; i++) {

340 memcpy(dst, src, 16);

341 src += pitch;

342 dst += pitch;

343 }

344 }

345

346 static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,

347 uint8_t *current, uint8_t *previous,

348 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,

349 int width, int height)

350 {

351 uint8_t *src;

352 uint8_t *dst;

353 svq1_pmv mv;

354 svq1_pmv *pmv[3];

355 int result;

356

357 /* predict and decode motion vector */

358 pmv[0] = &motion[0];

359 if (y == 0) {

360 pmv[1] =

361 pmv[2] = pmv[0];

362 } else {

363 pmv[1] = &motion[x / 8 + 2];

364 pmv[2] = &motion[x / 8 + 4];

365 }

366

367 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);

368 if (result)

369 return result;

370

371 motion[0].x =

372 motion[x / 8 + 2].x =

373 motion[x / 8 + 3].x = mv.x;

374 motion[0].y =

375 motion[x / 8 + 2].y =

376 motion[x / 8 + 3].y = mv.y;

377

378 mv.x = av_clip(mv.x, -2 * x, 2 * (width - x - 16));

379 mv.y = av_clip(mv.y, -2 * y, 2 * (height - y - 16));

380

381 src = &previous[(x + (mv.x >> 1)) + (y + (mv.y >> 1)) * pitch];

382 dst = current;

383

384 hdsp->put_pixels_tab[0][(mv.y & 1) << 1 | (mv.x & 1)](dst, src, pitch, 16);

385

386 return 0;

387 }

388

389 static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf,

390 uint8_t *current, uint8_t *previous,

391 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,

392 int width, int height)

393 {

394 uint8_t *src;

395 uint8_t *dst;

396 svq1_pmv mv;

397 svq1_pmv *pmv[4];

398 int i, result;

399

400 /* predict and decode motion vector (0) */

401 pmv[0] = &motion[0];

402 if (y == 0) {

403 pmv[1] =

404 pmv[2] = pmv[0];

405 } else {

406 pmv[1] = &motion[(x / 8) + 2];

407 pmv[2] = &motion[(x / 8) + 4];

408 }

409

410 result = svq1_decode_motion_vector(bitbuf, &mv, pmv);

411 if (result)

412 return result;

413

414 /* predict and decode motion vector (1) */

415 pmv[0] = &mv;

416 if (y == 0) {

417 pmv[1] =

418 pmv[2] = pmv[0];

419 } else {

420 pmv[1] = &motion[(x / 8) + 3];

421 }

422 result = svq1_decode_motion_vector(bitbuf, &motion[0], pmv);

423 if (result)

424 return result;

425

426 /* predict and decode motion vector (2) */

427 pmv[1] = &motion[0];

428 pmv[2] = &motion[(x / 8) + 1];

429

430 result = svq1_decode_motion_vector(bitbuf, &motion[(x / 8) + 2], pmv);

431 if (result)

432 return result;

433

434 /* predict and decode motion vector (3) */

435 pmv[2] = &motion[(x / 8) + 2];

436 pmv[3] = &motion[(x / 8) + 3];

437

438 result = svq1_decode_motion_vector(bitbuf, pmv[3], pmv);

439 if (result)

440 return result;

441

442 /* form predictions */

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

444 int mvx = pmv[i]->x + (i & 1) * 16;

445 int mvy = pmv[i]->y + (i >> 1) * 16;

446

447 // FIXME: clipping or padding?

448 mvx = av_clip(mvx, -2 * x, 2 * (width - x - 8));

449 mvy = av_clip(mvy, -2 * y, 2 * (height - y - 8));

450

451 src = &previous[(x + (mvx >> 1)) + (y + (mvy >> 1)) * pitch];

452 dst = current;

453

454 hdsp->put_pixels_tab[1][((mvy & 1) << 1) | (mvx & 1)](dst, src, pitch, 8);

455

456 /* select next block */

457 if (i & 1)

458 current += 8 * (pitch - 1);

459 else

460 current += 8;

461 }

462

463 return 0;

464 }

465

466 static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp,

467 GetBitContext *bitbuf,

468 uint8_t *current, uint8_t *previous,

469 ptrdiff_t pitch, svq1_pmv *motion, int x, int y,

470 int width, int height, int buggy)

471 {

472 uint32_t block_type;

473 int result = 0;

474

475 /* get block type */

476 block_type = get_vlc2(bitbuf, svq1_block_type,

477 SVQ1_BLOCK_TYPE_VLC_BITS, 1);

478

479 /* reset motion vectors */

480 if (block_type == SVQ1_BLOCK_SKIP || block_type == SVQ1_BLOCK_INTRA) {

481 motion[0].x =

482 motion[0].y =

483 motion[x / 8 + 2].x =

484 motion[x / 8 + 2].y =

485 motion[x / 8 + 3].x =

486 motion[x / 8 + 3].y = 0;

487 }

488

489 switch (block_type) {

490 case SVQ1_BLOCK_SKIP:

491 svq1_skip_block(current, previous, pitch, x, y);

492 break;

493

494 case SVQ1_BLOCK_INTER:

495 result = svq1_motion_inter_block(hdsp, bitbuf, current, previous,

496 pitch, motion, x, y, width, height);

497

498 if (result != 0) {

499 ff_dlog(avctx, "Error in svq1_motion_inter_block %i\n", result);

500 break;

501 }

502 result = svq1_decode_block_non_intra(bitbuf, current, pitch, buggy);

503 break;

504

505 case SVQ1_BLOCK_INTER_4V:

506 result = svq1_motion_inter_4v_block(hdsp, bitbuf, current, previous,

507 pitch, motion, x, y, width, height);

508

509 if (result != 0) {

510 ff_dlog(avctx, "Error in svq1_motion_inter_4v_block %i\n", result);

511 break;

512 }

513 result = svq1_decode_block_non_intra(bitbuf, current, pitch, buggy);

514 break;

515

516 case SVQ1_BLOCK_INTRA:

517 result = svq1_decode_block_intra(bitbuf, current, pitch);

518 break;

519 }

520

521 return result;

522 }

523

524 static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])

525 {

526 uint8_t seed;

527 int i;

528

529 out[0] = get_bits(bitbuf, 8);

530 seed = string_table[out[0]];

531

532 for (i = 1; i <= out[0]; i++) {

533 out[i] = get_bits(bitbuf, 8) ^ seed;

534 seed = string_table[out[i] ^ seed];

535 }

536 out[i] = 0;

537 }

538

539 static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame, int * buggy)

540 {

541 SVQ1Context *s = avctx->priv_data;

542 GetBitContext *bitbuf = &s->gb;

543 int frame_size_code;

544 int width = s->width;

545 int height = s->height;

546 int tempref;

547

548 tempref = get_bits(bitbuf, 8); /* temporal_reference */

549 *buggy = tempref == 0 && s->last_tempref == 0 && avctx->extradata_size == 0;

550 s->last_tempref = tempref;

551

552 /* frame type */

553 s->nonref = 0;

554 switch (get_bits(bitbuf, 2)) {

555 case 0:

556 frame->pict_type = AV_PICTURE_TYPE_I;

557 break;

558 case 2:

559 s->nonref = 1;

560 case 1:

561 frame->pict_type = AV_PICTURE_TYPE_P;

562 break;

563 default:

564 av_log(avctx, AV_LOG_ERROR, "Invalid frame type.\n");

565 return AVERROR_INVALIDDATA;

566 }

567

568 if (frame->pict_type == AV_PICTURE_TYPE_I) {

569 /* unknown fields */

570 if (s->frame_code == 0x50 || s->frame_code == 0x60) {

571 int csum = get_bits(bitbuf, 16);

572

573 csum = av_bswap16(av_crc(av_crc_get_table(AV_CRC_16_CCITT), av_bswap16(csum), bitbuf->buffer, bitbuf->size_in_bits >> 3));

574

575 ff_dlog(avctx, "%s checksum (%02x) for packet data\n",

576 (csum == 0) ? "correct" : "incorrect", csum);

577 }

578

579 if ((s->frame_code ^ 0x10) >= 0x50) {

580 uint8_t msg[257];

581

582 svq1_parse_string(bitbuf, msg);

583

584 av_log(avctx, AV_LOG_INFO,

585 "embedded message:\n%s\n", ((char *)msg) + 1);

586 }

587

588 skip_bits(bitbuf, 2);

589 skip_bits(bitbuf, 2);

590 skip_bits1(bitbuf);

591

592 /* load frame size */

593 frame_size_code = get_bits(bitbuf, 3);

594

595 if (frame_size_code == 7) {

596 /* load width, height (12 bits each) */

597 width = get_bits(bitbuf, 12);

598 height = get_bits(bitbuf, 12);

599

600 if (!width || !height)

601 return AVERROR_INVALIDDATA;

602 } else {

603 /* get width, height from table */

604 width = ff_svq1_frame_size_table[frame_size_code][0];

605 height = ff_svq1_frame_size_table[frame_size_code][1];

606 }

607 }

608

609 /* unknown fields */

610 if (get_bits1(bitbuf)) {

611 skip_bits1(bitbuf); /* use packet checksum if (1) */

612 skip_bits1(bitbuf); /* component checksums after image data if (1) */

613

614 if (get_bits(bitbuf, 2) != 0)

615 return AVERROR_INVALIDDATA;

616 }

617

618 if (get_bits1(bitbuf)) {

619 skip_bits1(bitbuf);

620 skip_bits(bitbuf, 4);

621 skip_bits1(bitbuf);

622 skip_bits(bitbuf, 2);

623

624 if (skip_1stop_8data_bits(bitbuf) < 0)

625 return AVERROR_INVALIDDATA;

626 }

627 if (get_bits_left(bitbuf) <= 0)

628 return AVERROR_INVALIDDATA;

629

630 s->width = width;

631 s->height = height;

632 return 0;

633 }

634

635 static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur,

636 int *got_frame, AVPacket *avpkt)

637 {

638 const uint8_t *buf = avpkt->data;

639 int buf_size = avpkt->size;

640 SVQ1Context *s = avctx->priv_data;

641 uint8_t *current;

642 int result, i, x, y, width, height, buggy;

643 int ret;

644

645 /* initialize bit buffer */

646 ret = init_get_bits8(&s->gb, buf, buf_size);

647 if (ret < 0)

648 return ret;

649

650 /* decode frame header */

651 s->frame_code = get_bits(&s->gb, 22);

652

653 if ((s->frame_code & ~0x70) || !(s->frame_code & 0x60))

654 return AVERROR_INVALIDDATA;

655

656 /* swap some header bytes (why?) */

657 if (s->frame_code != 0x20) {

658 uint32_t *src;

659

660 if (buf_size < 9 * 4) {

661 av_log(avctx, AV_LOG_ERROR, "Input packet too small\n");

662 return AVERROR_INVALIDDATA;

663 }

664

665 av_fast_padded_malloc(&s->pkt_swapped,

666 &s->pkt_swapped_allocated,

667 buf_size);

668 if (!s->pkt_swapped)

669 return AVERROR(ENOMEM);

670

671 memcpy(s->pkt_swapped, buf, buf_size);

672 buf = s->pkt_swapped;

673 init_get_bits(&s->gb, buf, buf_size * 8);

674 skip_bits(&s->gb, 22);

675

676 src = (uint32_t *)(s->pkt_swapped + 4);

677

678 for (i = 0; i < 4; i++)

679 src[i] = ((src[i] << 16) | (src[i] >> 16)) ^ src[7 - i];

680 }

681

682 result = svq1_decode_frame_header(avctx, cur, &buggy);

683 if (result != 0) {

684 ff_dlog(avctx, "Error in svq1_decode_frame_header %i\n", result);

685 return result;

686 }

687

688 result = ff_set_dimensions(avctx, s->width, s->height);

689 if (result < 0)

690 return result;

691

692 if ((avctx->skip_frame >= AVDISCARD_NONREF && s->nonref) ||

693 (avctx->skip_frame >= AVDISCARD_NONKEY &&

694 cur->pict_type != AV_PICTURE_TYPE_I) ||

695 avctx->skip_frame >= AVDISCARD_ALL)

696 return buf_size;

697

698 result = ff_get_buffer(avctx, cur, s->nonref ? 0 : AV_GET_BUFFER_FLAG_REF);

699 if (result < 0)

700 return result;

701

702 av_fast_padded_malloc(&s->pmv, &s->pmv_allocated, (FFALIGN(s->width, 16) / 8 + 3) * sizeof(*s->pmv));

703 if (!s->pmv)

704 return AVERROR(ENOMEM);

705

706 /* decode y, u and v components */

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

708 int linesize = cur->linesize[i];

709 if (i == 0) {

710 width = FFALIGN(s->width, 16);

711 height = FFALIGN(s->height, 16);

712 } else {

713 if (avctx->flags & AV_CODEC_FLAG_GRAY)

714 break;

715 width = FFALIGN(s->width / 4, 16);

716 height = FFALIGN(s->height / 4, 16);

717 }

718

719 current = cur->data[i];

720

721 if (cur->pict_type == AV_PICTURE_TYPE_I) {

722 /* keyframe */

723 for (y = 0; y < height; y += 16) {

724 for (x = 0; x < width; x += 16) {

725 result = svq1_decode_block_intra(&s->gb, &current[x],

726 linesize);

727 if (result) {

728 av_log(avctx, AV_LOG_ERROR,

729 "Error in svq1_decode_block %i (keyframe)\n",

730 result);

731 return result;

732 }

733 }

734 current += 16 * linesize;

735 }

736 } else {

737 /* delta frame */

738 uint8_t *previous = s->prev->data[i];

739 if (!previous ||

740 s->prev->width != s->width || s->prev->height != s->height) {

741 av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");

742 return AVERROR_INVALIDDATA;

743 }

744

745 memset(s->pmv, 0, ((width / 8) + 3) * sizeof(svq1_pmv));

746

747 for (y = 0; y < height; y += 16) {

748 for (x = 0; x < width; x += 16) {

749 result = svq1_decode_delta_block(avctx, &s->hdsp,

750 &s->gb, &current[x],

751 previous, linesize,

752 s->pmv, x, y, width, height, buggy);

753 if (result != 0) {

754 ff_dlog(avctx,

755 "Error in svq1_decode_delta_block %i\n",

756 result);

757 return result;

758 }

759 }

760

761 s->pmv[0].x =

762 s->pmv[0].y = 0;

763

764 current += 16 * linesize;

765 }

766 }

767 }

768

769 if (!s->nonref) {

770 result = av_frame_replace(s->prev, cur);

771 if (result < 0)

772 return result;

773 }

774

775 *got_frame = 1;

776 result = buf_size;

777

778 return result;

779 }

780

781 static av_cold void svq1_static_init(void)

782 {

783 static VLCElem table[196];

784 VLCInitState state = VLC_INIT_STATE(table);

785

786 VLC_INIT_STATIC_TABLE(svq1_block_type, SVQ1_BLOCK_TYPE_VLC_BITS, 4,

787 &ff_svq1_block_type_vlc[0][1], 2, 1,

788 &ff_svq1_block_type_vlc[0][0], 2, 1, 0);

789

790 VLC_INIT_STATIC_TABLE(svq1_motion_component, 7, 33,

791 &ff_mvtab[0][1], 2, 1,

792 &ff_mvtab[0][0], 2, 1, 0);

793

794 for (int i = 0; i < 6; i++) {

795 svq1_intra_multistage[i] =

796 ff_vlc_init_tables(&state, 4, 8,

797 &ff_svq1_intra_multistage_vlc[i][0][1], 2, 1,

798 &ff_svq1_intra_multistage_vlc[i][0][0], 2, 1, 0);

799 svq1_inter_multistage[i] =

800 ff_vlc_init_tables(&state, 3, 8,

801 &ff_svq1_inter_multistage_vlc[i][0][1], 2, 1,

802 &ff_svq1_inter_multistage_vlc[i][0][0], 2, 1, 0);

803 }

804

805 VLC_INIT_STATIC_TABLE(svq1_intra_mean, 8, 256,

806 &ff_svq1_intra_mean_vlc[0][1], 4, 2,

807 &ff_svq1_intra_mean_vlc[0][0], 4, 2, 0);

808

809 VLC_INIT_STATIC_TABLE(svq1_inter_mean, 9, 512,

810 &ff_svq1_inter_mean_vlc[0][1], 4, 2,

811 &ff_svq1_inter_mean_vlc[0][0], 4, 2, 0);

812 }

813

814 static av_cold int svq1_decode_init(AVCodecContext *avctx)

815 {

816 static AVOnce init_static_once = AV_ONCE_INIT;

817 SVQ1Context *s = avctx->priv_data;

818

819 s->prev = av_frame_alloc();

820 if (!s->prev)

821 return AVERROR(ENOMEM);

822

823 s->width = avctx->width + 3 & ~3;

824 s->height = avctx->height + 3 & ~3;

825 avctx->pix_fmt = AV_PIX_FMT_YUV410P;

826

827 ff_hpeldsp_init(&s->hdsp, avctx->flags);

828

829 ff_thread_once(&init_static_once, svq1_static_init);

830

831 s->last_tempref = 0xFF;

832

833 return 0;

834 }

835

836 static av_cold int svq1_decode_end(AVCodecContext *avctx)

837 {

838 SVQ1Context *s = avctx->priv_data;

839

840 av_frame_free(&s->prev);

841 av_freep(&s->pkt_swapped);

842 s->pkt_swapped_allocated = 0;

843 av_freep(&s->pmv);

844 s->pmv_allocated = 0;

845

846 return 0;

847 }

848

849 static void svq1_flush(AVCodecContext *avctx)

850 {

851 SVQ1Context *s = avctx->priv_data;

852

853 av_frame_unref(s->prev);

854 }

855

856 const FFCodec ff_svq1_decoder = {

857 .p.name = "svq1",

858 CODEC_LONG_NAME("Sorenson Vector Quantizer 1 / Sorenson Video 1 / SVQ1"),

859 .p.type = AVMEDIA_TYPE_VIDEO,

860 .p.id = AV_CODEC_ID_SVQ1,

861 .priv_data_size = sizeof(SVQ1Context),

862 .init = svq1_decode_init,

863 .close = svq1_decode_end,

864 FF_CODEC_DECODE_CB(svq1_decode_frame),

865 .p.capabilities = AV_CODEC_CAP_DR1,

866 .flush = svq1_flush,

867 };

h263data.h

level

uint8_t level

Definition: svq3.c:205

av_clip

#define av_clip

Definition: common.h:100

svq1_static_init

static av_cold void svq1_static_init(void)

Definition: svq1dec.c:781

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:695

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

out

FILE * out

Definition: movenc.c:55

svq1_block_type

static VLCElem svq1_block_type[8]

Definition: svq1dec.c:49

svq1_decode_block_non_intra

static int svq1_decode_block_non_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch, int buggy)

Definition: svq1dec.c:234

thread.h

ff_svq1_inter_codebooks

const FF_VISIBILITY_PUSH_HIDDEN int8_t *const ff_svq1_inter_codebooks[6]

Definition: svq1_cb.h:776

SVQ1Context::last_tempref

int last_tempref

Definition: svq1dec.c:78

SVQ1Context::height

int height

Definition: svq1dec.c:74

static const int8_t mv[256][2]

Definition: 4xm.c:81

ff_svq1_intra_codebooks

const int8_t *const ff_svq1_intra_codebooks[6]

Definition: svq1_cb.h:1519

GetBitContext::size_in_bits

int size_in_bits

Definition: get_bits.h:111

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:162

svq1_inter_multistage

static const VLCElem * svq1_inter_multistage[6]

Definition: svq1dec.c:52

AVFrame

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

Definition: frame.h:389

AVPacket::data

uint8_t * data

Definition: packet.h:539

table

static const uint16_t table[]

Definition: prosumer.c:203

FFCodec

Definition: codec_internal.h:127

svq1_skip_block

static void svq1_skip_block(uint8_t *current, uint8_t *previous, ptrdiff_t pitch, int x, int y)

Definition: svq1dec.c:329

ff_set_dimensions

int ff_set_dimensions(AVCodecContext *s, int width, int height)

Check that the provided frame dimensions are valid and set them on the codec context.

Definition: utils.c:94

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:514

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:410

ff_svq1_intra_multistage_vlc

const uint8_t ff_svq1_intra_multistage_vlc[6][8][2]

Definition: svq1_vlc.h:33

crc.h

skip_bits

static void skip_bits(GetBitContext *s, int n)

Definition: get_bits.h:381

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:335

ff_svq1_inter_mean_vlc

const uint16_t ff_svq1_inter_mean_vlc[512][2]

Definition: svq1_vlc.h:136

svq1_decode_block_intra

static int svq1_decode_block_intra(GetBitContext *bitbuf, uint8_t *pixels, ptrdiff_t pitch)

Definition: svq1dec.c:167

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

SVQ1_CALC_CODEBOOK_ENTRIES

#define SVQ1_CALC_CODEBOOK_ENTRIES(cbook)

Definition: svq1dec.c:155

AVCodecContext::skip_frame

enum AVDiscard skip_frame

Skip decoding for selected frames.

Definition: avcodec.h:1830

GetBitContext

Definition: get_bits.h:108

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:508

svq1_decode_end

static av_cold int svq1_decode_end(AVCodecContext *avctx)

Definition: svq1dec.c:836

svq1_pmv_s::x

int x

Definition: svq1dec.c:58

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:150

SVQ1_BLOCK_TYPE_VLC_BITS

#define SVQ1_BLOCK_TYPE_VLC_BITS

Definition: svq1dec.c:48

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:205

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:545

SVQ1Context::hdsp

HpelDSPContext hdsp

Definition: svq1dec.c:63

VLCInitState

For static VLCs, the number of bits can often be hardcoded at each get_vlc2() callsite.

Definition: vlc.h:212

svq1_decode_frame

static int svq1_decode_frame(AVCodecContext *avctx, AVFrame *cur, int *got_frame, AVPacket *avpkt)

Definition: svq1dec.c:635

SVQ1Context::gb

GetBitContext gb

Definition: svq1dec.c:64

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:530

svq1_inter_mean

static VLCElem svq1_inter_mean[1434]

Definition: svq1dec.c:54

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:311

#define s(width, name)

Definition: cbs_vp9.c:198

AV_GET_BUFFER_FLAG_REF

#define AV_GET_BUFFER_FLAG_REF

The decoder will keep a reference to the frame and may reuse it later.

Definition: avcodec.h:431

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

decode.h

get_bits.h

SVQ1Context

Definition: svq1dec.c:62

SVQ1Context::pmv

svq1_pmv * pmv

Definition: svq1dec.c:70

svq1_motion_inter_block

static int svq1_motion_inter_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)

Definition: svq1dec.c:346

SVQ1Context::frame_code

int frame_code

Definition: svq1dec.c:75

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:296

ff_hpeldsp_init

av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)

Definition: hpeldsp.c:338

SVQ1_ADD_CODEBOOK

#define SVQ1_ADD_CODEBOOK()

Definition: svq1dec.c:132

AVDISCARD_ALL

@ AVDISCARD_ALL

discard all

Definition: defs.h:221

GetBitContext::buffer

const uint8_t * buffer

Definition: get_bits.h:109

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

result

and forward the result(frame or status change) to the corresponding input. If nothing is possible

NULL

#define NULL

Definition: coverity.c:32

SVQ1_BLOCK_INTRA

#define SVQ1_BLOCK_INTRA

Definition: svq1.h:45

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:279

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:388

mathops.h

list

Definition: filter_design.txt:25

SVQ1_BLOCK_SKIP

#define SVQ1_BLOCK_SKIP

Definition: svq1.h:42

seed

static unsigned int seed

Definition: videogen.c:78

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:652

AVOnce

#define AVOnce

Definition: thread.h:202

ff_dlog

#define ff_dlog(a,...)

Definition: tableprint_vlc.h:28

HpelDSPContext

Half-pel DSP context.

Definition: hpeldsp.h:45

AVDISCARD_NONKEY

@ AVDISCARD_NONKEY

discard all frames except keyframes

Definition: defs.h:220

HpelDSPContext::put_pixels_tab

op_pixels_func put_pixels_tab[4][4]

Halfpel motion compensation with rounding (a+b+1)>>1.

Definition: hpeldsp.h:56

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1719

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:491

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

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

AV_CODEC_FLAG_GRAY

#define AV_CODEC_FLAG_GRAY

Only decode/encode grayscale.

Definition: avcodec.h:322

AVPacket::size

int size

Definition: packet.h:540

height

#define height

Definition: dsp.h:85

codec_internal.h

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:83

VLCElem

Definition: vlc.h:32

SVQ1_BLOCK_INTER_4V

#define SVQ1_BLOCK_INTER_4V

Definition: svq1.h:44

svq1_flush

static void svq1_flush(AVCodecContext *avctx)

Definition: svq1dec.c:849

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:164

av_crc_get_table

const AVCRC * av_crc_get_table(AVCRCId crc_id)

Get an initialized standard CRC table.

Definition: crc.c:374

skip_bits1

static void skip_bits1(GetBitContext *s)

Definition: get_bits.h:413

AV_CODEC_ID_SVQ1

@ AV_CODEC_ID_SVQ1

Definition: codec_id.h:74

AV_LOG_INFO

#define AV_LOG_INFO

Standard information.

Definition: log.h:191

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

Definition: cbs_h2645.c:256

AV_CRC_16_CCITT

@ AV_CRC_16_CCITT

Definition: crc.h:51

string_table

static const uint8_t string_table[256]

Definition: svq1dec.c:81

av_fast_padded_malloc

void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)

Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...

Definition: utils.c:52

svq1_decode_frame_header

static int svq1_decode_frame_header(AVCodecContext *avctx, AVFrame *frame, int *buggy)

Definition: svq1dec.c:539

SVQ1_PROCESS_VECTOR

#define SVQ1_PROCESS_VECTOR()

Definition: svq1dec.c:116

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:610

SVQ1Context::nonref

int nonref

Definition: svq1dec.c:76

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

AVCodecContext::height

int height

Definition: avcodec.h:624

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:663

SVQ1_BLOCK_INTER

#define SVQ1_BLOCK_INTER

Definition: svq1.h:43

avcodec.h

svq1_parse_string

static void svq1_parse_string(GetBitContext *bitbuf, uint8_t out[257])

Definition: svq1dec.c:524

svq1_intra_mean

static VLCElem svq1_intra_mean[632]

Definition: svq1dec.c:53

ff_svq1_inter_multistage_vlc

const uint8_t ff_svq1_inter_multistage_vlc[6][8][2]

Definition: svq1_vlc.h:50

mid_pred

#define mid_pred

Definition: mathops.h:96

SVQ1Context::prev

AVFrame * prev

Definition: svq1dec.c:65

ret

Definition: filter_design.txt:187

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

svq1_decode_delta_block

static int svq1_decode_delta_block(AVCodecContext *avctx, HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height, int buggy)

Definition: svq1dec.c:466

ff_mvtab

const uint8_t ff_mvtab[33][2]

Definition: h263data.c:88

av_frame_replace

int av_frame_replace(AVFrame *dst, const AVFrame *src)

Ensure the destination frame refers to the same data described by the source frame,...

Definition: frame.c:487

skip_1stop_8data_bits

static int skip_1stop_8data_bits(GetBitContext *gb)

Definition: get_bits.h:700

AVCodecContext

main external API structure.

Definition: avcodec.h:451

svq1_decode_motion_vector

static int svq1_decode_motion_vector(GetBitContext *bitbuf, svq1_pmv *mv, svq1_pmv **pmv)

Definition: svq1dec.c:303

ff_svq1_block_type_vlc

const uint8_t ff_svq1_block_type_vlc[4][2]

Definition: svq1_vlc.h:27

ff_svq1_intra_mean_vlc

const uint16_t ff_svq1_intra_mean_vlc[256][2]

Definition: svq1_vlc.h:67

av_crc

uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)

Calculate the CRC of a block.

Definition: crc.c:392

VLC_INIT_STATIC_TABLE

#define VLC_INIT_STATIC_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)

Definition: vlc.h:270

SVQ1Context::width

int width

Definition: svq1dec.c:73

SVQ1Context::pkt_swapped_allocated

int pkt_swapped_allocated

Definition: svq1dec.c:68

svq1.h

sign_extend

static av_const int sign_extend(int val, unsigned bits)

Definition: mathops.h:131

mean

static float mean(const float *input, int size)

Definition: vf_nnedi.c:866

svq1_decode_init

static av_cold int svq1_decode_init(AVCodecContext *avctx)

Definition: svq1dec.c:814

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:280

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:201

ff_vlc_init_tables

static const VLCElem * ff_vlc_init_tables(VLCInitState *state, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, int flags)

Definition: vlc.h:246

mem.h

SVQ1Context::pmv_allocated

int pmv_allocated

Definition: svq1dec.c:71

svq1_motion_component

static VLCElem svq1_motion_component[176]

Definition: svq1dec.c:50

SVQ1Context::pkt_swapped

uint8_t * pkt_swapped

Definition: svq1dec.c:67

FFALIGN

#define FFALIGN(x, a)

Definition: macros.h:78

state

static struct @454 state

VLC_INIT_STATE

#define VLC_INIT_STATE(_table)

Definition: vlc.h:217

AVPacket

This structure stores compressed data.

Definition: packet.h:516

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:478

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:34

svq1_motion_inter_4v_block

static int svq1_motion_inter_4v_block(HpelDSPContext *hdsp, GetBitContext *bitbuf, uint8_t *current, uint8_t *previous, ptrdiff_t pitch, svq1_pmv *motion, int x, int y, int width, int height)

Definition: svq1dec.c:389

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:624

hpeldsp.h

AVFrame::linesize

int linesize[AV_NUM_DATA_POINTERS]

For video, a positive or negative value, which is typically indicating the size in bytes of each pict...

Definition: frame.h:434

AV_PIX_FMT_YUV410P

@ AV_PIX_FMT_YUV410P