FFmpeg: libavcodec/mimic.c Source File

FFmpeg

[フレーム]

libavcodec

mimic.c

Go to the documentation of this file.

1 /*

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

23 #include <string.h>

24 #include <stdint.h>

26 #include "libavutil/mem_internal.h"

27 #include "libavutil/thread.h"

29 #include "avcodec.h"

30 #include "blockdsp.h"

31 #include "internal.h"

32 #include "get_bits.h"

33 #include "bytestream.h"

34 #include "bswapdsp.h"

35 #include "hpeldsp.h"

36 #include "idctdsp.h"

37 #include "thread.h"

39 #define MIMIC_HEADER_SIZE 20

40 #define MIMIC_VLC_BITS 11

42 typedef struct MimicContext {

43 AVCodecContext *avctx;

45 int num_vblocks[3];

46 int num_hblocks[3];

48 void *swap_buf;

49 int swap_buf_size;

51 int cur_index;

52 int prev_index;

54 ThreadFrame frames [16];

56 DECLARE_ALIGNED(32, int16_t, dct_block)[64];

58 GetBitContext gb;

59 ScanTable scantable;

60 BlockDSPContext bdsp;

61 BswapDSPContext bbdsp;

62 HpelDSPContext hdsp;

63 IDCTDSPContext idsp;

65 /* Kept in the context so multithreading can have a constant to read from */

66 int next_cur_index;

67 int next_prev_index;

68 } MimicContext;

70 static VLC block_vlc;

72 static const uint8_t huffsyms[] = {

73 0x10, 0x20, 0x30, 0x00, 0x11, 0x40, 0x50, 0x12, 0x13, 0x21, 0x31, 0x60,

74 0x14, 0x15, 0x16, 0x22, 0x41, 0x17, 0x18, 0x23, 0x24, 0x25, 0x32, 0x42,

75 0x51, 0x61, 0x70, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x26, 0x27,

76 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x33, 0x34, 0x35, 0x36, 0x37,

77 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x43, 0x44, 0x45, 0x46, 0x47,

78 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x52, 0x53, 0x54, 0x55, 0x56,

79 0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x62, 0x63, 0x64, 0x65,

80 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, 0x73,

81 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,

82 };

84 static const uint8_t huffbits[] = {

85 2, 2, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8,

86 8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12,

87 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17,

88 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21,

89 22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,

90 26, 26, 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30,

91 };

93 static const uint8_t col_zag[64] = {

94 0, 8, 1, 2, 9, 16, 24, 17,

95 10, 3, 4, 11, 18, 25, 32, 40,

96 33, 26, 19, 12, 5, 6, 13, 20,

97 27, 34, 41, 48, 56, 49, 42, 35,

98 28, 21, 14, 7, 15, 22, 29, 36,

99 43, 50, 57, 58, 51, 44, 37, 30,

100 23, 31, 38, 45, 52, 59, 39, 46,

101 53, 60, 61, 54, 47, 55, 62, 63,

102 };

103

104 static av_cold int mimic_decode_end(AVCodecContext *avctx)

105 {

106 MimicContext *ctx = avctx->priv_data;

107 int i;

108

109 av_freep(&ctx->swap_buf);

110 ctx->swap_buf_size = 0;

111

112 for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {

113 if (ctx->frames[i].f)

114 ff_thread_release_buffer(avctx, &ctx->frames[i]);

115 av_frame_free(&ctx->frames[i].f);

116 }

117

118 return 0;

119 }

120

121 static av_cold void mimic_init_static(void)

122 {

123 INIT_VLC_STATIC_FROM_LENGTHS(&block_vlc, MIMIC_VLC_BITS, FF_ARRAY_ELEMS(huffbits),

124 huffbits, 1, huffsyms, 1, 1, 0, 0, 4368);

125 }

126

127 static av_cold int mimic_decode_init(AVCodecContext *avctx)

128 {

129 static AVOnce init_static_once = AV_ONCE_INIT;

130 MimicContext *ctx = avctx->priv_data;

131 int i;

132

133 ctx->prev_index = 0;

134 ctx->cur_index = 15;

135

136 ff_blockdsp_init(&ctx->bdsp, avctx);

137 ff_bswapdsp_init(&ctx->bbdsp);

138 ff_hpeldsp_init(&ctx->hdsp, avctx->flags);

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

140 ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, col_zag);

141

142 for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {

143 ctx->frames[i].f = av_frame_alloc();

144 if (!ctx->frames[i].f)

145 return AVERROR(ENOMEM);

146 }

147

148 ff_thread_once(&init_static_once, mimic_init_static);

149

150 return 0;

151 }

152

153 #if HAVE_THREADS

154 static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)

155 {

156 MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;

157 int i, ret;

158

159 if (avctx == avctx_from)

160 return 0;

161

162 dst->cur_index = src->next_cur_index;

163 dst->prev_index = src->next_prev_index;

164

165 for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {

166 ff_thread_release_buffer(avctx, &dst->frames[i]);

167 if (i != src->next_cur_index && src->frames[i].f->data[0]) {

168 ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);

169 if (ret < 0)

170 return ret;

171 }

172 }

173

174 return 0;

175 }

176 #endif

177

178 static const int8_t vlcdec_lookup[9][64] = {

179 { 0, },

180 { -1, 1, },

181 { -3, 3, -2, 2, },

182 { -7, 7, -6, 6, -5, 5, -4, 4, },

183 { -15, 15, -14, 14, -13, 13, -12, 12,

184 -11, 11, -10, 10, -9, 9, -8, 8, },

185 { -31, 31, -30, 30, -29, 29, -28, 28,

186 -27, 27, -26, 26, -25, 25, -24, 24,

187 -23, 23, -22, 22, -21, 21, -20, 20,

188 -19, 19, -18, 18, -17, 17, -16, 16, },

189 { -63, 63, -62, 62, -61, 61, -60, 60,

190 -59, 59, -58, 58, -57, 57, -56, 56,

191 -55, 55, -54, 54, -53, 53, -52, 52,

192 -51, 51, -50, 50, -49, 49, -48, 48,

193 -47, 47, -46, 46, -45, 45, -44, 44,

194 -43, 43, -42, 42, -41, 41, -40, 40,

195 -39, 39, -38, 38, -37, 37, -36, 36,

196 -35, 35, -34, 34, -33, 33, -32, 32, },

197 { -127, 127, -126, 126, -125, 125, -124, 124,

198 -123, 123, -122, 122, -121, 121, -120, 120,

199 -119, 119, -118, 118, -117, 117, -116, 116,

200 -115, 115, -114, 114, -113, 113, -112, 112,

201 -111, 111, -110, 110, -109, 109, -108, 108,

202 -107, 107, -106, 106, -105, 105, -104, 104,

203 -103, 103, -102, 102, -101, 101, -100, 100,

204 -99, 99, -98, 98, -97, 97, -96, 96, },

205 { -95, 95, -94, 94, -93, 93, -92, 92,

206 -91, 91, -90, 90, -89, 89, -88, 88,

207 -87, 87, -86, 86, -85, 85, -84, 84,

208 -83, 83, -82, 82, -81, 81, -80, 80,

209 -79, 79, -78, 78, -77, 77, -76, 76,

210 -75, 75, -74, 74, -73, 73, -72, 72,

211 -71, 71, -70, 70, -69, 69, -68, 68,

212 -67, 67, -66, 66, -65, 65, -64, 64, },

213 };

214

215 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)

216 {

217 int16_t *block = ctx->dct_block;

218 unsigned int pos;

219

220 ctx->bdsp.clear_block(block);

221

222 block[0] = get_bits(&ctx->gb, 8) << 3;

223

224 for (pos = 1; pos < num_coeffs; pos++) {

225 uint32_t vlc, num_bits;

226 int value;

227 int coeff;

228

229 vlc = get_vlc2(&ctx->gb, block_vlc.table, MIMIC_VLC_BITS, 3);

230 if (!vlc) /* end-of-block code */

231 return 0;

232 if (vlc == -1)

233 return AVERROR_INVALIDDATA;

234

235 /* pos_add and num_bits are coded in the vlc code */

236 pos += vlc & 15; // pos_add

237 num_bits = vlc >> 4; // num_bits

238

239 if (pos >= 64)

240 return AVERROR_INVALIDDATA;

241

242 value = get_bits(&ctx->gb, num_bits);

243

244 /* FFmpeg's IDCT behaves somewhat different from the original code, so

245 * a factor of 4 was added to the input */

246

247 coeff = ((int8_t*)vlcdec_lookup[num_bits])[value];

248 if (pos < 3)

249 coeff *= 16;

250 else /* TODO Use >> 10 instead of / 1001 */

251 coeff = (coeff * qscale) / 1001;

252

253 block[ctx->scantable.permutated[pos]] = coeff;

254 }

255

256 return 0;

257 }

258

259 static int decode(MimicContext *ctx, int quality, int num_coeffs,

260 int is_iframe)

261 {

262 int ret, y, x, plane, cur_row = 0;

263

264 for (plane = 0; plane < 3; plane++) {

265 const int is_chroma = !!plane;

266 const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,

267 10000) << 2;

268 const int stride = ctx->frames[ctx->cur_index ].f->linesize[plane];

269 const uint8_t *src = ctx->frames[ctx->prev_index].f->data[plane];

270 uint8_t *dst = ctx->frames[ctx->cur_index ].f->data[plane];

271

272 for (y = 0; y < ctx->num_vblocks[plane]; y++) {

273 for (x = 0; x < ctx->num_hblocks[plane]; x++) {

274 /* Check for a change condition in the current block.

275 * - iframes always change.

276 * - Luma plane changes on get_bits1 == 0

277 * - Chroma planes change on get_bits1 == 1 */

278 if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {

279 /* Luma planes may use a backreference from the 15 last

280 * frames preceding the previous. (get_bits1 == 1)

281 * Chroma planes don't use backreferences. */

282 if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {

283 if ((ret = vlc_decode_block(ctx, num_coeffs,

284 qscale)) < 0) {

285 av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "

286 "block.\n");

287 return ret;

288 }

289 ctx->idsp.idct_put(dst, stride, ctx->dct_block);

290 } else {

291 unsigned int backref = get_bits(&ctx->gb, 4);

292 int index = (ctx->cur_index + backref) & 15;

293 uint8_t *p = ctx->frames[index].f->data[0];

294

295 if (index != ctx->cur_index && p) {

296 ff_thread_await_progress(&ctx->frames[index],

297 cur_row, 0);

298 p += src -

299 ctx->frames[ctx->prev_index].f->data[plane];

300 ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);

301 } else {

302 av_log(ctx->avctx, AV_LOG_ERROR,

303 "No such backreference! Buggy sample.\n");

304 }

305 }

306 } else {

307 ff_thread_await_progress(&ctx->frames[ctx->prev_index],

308 cur_row, 0);

309 ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);

310 }

311 src += 8;

312 dst += 8;

313 }

314 src += (stride - ctx->num_hblocks[plane]) << 3;

315 dst += (stride - ctx->num_hblocks[plane]) << 3;

316

317 ff_thread_report_progress(&ctx->frames[ctx->cur_index],

318 cur_row++, 0);

319 }

320 }

321

322 return 0;

323 }

324

325 /**

326 * Flip the buffer upside-down and put it in the YVU order to revert the

327 * way Mimic encodes frames.

328 */

329 static void flip_swap_frame(AVFrame *f)

330 {

331 int i;

332 uint8_t *data_1 = f->data[1];

333 f->data[0] = f->data[0] + ( f->height - 1) * f->linesize[0];

334 f->data[1] = f->data[2] + ((f->height >> 1) - 1) * f->linesize[2];

335 f->data[2] = data_1 + ((f->height >> 1) - 1) * f->linesize[1];

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

337 f->linesize[i] *= -1;

338 }

339

340 static int mimic_decode_frame(AVCodecContext *avctx, void *data,

341 int *got_frame, AVPacket *avpkt)

342 {

343 const uint8_t *buf = avpkt->data;

344 int buf_size = avpkt->size;

345 int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;

346 MimicContext *ctx = avctx->priv_data;

347 GetByteContext gb;

348 int is_pframe;

349 int width, height;

350 int quality, num_coeffs;

351 int res;

352

353 if (buf_size <= MIMIC_HEADER_SIZE) {

354 av_log(avctx, AV_LOG_ERROR, "insufficient data\n");

355 return AVERROR_INVALIDDATA;

356 }

357

358 bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);

359 bytestream2_skip(&gb, 2); /* some constant (always 256) */

360 quality = bytestream2_get_le16u(&gb);

361 width = bytestream2_get_le16u(&gb);

362 height = bytestream2_get_le16u(&gb);

363 bytestream2_skip(&gb, 4); /* some constant */

364 is_pframe = bytestream2_get_le32u(&gb);

365 num_coeffs = bytestream2_get_byteu(&gb);

366 bytestream2_skip(&gb, 3); /* some constant */

367

368 if (!ctx->avctx) {

369 int i;

370

371 if (!(width == 160 && height == 120) &&

372 !(width == 320 && height == 240)) {

373 av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");

374 return AVERROR_INVALIDDATA;

375 }

376

377 res = ff_set_dimensions(avctx, width, height);

378 if (res < 0)

379 return res;

380

381 ctx->avctx = avctx;

382 avctx->pix_fmt = AV_PIX_FMT_YUV420P;

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

384 ctx->num_vblocks[i] = AV_CEIL_RSHIFT(height, 3 + !!i);

385 ctx->num_hblocks[i] = width >> (3 + !!i);

386 }

387 } else if (width != ctx->avctx->width || height != ctx->avctx->height) {

388 avpriv_request_sample(avctx, "Resolution changing");

389 return AVERROR_PATCHWELCOME;

390 }

391

392 if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {

393 av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");

394 return AVERROR_INVALIDDATA;

395 }

396

397 ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);

398 ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :

399 AV_PICTURE_TYPE_I;

400 if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],

401 AV_GET_BUFFER_FLAG_REF)) < 0)

402 return res;

403

404 ctx->next_prev_index = ctx->cur_index;

405 ctx->next_cur_index = (ctx->cur_index - 1) & 15;

406

407 ff_thread_finish_setup(avctx);

408

409 av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);

410 if (!ctx->swap_buf)

411 return AVERROR(ENOMEM);

412

413 ctx->bbdsp.bswap_buf(ctx->swap_buf,

414 (const uint32_t *) (buf + MIMIC_HEADER_SIZE),

415 swap_buf_size >> 2);

416 init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);

417

418 res = decode(ctx, quality, num_coeffs, !is_pframe);

419 ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);

420 if (res < 0) {

421 if (!(avctx->active_thread_type & FF_THREAD_FRAME))

422 ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);

423 return res;

424 }

425

426 if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0)

427 return res;

428 *got_frame = 1;

429

430 flip_swap_frame(data);

431

432 ctx->prev_index = ctx->next_prev_index;

433 ctx->cur_index = ctx->next_cur_index;

434

435 return buf_size;

436 }

437

438 const AVCodec ff_mimic_decoder = {

439 .name = "mimic",

440 .long_name = NULL_IF_CONFIG_SMALL("Mimic"),

441 .type = AVMEDIA_TYPE_VIDEO,

442 .id = AV_CODEC_ID_MIMIC,

443 .priv_data_size = sizeof(MimicContext),

444 .init = mimic_decode_init,

445 .close = mimic_decode_end,

446 .decode = mimic_decode_frame,

447 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

448 .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context),

449 .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS |

450 FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE,

451 };

MimicContext::hdsp

HpelDSPContext hdsp

Definition: mimic.c:62

AVCodec

AVCodec.

Definition: codec.h:202

bswapdsp.h

stride

int stride

Definition: mace.c:144

MimicContext::next_prev_index

int next_prev_index

Definition: mimic.c:67

FF_CODEC_CAP_INIT_THREADSAFE

#define FF_CODEC_CAP_INIT_THREADSAFE

The codec does not modify any global variables in the init function, allowing to call the init functi...

Definition: internal.h:42

ff_init_scantable

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

Definition: idctdsp.c:29

MimicContext::idsp

IDCTDSPContext idsp

Definition: mimic.c:63

av_clip

#define av_clip

Definition: common.h:96

huffsyms

static const uint8_t huffsyms[]

Definition: mimic.c:72

MIMIC_HEADER_SIZE

#define MIMIC_HEADER_SIZE

Definition: mimic.c:39

blockdsp.h

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

huffbits

static const uint8_t huffbits[]

Definition: mimic.c:84

mem_internal.h

ff_thread_ref_frame

int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)

Definition: utils.c:866

GetByteContext

Definition: bytestream.h:33

thread.h

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:109

AVFrame

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

Definition: frame.h:317

index

fg index

Definition: ffmpeg_filter.c:167

mimic_decode_frame

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

Definition: mimic.c:340

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:373

data

const char data[16]

Definition: mxf.c:143

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:798

mimic_init_static

static av_cold void mimic_init_static(void)

Definition: mimic.c:121

BlockDSPContext

Definition: blockdsp.h:34

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:660

thread.h

ff_thread_await_progress

the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_thread_report_progress() has been called on them. This includes draw_edges(). Porting codecs to frame threading

quality

trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality

Definition: rate_distortion.txt:12

init

static int init

Definition: av_tx.c:47

bytestream2_skip

static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)

Definition: bytestream.h:168

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:380

AV_CODEC_ID_MIMIC

@ AV_CODEC_ID_MIMIC

Definition: codec_id.h:163

GetBitContext

Definition: get_bits.h:62

ff_thread_get_buffer

the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:463

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:97

ff_thread_once

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

Definition: thread.h:175

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

MimicContext::swap_buf_size

int swap_buf_size

Definition: mimic.c:49

ff_thread_report_progress

void ff_thread_report_progress(ThreadFrame *f, int n, int field)

Notify later decoding threads when part of their reference picture is ready.

Definition: pthread_frame.c:588

width

#define width

AV_CEIL_RSHIFT

#define AV_CEIL_RSHIFT(a, b)

Definition: common.h:51

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

MimicContext::cur_index

int cur_index

Definition: mimic.c:51

ctx

AVFormatContext * ctx

Definition: movenc.c:48

get_bits.h

flip_swap_frame

static void flip_swap_frame(AVFrame *f)

Flip the buffer upside-down and put it in the YVU order to revert the way Mimic encodes frames.

Definition: mimic.c:329

MimicContext::bbdsp

BswapDSPContext bbdsp

Definition: mimic.c:61

AV_PIX_FMT_YUV420P

@ AV_PIX_FMT_YUV420P

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

Definition: pixfmt.h:66

#define f(width, name)

Definition: cbs_vp9.c:255

ff_hpeldsp_init

av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)

Definition: hpeldsp.c:338

AV_CODEC_CAP_FRAME_THREADS

#define AV_CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: codec.h:113

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:173

ff_bswapdsp_init

av_cold void ff_bswapdsp_init(BswapDSPContext *c)

Definition: bswapdsp.c:49

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

INIT_VLC_STATIC_FROM_LENGTHS

#define INIT_VLC_STATIC_FROM_LENGTHS(vlc, bits, nb_codes, lens, len_wrap, symbols, symbols_wrap, symbols_size, offset, flags, static_size)

Definition: vlc.h:126

MimicContext::swap_buf

void * swap_buf

Definition: mimic.c:48

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:499

src

#define src

Definition: vp8dsp.c:255

ONLY_IF_THREADS_ENABLED

#define ONLY_IF_THREADS_ENABLED(x)

Define a function with only the non-default version specified.

Definition: internal.h:156

ff_mimic_decoder

const AVCodec ff_mimic_decoder

Definition: mimic.c:438

block_vlc

static VLC block_vlc

Definition: mimic.c:70

AVOnce

#define AVOnce

Definition: thread.h:172

mimic_decode_end

static av_cold int mimic_decode_end(AVCodecContext *avctx)

Definition: mimic.c:104

for

for(j=16;j >0;--j)

Definition: h264pred_template.c:469

ff_thread_release_buffer

void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)

Wrapper around release_buffer() frame-for multithreaded codecs.

Definition: pthread_frame.c:1056

HpelDSPContext

Half-pel DSP context.

Definition: hpeldsp.h:45

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

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

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

MimicContext::avctx

AVCodecContext * avctx

Definition: mimic.c:43

mimic_decode_init

static av_cold int mimic_decode_init(AVCodecContext *avctx)

Definition: mimic.c:127

height

#define height

MimicContext::dct_block

int16_t dct_block[64]

Definition: mimic.c:56

FF_THREAD_FRAME

#define FF_THREAD_FRAME

Decode more than one frame at once.

Definition: avcodec.h:1451

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem.h:116

MimicContext::num_hblocks

int num_hblocks[3]

Definition: mimic.c:46

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

Definition: cbs_h2645.c:271

FF_CODEC_CAP_INIT_CLEANUP

#define FF_CODEC_CAP_INIT_CLEANUP

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

Definition: internal.h:50

MimicContext::next_cur_index

int next_cur_index

Definition: mimic.c:66

decode

static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)

Definition: mimic.c:259

vlcdec_lookup

static const int8_t vlcdec_lookup[9][64]

Definition: mimic.c:178

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

MIMIC_VLC_BITS

#define MIMIC_VLC_BITS

Definition: mimic.c:40

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

ff_idctdsp_init

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

Definition: idctdsp.c:238

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:209

update_thread_context

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.