• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
initialize_dec()36 static void initialize_dec() {
37   static int init_done = 0;
38 
39   if (!init_done) {
40     vp9_rtcd();
41     vp9_init_neighbors();
42     vp9_init_intra_predictors();
43     init_done = 1;
44   }
45 }
46 
vp9_decoder_create()47 VP9Decoder *vp9_decoder_create() {
48   VP9Decoder *const pbi = vpx_memalign(32, sizeof(*pbi));
49   VP9_COMMON *const cm = pbi ? &pbi->common : NULL;
50 
51   if (!cm)
52     return NULL;
53 
54   vp9_zero(*pbi);
55 
56   if (setjmp(cm->error.jmp)) {
57     cm->error.setjmp = 0;
58     vp9_decoder_remove(pbi);
59     return NULL;
60   }
61 
62   cm->error.setjmp = 1;
63   pbi->need_resync = 1;
64   initialize_dec();
65 
66   // Initialize the references to not point to any frame buffers.
67   vpx_memset(&cm->ref_frame_map, -1, sizeof(cm->ref_frame_map));
68 
69   cm->current_video_frame = 0;
70   pbi->ready_for_new_data = 1;
71   cm->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 
vp9_decoder_remove(VP9Decoder * pbi)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 
equal_dimensions(const YV12_BUFFER_CONFIG * a,const YV12_BUFFER_CONFIG * b)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 
vp9_copy_reference_dec(VP9Decoder * pbi,VP9_REFFRAME ref_frame_flag,YV12_BUFFER_CONFIG * sd)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 
vp9_set_reference_dec(VP9_COMMON * cm,VP9_REFFRAME ref_frame_flag,YV12_BUFFER_CONFIG * sd)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. */
swap_frame_buffers(VP9Decoder * pbi)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 
vp9_receive_compressed_data(VP9Decoder * pbi,size_t size,const uint8_t ** psource)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   // Check if the previous frame was a frame without any references to it.
236   if (cm->new_fb_idx >= 0 && cm->frame_bufs[cm->new_fb_idx].ref_count == 0)
237     cm->release_fb_cb(cm->cb_priv,
238                       &cm->frame_bufs[cm->new_fb_idx].raw_frame_buffer);
239   cm->new_fb_idx = get_free_fb(cm);
240 
241   if (setjmp(cm->error.jmp)) {
242     pbi->need_resync = 1;
243     cm->error.setjmp = 0;
244     vp9_clear_system_state();
245 
246     // We do not know if the missing frame(s) was supposed to update
247     // any of the reference buffers, but we act conservative and
248     // mark only the last buffer as corrupted.
249     //
250     // TODO(jkoleszar): Error concealment is undefined and non-normative
251     // at this point, but if it becomes so, [0] may not always be the correct
252     // thing to do here.
253     if (cm->frame_refs[0].idx != INT_MAX && cm->frame_refs[0].buf != NULL)
254       cm->frame_refs[0].buf->corrupted = 1;
255 
256     if (cm->new_fb_idx > 0 && cm->frame_bufs[cm->new_fb_idx].ref_count > 0)
257       cm->frame_bufs[cm->new_fb_idx].ref_count--;
258 
259     return -1;
260   }
261 
262   cm->error.setjmp = 1;
263 
264   vp9_decode_frame(pbi, source, source + size, psource);
265 
266   swap_frame_buffers(pbi);
267 
268   vp9_clear_system_state();
269 
270   cm->last_width = cm->width;
271   cm->last_height = cm->height;
272 
273   if (!cm->show_existing_frame)
274     cm->last_show_frame = cm->show_frame;
275   if (cm->show_frame) {
276     if (!cm->show_existing_frame)
277       vp9_swap_mi_and_prev_mi(cm);
278 
279     cm->current_video_frame++;
280   }
281 
282   pbi->ready_for_new_data = 0;
283 
284   cm->error.setjmp = 0;
285   return retcode;
286 }
287 
vp9_get_raw_frame(VP9Decoder * pbi,YV12_BUFFER_CONFIG * sd,vp9_ppflags_t * flags)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   /* no raw frame to show!!! */
300   if (!cm->show_frame)
301     return ret;
302 
303   pbi->ready_for_new_data = 1;
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 
vp9_parse_superframe_index(const uint8_t * data,size_t data_sz,uint32_t sizes[8],int * count,vpx_decrypt_cb decrypt_cb,void * decrypt_state)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 }
383