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#include <assert.h> 12#include <limits.h> 13#include <stdio.h> 14 15#include "./vp9_rtcd.h" 16#include "./vpx_dsp_rtcd.h" 17#include "./vpx_scale_rtcd.h" 18 19#include "vpx_mem/vpx_mem.h" 20#include "vpx_ports/system_state.h" 21#include "vpx_ports/vpx_once.h" 22#include "vpx_ports/vpx_timer.h" 23#include "vpx_scale/vpx_scale.h" 24#include "vpx_util/vpx_thread.h" 25 26#include "vp9/common/vp9_alloccommon.h" 27#include "vp9/common/vp9_loopfilter.h" 28#include "vp9/common/vp9_onyxc_int.h" 29#if CONFIG_VP9_POSTPROC 30#include "vp9/common/vp9_postproc.h" 31#endif 32#include "vp9/common/vp9_quant_common.h" 33#include "vp9/common/vp9_reconintra.h" 34 35#include "vp9/decoder/vp9_decodeframe.h" 36#include "vp9/decoder/vp9_decoder.h" 37#include "vp9/decoder/vp9_detokenize.h" 38 39static void initialize_dec(void) { 40 static volatile int init_done = 0; 41 42 if (!init_done) { 43 vp9_rtcd(); 44 vpx_dsp_rtcd(); 45 vpx_scale_rtcd(); 46 vp9_init_intra_predictors(); 47 init_done = 1; 48 } 49} 50 51static void vp9_dec_setup_mi(VP9_COMMON *cm) { 52 cm->mi = cm->mip + cm->mi_stride + 1; 53 cm->mi_grid_visible = cm->mi_grid_base + cm->mi_stride + 1; 54 memset(cm->mi_grid_base, 0, 55 cm->mi_stride * (cm->mi_rows + 1) * sizeof(*cm->mi_grid_base)); 56} 57 58static int vp9_dec_alloc_mi(VP9_COMMON *cm, int mi_size) { 59 cm->mip = vpx_calloc(mi_size, sizeof(*cm->mip)); 60 if (!cm->mip) 61 return 1; 62 cm->mi_alloc_size = mi_size; 63 cm->mi_grid_base = (MODE_INFO **)vpx_calloc(mi_size, sizeof(MODE_INFO*)); 64 if (!cm->mi_grid_base) 65 return 1; 66 return 0; 67} 68 69static void vp9_dec_free_mi(VP9_COMMON *cm) { 70 vpx_free(cm->mip); 71 cm->mip = NULL; 72 vpx_free(cm->mi_grid_base); 73 cm->mi_grid_base = NULL; 74} 75 76VP9Decoder *vp9_decoder_create(BufferPool *const pool) { 77 VP9Decoder *volatile const pbi = vpx_memalign(32, sizeof(*pbi)); 78 VP9_COMMON *volatile const cm = pbi ? &pbi->common : NULL; 79 80 if (!cm) 81 return NULL; 82 83 vp9_zero(*pbi); 84 85 if (setjmp(cm->error.jmp)) { 86 cm->error.setjmp = 0; 87 vp9_decoder_remove(pbi); 88 return NULL; 89 } 90 91 cm->error.setjmp = 1; 92 93 CHECK_MEM_ERROR(cm, cm->fc, 94 (FRAME_CONTEXT *)vpx_calloc(1, sizeof(*cm->fc))); 95 CHECK_MEM_ERROR(cm, cm->frame_contexts, 96 (FRAME_CONTEXT *)vpx_calloc(FRAME_CONTEXTS, 97 sizeof(*cm->frame_contexts))); 98 99 pbi->need_resync = 1; 100 once(initialize_dec); 101 102 // Initialize the references to not point to any frame buffers. 103 memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map)); 104 memset(&cm->next_ref_frame_map, -1, sizeof(cm->next_ref_frame_map)); 105 106 cm->current_video_frame = 0; 107 pbi->ready_for_new_data = 1; 108 pbi->common.buffer_pool = pool; 109 110 cm->bit_depth = VPX_BITS_8; 111 cm->dequant_bit_depth = VPX_BITS_8; 112 113 cm->alloc_mi = vp9_dec_alloc_mi; 114 cm->free_mi = vp9_dec_free_mi; 115 cm->setup_mi = vp9_dec_setup_mi; 116 117 vp9_loop_filter_init(cm); 118 119 cm->error.setjmp = 0; 120 121 vpx_get_worker_interface()->init(&pbi->lf_worker); 122 123 return pbi; 124} 125 126void vp9_decoder_remove(VP9Decoder *pbi) { 127 int i; 128 129 if (!pbi) 130 return; 131 132 vpx_get_worker_interface()->end(&pbi->lf_worker); 133 vpx_free(pbi->lf_worker.data1); 134 vpx_free(pbi->tile_data); 135 for (i = 0; i < pbi->num_tile_workers; ++i) { 136 VPxWorker *const worker = &pbi->tile_workers[i]; 137 vpx_get_worker_interface()->end(worker); 138 } 139 vpx_free(pbi->tile_worker_data); 140 vpx_free(pbi->tile_workers); 141 142 if (pbi->num_tile_workers > 0) { 143 vp9_loop_filter_dealloc(&pbi->lf_row_sync); 144 } 145 146 vpx_free(pbi); 147} 148 149static int equal_dimensions(const YV12_BUFFER_CONFIG *a, 150 const YV12_BUFFER_CONFIG *b) { 151 return a->y_height == b->y_height && a->y_width == b->y_width && 152 a->uv_height == b->uv_height && a->uv_width == b->uv_width; 153} 154 155vpx_codec_err_t vp9_copy_reference_dec(VP9Decoder *pbi, 156 VP9_REFFRAME ref_frame_flag, 157 YV12_BUFFER_CONFIG *sd) { 158 VP9_COMMON *cm = &pbi->common; 159 160 /* TODO(jkoleszar): The decoder doesn't have any real knowledge of what the 161 * encoder is using the frame buffers for. This is just a stub to keep the 162 * vpxenc --test-decode functionality working, and will be replaced in a 163 * later commit that adds VP9-specific controls for this functionality. 164 */ 165 if (ref_frame_flag == VP9_LAST_FLAG) { 166 const YV12_BUFFER_CONFIG *const cfg = get_ref_frame(cm, 0); 167 if (cfg == NULL) { 168 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 169 "No 'last' reference frame"); 170 return VPX_CODEC_ERROR; 171 } 172 if (!equal_dimensions(cfg, sd)) 173 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 174 "Incorrect buffer dimensions"); 175 else 176 vp8_yv12_copy_frame(cfg, sd); 177 } else { 178 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 179 "Invalid reference frame"); 180 } 181 182 return cm->error.error_code; 183} 184 185 186vpx_codec_err_t vp9_set_reference_dec(VP9_COMMON *cm, 187 VP9_REFFRAME ref_frame_flag, 188 YV12_BUFFER_CONFIG *sd) { 189 RefBuffer *ref_buf = NULL; 190 RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; 191 192 // TODO(jkoleszar): The decoder doesn't have any real knowledge of what the 193 // encoder is using the frame buffers for. This is just a stub to keep the 194 // vpxenc --test-decode functionality working, and will be replaced in a 195 // later commit that adds VP9-specific controls for this functionality. 196 if (ref_frame_flag == VP9_LAST_FLAG) { 197 ref_buf = &cm->frame_refs[0]; 198 } else if (ref_frame_flag == VP9_GOLD_FLAG) { 199 ref_buf = &cm->frame_refs[1]; 200 } else if (ref_frame_flag == VP9_ALT_FLAG) { 201 ref_buf = &cm->frame_refs[2]; 202 } else { 203 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 204 "Invalid reference frame"); 205 return cm->error.error_code; 206 } 207 208 if (!equal_dimensions(ref_buf->buf, sd)) { 209 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, 210 "Incorrect buffer dimensions"); 211 } else { 212 int *ref_fb_ptr = &ref_buf->idx; 213 214 // Find an empty frame buffer. 215 const int free_fb = get_free_fb(cm); 216 if (cm->new_fb_idx == INVALID_IDX) 217 return VPX_CODEC_MEM_ERROR; 218 219 // Decrease ref_count since it will be increased again in 220 // ref_cnt_fb() below. 221 --frame_bufs[free_fb].ref_count; 222 223 // Manage the reference counters and copy image. 224 ref_cnt_fb(frame_bufs, ref_fb_ptr, free_fb); 225 ref_buf->buf = &frame_bufs[*ref_fb_ptr].buf; 226 vp8_yv12_copy_frame(sd, ref_buf->buf); 227 } 228 229 return cm->error.error_code; 230} 231 232/* If any buffer updating is signaled it should be done here. */ 233static void swap_frame_buffers(VP9Decoder *pbi) { 234 int ref_index = 0, mask; 235 VP9_COMMON *const cm = &pbi->common; 236 BufferPool *const pool = cm->buffer_pool; 237 RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs; 238 239 lock_buffer_pool(pool); 240 for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) { 241 const int old_idx = cm->ref_frame_map[ref_index]; 242 // Current thread releases the holding of reference frame. 243 decrease_ref_count(old_idx, frame_bufs, pool); 244 245 // Release the reference frame in reference map. 246 if ((mask & 1) && old_idx >= 0) { 247 decrease_ref_count(old_idx, frame_bufs, pool); 248 } 249 cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index]; 250 ++ref_index; 251 } 252 253 // Current thread releases the holding of reference frame. 254 for (; ref_index < REF_FRAMES && !cm->show_existing_frame; ++ref_index) { 255 const int old_idx = cm->ref_frame_map[ref_index]; 256 decrease_ref_count(old_idx, frame_bufs, pool); 257 cm->ref_frame_map[ref_index] = cm->next_ref_frame_map[ref_index]; 258 } 259 unlock_buffer_pool(pool); 260 pbi->hold_ref_buf = 0; 261 cm->frame_to_show = get_frame_new_buffer(cm); 262 263 if (!pbi->frame_parallel_decode || !cm->show_frame) { 264 lock_buffer_pool(pool); 265 --frame_bufs[cm->new_fb_idx].ref_count; 266 unlock_buffer_pool(pool); 267 } 268 269 // Invalidate these references until the next frame starts. 270 for (ref_index = 0; ref_index < 3; ref_index++) 271 cm->frame_refs[ref_index].idx = -1; 272} 273 274int vp9_receive_compressed_data(VP9Decoder *pbi, 275 size_t size, const uint8_t **psource) { 276 VP9_COMMON *volatile const cm = &pbi->common; 277 BufferPool *volatile const pool = cm->buffer_pool; 278 RefCntBuffer *volatile const frame_bufs = cm->buffer_pool->frame_bufs; 279 const uint8_t *source = *psource; 280 int retcode = 0; 281 cm->error.error_code = VPX_CODEC_OK; 282 283 if (size == 0) { 284 // This is used to signal that we are missing frames. 285 // We do not know if the missing frame(s) was supposed to update 286 // any of the reference buffers, but we act conservative and 287 // mark only the last buffer as corrupted. 288 // 289 // TODO(jkoleszar): Error concealment is undefined and non-normative 290 // at this point, but if it becomes so, [0] may not always be the correct 291 // thing to do here. 292 if (cm->frame_refs[0].idx > 0) { 293 assert(cm->frame_refs[0].buf != NULL); 294 cm->frame_refs[0].buf->corrupted = 1; 295 } 296 } 297 298 pbi->ready_for_new_data = 0; 299 300 // Check if the previous frame was a frame without any references to it. 301 // Release frame buffer if not decoding in frame parallel mode. 302 if (!pbi->frame_parallel_decode && cm->new_fb_idx >= 0 303 && frame_bufs[cm->new_fb_idx].ref_count == 0) 304 pool->release_fb_cb(pool->cb_priv, 305 &frame_bufs[cm->new_fb_idx].raw_frame_buffer); 306 // Find a free frame buffer. Return error if can not find any. 307 cm->new_fb_idx = get_free_fb(cm); 308 if (cm->new_fb_idx == INVALID_IDX) 309 return VPX_CODEC_MEM_ERROR; 310 311 // Assign a MV array to the frame buffer. 312 cm->cur_frame = &pool->frame_bufs[cm->new_fb_idx]; 313 314 pbi->hold_ref_buf = 0; 315 if (pbi->frame_parallel_decode) { 316 VPxWorker *const worker = pbi->frame_worker_owner; 317 vp9_frameworker_lock_stats(worker); 318 frame_bufs[cm->new_fb_idx].frame_worker_owner = worker; 319 // Reset decoding progress. 320 pbi->cur_buf = &frame_bufs[cm->new_fb_idx]; 321 pbi->cur_buf->row = -1; 322 pbi->cur_buf->col = -1; 323 vp9_frameworker_unlock_stats(worker); 324 } else { 325 pbi->cur_buf = &frame_bufs[cm->new_fb_idx]; 326 } 327 328 329 if (setjmp(cm->error.jmp)) { 330 const VPxWorkerInterface *const winterface = vpx_get_worker_interface(); 331 int i; 332 333 cm->error.setjmp = 0; 334 pbi->ready_for_new_data = 1; 335 336 // Synchronize all threads immediately as a subsequent decode call may 337 // cause a resize invalidating some allocations. 338 winterface->sync(&pbi->lf_worker); 339 for (i = 0; i < pbi->num_tile_workers; ++i) { 340 winterface->sync(&pbi->tile_workers[i]); 341 } 342 343 lock_buffer_pool(pool); 344 // Release all the reference buffers if worker thread is holding them. 345 if (pbi->hold_ref_buf == 1) { 346 int ref_index = 0, mask; 347 for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) { 348 const int old_idx = cm->ref_frame_map[ref_index]; 349 // Current thread releases the holding of reference frame. 350 decrease_ref_count(old_idx, frame_bufs, pool); 351 352 // Release the reference frame in reference map. 353 if ((mask & 1) && old_idx >= 0) { 354 decrease_ref_count(old_idx, frame_bufs, pool); 355 } 356 ++ref_index; 357 } 358 359 // Current thread releases the holding of reference frame. 360 for (; ref_index < REF_FRAMES && !cm->show_existing_frame; ++ref_index) { 361 const int old_idx = cm->ref_frame_map[ref_index]; 362 decrease_ref_count(old_idx, frame_bufs, pool); 363 } 364 pbi->hold_ref_buf = 0; 365 } 366 // Release current frame. 367 decrease_ref_count(cm->new_fb_idx, frame_bufs, pool); 368 unlock_buffer_pool(pool); 369 370 vpx_clear_system_state(); 371 return -1; 372 } 373 374 cm->error.setjmp = 1; 375 vp9_decode_frame(pbi, source, source + size, psource); 376 377 swap_frame_buffers(pbi); 378 379 vpx_clear_system_state(); 380 381 if (!cm->show_existing_frame) { 382 cm->last_show_frame = cm->show_frame; 383 cm->prev_frame = cm->cur_frame; 384 if (cm->seg.enabled && !pbi->frame_parallel_decode) 385 vp9_swap_current_and_last_seg_map(cm); 386 } 387 388 // Update progress in frame parallel decode. 389 if (pbi->frame_parallel_decode) { 390 // Need to lock the mutex here as another thread may 391 // be accessing this buffer. 392 VPxWorker *const worker = pbi->frame_worker_owner; 393 FrameWorkerData *const frame_worker_data = worker->data1; 394 vp9_frameworker_lock_stats(worker); 395 396 if (cm->show_frame) { 397 cm->current_video_frame++; 398 } 399 frame_worker_data->frame_decoded = 1; 400 frame_worker_data->frame_context_ready = 1; 401 vp9_frameworker_signal_stats(worker); 402 vp9_frameworker_unlock_stats(worker); 403 } else { 404 cm->last_width = cm->width; 405 cm->last_height = cm->height; 406 if (cm->show_frame) { 407 cm->current_video_frame++; 408 } 409 } 410 411 cm->error.setjmp = 0; 412 return retcode; 413} 414 415int vp9_get_raw_frame(VP9Decoder *pbi, YV12_BUFFER_CONFIG *sd, 416 vp9_ppflags_t *flags) { 417 VP9_COMMON *const cm = &pbi->common; 418 int ret = -1; 419#if !CONFIG_VP9_POSTPROC 420 (void)*flags; 421#endif 422 423 if (pbi->ready_for_new_data == 1) 424 return ret; 425 426 pbi->ready_for_new_data = 1; 427 428 /* no raw frame to show!!! */ 429 if (!cm->show_frame) 430 return ret; 431 432 pbi->ready_for_new_data = 1; 433 434#if CONFIG_VP9_POSTPROC 435 if (!cm->show_existing_frame) { 436 ret = vp9_post_proc_frame(cm, sd, flags); 437 } else { 438 *sd = *cm->frame_to_show; 439 ret = 0; 440 } 441#else 442 *sd = *cm->frame_to_show; 443 ret = 0; 444#endif /*!CONFIG_POSTPROC*/ 445 vpx_clear_system_state(); 446 return ret; 447} 448 449vpx_codec_err_t vp9_parse_superframe_index(const uint8_t *data, 450 size_t data_sz, 451 uint32_t sizes[8], int *count, 452 vpx_decrypt_cb decrypt_cb, 453 void *decrypt_state) { 454 // A chunk ending with a byte matching 0xc0 is an invalid chunk unless 455 // it is a super frame index. If the last byte of real video compression 456 // data is 0xc0 the encoder must add a 0 byte. If we have the marker but 457 // not the associated matching marker byte at the front of the index we have 458 // an invalid bitstream and need to return an error. 459 460 uint8_t marker; 461 462 assert(data_sz); 463 marker = read_marker(decrypt_cb, decrypt_state, data + data_sz - 1); 464 *count = 0; 465 466 if ((marker & 0xe0) == 0xc0) { 467 const uint32_t frames = (marker & 0x7) + 1; 468 const uint32_t mag = ((marker >> 3) & 0x3) + 1; 469 const size_t index_sz = 2 + mag * frames; 470 471 // This chunk is marked as having a superframe index but doesn't have 472 // enough data for it, thus it's an invalid superframe index. 473 if (data_sz < index_sz) 474 return VPX_CODEC_CORRUPT_FRAME; 475 476 { 477 const uint8_t marker2 = read_marker(decrypt_cb, decrypt_state, 478 data + data_sz - index_sz); 479 480 // This chunk is marked as having a superframe index but doesn't have 481 // the matching marker byte at the front of the index therefore it's an 482 // invalid chunk. 483 if (marker != marker2) 484 return VPX_CODEC_CORRUPT_FRAME; 485 } 486 487 { 488 // Found a valid superframe index. 489 uint32_t i, j; 490 const uint8_t *x = &data[data_sz - index_sz + 1]; 491 492 // Frames has a maximum of 8 and mag has a maximum of 4. 493 uint8_t clear_buffer[32]; 494 assert(sizeof(clear_buffer) >= frames * mag); 495 if (decrypt_cb) { 496 decrypt_cb(decrypt_state, x, clear_buffer, frames * mag); 497 x = clear_buffer; 498 } 499 500 for (i = 0; i < frames; ++i) { 501 uint32_t this_sz = 0; 502 503 for (j = 0; j < mag; ++j) 504 this_sz |= (*x++) << (j * 8); 505 sizes[i] = this_sz; 506 } 507 *count = frames; 508 } 509 } 510 return VPX_CODEC_OK; 511} 512