FFmpeg: libavcodec/golomb.h Source File

FFmpeg

[フレーム]

libavcodec

golomb.h

Go to the documentation of this file.

1 /*

2 * exp golomb vlc stuff

5 *

6 * This file is part of FFmpeg.

7 *

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

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

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

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

12 *

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

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

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

16 * Lesser General Public License for more details.

17 *

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

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

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

21 */

23 /**

24 * @file

25 * @brief

26 * exp golomb vlc stuff

27 * @author Michael Niedermayer <michaelni@gmx.at> and Alex Beregszaszi

28 */

30 #ifndef AVCODEC_GOLOMB_H

31 #define AVCODEC_GOLOMB_H

33 #include <stdint.h>

35 #include "get_bits.h"

36 #include "put_bits.h"

38 #define INVALID_VLC 0x80000000

40 extern const uint8_t ff_golomb_vlc_len[512];

41 extern const uint8_t ff_ue_golomb_vlc_code[512];

42 extern const int8_t ff_se_golomb_vlc_code[512];

43 extern const uint8_t ff_ue_golomb_len[256];

45 extern const uint8_t ff_interleaved_golomb_vlc_len[256];

46 extern const uint8_t ff_interleaved_ue_golomb_vlc_code[256];

47 extern const int8_t ff_interleaved_se_golomb_vlc_code[256];

48 extern const uint8_t ff_interleaved_dirac_golomb_vlc_code[256];

50 /**

51 * read unsigned exp golomb code.

52 */

53 static inline int get_ue_golomb(GetBitContext *gb)

54 {

55 unsigned int buf;

57 OPEN_READER(re, gb);

58 UPDATE_CACHE(re, gb);

59 buf = GET_CACHE(re, gb);

61 if (buf >= (1 << 27)) {

62 buf >>= 32 - 9;

63 LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);

64 CLOSE_READER(re, gb);

66 return ff_ue_golomb_vlc_code[buf];

67 } else {

68 int log = 2 * av_log2(buf) - 31;

69 LAST_SKIP_BITS(re, gb, 32 - log);

70 CLOSE_READER(re, gb);

71 if (CONFIG_FTRAPV && log < 0) {

72 av_log(NULL, AV_LOG_ERROR, "Invalid UE golomb code\n");

73 return AVERROR_INVALIDDATA;

74 }

75 buf >>= log;

76 buf--;

78 return buf;

79 }

80 }

82 /**

83 * Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.

84 */

85 static inline unsigned get_ue_golomb_long(GetBitContext *gb)

86 {

87 unsigned buf, log;

89 buf = show_bits_long(gb, 32);

90 log = 31 - av_log2(buf);

91 skip_bits_long(gb, log);

93 return get_bits_long(gb, log + 1) - 1;

94 }

96 /**

97 * read unsigned exp golomb code, constraint to a max of 31.

98 * the return value is undefined if the stored value exceeds 31.

99 */

100 static inline int get_ue_golomb_31(GetBitContext *gb)

101 {

102 unsigned int buf;

103

104 OPEN_READER(re, gb);

105 UPDATE_CACHE(re, gb);

106 buf = GET_CACHE(re, gb);

107

108 buf >>= 32 - 9;

109 LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);

110 CLOSE_READER(re, gb);

111

112 return ff_ue_golomb_vlc_code[buf];

113 }

114

115 static inline unsigned svq3_get_ue_golomb(GetBitContext *gb)

116 {

117 uint32_t buf;

118

119 OPEN_READER(re, gb);

120 UPDATE_CACHE(re, gb);

121 buf = GET_CACHE(re, gb);

122

123 if (buf & 0xAA800000) {

124 buf >>= 32 - 8;

125 LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);

126 CLOSE_READER(re, gb);

127

128 return ff_interleaved_ue_golomb_vlc_code[buf];

129 } else {

130 unsigned ret = 1;

131

132 do {

133 buf >>= 32 - 8;

134 LAST_SKIP_BITS(re, gb,

135 FFMIN(ff_interleaved_golomb_vlc_len[buf], 8));

136

137 if (ff_interleaved_golomb_vlc_len[buf] != 9) {

138 ret <<= (ff_interleaved_golomb_vlc_len[buf] - 1) >> 1;

139 ret |= ff_interleaved_dirac_golomb_vlc_code[buf];

140 break;

141 }

142 ret = (ret << 4) | ff_interleaved_dirac_golomb_vlc_code[buf];

143 UPDATE_CACHE(re, gb);

144 buf = GET_CACHE(re, gb);

145 } while (ret<0x8000000U && BITS_AVAILABLE(re, gb));

146

147 CLOSE_READER(re, gb);

148 return ret - 1;

149 }

150 }

151

152 /**

153 * read unsigned truncated exp golomb code.

154 */

155 static inline int get_te0_golomb(GetBitContext *gb, int range)

156 {

157 av_assert2(range >= 1);

158

159 if (range == 1)

160 return 0;

161 else if (range == 2)

162 return get_bits1(gb) ^ 1;

163 else

164 return get_ue_golomb(gb);

165 }

166

167 /**

168 * read unsigned truncated exp golomb code.

169 */

170 static inline int get_te_golomb(GetBitContext *gb, int range)

171 {

172 av_assert2(range >= 1);

173

174 if (range == 2)

175 return get_bits1(gb) ^ 1;

176 else

177 return get_ue_golomb(gb);

178 }

179

180 /**

181 * read signed exp golomb code.

182 */

183 static inline int get_se_golomb(GetBitContext *gb)

184 {

185 unsigned int buf;

186

187 OPEN_READER(re, gb);

188 UPDATE_CACHE(re, gb);

189 buf = GET_CACHE(re, gb);

190

191 if (buf >= (1 << 27)) {

192 buf >>= 32 - 9;

193 LAST_SKIP_BITS(re, gb, ff_golomb_vlc_len[buf]);

194 CLOSE_READER(re, gb);

195

196 return ff_se_golomb_vlc_code[buf];

197 } else {

198 int log = av_log2(buf), sign;

199 LAST_SKIP_BITS(re, gb, 31 - log);

200 UPDATE_CACHE(re, gb);

201 buf = GET_CACHE(re, gb);

202

203 buf >>= log;

204

205 LAST_SKIP_BITS(re, gb, 32 - log);

206 CLOSE_READER(re, gb);

207

208 sign = -(buf & 1);

209 buf = ((buf >> 1) ^ sign) - sign;

210

211 return buf;

212 }

213 }

214

215 static inline int get_se_golomb_long(GetBitContext *gb)

216 {

217 unsigned int buf = get_ue_golomb_long(gb);

218 int sign;

219

220 sign = (buf & 1) - 1;

221 return ((buf >> 1) ^ sign) + 1;

222 }

223

224 static inline int svq3_get_se_golomb(GetBitContext *gb)

225 {

226 unsigned int buf;

227

228 OPEN_READER(re, gb);

229 UPDATE_CACHE(re, gb);

230 buf = GET_CACHE(re, gb);

231

232 if (buf & 0xAA800000) {

233 buf >>= 32 - 8;

234 LAST_SKIP_BITS(re, gb, ff_interleaved_golomb_vlc_len[buf]);

235 CLOSE_READER(re, gb);

236

237 return ff_interleaved_se_golomb_vlc_code[buf];

238 } else {

239 int log;

240 LAST_SKIP_BITS(re, gb, 8);

241 UPDATE_CACHE(re, gb);

242 buf |= 1 | (GET_CACHE(re, gb) >> 8);

243

244 if ((buf & 0xAAAAAAAA) == 0)

245 return INVALID_VLC;

246

247 for (log = 31; (buf & 0x80000000) == 0; log--)

248 buf = (buf << 2) - ((buf << log) >> (log - 1)) + (buf >> 30);

249

250 LAST_SKIP_BITS(re, gb, 63 - 2 * log - 8);

251 CLOSE_READER(re, gb);

252

253 return (signed) (((((buf << log) >> log) - 1) ^ -(buf & 0x1)) + 1) >> 1;

254 }

255 }

256

257 static inline int dirac_get_se_golomb(GetBitContext *gb)

258 {

259 uint32_t ret = svq3_get_ue_golomb(gb);

260

261 if (ret) {

262 int sign;

263 sign = -get_bits1(gb);

264 ret = (ret ^ sign) - sign;

265 }

266

267 return ret;

268 }

269

270 /**

271 * read unsigned golomb rice code (ffv1).

272 */

273 static inline int get_ur_golomb(GetBitContext *gb, int k, int limit,

274 int esc_len)

275 {

276 unsigned int buf;

277 int log;

278

279 OPEN_READER(re, gb);

280 UPDATE_CACHE(re, gb);

281 buf = GET_CACHE(re, gb);

282

283 log = av_log2(buf);

284

285 if (log > 31 - limit) {

286 buf >>= log - k;

287 buf += (30 - log) << k;

288 LAST_SKIP_BITS(re, gb, 32 + k - log);

289 CLOSE_READER(re, gb);

290

291 return buf;

292 } else {

293 LAST_SKIP_BITS(re, gb, limit);

294 UPDATE_CACHE(re, gb);

295

296 buf = SHOW_UBITS(re, gb, esc_len);

297

298 LAST_SKIP_BITS(re, gb, esc_len);

299 CLOSE_READER(re, gb);

300

301 return buf + limit - 1;

302 }

303 }

304

305 /**

306 * read unsigned golomb rice code (jpegls).

307 */

308 static inline int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit,

309 int esc_len)

310 {

311 unsigned int buf;

312 int log;

313

314 OPEN_READER(re, gb);

315 UPDATE_CACHE(re, gb);

316 buf = GET_CACHE(re, gb);

317

318 log = av_log2(buf);

319

320 if (log - k >= 32 - MIN_CACHE_BITS + (MIN_CACHE_BITS == 32) &&

321 32 - log < limit) {

322 buf >>= log - k;

323 buf += (30 - log) << k;

324 LAST_SKIP_BITS(re, gb, 32 + k - log);

325 CLOSE_READER(re, gb);

326

327 return buf;

328 } else {

329 int i;

330 for (i = 0; i < limit && SHOW_UBITS(re, gb, 1) == 0; i++) {

331 if (gb->size_in_bits <= re_index)

332 return -1;

333 LAST_SKIP_BITS(re, gb, 1);

334 UPDATE_CACHE(re, gb);

335 }

336 SKIP_BITS(re, gb, 1);

337

338 if (i < limit - 1) {

339 if (k) {

340 buf = SHOW_UBITS(re, gb, k);

341 LAST_SKIP_BITS(re, gb, k);

342 } else {

343 buf = 0;

344 }

345

346 CLOSE_READER(re, gb);

347 return buf + (i << k);

348 } else if (i == limit - 1) {

349 buf = SHOW_UBITS(re, gb, esc_len);

350 LAST_SKIP_BITS(re, gb, esc_len);

351 CLOSE_READER(re, gb);

352

353 return buf + 1;

354 } else

355 return -1;

356 }

357 }

358

359 /**

360 * read signed golomb rice code (ffv1).

361 */

362 static inline int get_sr_golomb(GetBitContext *gb, int k, int limit,

363 int esc_len)

364 {

365 int v = get_ur_golomb(gb, k, limit, esc_len);

366 int sign;

367

368 v++;

369 sign = (v & 1) - 1;

370 return ((v >> 1) ^ sign) - sign;

371 }

372

373 /**

374 * read signed golomb rice code (flac).

375 */

376 static inline int get_sr_golomb_flac(GetBitContext *gb, int k, int limit,

377 int esc_len)

378 {

379 int v = get_ur_golomb_jpegls(gb, k, limit, esc_len);

380 return (v >> 1) ^ -(v & 1);

381 }

382

383 /**

384 * read unsigned golomb rice code (shorten).

385 */

386 static inline unsigned int get_ur_golomb_shorten(GetBitContext *gb, int k)

387 {

388 return get_ur_golomb_jpegls(gb, k, INT_MAX, 0);

389 }

390

391 /**

392 * read signed golomb rice code (shorten).

393 */

394 static inline int get_sr_golomb_shorten(GetBitContext *gb, int k)

395 {

396 int uvar = get_ur_golomb_jpegls(gb, k + 1, INT_MAX, 0);

397 return (uvar >> 1) ^ -(uvar & 1);

398 }

399

400 #ifdef TRACE

401

402 static inline int get_ue(GetBitContext *s, const char *file, const char *func,

403 int line)

404 {

405 int show = show_bits(s, 24);

406 int pos = get_bits_count(s);

407 int i = get_ue_golomb(s);

408 int len = get_bits_count(s) - pos;

409 int bits = show >> (24 - len);

410

411 print_bin(bits, len);

412

413 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d ue @%5d in %s %s:%d\n",

414 bits, len, i, pos, file, func, line);

415

416 return i;

417 }

418

419 static inline int get_se(GetBitContext *s, const char *file, const char *func,

420 int line)

421 {

422 int show = show_bits(s, 24);

423 int pos = get_bits_count(s);

424 int i = get_se_golomb(s);

425 int len = get_bits_count(s) - pos;

426 int bits = show >> (24 - len);

427

428 print_bin(bits, len);

429

430 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d se @%5d in %s %s:%d\n",

431 bits, len, i, pos, file, func, line);

432

433 return i;

434 }

435

436 static inline int get_te(GetBitContext *s, int r, char *file, const char *func,

437 int line)

438 {

439 int show = show_bits(s, 24);

440 int pos = get_bits_count(s);

441 int i = get_te0_golomb(s, r);

442 int len = get_bits_count(s) - pos;

443 int bits = show >> (24 - len);

444

445 print_bin(bits, len);

446

447 av_log(NULL, AV_LOG_DEBUG, "%5d %2d %3d te @%5d in %s %s:%d\n",

448 bits, len, i, pos, file, func, line);

449

450 return i;

451 }

452

453 #define get_ue_golomb(a) get_ue(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)

454 #define get_se_golomb(a) get_se(a, __FILE__, __PRETTY_FUNCTION__, __LINE__)

455 #define get_te_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)

456 #define get_te0_golomb(a, r) get_te(a, r, __FILE__, __PRETTY_FUNCTION__, __LINE__)

457

458 #endif /* TRACE */

459

460 /**

461 * write unsigned exp golomb code.

462 */

463 static inline void set_ue_golomb(PutBitContext *pb, int i)

464 {

465 av_assert2(i >= 0);

466

467 #if 0

468 if (i = 0) {

469 put_bits(pb, 1, 1);

470 return;

471 }

472 #endif

473 if (i < 256)

474 put_bits(pb, ff_ue_golomb_len[i], i + 1);

475 else {

476 int e = av_log2(i + 1);

477 put_bits(pb, 2 * e + 1, i + 1);

478 }

479 }

480

481 /**

482 * write truncated unsigned exp golomb code.

483 */

484 static inline void set_te_golomb(PutBitContext *pb, int i, int range)

485 {

486 av_assert2(range >= 1);

487 av_assert2(i <= range);

488

489 if (range == 2)

490 put_bits(pb, 1, i ^ 1);

491 else

492 set_ue_golomb(pb, i);

493 }

494

495 /**

496 * write signed exp golomb code. 16 bits at most.

497 */

498 static inline void set_se_golomb(PutBitContext *pb, int i)

499 {

500 #if 0

501 if (i <= 0)

502 i = -2 * i;

503 else

504 i = 2 * i - 1;

505 #elif 1

506 i = 2 * i - 1;

507 if (i < 0)

508 i ^= -1; //FIXME check if gcc does the right thing

509 #else

510 i = 2 * i - 1;

511 i ^= (i >> 31);

512 #endif

513 set_ue_golomb(pb, i);

514 }

515

516 /**

517 * write unsigned golomb rice code (ffv1).

518 */

519 static inline void set_ur_golomb(PutBitContext *pb, int i, int k, int limit,

520 int esc_len)

521 {

522 int e;

523

524 av_assert2(i >= 0);

525

526 e = i >> k;

527 if (e < limit)

528 put_bits(pb, e + k + 1, (1 << k) + (i & ((1 << k) - 1)));

529 else

530 put_bits(pb, limit + esc_len, i - limit + 1);

531 }

532

533 /**

534 * write unsigned golomb rice code (jpegls).

535 */

536 static inline void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k,

537 int limit, int esc_len)

538 {

539 int e;

540

541 av_assert2(i >= 0);

542

543 e = (i >> k) + 1;

544 if (e < limit) {

545 while (e > 31) {

546 put_bits(pb, 31, 0);

547 e -= 31;

548 }

549 put_bits(pb, e, 1);

550 if (k)

551 put_sbits(pb, k, i);

552 } else {

553 while (limit > 31) {

554 put_bits(pb, 31, 0);

555 limit -= 31;

556 }

557 put_bits(pb, limit, 1);

558 put_bits(pb, esc_len, i - 1);

559 }

560 }

561

562 /**

563 * write signed golomb rice code (ffv1).

564 */

565 static inline void set_sr_golomb(PutBitContext *pb, int i, int k, int limit,

566 int esc_len)

567 {

568 int v;

569

570 v = -2 * i - 1;

571 v ^= (v >> 31);

572

573 set_ur_golomb(pb, v, k, limit, esc_len);

574 }

575

576 /**

577 * write signed golomb rice code (flac).

578 */

579 static inline void set_sr_golomb_flac(PutBitContext *pb, int i, int k,

580 int limit, int esc_len)

581 {

582 int v;

583

584 v = -2 * i - 1;

585 v ^= (v >> 31);

586

587 set_ur_golomb_jpegls(pb, v, k, limit, esc_len);

588 }

589

590 #endif /* AVCODEC_GOLOMB_H */

Generated on Sun Mar 8 2015 02:34:52 for FFmpeg by doxygen 1.8.2