FFmpeg: libavcodec/escape124.c Source File

FFmpeg

[フレーム]

libavcodec

escape124.c

Go to the documentation of this file.

1 /*

2 * Escape 124 Video Decoder

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 #define BITSTREAM_READER_LE

23 #include "libavutil/mem.h"

24 #include "avcodec.h"

25 #include "codec_internal.h"

26 #include "decode.h"

27 #include "get_bits.h"

29 typedef union MacroBlock {

30 uint16_t pixels[4];

31 uint32_t pixels32[2];

32 } MacroBlock;

34 typedef union SuperBlock {

35 uint16_t pixels[64];

36 uint32_t pixels32[32];

37 } SuperBlock;

39 typedef struct CodeBook {

40 unsigned depth;

41 unsigned size;

42 MacroBlock* blocks;

43 } CodeBook;

45 typedef struct Escape124Context {

46 AVFrame *frame;

48 unsigned num_superblocks;

50 CodeBook codebooks[3];

51 } Escape124Context;

53 /**

54 * Initialize the decoder

55 * @param avctx decoder context

56 * @return 0 success, negative on error

57 */

58 static av_cold int escape124_decode_init(AVCodecContext *avctx)

59 {

60 Escape124Context *s = avctx->priv_data;

62 avctx->pix_fmt = AV_PIX_FMT_RGB555;

64 s->num_superblocks = ((unsigned)avctx->width / 8) *

65 ((unsigned)avctx->height / 8);

67 s->frame = av_frame_alloc();

68 if (!s->frame)

69 return AVERROR(ENOMEM);

71 return 0;

72 }

74 static av_cold int escape124_decode_close(AVCodecContext *avctx)

75 {

76 unsigned i;

77 Escape124Context *s = avctx->priv_data;

79 for (i = 0; i < 3; i++)

80 av_freep(&s->codebooks[i].blocks);

82 av_frame_free(&s->frame);

84 return 0;

85 }

87 static CodeBook unpack_codebook(GetBitContext* gb, unsigned depth,

88 unsigned size)

89 {

90 unsigned i, j;

91 CodeBook cb = { 0 };

93 cb.blocks = av_malloc(size ? size * sizeof(MacroBlock) : 1);

94 if (!cb.blocks)

95 return cb;

97 cb.depth = depth;

98 cb.size = size;

99 for (i = 0; i < size; i++) {

100 unsigned mask_bits = get_bits(gb, 4);

101 unsigned color[2];

102 color[0] = get_bits(gb, 15);

103 color[1] = get_bits(gb, 15);

104

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

106 cb.blocks[i].pixels[j] = color[(mask_bits>>j) & 1];

107 }

108 return cb;

109 }

110

111 static unsigned decode_skip_count(GetBitContext* gb)

112 {

113 unsigned value;

114 // This function reads a maximum of 23 bits,

115 // which is within the padding space

116 if (get_bits_left(gb) < 1)

117 return -1;

118 value = get_bits1(gb);

119 if (!value)

120 return value;

121

122 value += get_bits(gb, 3);

123 if (value != (1 + ((1 << 3) - 1)))

124 return value;

125

126 value += get_bits(gb, 7);

127 if (value != (1 + ((1 << 3) - 1)) + ((1 << 7) - 1))

128 return value;

129

130 return value + get_bits(gb, 12);

131 }

132

133 static MacroBlock decode_macroblock(Escape124Context* s, GetBitContext* gb,

134 int* codebook_index, int superblock_index)

135 {

136 // This function reads a maximum of 22 bits; the callers

137 // guard this function appropriately

138 unsigned block_index, depth;

139 int value = get_bits1(gb);

140 if (value) {

141 static const int8_t transitions[3][2] = { {2, 1}, {0, 2}, {1, 0} };

142 value = get_bits1(gb);

143 *codebook_index = transitions[*codebook_index][value];

144 }

145

146 depth = s->codebooks[*codebook_index].depth;

147

148 // depth = 0 means that this shouldn't read any bits;

149 // in theory, this is the same as get_bits(gb, 0), but

150 // that doesn't actually work.

151 block_index = get_bitsz(gb, depth);

152

153 if (*codebook_index == 1) {

154 block_index += superblock_index << s->codebooks[1].depth;

155 }

156

157 // This condition can occur with invalid bitstreams and

158 // *codebook_index == 2

159 if (block_index >= s->codebooks[*codebook_index].size || !s->codebooks[*codebook_index].blocks)

160 return (MacroBlock) { { 0 } };

161

162 return s->codebooks[*codebook_index].blocks[block_index];

163 }

164

165 static void insert_mb_into_sb(SuperBlock* sb, MacroBlock mb, unsigned index) {

166 // Formula: ((index / 4) * 16 + (index % 4) * 2) / 2

167 uint32_t *dst = sb->pixels32 + index + (index & -4);

168

169 // This technically violates C99 aliasing rules, but it should be safe.

170 dst[0] = mb.pixels32[0];

171 dst[4] = mb.pixels32[1];

172 }

173

174 static void copy_superblock(uint16_t* dest, ptrdiff_t dest_stride,

175 uint16_t* src, ptrdiff_t src_stride)

176 {

177 unsigned y;

178 if (src)

179 for (y = 0; y < 8; y++)

180 memcpy(dest + y * dest_stride, src + y * src_stride,

181 sizeof(uint16_t) * 8);

182 else

183 for (y = 0; y < 8; y++)

184 memset(dest + y * dest_stride, 0, sizeof(uint16_t) * 8);

185 }

186

187 static const uint16_t mask_matrix[] = {0x1, 0x2, 0x10, 0x20,

188 0x4, 0x8, 0x40, 0x80,

189 0x100, 0x200, 0x1000, 0x2000,

190 0x400, 0x800, 0x4000, 0x8000};

191

192 static int escape124_decode_frame(AVCodecContext *avctx, AVFrame *frame,

193 int *got_frame, AVPacket *avpkt)

194 {

195 int buf_size = avpkt->size;

196 Escape124Context *s = avctx->priv_data;

197

198 GetBitContext gb;

199 unsigned frame_flags, frame_size;

200 unsigned i;

201

202 unsigned superblock_index, cb_index = 1,

203 superblock_col_index = 0,

204 superblocks_per_row = avctx->width / 8, skip = -1;

205

206 uint16_t* old_frame_data, *new_frame_data;

207 ptrdiff_t old_stride, new_stride;

208

209 int ret;

210

211 if ((ret = init_get_bits8(&gb, avpkt->data, avpkt->size)) < 0)

212 return ret;

213

214 // This call also guards the potential depth reads for the

215 // codebook unpacking.

216 // Check if the amount we will read minimally is available on input.

217 // The 64 represent the immediately next 2 frame_* elements read, the 23/4320

218 // represent a lower bound of the space needed for skipped superblocks. Non

219 // skipped SBs need more space.

220 if (get_bits_left(&gb) < 64 + s->num_superblocks * 23LL / 4320)

221 return AVERROR_INVALIDDATA;

222

223 frame_flags = get_bits_long(&gb, 32);

224 frame_size = get_bits_long(&gb, 32);

225

226 // Leave last frame unchanged

227 // FIXME: Is this necessary? I haven't seen it in any real samples

228 if (!(frame_flags & 0x114) || !(frame_flags & 0x7800000)) {

229 if (!s->frame->data[0])

230 return AVERROR_INVALIDDATA;

231

232 av_log(avctx, AV_LOG_DEBUG, "Skipping frame\n");

233

234 *got_frame = 1;

235 if ((ret = av_frame_ref(frame, s->frame)) < 0)

236 return ret;

237

238 return 0;

239 }

240

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

242 if (frame_flags & (1 << (17 + i))) {

243 unsigned cb_depth, cb_size;

244 if (i == 2) {

245 // This codebook can be cut off at places other than

246 // powers of 2, leaving some of the entries undefined.

247 cb_size = get_bits(&gb, 20);

248 if (!cb_size) {

249 av_log(avctx, AV_LOG_ERROR, "Invalid codebook size 0.\n");

250 return AVERROR_INVALIDDATA;

251 }

252 cb_depth = av_log2(cb_size - 1) + 1;

253 } else {

254 cb_depth = get_bits(&gb, 4);

255 if (i == 0) {

256 // This is the most basic codebook: pow(2,depth) entries

257 // for a depth-length key

258 cb_size = 1 << cb_depth;

259 } else {

260 // This codebook varies per superblock

261 // FIXME: I don't think this handles integer overflow

262 // properly

263 cb_size = s->num_superblocks << cb_depth;

264 }

265 }

266 if (s->num_superblocks >= INT_MAX >> cb_depth) {

267 av_log(avctx, AV_LOG_ERROR, "Depth or num_superblocks are too large\n");

268 return AVERROR_INVALIDDATA;

269 }

270

271 av_freep(&s->codebooks[i].blocks);

272 if (cb_size >= INT_MAX / 34 || get_bits_left(&gb) < (int)cb_size * 34)

273 return AVERROR_INVALIDDATA;

274

275 if (cb_size >= INT_MAX / sizeof(MacroBlock))

276 return AVERROR_INVALIDDATA;

277 s->codebooks[i] = unpack_codebook(&gb, cb_depth, cb_size);

278 if (!s->codebooks[i].blocks)

279 return AVERROR(ENOMEM);

280 }

281 }

282

283 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)

284 return ret;

285

286 new_frame_data = (uint16_t*)frame->data[0];

287 new_stride = frame->linesize[0] / 2;

288 old_frame_data = (uint16_t*)s->frame->data[0];

289 old_stride = s->frame->linesize[0] / 2;

290

291 for (superblock_index = 0; superblock_index < s->num_superblocks;

292 superblock_index++) {

293 MacroBlock mb;

294 SuperBlock sb;

295 unsigned multi_mask = 0;

296

297 if (skip == -1) {

298 // Note that this call will make us skip the rest of the blocks

299 // if the frame prematurely ends

300 skip = decode_skip_count(&gb);

301 }

302

303 if (skip) {

304 copy_superblock(new_frame_data, new_stride,

305 old_frame_data, old_stride);

306 } else {

307 copy_superblock(sb.pixels, 8,

308 old_frame_data, old_stride);

309

310 while (get_bits_left(&gb) >= 1 && !get_bits1(&gb)) {

311 unsigned mask;

312 mb = decode_macroblock(s, &gb, &cb_index, superblock_index);

313 mask = get_bits(&gb, 16);

314 multi_mask |= mask;

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

316 if (mask & mask_matrix[i]) {

317 insert_mb_into_sb(&sb, mb, i);

318 }

319 }

320 }

321

322 if (!get_bits1(&gb)) {

323 unsigned inv_mask = get_bits(&gb, 4);

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

325 if (inv_mask & (1 << i)) {

326 multi_mask ^= 0xF << i*4;

327 } else {

328 multi_mask ^= get_bits(&gb, 4) << i*4;

329 }

330 }

331

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

333 if (multi_mask & mask_matrix[i]) {

334 mb = decode_macroblock(s, &gb, &cb_index,

335 superblock_index);

336 insert_mb_into_sb(&sb, mb, i);

337 }

338 }

339 } else if (frame_flags & (1 << 16)) {

340 while (get_bits_left(&gb) >= 1 && !get_bits1(&gb)) {

341 mb = decode_macroblock(s, &gb, &cb_index, superblock_index);

342 insert_mb_into_sb(&sb, mb, get_bits(&gb, 4));

343 }

344 }

345

346 copy_superblock(new_frame_data, new_stride, sb.pixels, 8);

347 }

348

349 superblock_col_index++;

350 new_frame_data += 8;

351 if (old_frame_data)

352 old_frame_data += 8;

353 if (superblock_col_index == superblocks_per_row) {

354 new_frame_data += new_stride * 8 - superblocks_per_row * 8;

355 if (old_frame_data)

356 old_frame_data += old_stride * 8 - superblocks_per_row * 8;

357 superblock_col_index = 0;

358 }

359 skip--;

360 }

361

362 av_log(avctx, AV_LOG_DEBUG,

363 "Escape sizes: %i, %i, %i\n",

364 frame_size, buf_size, get_bits_count(&gb) / 8);

365

366 if ((ret = av_frame_replace(s->frame, frame)) < 0)

367 return ret;

368

369 *got_frame = 1;

370

371 return 0;

372 }

373

374

375 const FFCodec ff_escape124_decoder = {

376 .p.name = "escape124",

377 CODEC_LONG_NAME("Escape 124"),

378 .p.type = AVMEDIA_TYPE_VIDEO,

379 .p.id = AV_CODEC_ID_ESCAPE124,

380 .priv_data_size = sizeof(Escape124Context),

381 .init = escape124_decode_init,

382 .close = escape124_decode_close,

383 FF_CODEC_DECODE_CB(escape124_decode_frame),

384 .p.capabilities = AV_CODEC_CAP_DR1,

385 };

copy_superblock

static void copy_superblock(uint16_t *dest, ptrdiff_t dest_stride, uint16_t *src, ptrdiff_t src_stride)

Definition: escape124.c:174

insert_mb_into_sb

static void insert_mb_into_sb(SuperBlock *sb, MacroBlock mb, unsigned index)

Definition: escape124.c:165

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:689

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

mask_matrix

static const uint16_t mask_matrix[]

Definition: escape124.c:187

color

Definition: vf_paletteuse.c:513

static double cb(void *priv, double x, double y)

Definition: vf_geq.c:247

get_bits_long

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

Read 0-32 bits.

Definition: get_bits.h:419

MacroBlock::pixels32

uint32_t pixels32[2]

Definition: escape124.c:31

get_bits_count

static int get_bits_count(const GetBitContext *s)

Definition: get_bits.h:250

mask

int mask

Definition: mediacodecdec_common.c:154

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

AVFrame

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

Definition: frame.h:427

AVPacket::data

uint8_t * data

Definition: packet.h:558

MacroBlock

Definition: escape124.c:29

FFCodec

Definition: codec_internal.h:127

SuperBlock::pixels

uint16_t pixels[64]

Definition: escape124.c:35

decode_macroblock

static MacroBlock decode_macroblock(Escape124Context *s, GetBitContext *gb, int *codebook_index, int superblock_index)

Definition: escape124.c:133

Escape124Context

Definition: escape124.c:45

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:31

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:135

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:333

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

SuperBlock::pixels32

uint32_t pixels32[32]

Definition: escape124.c:36

GetBitContext

Definition: get_bits.h:109

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:52

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

init_get_bits8

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

Initialize GetBitContext.

Definition: get_bits.h:539

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:346

MacroBlock::pixels

uint16_t pixels[4]

Definition: escape124.c:30

#define s(width, name)

Definition: cbs_vp9.c:198

Escape124Context::codebooks

CodeBook codebooks[3]

Definition: escape124.c:50

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

frame_size

int frame_size

Definition: mxfenc.c:2474

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

decode.h

get_bits.h

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

Escape124Context::frame

AVFrame * frame

Definition: escape124.c:46

escape124_decode_frame

static int escape124_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)

Definition: escape124.c:192

CodeBook::size

unsigned size

Definition: escape124.c:41

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:386

index

int index

Definition: gxfenc.c:90

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1720

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

ff_escape124_decoder

const FFCodec ff_escape124_decoder

Definition: escape124.c:375

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

AVPacket::size

int size

Definition: packet.h:559

av_frame_ref

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

Set up a new reference to the data described by the source frame.

Definition: frame.c:278

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

size

int size

Definition: twinvq_data.h:10344

#define mb

Definition: vf_colormatrix.c:99

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

Definition: cbs_h2645.c:256

unpack_codebook

static CodeBook unpack_codebook(GetBitContext *gb, unsigned depth, unsigned size)

Definition: escape124.c:87

escape124_decode_close

static av_cold int escape124_decode_close(AVCodecContext *avctx)

Definition: escape124.c:74

SuperBlock

Definition: escape124.c:34

AV_PIX_FMT_RGB555

#define AV_PIX_FMT_RGB555

Definition: pixfmt.h:527

value

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value

Definition: writing_filters.txt:86

CodeBook::depth

unsigned depth

Definition: escape124.c:40

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

AVCodecContext::height

int height

Definition: avcodec.h:592

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:631

avcodec.h

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

AV_CODEC_ID_ESCAPE124

@ AV_CODEC_ID_ESCAPE124

Definition: codec_id.h:167

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

AVCodecContext

main external API structure.

Definition: avcodec.h:431

CodeBook::blocks