The Tor Browser / file comparison

comparison: media/libvpx/vp9/vp9_dx_iface.c

media/libvpx/vp9/vp9_dx_iface.c

changeset 0
6474c204b198
equal deleted inserted replaced
-1:000000000000 0:132c8ca8f111
1 /*
2 * Copyright (c) 2010 The WebM project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11
12 #include <stdlib.h>
13 #include <string.h>
14 #include "vpx/vpx_decoder.h"
15 #include "vpx/vp8dx.h"
16 #include "vpx/internal/vpx_codec_internal.h"
17 #include "./vpx_version.h"
18 #include "vp9/decoder/vp9_onyxd.h"
19 #include "vp9/decoder/vp9_onyxd_int.h"
20 #include "vp9/decoder/vp9_read_bit_buffer.h"
21 #include "vp9/vp9_iface_common.h"
22
23 #define VP9_CAP_POSTPROC (CONFIG_VP9_POSTPROC ? VPX_CODEC_CAP_POSTPROC : 0)
24 typedef vpx_codec_stream_info_t vp9_stream_info_t;
25
26 /* Structures for handling memory allocations */
27 typedef enum {
28 VP9_SEG_ALG_PRIV = 256,
29 VP9_SEG_MAX
30 } mem_seg_id_t;
31 #define NELEMENTS(x) ((int)(sizeof(x)/sizeof(x[0])))
32
33 static unsigned long priv_sz(const vpx_codec_dec_cfg_t *si,
34 vpx_codec_flags_t flags);
35
36 static const mem_req_t vp9_mem_req_segs[] = {
37 {VP9_SEG_ALG_PRIV, 0, 8, VPX_CODEC_MEM_ZERO, priv_sz},
38 {VP9_SEG_MAX, 0, 0, 0, NULL}
39 };
40
41 struct vpx_codec_alg_priv {
42 vpx_codec_priv_t base;
43 vpx_codec_mmap_t mmaps[NELEMENTS(vp9_mem_req_segs) - 1];
44 vpx_codec_dec_cfg_t cfg;
45 vp9_stream_info_t si;
46 int defer_alloc;
47 int decoder_init;
48 VP9D_PTR pbi;
49 int postproc_cfg_set;
50 vp8_postproc_cfg_t postproc_cfg;
51 #if CONFIG_POSTPROC_VISUALIZER
52 unsigned int dbg_postproc_flag;
53 int dbg_color_ref_frame_flag;
54 int dbg_color_mb_modes_flag;
55 int dbg_color_b_modes_flag;
56 int dbg_display_mv_flag;
57 #endif
58 vpx_image_t img;
59 int img_setup;
60 int img_avail;
61 int invert_tile_order;
62 };
63
64 static unsigned long priv_sz(const vpx_codec_dec_cfg_t *si,
65 vpx_codec_flags_t flags) {
66 /* Although this declaration is constant, we can't use it in the requested
67 * segments list because we want to define the requested segments list
68 * before defining the private type (so that the number of memory maps is
69 * known)
70 */
71 (void)si;
72 return sizeof(vpx_codec_alg_priv_t);
73 }
74
75 static void vp9_init_ctx(vpx_codec_ctx_t *ctx, const vpx_codec_mmap_t *mmap) {
76 int i;
77
78 ctx->priv = mmap->base;
79 ctx->priv->sz = sizeof(*ctx->priv);
80 ctx->priv->iface = ctx->iface;
81 ctx->priv->alg_priv = mmap->base;
82
83 for (i = 0; i < NELEMENTS(ctx->priv->alg_priv->mmaps); i++)
84 ctx->priv->alg_priv->mmaps[i].id = vp9_mem_req_segs[i].id;
85
86 ctx->priv->alg_priv->mmaps[0] = *mmap;
87 ctx->priv->alg_priv->si.sz = sizeof(ctx->priv->alg_priv->si);
88 ctx->priv->init_flags = ctx->init_flags;
89
90 if (ctx->config.dec) {
91 /* Update the reference to the config structure to an internal copy. */
92 ctx->priv->alg_priv->cfg = *ctx->config.dec;
93 ctx->config.dec = &ctx->priv->alg_priv->cfg;
94 }
95 }
96
97 static void vp9_finalize_mmaps(vpx_codec_alg_priv_t *ctx) {
98 /* nothing to clean up */
99 }
100
101 static vpx_codec_err_t vp9_init(vpx_codec_ctx_t *ctx,
102 vpx_codec_priv_enc_mr_cfg_t *data) {
103 vpx_codec_err_t res = VPX_CODEC_OK;
104
105 /* This function only allocates space for the vpx_codec_alg_priv_t
106 * structure. More memory may be required at the time the stream
107 * information becomes known.
108 */
109 if (!ctx->priv) {
110 vpx_codec_mmap_t mmap;
111
112 mmap.id = vp9_mem_req_segs[0].id;
113 mmap.sz = sizeof(vpx_codec_alg_priv_t);
114 mmap.align = vp9_mem_req_segs[0].align;
115 mmap.flags = vp9_mem_req_segs[0].flags;
116
117 res = vpx_mmap_alloc(&mmap);
118
119 if (!res) {
120 vp9_init_ctx(ctx, &mmap);
121
122 ctx->priv->alg_priv->defer_alloc = 1;
123 /*post processing level initialized to do nothing */
124 }
125 }
126
127 return res;
128 }
129
130 static vpx_codec_err_t vp9_destroy(vpx_codec_alg_priv_t *ctx) {
131 int i;
132
133 vp9_remove_decompressor(ctx->pbi);
134
135 for (i = NELEMENTS(ctx->mmaps) - 1; i >= 0; i--) {
136 if (ctx->mmaps[i].dtor)
137 ctx->mmaps[i].dtor(&ctx->mmaps[i]);
138 }
139
140 return VPX_CODEC_OK;
141 }
142
143 static vpx_codec_err_t vp9_peek_si(const uint8_t *data,
144 unsigned int data_sz,
145 vpx_codec_stream_info_t *si) {
146 if (data_sz <= 8) return VPX_CODEC_UNSUP_BITSTREAM;
147 if (data + data_sz <= data) return VPX_CODEC_INVALID_PARAM;
148
149 si->is_kf = 0;
150 si->w = si->h = 0;
151
152 {
153 struct vp9_read_bit_buffer rb = { data, data + data_sz, 0, NULL, NULL };
154 const int frame_marker = vp9_rb_read_literal(&rb, 2);
155 const int version = vp9_rb_read_bit(&rb) | (vp9_rb_read_bit(&rb) << 1);
156 if (frame_marker != 0x2) return VPX_CODEC_UNSUP_BITSTREAM;
157 #if CONFIG_NON420
158 if (version > 1) return VPX_CODEC_UNSUP_BITSTREAM;
159 #else
160 if (version != 0) return VPX_CODEC_UNSUP_BITSTREAM;
161 #endif
162
163 if (vp9_rb_read_bit(&rb)) { // show an existing frame
164 return VPX_CODEC_OK;
165 }
166
167 si->is_kf = !vp9_rb_read_bit(&rb);
168 if (si->is_kf) {
169 const int sRGB = 7;
170 int colorspace;
171
172 rb.bit_offset += 1; // show frame
173 rb.bit_offset += 1; // error resilient
174
175 if (vp9_rb_read_literal(&rb, 8) != VP9_SYNC_CODE_0 ||
176 vp9_rb_read_literal(&rb, 8) != VP9_SYNC_CODE_1 ||
177 vp9_rb_read_literal(&rb, 8) != VP9_SYNC_CODE_2) {
178 return VPX_CODEC_UNSUP_BITSTREAM;
179 }
180
181 colorspace = vp9_rb_read_literal(&rb, 3);
182 if (colorspace != sRGB) {
183 rb.bit_offset += 1; // [16,235] (including xvycc) vs [0,255] range
184 if (version == 1) {
185 rb.bit_offset += 2; // subsampling x/y
186 rb.bit_offset += 1; // has extra plane
187 }
188 } else {
189 if (version == 1) {
190 rb.bit_offset += 1; // has extra plane
191 } else {
192 // RGB is only available in version 1
193 return VPX_CODEC_UNSUP_BITSTREAM;
194 }
195 }
196
197 // TODO(jzern): these are available on non-keyframes in intra only mode.
198 si->w = vp9_rb_read_literal(&rb, 16) + 1;
199 si->h = vp9_rb_read_literal(&rb, 16) + 1;
200 }
201 }
202
203 return VPX_CODEC_OK;
204 }
205
206 static vpx_codec_err_t vp9_get_si(vpx_codec_alg_priv_t *ctx,
207 vpx_codec_stream_info_t *si) {
208 unsigned int sz;
209
210 if (si->sz >= sizeof(vp9_stream_info_t))
211 sz = sizeof(vp9_stream_info_t);
212 else
213 sz = sizeof(vpx_codec_stream_info_t);
214
215 memcpy(si, &ctx->si, sz);
216 si->sz = sz;
217
218 return VPX_CODEC_OK;
219 }
220
221
222 static vpx_codec_err_t
223 update_error_state(vpx_codec_alg_priv_t *ctx,
224 const struct vpx_internal_error_info *error) {
225 vpx_codec_err_t res;
226
227 if ((res = error->error_code))
228 ctx->base.err_detail = error->has_detail
229 ? error->detail
230 : NULL;
231
232 return res;
233 }
234
235 static vpx_codec_err_t decode_one(vpx_codec_alg_priv_t *ctx,
236 const uint8_t **data,
237 unsigned int data_sz,
238 void *user_priv,
239 long deadline) {
240 vpx_codec_err_t res = VPX_CODEC_OK;
241
242 ctx->img_avail = 0;
243
244 /* Determine the stream parameters. Note that we rely on peek_si to
245 * validate that we have a buffer that does not wrap around the top
246 * of the heap.
247 */
248 if (!ctx->si.h)
249 res = ctx->base.iface->dec.peek_si(*data, data_sz, &ctx->si);
250
251
252 /* Perform deferred allocations, if required */
253 if (!res && ctx->defer_alloc) {
254 int i;
255
256 for (i = 1; !res && i < NELEMENTS(ctx->mmaps); i++) {
257 vpx_codec_dec_cfg_t cfg;
258
259 cfg.w = ctx->si.w;
260 cfg.h = ctx->si.h;
261 ctx->mmaps[i].id = vp9_mem_req_segs[i].id;
262 ctx->mmaps[i].sz = vp9_mem_req_segs[i].sz;
263 ctx->mmaps[i].align = vp9_mem_req_segs[i].align;
264 ctx->mmaps[i].flags = vp9_mem_req_segs[i].flags;
265
266 if (!ctx->mmaps[i].sz)
267 ctx->mmaps[i].sz = vp9_mem_req_segs[i].calc_sz(&cfg,
268 ctx->base.init_flags);
269
270 res = vpx_mmap_alloc(&ctx->mmaps[i]);
271 }
272
273 if (!res)
274 vp9_finalize_mmaps(ctx);
275
276 ctx->defer_alloc = 0;
277 }
278
279 /* Initialize the decoder instance on the first frame*/
280 if (!res && !ctx->decoder_init) {
281 res = vpx_validate_mmaps(&ctx->si, ctx->mmaps,
282 vp9_mem_req_segs, NELEMENTS(vp9_mem_req_segs),
283 ctx->base.init_flags);
284
285 if (!res) {
286 VP9D_CONFIG oxcf;
287 VP9D_PTR optr;
288
289 vp9_initialize_dec();
290
291 oxcf.width = ctx->si.w;
292 oxcf.height = ctx->si.h;
293 oxcf.version = 9;
294 oxcf.postprocess = 0;
295 oxcf.max_threads = ctx->cfg.threads;
296 oxcf.inv_tile_order = ctx->invert_tile_order;
297 optr = vp9_create_decompressor(&oxcf);
298
299 /* If postprocessing was enabled by the application and a
300 * configuration has not been provided, default it.
301 */
302 if (!ctx->postproc_cfg_set
303 && (ctx->base.init_flags & VPX_CODEC_USE_POSTPROC)) {
304 ctx->postproc_cfg.post_proc_flag =
305 VP8_DEBLOCK | VP8_DEMACROBLOCK;
306 ctx->postproc_cfg.deblocking_level = 4;
307 ctx->postproc_cfg.noise_level = 0;
308 }
309
310 if (!optr)
311 res = VPX_CODEC_ERROR;
312 else
313 ctx->pbi = optr;
314 }
315
316 ctx->decoder_init = 1;
317 }
318
319 if (!res && ctx->pbi) {
320 YV12_BUFFER_CONFIG sd;
321 int64_t time_stamp = 0, time_end_stamp = 0;
322 vp9_ppflags_t flags = {0};
323
324 if (ctx->base.init_flags & VPX_CODEC_USE_POSTPROC) {
325 flags.post_proc_flag =
326 #if CONFIG_POSTPROC_VISUALIZER
327 ((ctx->dbg_color_ref_frame_flag != 0) ?
328 VP9D_DEBUG_CLR_FRM_REF_BLKS : 0)
329 | ((ctx->dbg_color_mb_modes_flag != 0) ?
330 VP9D_DEBUG_CLR_BLK_MODES : 0)
331 | ((ctx->dbg_color_b_modes_flag != 0) ?
332 VP9D_DEBUG_CLR_BLK_MODES : 0)
333 | ((ctx->dbg_display_mv_flag != 0) ?
334 VP9D_DEBUG_DRAW_MV : 0)
335 |
336 #endif
337 ctx->postproc_cfg.post_proc_flag;
338
339 flags.deblocking_level = ctx->postproc_cfg.deblocking_level;
340 flags.noise_level = ctx->postproc_cfg.noise_level;
341 #if CONFIG_POSTPROC_VISUALIZER
342 flags.display_ref_frame_flag = ctx->dbg_color_ref_frame_flag;
343 flags.display_mb_modes_flag = ctx->dbg_color_mb_modes_flag;
344 flags.display_b_modes_flag = ctx->dbg_color_b_modes_flag;
345 flags.display_mv_flag = ctx->dbg_display_mv_flag;
346 #endif
347 }
348
349 if (vp9_receive_compressed_data(ctx->pbi, data_sz, data, deadline)) {
350 VP9D_COMP *pbi = (VP9D_COMP *)ctx->pbi;
351 res = update_error_state(ctx, &pbi->common.error);
352 }
353
354 if (!res && 0 == vp9_get_raw_frame(ctx->pbi, &sd, &time_stamp,
355 &time_end_stamp, &flags)) {
356 yuvconfig2image(&ctx->img, &sd, user_priv);
357 ctx->img_avail = 1;
358 }
359 }
360
361 return res;
362 }
363
364 static void parse_superframe_index(const uint8_t *data,
365 size_t data_sz,
366 uint32_t sizes[8],
367 int *count) {
368 uint8_t marker;
369
370 assert(data_sz);
371 marker = data[data_sz - 1];
372 *count = 0;
373
374 if ((marker & 0xe0) == 0xc0) {
375 const uint32_t frames = (marker & 0x7) + 1;
376 const uint32_t mag = ((marker >> 3) & 0x3) + 1;
377 const size_t index_sz = 2 + mag * frames;
378
379 if (data_sz >= index_sz && data[data_sz - index_sz] == marker) {
380 // found a valid superframe index
381 uint32_t i, j;
382 const uint8_t *x = data + data_sz - index_sz + 1;
383
384 for (i = 0; i < frames; i++) {
385 uint32_t this_sz = 0;
386
387 for (j = 0; j < mag; j++)
388 this_sz |= (*x++) << (j * 8);
389 sizes[i] = this_sz;
390 }
391
392 *count = frames;
393 }
394 }
395 }
396
397 static vpx_codec_err_t vp9_decode(vpx_codec_alg_priv_t *ctx,
398 const uint8_t *data,
399 unsigned int data_sz,
400 void *user_priv,
401 long deadline) {
402 const uint8_t *data_start = data;
403 const uint8_t *data_end = data + data_sz;
404 vpx_codec_err_t res = 0;
405 uint32_t sizes[8];
406 int frames_this_pts, frame_count = 0;
407
408 if (data == NULL || data_sz == 0) return VPX_CODEC_INVALID_PARAM;
409
410 parse_superframe_index(data, data_sz, sizes, &frames_this_pts);
411
412 do {
413 // Skip over the superframe index, if present
414 if (data_sz && (*data_start & 0xe0) == 0xc0) {
415 const uint8_t marker = *data_start;
416 const uint32_t frames = (marker & 0x7) + 1;
417 const uint32_t mag = ((marker >> 3) & 0x3) + 1;
418 const uint32_t index_sz = 2 + mag * frames;
419
420 if (data_sz >= index_sz && data_start[index_sz - 1] == marker) {
421 data_start += index_sz;
422 data_sz -= index_sz;
423 if (data_start < data_end)
424 continue;
425 else
426 break;
427 }
428 }
429
430 // Use the correct size for this frame, if an index is present.
431 if (frames_this_pts) {
432 uint32_t this_sz = sizes[frame_count];
433
434 if (data_sz < this_sz) {
435 ctx->base.err_detail = "Invalid frame size in index";
436 return VPX_CODEC_CORRUPT_FRAME;
437 }
438
439 data_sz = this_sz;
440 frame_count++;
441 }
442
443 res = decode_one(ctx, &data_start, data_sz, user_priv, deadline);
444 assert(data_start >= data);
445 assert(data_start <= data_end);
446
447 /* Early exit if there was a decode error */
448 if (res)
449 break;
450
451 /* Account for suboptimal termination by the encoder. */
452 while (data_start < data_end && *data_start == 0)
453 data_start++;
454
455 data_sz = data_end - data_start;
456 } while (data_start < data_end);
457 return res;
458 }
459
460 static vpx_image_t *vp9_get_frame(vpx_codec_alg_priv_t *ctx,
461 vpx_codec_iter_t *iter) {
462 vpx_image_t *img = NULL;
463
464 if (ctx->img_avail) {
465 /* iter acts as a flip flop, so an image is only returned on the first
466 * call to get_frame.
467 */
468 if (!(*iter)) {
469 img = &ctx->img;
470 *iter = img;
471 }
472 }
473 ctx->img_avail = 0;
474
475 return img;
476 }
477
478 static vpx_codec_err_t vp9_xma_get_mmap(const vpx_codec_ctx_t *ctx,
479 vpx_codec_mmap_t *mmap,
480 vpx_codec_iter_t *iter) {
481 vpx_codec_err_t res;
482 const mem_req_t *seg_iter = *iter;
483
484 /* Get address of next segment request */
485 do {
486 if (!seg_iter)
487 seg_iter = vp9_mem_req_segs;
488 else if (seg_iter->id != VP9_SEG_MAX)
489 seg_iter++;
490
491 *iter = (vpx_codec_iter_t)seg_iter;
492
493 if (seg_iter->id != VP9_SEG_MAX) {
494 mmap->id = seg_iter->id;
495 mmap->sz = seg_iter->sz;
496 mmap->align = seg_iter->align;
497 mmap->flags = seg_iter->flags;
498
499 if (!seg_iter->sz)
500 mmap->sz = seg_iter->calc_sz(ctx->config.dec, ctx->init_flags);
501
502 res = VPX_CODEC_OK;
503 } else {
504 res = VPX_CODEC_LIST_END;
505 }
506 } while (!mmap->sz && res != VPX_CODEC_LIST_END);
507
508 return res;
509 }
510
511 static vpx_codec_err_t vp9_xma_set_mmap(vpx_codec_ctx_t *ctx,
512 const vpx_codec_mmap_t *mmap) {
513 vpx_codec_err_t res = VPX_CODEC_MEM_ERROR;
514 int i, done;
515
516 if (!ctx->priv) {
517 if (mmap->id == VP9_SEG_ALG_PRIV) {
518 if (!ctx->priv) {
519 vp9_init_ctx(ctx, mmap);
520 res = VPX_CODEC_OK;
521 }
522 }
523 }
524
525 done = 1;
526
527 if (!res && ctx->priv->alg_priv) {
528 for (i = 0; i < NELEMENTS(ctx->priv->alg_priv->mmaps); i++) {
529 if (ctx->priv->alg_priv->mmaps[i].id == mmap->id)
530 if (!ctx->priv->alg_priv->mmaps[i].base) {
531 ctx->priv->alg_priv->mmaps[i] = *mmap;
532 res = VPX_CODEC_OK;
533 }
534
535 done &= (ctx->priv->alg_priv->mmaps[i].base != NULL);
536 }
537 }
538
539 if (done && !res) {
540 vp9_finalize_mmaps(ctx->priv->alg_priv);
541 res = ctx->iface->init(ctx, NULL);
542 }
543
544 return res;
545 }
546
547 static vpx_codec_err_t set_reference(vpx_codec_alg_priv_t *ctx,
548 int ctr_id,
549 va_list args) {
550 vpx_ref_frame_t *data = va_arg(args, vpx_ref_frame_t *);
551
552 if (data) {
553 vpx_ref_frame_t *frame = (vpx_ref_frame_t *)data;
554 YV12_BUFFER_CONFIG sd;
555
556 image2yuvconfig(&frame->img, &sd);
557
558 return vp9_set_reference_dec(ctx->pbi,
559 (VP9_REFFRAME)frame->frame_type, &sd);
560 } else {
561 return VPX_CODEC_INVALID_PARAM;
562 }
563 }
564
565 static vpx_codec_err_t copy_reference(vpx_codec_alg_priv_t *ctx,
566 int ctr_id,
567 va_list args) {
568 vpx_ref_frame_t *data = va_arg(args, vpx_ref_frame_t *);
569
570 if (data) {
571 vpx_ref_frame_t *frame = (vpx_ref_frame_t *)data;
572 YV12_BUFFER_CONFIG sd;
573
574 image2yuvconfig(&frame->img, &sd);
575
576 return vp9_copy_reference_dec(ctx->pbi,
577 (VP9_REFFRAME)frame->frame_type, &sd);
578 } else {
579 return VPX_CODEC_INVALID_PARAM;
580 }
581 }
582
583 static vpx_codec_err_t get_reference(vpx_codec_alg_priv_t *ctx,
584 int ctr_id,
585 va_list args) {
586 vp9_ref_frame_t *data = va_arg(args, vp9_ref_frame_t *);
587
588 if (data) {
589 YV12_BUFFER_CONFIG* fb;
590
591 vp9_get_reference_dec(ctx->pbi, data->idx, &fb);
592 yuvconfig2image(&data->img, fb, NULL);
593 return VPX_CODEC_OK;
594 } else {
595 return VPX_CODEC_INVALID_PARAM;
596 }
597 }
598
599 static vpx_codec_err_t set_postproc(vpx_codec_alg_priv_t *ctx,
600 int ctr_id,
601 va_list args) {
602 #if CONFIG_VP9_POSTPROC
603 vp8_postproc_cfg_t *data = va_arg(args, vp8_postproc_cfg_t *);
604
605 if (data) {
606 ctx->postproc_cfg_set = 1;
607 ctx->postproc_cfg = *((vp8_postproc_cfg_t *)data);
608 return VPX_CODEC_OK;
609 } else {
610 return VPX_CODEC_INVALID_PARAM;
611 }
612 #else
613 return VPX_CODEC_INCAPABLE;
614 #endif
615 }
616
617 static vpx_codec_err_t set_dbg_options(vpx_codec_alg_priv_t *ctx,
618 int ctrl_id,
619 va_list args) {
620 #if CONFIG_POSTPROC_VISUALIZER && CONFIG_POSTPROC
621 int data = va_arg(args, int);
622
623 #define MAP(id, var) case id: var = data; break;
624
625 switch (ctrl_id) {
626 MAP(VP8_SET_DBG_COLOR_REF_FRAME, ctx->dbg_color_ref_frame_flag);
627 MAP(VP8_SET_DBG_COLOR_MB_MODES, ctx->dbg_color_mb_modes_flag);
628 MAP(VP8_SET_DBG_COLOR_B_MODES, ctx->dbg_color_b_modes_flag);
629 MAP(VP8_SET_DBG_DISPLAY_MV, ctx->dbg_display_mv_flag);
630 }
631
632 return VPX_CODEC_OK;
633 #else
634 return VPX_CODEC_INCAPABLE;
635 #endif
636 }
637
638 static vpx_codec_err_t get_last_ref_updates(vpx_codec_alg_priv_t *ctx,
639 int ctrl_id,
640 va_list args) {
641 int *update_info = va_arg(args, int *);
642 VP9D_COMP *pbi = (VP9D_COMP *)ctx->pbi;
643
644 if (update_info) {
645 *update_info = pbi->refresh_frame_flags;
646
647 return VPX_CODEC_OK;
648 } else {
649 return VPX_CODEC_INVALID_PARAM;
650 }
651 }
652
653
654 static vpx_codec_err_t get_frame_corrupted(vpx_codec_alg_priv_t *ctx,
655 int ctrl_id,
656 va_list args) {
657 int *corrupted = va_arg(args, int *);
658
659 if (corrupted) {
660 VP9D_COMP *pbi = (VP9D_COMP *)ctx->pbi;
661 if (pbi)
662 *corrupted = pbi->common.frame_to_show->corrupted;
663 else
664 return VPX_CODEC_ERROR;
665 return VPX_CODEC_OK;
666 } else {
667 return VPX_CODEC_INVALID_PARAM;
668 }
669 }
670
671 static vpx_codec_err_t set_invert_tile_order(vpx_codec_alg_priv_t *ctx,
672 int ctr_id,
673 va_list args) {
674 ctx->invert_tile_order = va_arg(args, int);
675 return VPX_CODEC_OK;
676 }
677
678 static vpx_codec_ctrl_fn_map_t ctf_maps[] = {
679 {VP8_SET_REFERENCE, set_reference},
680 {VP8_COPY_REFERENCE, copy_reference},
681 {VP8_SET_POSTPROC, set_postproc},
682 {VP8_SET_DBG_COLOR_REF_FRAME, set_dbg_options},
683 {VP8_SET_DBG_COLOR_MB_MODES, set_dbg_options},
684 {VP8_SET_DBG_COLOR_B_MODES, set_dbg_options},
685 {VP8_SET_DBG_DISPLAY_MV, set_dbg_options},
686 {VP8D_GET_LAST_REF_UPDATES, get_last_ref_updates},
687 {VP8D_GET_FRAME_CORRUPTED, get_frame_corrupted},
688 {VP9_GET_REFERENCE, get_reference},
689 {VP9_INVERT_TILE_DECODE_ORDER, set_invert_tile_order},
690 { -1, NULL},
691 };
692
693
694 #ifndef VERSION_STRING
695 #define VERSION_STRING
696 #endif
697 CODEC_INTERFACE(vpx_codec_vp9_dx) = {
698 "WebM Project VP9 Decoder" VERSION_STRING,
699 VPX_CODEC_INTERNAL_ABI_VERSION,
700 VPX_CODEC_CAP_DECODER | VP9_CAP_POSTPROC,
701 /* vpx_codec_caps_t caps; */
702 vp9_init, /* vpx_codec_init_fn_t init; */
703 vp9_destroy, /* vpx_codec_destroy_fn_t destroy; */
704 ctf_maps, /* vpx_codec_ctrl_fn_map_t *ctrl_maps; */
705 vp9_xma_get_mmap, /* vpx_codec_get_mmap_fn_t get_mmap; */
706 vp9_xma_set_mmap, /* vpx_codec_set_mmap_fn_t set_mmap; */
707 { // NOLINT
708 vp9_peek_si, /* vpx_codec_peek_si_fn_t peek_si; */
709 vp9_get_si, /* vpx_codec_get_si_fn_t get_si; */
710 vp9_decode, /* vpx_codec_decode_fn_t decode; */
711 vp9_get_frame, /* vpx_codec_frame_get_fn_t frame_get; */
712 },
713 { // NOLINT
714 /* encoder functions */
715 NOT_IMPLEMENTED,
716 NOT_IMPLEMENTED,
717 NOT_IMPLEMENTED,
718 NOT_IMPLEMENTED,
719 NOT_IMPLEMENTED,
720 NOT_IMPLEMENTED
721 }
722 };

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial