src/third_party/libvpx/source/libvpx/vp9/decoder/vp9_decoder.c

   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_reconintra.h"
  29 #include "vp9/common/vp9_systemdependent.h"
  30
  31 #include "vp9/decoder/vp9_decodeframe.h"
  32 #include "vp9/decoder/vp9_decoder.h"
  33 #include "vp9/decoder/vp9_detokenize.h"
  34 #include "vp9/decoder/vp9_dthread.h"
  35
  36 static void initialize_dec() {
  37   static int init_done = 0;
  38
  39   if (!init_done) {
  40     vp9_rtcd();
  41     vp9_init_intra_predictors();
  42     init_done = 1;
  43   }
  44 }
  45
  46 VP9Decoder *vp9_decoder_create() {
  47   VP9Decoder *const pbi = vpx_memalign(32, sizeof(*pbi));
  48   VP9_COMMON *const cm = pbi ? &pbi->common : NULL;
  49
  50   if (!cm)
  51     return NULL;
  52
  53   vp9_zero(*pbi);
  54
  55   if (setjmp(cm->error.jmp)) {
  56     cm->error.setjmp = 0;
  57     vp9_decoder_remove(pbi);
  58     return NULL;
  59   }
  60
  61   cm->error.setjmp = 1;
  62   pbi->need_resync = 1;
  63   initialize_dec();
  64
  65   // Initialize the references to not point to any frame buffers.
  66   vpx_memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map));
  67
  68   cm->current_video_frame = 0;
  69   pbi->ready_for_new_data = 1;
  70   cm->bit_depth = VPX_BITS_8;
  71   cm->dequant_bit_depth = VPX_BITS_8;
  72
  73   // vp9_init_dequantizer() is first called here. Add check in
  74   // frame_init_dequantizer() to avoid unnecessary calling of
  75   // vp9_init_dequantizer() for every frame.
  76   vp9_init_dequantizer(cm);
  77
  78   vp9_loop_filter_init(cm);
  79
  80   cm->error.setjmp = 0;
  81
  82   vp9_get_worker_interface()->init(&pbi->lf_worker);
  83
  84   return pbi;
  85 }
  86
  87 void vp9_decoder_remove(VP9Decoder *pbi) {
  88   VP9_COMMON *const cm = &pbi->common;
  89   int i;
  90
  91   vp9_get_worker_interface()->end(&pbi->lf_worker);
  92   vpx_free(pbi->lf_worker.data1);
  93   vpx_free(pbi->tile_data);
  94   for (i = 0; i < pbi->num_tile_workers; ++i) {
  95     VP9Worker *const worker = &pbi->tile_workers[i];
  96     vp9_get_worker_interface()->end(worker);
  97     vpx_free(worker->data1);
  98     vpx_free(worker->data2);
  99   }
 100   vpx_free(pbi->tile_workers);
 101
 102   if (pbi->num_tile_workers > 0) {
 103     vp9_loop_filter_dealloc(&pbi->lf_row_sync);
 104   }
 105
 106   vp9_remove_common(cm);
 107   vpx_free(pbi);
 108 }
 109
 110 static int equal_dimensions(const YV12_BUFFER_CONFIG *a,
 111                             const YV12_BUFFER_CONFIG *b) {
 112     return a->y_height == b->y_height && a->y_width == b->y_width &&
 113            a->uv_height == b->uv_height && a->uv_width == b->uv_width;
 114 }
 115
 116 vpx_codec_err_t vp9_copy_reference_dec(VP9Decoder *pbi,
 117                                        VP9_REFFRAME ref_frame_flag,
 118                                        YV12_BUFFER_CONFIG *sd) {
 119   VP9_COMMON *cm = &pbi->common;
 120
 121   /* TODO(jkoleszar): The decoder doesn't have any real knowledge of what the
 122    * encoder is using the frame buffers for. This is just a stub to keep the
 123    * vpxenc --test-decode functionality working, and will be replaced in a
 124    * later commit that adds VP9-specific controls for this functionality.
 125    */
 126   if (ref_frame_flag == VP9_LAST_FLAG) {
 127     const YV12_BUFFER_CONFIG *const cfg = get_ref_frame(cm, 0);
 128     if (cfg == NULL) {
 129       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
 130                          "No 'last' reference frame");
 131       return VPX_CODEC_ERROR;
 132     }
 133     if (!equal_dimensions(cfg, sd))
 134       vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
 135                          "Incorrect buffer dimensions");
 136     else
 137       vp8_yv12_copy_frame(cfg, sd);
 138   } else {
 139     vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
 140                        "Invalid reference frame");
 141   }
 142
 143   return cm->error.error_code;
 144 }
 145
 146
 147 vpx_codec_err_t vp9_set_reference_dec(VP9_COMMON *cm,
 148                                       VP9_REFFRAME ref_frame_flag,
 149                                       YV12_BUFFER_CONFIG *sd) {
 150   RefBuffer *ref_buf = NULL;
 151
 152   // TODO(jkoleszar): The decoder doesn't have any real knowledge of what the
 153   // encoder is using the frame buffers for. This is just a stub to keep the
 154   // vpxenc --test-decode functionality working, and will be replaced in a
 155   // later commit that adds VP9-specific controls for this functionality.
 156   if (ref_frame_flag == VP9_LAST_FLAG) {
 157     ref_buf = &cm->frame_refs[0];
 158   } else if (ref_frame_flag == VP9_GOLD_FLAG) {
 159     ref_buf = &cm->frame_refs[1];
 160   } else if (ref_frame_flag == VP9_ALT_FLAG) {
 161     ref_buf = &cm->frame_refs[2];
 162   } else {
 163     vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
 164                        "Invalid reference frame");
 165     return cm->error.error_code;
 166   }
 167
 168   if (!equal_dimensions(ref_buf->buf, sd)) {
 169     vpx_internal_error(&cm->error, VPX_CODEC_ERROR,
 170                        "Incorrect buffer dimensions");
 171   } else {
 172     int *ref_fb_ptr = &ref_buf->idx;
 173
 174     // Find an empty frame buffer.
 175     const int free_fb = get_free_fb(cm);
 176     // Decrease ref_count since it will be increased again in
 177     // ref_cnt_fb() below.
 178     cm->frame_bufs[free_fb].ref_count--;
 179
 180     // Manage the reference counters and copy image.
 181     ref_cnt_fb(cm->frame_bufs, ref_fb_ptr, free_fb);
 182     ref_buf->buf = &cm->frame_bufs[*ref_fb_ptr].buf;
 183     vp8_yv12_copy_frame(sd, ref_buf->buf);
 184   }
 185
 186   return cm->error.error_code;
 187 }
 188
 189 /* If any buffer updating is signaled it should be done here. */
 190 static void swap_frame_buffers(VP9Decoder *pbi) {
 191   int ref_index = 0, mask;
 192   VP9_COMMON *const cm = &pbi->common;
 193
 194   for (mask = pbi->refresh_frame_flags; mask; mask >>= 1) {
 195     if (mask & 1) {
 196       const int old_idx = cm->ref_frame_map[ref_index];
 197       ref_cnt_fb(cm->frame_bufs, &cm->ref_frame_map[ref_index],
 198                  cm->new_fb_idx);
 199       if (old_idx >= 0 && cm->frame_bufs[old_idx].ref_count == 0)
 200         cm->release_fb_cb(cm->cb_priv,
 201                           &cm->frame_bufs[old_idx].raw_frame_buffer);
 202     }
 203     ++ref_index;
 204   }
 205
 206   cm->frame_to_show = get_frame_new_buffer(cm);
 207   cm->frame_bufs[cm->new_fb_idx].ref_count--;
 208
 209   // Invalidate these references until the next frame starts.
 210   for (ref_index = 0; ref_index < 3; ref_index++)
 211     cm->frame_refs[ref_index].idx = INT_MAX;
 212 }
 213
 214 int vp9_receive_compressed_data(VP9Decoder *pbi,
 215                                 size_t size, const uint8_t **psource) {
 216   VP9_COMMON *const cm = &pbi->common;
 217   const uint8_t *source = *psource;
 218   int retcode = 0;
 219
 220   cm->error.error_code = VPX_CODEC_OK;
 221
 222   if (size == 0) {
 223     // This is used to signal that we are missing frames.
 224     // We do not know if the missing frame(s) was supposed to update
 225     // any of the reference buffers, but we act conservative and
 226     // mark only the last buffer as corrupted.
 227     //
 228     // TODO(jkoleszar): Error concealment is undefined and non-normative
 229     // at this point, but if it becomes so, [0] may not always be the correct
 230     // thing to do here.
 231     if (cm->frame_refs[0].idx != INT_MAX)
 232       cm->frame_refs[0].buf->corrupted = 1;
 233   }
 234
 235   pbi->ready_for_new_data = 0;
 236
 237   // Check if the previous frame was a frame without any references to it.
 238   if (cm->new_fb_idx >= 0 && cm->frame_bufs[cm->new_fb_idx].ref_count == 0)
 239     cm->release_fb_cb(cm->cb_priv,
 240                       &cm->frame_bufs[cm->new_fb_idx].raw_frame_buffer);
 241   cm->new_fb_idx = get_free_fb(cm);
 242
 243   if (setjmp(cm->error.jmp)) {
 244     pbi->need_resync = 1;
 245     cm->error.setjmp = 0;
 246     vp9_clear_system_state();
 247
 248     // We do not know if the missing frame(s) was supposed to update
 249     // any of the reference buffers, but we act conservative and
 250     // mark only the last buffer as corrupted.
 251     //
 252     // TODO(jkoleszar): Error concealment is undefined and non-normative
 253     // at this point, but if it becomes so, [0] may not always be the correct
 254     // thing to do here.
 255     if (cm->frame_refs[0].idx != INT_MAX && cm->frame_refs[0].buf != NULL)
 256       cm->frame_refs[0].buf->corrupted = 1;
 257
 258     if (cm->new_fb_idx > 0 && cm->frame_bufs[cm->new_fb_idx].ref_count > 0)
 259       cm->frame_bufs[cm->new_fb_idx].ref_count--;
 260
 261     return -1;
 262   }
 263
 264   cm->error.setjmp = 1;
 265
 266   vp9_decode_frame(pbi, source, source + size, psource);
 267
 268   swap_frame_buffers(pbi);
 269
 270   vp9_clear_system_state();
 271
 272   cm->last_width = cm->width;
 273   cm->last_height = cm->height;
 274
 275   if (!cm->show_existing_frame)
 276     cm->last_show_frame = cm->show_frame;
 277   if (cm->show_frame) {
 278     if (!cm->show_existing_frame)
 279       vp9_swap_mi_and_prev_mi(cm);
 280
 281     cm->current_video_frame++;
 282   }
 283
 284   cm->error.setjmp = 0;
 285   return retcode;
 286 }
 287
 288 int vp9_get_raw_frame(VP9Decoder *pbi, YV12_BUFFER_CONFIG *sd,
 289                       vp9_ppflags_t *flags) {
 290   VP9_COMMON *const cm = &pbi->common;
 291   int ret = -1;
 292 #if !CONFIG_VP9_POSTPROC
 293   (void)*flags;
 294 #endif
 295
 296   if (pbi->ready_for_new_data == 1)
 297     return ret;
 298
 299   pbi->ready_for_new_data = 1;
 300
 301   /* no raw frame to show!!! */
 302   if (!cm->show_frame)
 303     return ret;
 304
 305 #if CONFIG_VP9_POSTPROC
 306   if (!cm->show_existing_frame) {
 307     ret = vp9_post_proc_frame(cm, sd, flags);
 308   } else {
 309     *sd = *cm->frame_to_show;
 310     ret = 0;
 311   }
 312 #else
 313   *sd = *cm->frame_to_show;
 314   ret = 0;
 315 #endif /*!CONFIG_POSTPROC*/
 316   vp9_clear_system_state();
 317   return ret;
 318 }
 319
 320 vpx_codec_err_t vp9_parse_superframe_index(const uint8_t *data,
 321                                            size_t data_sz,
 322                                            uint32_t sizes[8], int *count,
 323                                            vpx_decrypt_cb decrypt_cb,
 324                                            void *decrypt_state) {
 325   // A chunk ending with a byte matching 0xc0 is an invalid chunk unless
 326   // it is a super frame index. If the last byte of real video compression
 327   // data is 0xc0 the encoder must add a 0 byte. If we have the marker but
 328   // not the associated matching marker byte at the front of the index we have
 329   // an invalid bitstream and need to return an error.
 330
 331   uint8_t marker;
 332
 333   assert(data_sz);
 334   marker = read_marker(decrypt_cb, decrypt_state, data + data_sz - 1);
 335   *count = 0;
 336
 337   if ((marker & 0xe0) == 0xc0) {
 338     const uint32_t frames = (marker & 0x7) + 1;
 339     const uint32_t mag = ((marker >> 3) & 0x3) + 1;
 340     const size_t index_sz = 2 + mag * frames;
 341
 342     // This chunk is marked as having a superframe index but doesn't have
 343     // enough data for it, thus it's an invalid superframe index.
 344     if (data_sz < index_sz)
 345       return VPX_CODEC_CORRUPT_FRAME;
 346
 347     {
 348       const uint8_t marker2 = read_marker(decrypt_cb, decrypt_state,
 349                                           data + data_sz - index_sz);
 350
 351       // This chunk is marked as having a superframe index but doesn't have
 352       // the matching marker byte at the front of the index therefore it's an
 353       // invalid chunk.
 354       if (marker != marker2)
 355         return VPX_CODEC_CORRUPT_FRAME;
 356     }
 357
 358     {
 359       // Found a valid superframe index.
 360       uint32_t i, j;
 361       const uint8_t *x = &data[data_sz - index_sz + 1];
 362
 363       // Frames has a maximum of 8 and mag has a maximum of 4.
 364       uint8_t clear_buffer[32];
 365       assert(sizeof(clear_buffer) >= frames * mag);
 366       if (decrypt_cb) {
 367         decrypt_cb(decrypt_state, x, clear_buffer, frames * mag);
 368         x = clear_buffer;
 369       }
 370
 371       for (i = 0; i < frames; ++i) {
 372         uint32_t this_sz = 0;
 373
 374         for (j = 0; j < mag; ++j)
 375           this_sz |= (*x++) << (j * 8);
 376         sizes[i] = this_sz;
 377       }
 378       *count = frames;
 379     }
 380   }
 381   return VPX_CODEC_OK;
 382 }