OLD | NEW |
(Empty) | |
| 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 "./vpx_scale_rtcd.h" |
| 16 |
| 17 #include "vpx_mem/vpx_mem.h" |
| 18 #include "vpx_ports/vpx_timer.h" |
| 19 #include "vpx_scale/vpx_scale.h" |
| 20 |
| 21 #include "vp9/common/vp9_alloccommon.h" |
| 22 #include "vp9/common/vp9_loopfilter.h" |
| 23 #include "vp9/common/vp9_onyxc_int.h" |
| 24 #if CONFIG_VP9_POSTPROC |
| 25 #include "vp9/common/vp9_postproc.h" |
| 26 #endif |
| 27 #include "vp9/common/vp9_quant_common.h" |
| 28 #include "vp9/common/vp9_systemdependent.h" |
| 29 |
| 30 #include "vp9/decoder/vp9_decodeframe.h" |
| 31 #include "vp9/decoder/vp9_decoder.h" |
| 32 #include "vp9/decoder/vp9_detokenize.h" |
| 33 #include "vp9/decoder/vp9_dthread.h" |
| 34 |
| 35 #define WRITE_RECON_BUFFER 0 |
| 36 #if WRITE_RECON_BUFFER == 1 |
| 37 static void recon_write_yuv_frame(const char *name, |
| 38 const YV12_BUFFER_CONFIG *s, |
| 39 int w, int _h) { |
| 40 FILE *yuv_file = fopen(name, "ab"); |
| 41 const uint8_t *src = s->y_buffer; |
| 42 int h = _h; |
| 43 |
| 44 do { |
| 45 fwrite(src, w, 1, yuv_file); |
| 46 src += s->y_stride; |
| 47 } while (--h); |
| 48 |
| 49 src = s->u_buffer; |
| 50 h = (_h + 1) >> 1; |
| 51 w = (w + 1) >> 1; |
| 52 |
| 53 do { |
| 54 fwrite(src, w, 1, yuv_file); |
| 55 src += s->uv_stride; |
| 56 } while (--h); |
| 57 |
| 58 src = s->v_buffer; |
| 59 h = (_h + 1) >> 1; |
| 60 |
| 61 do { |
| 62 fwrite(src, w, 1, yuv_file); |
| 63 src += s->uv_stride; |
| 64 } while (--h); |
| 65 |
| 66 fclose(yuv_file); |
| 67 } |
| 68 #endif |
| 69 #if WRITE_RECON_BUFFER == 2 |
| 70 void write_dx_frame_to_file(YV12_BUFFER_CONFIG *frame, int this_frame) { |
| 71 // write the frame |
| 72 FILE *yframe; |
| 73 int i; |
| 74 char filename[255]; |
| 75 |
| 76 snprintf(filename, sizeof(filename)-1, "dx\\y%04d.raw", this_frame); |
| 77 yframe = fopen(filename, "wb"); |
| 78 |
| 79 for (i = 0; i < frame->y_height; i++) |
| 80 fwrite(frame->y_buffer + i * frame->y_stride, |
| 81 frame->y_width, 1, yframe); |
| 82 |
| 83 fclose(yframe); |
| 84 snprintf(filename, sizeof(filename)-1, "dx\\u%04d.raw", this_frame); |
| 85 yframe = fopen(filename, "wb"); |
| 86 |
| 87 for (i = 0; i < frame->uv_height; i++) |
| 88 fwrite(frame->u_buffer + i * frame->uv_stride, |
| 89 frame->uv_width, 1, yframe); |
| 90 |
| 91 fclose(yframe); |
| 92 snprintf(filename, sizeof(filename)-1, "dx\\v%04d.raw", this_frame); |
| 93 yframe = fopen(filename, "wb"); |
| 94 |
| 95 for (i = 0; i < frame->uv_height; i++) |
| 96 fwrite(frame->v_buffer + i * frame->uv_stride, |
| 97 frame->uv_width, 1, yframe); |
| 98 |
| 99 fclose(yframe); |
| 100 } |
| 101 #endif |
| 102 |
| 103 void vp9_initialize_dec() { |
| 104 static int init_done = 0; |
| 105 |
| 106 if (!init_done) { |
| 107 vp9_init_neighbors(); |
| 108 vp9_init_quant_tables(); |
| 109 init_done = 1; |
| 110 } |
| 111 } |
| 112 |
| 113 VP9Decoder *vp9_decoder_create(const VP9D_CONFIG *oxcf) { |
| 114 VP9Decoder *const pbi = vpx_memalign(32, sizeof(*pbi)); |
| 115 VP9_COMMON *const cm = pbi ? &pbi->common : NULL; |
| 116 |
| 117 if (!cm) |
| 118 return NULL; |
| 119 |
| 120 vp9_zero(*pbi); |
| 121 |
| 122 if (setjmp(cm->error.jmp)) { |
| 123 cm->error.setjmp = 0; |
| 124 vp9_decoder_remove(pbi); |
| 125 return NULL; |
| 126 } |
| 127 |
| 128 cm->error.setjmp = 1; |
| 129 vp9_initialize_dec(); |
| 130 |
| 131 vp9_rtcd(); |
| 132 |
| 133 // Initialize the references to not point to any frame buffers. |
| 134 vpx_memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map)); |
| 135 |
| 136 cm->current_video_frame = 0; |
| 137 pbi->oxcf = *oxcf; |
| 138 pbi->ready_for_new_data = 1; |
| 139 pbi->decoded_key_frame = 0; |
| 140 |
| 141 // vp9_init_dequantizer() is first called here. Add check in |
| 142 // frame_init_dequantizer() to avoid unnecessary calling of |
| 143 // vp9_init_dequantizer() for every frame. |
| 144 vp9_init_dequantizer(cm); |
| 145 |
| 146 vp9_loop_filter_init(cm); |
| 147 |
| 148 cm->error.setjmp = 0; |
| 149 |
| 150 vp9_worker_init(&pbi->lf_worker); |
| 151 |
| 152 return pbi; |
| 153 } |
| 154 |
| 155 void vp9_decoder_remove(VP9Decoder *pbi) { |
| 156 VP9_COMMON *const cm = &pbi->common; |
| 157 int i; |
| 158 |
| 159 vp9_remove_common(cm); |
| 160 vp9_worker_end(&pbi->lf_worker); |
| 161 vpx_free(pbi->lf_worker.data1); |
| 162 for (i = 0; i < pbi->num_tile_workers; ++i) { |
| 163 VP9Worker *const worker = &pbi->tile_workers[i]; |
| 164 vp9_worker_end(worker); |
| 165 vpx_free(worker->data1); |
| 166 vpx_free(worker->data2); |
| 167 } |
| 168 vpx_free(pbi->tile_workers); |
| 169 |
| 170 if (pbi->num_tile_workers) { |
| 171 const int sb_rows = |
| 172 mi_cols_aligned_to_sb(cm->mi_rows) >> MI_BLOCK_SIZE_LOG2; |
| 173 vp9_loop_filter_dealloc(&pbi->lf_row_sync, sb_rows); |
| 174 } |
| 175 |
| 176 vpx_free(pbi); |
| 177 } |
| 178 |
| 179 static int equal_dimensions(const YV12_BUFFER_CONFIG *a, |
| 180 const YV12_BUFFER_CONFIG *b) { |
| 181 return a->y_height == b->y_height && a->y_width == b->y_width && |
| 182 a->uv_height == b->uv_height && a->uv_width == b->uv_width; |
| 183 } |
| 184 |
| 185 vpx_codec_err_t vp9_copy_reference_dec(VP9Decoder *pbi, |
| 186 VP9_REFFRAME ref_frame_flag, |
| 187 YV12_BUFFER_CONFIG *sd) { |
| 188 VP9_COMMON *cm = &pbi->common; |
| 189 |
| 190 /* TODO(jkoleszar): The decoder doesn't have any real knowledge of what the |
| 191 * encoder is using the frame buffers for. This is just a stub to keep the |
| 192 * vpxenc --test-decode functionality working, and will be replaced in a |
| 193 * later commit that adds VP9-specific controls for this functionality. |
| 194 */ |
| 195 if (ref_frame_flag == VP9_LAST_FLAG) { |
| 196 const YV12_BUFFER_CONFIG *const cfg = |
| 197 &cm->frame_bufs[cm->ref_frame_map[0]].buf; |
| 198 if (!equal_dimensions(cfg, sd)) |
| 199 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, |
| 200 "Incorrect buffer dimensions"); |
| 201 else |
| 202 vp8_yv12_copy_frame(cfg, sd); |
| 203 } else { |
| 204 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, |
| 205 "Invalid reference frame"); |
| 206 } |
| 207 |
| 208 return cm->error.error_code; |
| 209 } |
| 210 |
| 211 |
| 212 vpx_codec_err_t vp9_set_reference_dec(VP9_COMMON *cm, |
| 213 VP9_REFFRAME ref_frame_flag, |
| 214 YV12_BUFFER_CONFIG *sd) { |
| 215 RefBuffer *ref_buf = NULL; |
| 216 |
| 217 // TODO(jkoleszar): The decoder doesn't have any real knowledge of what the |
| 218 // encoder is using the frame buffers for. This is just a stub to keep the |
| 219 // vpxenc --test-decode functionality working, and will be replaced in a |
| 220 // later commit that adds VP9-specific controls for this functionality. |
| 221 if (ref_frame_flag == VP9_LAST_FLAG) { |
| 222 ref_buf = &cm->frame_refs[0]; |
| 223 } else if (ref_frame_flag == VP9_GOLD_FLAG) { |
| 224 ref_buf = &cm->frame_refs[1]; |
| 225 } else if (ref_frame_flag == VP9_ALT_FLAG) { |
| 226 ref_buf = &cm->frame_refs[2]; |
| 227 } else { |
| 228 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, |
| 229 "Invalid reference frame"); |
| 230 return cm->error.error_code; |
| 231 } |
| 232 |
| 233 if (!equal_dimensions(ref_buf->buf, sd)) { |
| 234 vpx_internal_error(&cm->error, VPX_CODEC_ERROR, |
| 235 "Incorrect buffer dimensions"); |
| 236 } else { |
| 237 int *ref_fb_ptr = &ref_buf->idx; |
| 238 |
| 239 // Find an empty frame buffer. |
| 240 const int free_fb = get_free_fb(cm); |
| 241 // Decrease ref_count since it will be increased again in |
| 242 // ref_cnt_fb() below. |
| 243 cm->frame_bufs[free_fb].ref_count--; |
| 244 |
| 245 // Manage the reference counters and copy image. |
| 246 ref_cnt_fb(cm->frame_bufs, ref_fb_ptr, free_fb); |
| 247 ref_buf->buf = &cm->frame_bufs[*ref_fb_ptr].buf; |
| 248 vp8_yv12_copy_frame(sd, ref_buf->buf); |
| 249 } |
| 250 |
| 251 return cm->error.error_code; |
| 252 } |
| 253 |
| 254 |
| 255 int vp9_get_reference_dec(VP9Decoder *pbi, int index, YV12_BUFFER_CONFIG **fb) { |
| 256 VP9_COMMON *cm = &pbi->common; |
| 257 |
| 258 if (index < 0 || index >= REF_FRAMES) |
| 259 return -1; |
| 260 |
| 261 *fb = &cm->frame_bufs[cm->ref_frame_map[index]].buf; |
| 262 return 0; |
| 263 } |
| 264 |
| 265 /* If any buffer updating is signaled it should be done here. */ |
| 266 static void swap_frame_buffers(VP9Decoder *pbi) { |
| 267 int ref_index = 0, mask; |
| 268 VP9_COMMON *const cm = &pbi->common; |
| 269 |
| 270 for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) { |
| 271 if (mask & 1) { |
| 272 const int old_idx = cm->ref_frame_map[ref_index]; |
| 273 ref_cnt_fb(cm->frame_bufs, &cm->ref_frame_map[ref_index], |
| 274 cm->new_fb_idx); |
| 275 if (old_idx >= 0 && cm->frame_bufs[old_idx].ref_count == 0) |
| 276 cm->release_fb_cb(cm->cb_priv, |
| 277 &cm->frame_bufs[old_idx].raw_frame_buffer); |
| 278 } |
| 279 ++ref_index; |
| 280 } |
| 281 |
| 282 cm->frame_to_show = get_frame_new_buffer(cm); |
| 283 cm->frame_bufs[cm->new_fb_idx].ref_count--; |
| 284 |
| 285 // Invalidate these references until the next frame starts. |
| 286 for (ref_index = 0; ref_index < 3; ref_index++) |
| 287 cm->frame_refs[ref_index].idx = INT_MAX; |
| 288 } |
| 289 |
| 290 int vp9_receive_compressed_data(VP9Decoder *pbi, |
| 291 size_t size, const uint8_t **psource, |
| 292 int64_t time_stamp) { |
| 293 VP9_COMMON *const cm = &pbi->common; |
| 294 const uint8_t *source = *psource; |
| 295 int retcode = 0; |
| 296 |
| 297 cm->error.error_code = VPX_CODEC_OK; |
| 298 |
| 299 if (size == 0) { |
| 300 // This is used to signal that we are missing frames. |
| 301 // We do not know if the missing frame(s) was supposed to update |
| 302 // any of the reference buffers, but we act conservative and |
| 303 // mark only the last buffer as corrupted. |
| 304 // |
| 305 // TODO(jkoleszar): Error concealment is undefined and non-normative |
| 306 // at this point, but if it becomes so, [0] may not always be the correct |
| 307 // thing to do here. |
| 308 if (cm->frame_refs[0].idx != INT_MAX) |
| 309 cm->frame_refs[0].buf->corrupted = 1; |
| 310 } |
| 311 |
| 312 // Check if the previous frame was a frame without any references to it. |
| 313 if (cm->new_fb_idx >= 0 && cm->frame_bufs[cm->new_fb_idx].ref_count == 0) |
| 314 cm->release_fb_cb(cm->cb_priv, |
| 315 &cm->frame_bufs[cm->new_fb_idx].raw_frame_buffer); |
| 316 cm->new_fb_idx = get_free_fb(cm); |
| 317 |
| 318 if (setjmp(cm->error.jmp)) { |
| 319 cm->error.setjmp = 0; |
| 320 |
| 321 // We do not know if the missing frame(s) was supposed to update |
| 322 // any of the reference buffers, but we act conservative and |
| 323 // mark only the last buffer as corrupted. |
| 324 // |
| 325 // TODO(jkoleszar): Error concealment is undefined and non-normative |
| 326 // at this point, but if it becomes so, [0] may not always be the correct |
| 327 // thing to do here. |
| 328 if (cm->frame_refs[0].idx != INT_MAX) |
| 329 cm->frame_refs[0].buf->corrupted = 1; |
| 330 |
| 331 if (cm->frame_bufs[cm->new_fb_idx].ref_count > 0) |
| 332 cm->frame_bufs[cm->new_fb_idx].ref_count--; |
| 333 |
| 334 return -1; |
| 335 } |
| 336 |
| 337 cm->error.setjmp = 1; |
| 338 |
| 339 retcode = vp9_decode_frame(pbi, source, source + size, psource); |
| 340 |
| 341 if (retcode < 0) { |
| 342 cm->error.error_code = VPX_CODEC_ERROR; |
| 343 cm->error.setjmp = 0; |
| 344 if (cm->frame_bufs[cm->new_fb_idx].ref_count > 0) |
| 345 cm->frame_bufs[cm->new_fb_idx].ref_count--; |
| 346 return retcode; |
| 347 } |
| 348 |
| 349 swap_frame_buffers(pbi); |
| 350 |
| 351 #if WRITE_RECON_BUFFER == 2 |
| 352 if (cm->show_frame) |
| 353 write_dx_frame_to_file(cm->frame_to_show, |
| 354 cm->current_video_frame); |
| 355 else |
| 356 write_dx_frame_to_file(cm->frame_to_show, |
| 357 cm->current_video_frame + 1000); |
| 358 #endif |
| 359 |
| 360 if (!pbi->do_loopfilter_inline) { |
| 361 // If multiple threads are used to decode tiles, then we use those threads |
| 362 // to do parallel loopfiltering. |
| 363 if (pbi->num_tile_workers) { |
| 364 vp9_loop_filter_frame_mt(pbi, cm, &pbi->mb, cm->lf.filter_level, 0, 0); |
| 365 } else { |
| 366 vp9_loop_filter_frame(cm, &pbi->mb, cm->lf.filter_level, 0, 0); |
| 367 } |
| 368 } |
| 369 |
| 370 #if WRITE_RECON_BUFFER == 2 |
| 371 if (cm->show_frame) |
| 372 write_dx_frame_to_file(cm->frame_to_show, |
| 373 cm->current_video_frame + 2000); |
| 374 else |
| 375 write_dx_frame_to_file(cm->frame_to_show, |
| 376 cm->current_video_frame + 3000); |
| 377 #endif |
| 378 |
| 379 #if WRITE_RECON_BUFFER == 1 |
| 380 if (cm->show_frame) |
| 381 recon_write_yuv_frame("recon.yuv", cm->frame_to_show, |
| 382 cm->width, cm->height); |
| 383 #endif |
| 384 |
| 385 vp9_clear_system_state(); |
| 386 |
| 387 cm->last_width = cm->width; |
| 388 cm->last_height = cm->height; |
| 389 |
| 390 if (!cm->show_existing_frame) |
| 391 cm->last_show_frame = cm->show_frame; |
| 392 if (cm->show_frame) { |
| 393 if (!cm->show_existing_frame) |
| 394 vp9_swap_mi_and_prev_mi(cm); |
| 395 |
| 396 cm->current_video_frame++; |
| 397 } |
| 398 |
| 399 pbi->ready_for_new_data = 0; |
| 400 pbi->last_time_stamp = time_stamp; |
| 401 |
| 402 cm->error.setjmp = 0; |
| 403 return retcode; |
| 404 } |
| 405 |
| 406 int vp9_get_raw_frame(VP9Decoder *pbi, YV12_BUFFER_CONFIG *sd, |
| 407 int64_t *time_stamp, int64_t *time_end_stamp, |
| 408 vp9_ppflags_t *flags) { |
| 409 int ret = -1; |
| 410 |
| 411 if (pbi->ready_for_new_data == 1) |
| 412 return ret; |
| 413 |
| 414 /* ie no raw frame to show!!! */ |
| 415 if (pbi->common.show_frame == 0) |
| 416 return ret; |
| 417 |
| 418 pbi->ready_for_new_data = 1; |
| 419 *time_stamp = pbi->last_time_stamp; |
| 420 *time_end_stamp = 0; |
| 421 |
| 422 #if CONFIG_VP9_POSTPROC |
| 423 ret = vp9_post_proc_frame(&pbi->common, sd, flags); |
| 424 #else |
| 425 *sd = *pbi->common.frame_to_show; |
| 426 sd->y_width = pbi->common.width; |
| 427 sd->y_height = pbi->common.height; |
| 428 sd->uv_width = sd->y_width >> pbi->common.subsampling_x; |
| 429 sd->uv_height = sd->y_height >> pbi->common.subsampling_y; |
| 430 ret = 0; |
| 431 #endif /*!CONFIG_POSTPROC*/ |
| 432 vp9_clear_system_state(); |
| 433 return ret; |
| 434 } |
OLD | NEW |