| /* | |
| * Copyright (c) 2010 The WebM project authors. All Rights Reserved. | |
| * | |
| * Use of this source code is governed by a BSD-style license | |
| * that can be found in the LICENSE file in the root of the source | |
| * tree. An additional intellectual property rights grant can be found | |
| * in the file PATENTS. All contributing project authors may | |
| * be found in the AUTHORS file in the root of the source tree. | |
| */ | |
| #include "vp8/common/onyxc_int.h" | |
| #if CONFIG_POSTPROC | |
| #include "vp8/common/postproc.h" | |
| #endif | |
| #include "vp8/common/onyxd.h" | |
| #include "onyxd_int.h" | |
| #include "vpx_mem/vpx_mem.h" | |
| #include "vp8/common/alloccommon.h" | |
| #include "vpx_scale/yv12extend.h" | |
| #include "vp8/common/loopfilter.h" | |
| #include "vp8/common/swapyv12buffer.h" | |
| #include "vp8/common/g_common.h" | |
| #include "vp8/common/threading.h" | |
| #include "decoderthreading.h" | |
| #include <stdio.h> | |
| #include "vp8/common/quant_common.h" | |
| #include "vpx_scale/vpxscale.h" | |
| #include "vp8/common/systemdependent.h" | |
| #include "vpx_ports/vpx_timer.h" | |
| #include "detokenize.h" | |
| #if ARCH_ARM | |
| #include "vpx_ports/arm.h" | |
| #endif | |
| extern void vp8_init_loop_filter(VP8_COMMON *cm); | |
| extern void vp8cx_init_de_quantizer(VP8D_COMP *pbi); | |
| void vp8dx_initialize() | |
| { | |
| static int init_done = 0; | |
| if (!init_done) | |
| { | |
| vp8_initialize_common(); | |
| vp8_scale_machine_specific_config(); | |
| init_done = 1; | |
| } | |
| } | |
| VP8D_PTR vp8dx_create_decompressor(VP8D_CONFIG *oxcf) | |
| { | |
| VP8D_COMP *pbi = vpx_memalign(32, sizeof(VP8D_COMP)); | |
| if (!pbi) | |
| return NULL; | |
| vpx_memset(pbi, 0, sizeof(VP8D_COMP)); | |
| if (setjmp(pbi->common.error.jmp)) | |
| { | |
| pbi->common.error.setjmp = 0; | |
| vp8dx_remove_decompressor(pbi); | |
| return 0; | |
| } | |
| pbi->common.error.setjmp = 1; | |
| vp8dx_initialize(); | |
| vp8_create_common(&pbi->common); | |
| vp8_dmachine_specific_config(pbi); | |
| pbi->common.current_video_frame = 0; | |
| pbi->ready_for_new_data = 1; | |
| pbi->CPUFreq = 0; /*vp8_get_processor_freq();*/ | |
| #if CONFIG_MULTITHREAD | |
| pbi->max_threads = oxcf->max_threads; | |
| vp8_decoder_create_threads(pbi); | |
| #endif | |
| /* vp8cx_init_de_quantizer() is first called here. Add check in frame_init_dequantizer() to avoid | |
| * unnecessary calling of vp8cx_init_de_quantizer() for every frame. | |
| */ | |
| vp8cx_init_de_quantizer(pbi); | |
| { | |
| VP8_COMMON *cm = &pbi->common; | |
| vp8_init_loop_filter(cm); | |
| cm->last_frame_type = KEY_FRAME; | |
| cm->last_filter_type = cm->filter_type; | |
| cm->last_sharpness_level = cm->sharpness_level; | |
| } | |
| pbi->common.error.setjmp = 0; | |
| return (VP8D_PTR) pbi; | |
| } | |
| void vp8dx_remove_decompressor(VP8D_PTR ptr) | |
| { | |
| VP8D_COMP *pbi = (VP8D_COMP *) ptr; | |
| if (!pbi) | |
| return; | |
| #if CONFIG_MULTITHREAD | |
| if (pbi->b_multithreaded_rd) | |
| vp8mt_de_alloc_temp_buffers(pbi, pbi->common.mb_rows); | |
| vp8_decoder_remove_threads(pbi); | |
| #endif | |
| vp8_remove_common(&pbi->common); | |
| vpx_free(pbi); | |
| } | |
| int vp8dx_get_reference(VP8D_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd) | |
| { | |
| VP8D_COMP *pbi = (VP8D_COMP *) ptr; | |
| VP8_COMMON *cm = &pbi->common; | |
| int ref_fb_idx; | |
| if (ref_frame_flag == VP8_LAST_FLAG) | |
| ref_fb_idx = cm->lst_fb_idx; | |
| else if (ref_frame_flag == VP8_GOLD_FLAG) | |
| ref_fb_idx = cm->gld_fb_idx; | |
| else if (ref_frame_flag == VP8_ALT_FLAG) | |
| ref_fb_idx = cm->alt_fb_idx; | |
| else | |
| return -1; | |
| vp8_yv12_copy_frame_ptr(&cm->yv12_fb[ref_fb_idx], sd); | |
| return 0; | |
| } | |
| int vp8dx_set_reference(VP8D_PTR ptr, VP8_REFFRAME ref_frame_flag, YV12_BUFFER_CONFIG *sd) | |
| { | |
| VP8D_COMP *pbi = (VP8D_COMP *) ptr; | |
| VP8_COMMON *cm = &pbi->common; | |
| int ref_fb_idx; | |
| if (ref_frame_flag == VP8_LAST_FLAG) | |
| ref_fb_idx = cm->lst_fb_idx; | |
| else if (ref_frame_flag == VP8_GOLD_FLAG) | |
| ref_fb_idx = cm->gld_fb_idx; | |
| else if (ref_frame_flag == VP8_ALT_FLAG) | |
| ref_fb_idx = cm->alt_fb_idx; | |
| else | |
| return -1; | |
| vp8_yv12_copy_frame_ptr(sd, &cm->yv12_fb[ref_fb_idx]); | |
| return 0; | |
| } | |
| /*For ARM NEON, d8-d15 are callee-saved registers, and need to be saved by us.*/ | |
| #if HAVE_ARMV7 | |
| extern void vp8_push_neon(INT64 *store); | |
| extern void vp8_pop_neon(INT64 *store); | |
| #endif | |
| static int get_free_fb (VP8_COMMON *cm) | |
| { | |
| int i; | |
| for (i = 0; i < NUM_YV12_BUFFERS; i++) | |
| if (cm->fb_idx_ref_cnt[i] == 0) | |
| break; | |
| cm->fb_idx_ref_cnt[i] = 1; | |
| return i; | |
| } | |
| static void ref_cnt_fb (int *buf, int *idx, int new_idx) | |
| { | |
| if (buf[*idx] > 0) | |
| buf[*idx]--; | |
| *idx = new_idx; | |
| buf[new_idx]++; | |
| } | |
| /* If any buffer copy / swapping is signalled it should be done here. */ | |
| static int swap_frame_buffers (VP8_COMMON *cm) | |
| { | |
| int err = 0; | |
| /* The alternate reference frame or golden frame can be updated | |
| * using the new, last, or golden/alt ref frame. If it | |
| * is updated using the newly decoded frame it is a refresh. | |
| * An update using the last or golden/alt ref frame is a copy. | |
| */ | |
| if (cm->copy_buffer_to_arf) | |
| { | |
| int new_fb = 0; | |
| if (cm->copy_buffer_to_arf == 1) | |
| new_fb = cm->lst_fb_idx; | |
| else if (cm->copy_buffer_to_arf == 2) | |
| new_fb = cm->gld_fb_idx; | |
| else | |
| err = -1; | |
| ref_cnt_fb (cm->fb_idx_ref_cnt, &cm->alt_fb_idx, new_fb); | |
| } | |
| if (cm->copy_buffer_to_gf) | |
| { | |
| int new_fb = 0; | |
| if (cm->copy_buffer_to_gf == 1) | |
| new_fb = cm->lst_fb_idx; | |
| else if (cm->copy_buffer_to_gf == 2) | |
| new_fb = cm->alt_fb_idx; | |
| else | |
| err = -1; | |
| ref_cnt_fb (cm->fb_idx_ref_cnt, &cm->gld_fb_idx, new_fb); | |
| } | |
| if (cm->refresh_golden_frame) | |
| ref_cnt_fb (cm->fb_idx_ref_cnt, &cm->gld_fb_idx, cm->new_fb_idx); | |
| if (cm->refresh_alt_ref_frame) | |
| ref_cnt_fb (cm->fb_idx_ref_cnt, &cm->alt_fb_idx, cm->new_fb_idx); | |
| if (cm->refresh_last_frame) | |
| { | |
| ref_cnt_fb (cm->fb_idx_ref_cnt, &cm->lst_fb_idx, cm->new_fb_idx); | |
| cm->frame_to_show = &cm->yv12_fb[cm->lst_fb_idx]; | |
| } | |
| else | |
| cm->frame_to_show = &cm->yv12_fb[cm->new_fb_idx]; | |
| cm->fb_idx_ref_cnt[cm->new_fb_idx]--; | |
| return err; | |
| } | |
| int vp8dx_receive_compressed_data(VP8D_PTR ptr, unsigned long size, const unsigned char *source, INT64 time_stamp) | |
| { | |
| #if HAVE_ARMV7 | |
| INT64 dx_store_reg[8]; | |
| #endif | |
| VP8D_COMP *pbi = (VP8D_COMP *) ptr; | |
| VP8_COMMON *cm = &pbi->common; | |
| int retcode = 0; | |
| struct vpx_usec_timer timer; | |
| /*if(pbi->ready_for_new_data == 0) | |
| return -1;*/ | |
| if (ptr == 0) | |
| { | |
| return -1; | |
| } | |
| pbi->common.error.error_code = VPX_CODEC_OK; | |
| if (size == 0) | |
| { | |
| /* This is used to signal that we are missing frames. | |
| * We do not know if the missing frame(s) was supposed to update | |
| * any of the reference buffers, but we act conservative and | |
| * mark only the last buffer as corrupted. | |
| */ | |
| cm->yv12_fb[cm->lst_fb_idx].corrupted = 1; | |
| /* Signal that we have no frame to show. */ | |
| cm->show_frame = 0; | |
| /* Nothing more to do. */ | |
| return 0; | |
| } | |
| #if HAVE_ARMV7 | |
| #if CONFIG_RUNTIME_CPU_DETECT | |
| if (cm->rtcd.flags & HAS_NEON) | |
| #endif | |
| { | |
| vp8_push_neon(dx_store_reg); | |
| } | |
| #endif | |
| cm->new_fb_idx = get_free_fb (cm); | |
| if (setjmp(pbi->common.error.jmp)) | |
| { | |
| #if HAVE_ARMV7 | |
| #if CONFIG_RUNTIME_CPU_DETECT | |
| if (cm->rtcd.flags & HAS_NEON) | |
| #endif | |
| { | |
| vp8_pop_neon(dx_store_reg); | |
| } | |
| #endif | |
| pbi->common.error.setjmp = 0; | |
| /* We do not know if the missing frame(s) was supposed to update | |
| * any of the reference buffers, but we act conservative and | |
| * mark only the last buffer as corrupted. | |
| */ | |
| cm->yv12_fb[cm->lst_fb_idx].corrupted = 1; | |
| if (cm->fb_idx_ref_cnt[cm->new_fb_idx] > 0) | |
| cm->fb_idx_ref_cnt[cm->new_fb_idx]--; | |
| return -1; | |
| } | |
| pbi->common.error.setjmp = 1; | |
| vpx_usec_timer_start(&timer); | |
| /*cm->current_video_frame++;*/ | |
| pbi->Source = source; | |
| pbi->source_sz = size; | |
| retcode = vp8_decode_frame(pbi); | |
| if (retcode < 0) | |
| { | |
| #if HAVE_ARMV7 | |
| #if CONFIG_RUNTIME_CPU_DETECT | |
| if (cm->rtcd.flags & HAS_NEON) | |
| #endif | |
| { | |
| vp8_pop_neon(dx_store_reg); | |
| } | |
| #endif | |
| pbi->common.error.error_code = VPX_CODEC_ERROR; | |
| pbi->common.error.setjmp = 0; | |
| if (cm->fb_idx_ref_cnt[cm->new_fb_idx] > 0) | |
| cm->fb_idx_ref_cnt[cm->new_fb_idx]--; | |
| return retcode; | |
| } | |
| #if CONFIG_MULTITHREAD | |
| if (pbi->b_multithreaded_rd && cm->multi_token_partition != ONE_PARTITION) | |
| { | |
| if (swap_frame_buffers (cm)) | |
| { | |
| #if HAVE_ARMV7 | |
| #if CONFIG_RUNTIME_CPU_DETECT | |
| if (cm->rtcd.flags & HAS_NEON) | |
| #endif | |
| { | |
| vp8_pop_neon(dx_store_reg); | |
| } | |
| #endif | |
| pbi->common.error.error_code = VPX_CODEC_ERROR; | |
| pbi->common.error.setjmp = 0; | |
| return -1; | |
| } | |
| } else | |
| #endif | |
| { | |
| if (swap_frame_buffers (cm)) | |
| { | |
| #if HAVE_ARMV7 | |
| #if CONFIG_RUNTIME_CPU_DETECT | |
| if (cm->rtcd.flags & HAS_NEON) | |
| #endif | |
| { | |
| vp8_pop_neon(dx_store_reg); | |
| } | |
| #endif | |
| pbi->common.error.error_code = VPX_CODEC_ERROR; | |
| pbi->common.error.setjmp = 0; | |
| return -1; | |
| } | |
| if(pbi->common.filter_level) | |
| { | |
| struct vpx_usec_timer lpftimer; | |
| vpx_usec_timer_start(&lpftimer); | |
| /* Apply the loop filter if appropriate. */ | |
| vp8_loop_filter_frame(cm, &pbi->mb, cm->filter_level); | |
| vpx_usec_timer_mark(&lpftimer); | |
| pbi->time_loop_filtering += vpx_usec_timer_elapsed(&lpftimer); | |
| cm->last_frame_type = cm->frame_type; | |
| cm->last_filter_type = cm->filter_type; | |
| cm->last_sharpness_level = cm->sharpness_level; | |
| } | |
| vp8_yv12_extend_frame_borders_ptr(cm->frame_to_show); | |
| } | |
| vp8_clear_system_state(); | |
| vpx_usec_timer_mark(&timer); | |
| pbi->decode_microseconds = vpx_usec_timer_elapsed(&timer); | |
| pbi->time_decoding += pbi->decode_microseconds; | |
| /*vp8_print_modes_and_motion_vectors( cm->mi, cm->mb_rows,cm->mb_cols, cm->current_video_frame);*/ | |
| if (cm->show_frame) | |
| cm->current_video_frame++; | |
| pbi->ready_for_new_data = 0; | |
| pbi->last_time_stamp = time_stamp; | |
| #if 0 | |
| { | |
| int i; | |
| INT64 earliest_time = pbi->dr[0].time_stamp; | |
| INT64 latest_time = pbi->dr[0].time_stamp; | |
| INT64 time_diff = 0; | |
| int bytes = 0; | |
| pbi->dr[pbi->common.current_video_frame&0xf].size = pbi->bc.pos + pbi->bc2.pos + 4;; | |
| pbi->dr[pbi->common.current_video_frame&0xf].time_stamp = time_stamp; | |
| for (i = 0; i < 16; i++) | |
| { | |
| bytes += pbi->dr[i].size; | |
| if (pbi->dr[i].time_stamp < earliest_time) | |
| earliest_time = pbi->dr[i].time_stamp; | |
| if (pbi->dr[i].time_stamp > latest_time) | |
| latest_time = pbi->dr[i].time_stamp; | |
| } | |
| time_diff = latest_time - earliest_time; | |
| if (time_diff > 0) | |
| { | |
| pbi->common.bitrate = 80000.00 * bytes / time_diff ; | |
| pbi->common.framerate = 160000000.00 / time_diff ; | |
| } | |
| } | |
| #endif | |
| #if HAVE_ARMV7 | |
| #if CONFIG_RUNTIME_CPU_DETECT | |
| if (cm->rtcd.flags & HAS_NEON) | |
| #endif | |
| { | |
| vp8_pop_neon(dx_store_reg); | |
| } | |
| #endif | |
| pbi->common.error.setjmp = 0; | |
| return retcode; | |
| } | |
| int vp8dx_get_raw_frame(VP8D_PTR ptr, YV12_BUFFER_CONFIG *sd, INT64 *time_stamp, INT64 *time_end_stamp, vp8_ppflags_t *flags) | |
| { | |
| int ret = -1; | |
| VP8D_COMP *pbi = (VP8D_COMP *) ptr; | |
| if (pbi->ready_for_new_data == 1) | |
| return ret; | |
| /* ie no raw frame to show!!! */ | |
| if (pbi->common.show_frame == 0) | |
| return ret; | |
| pbi->ready_for_new_data = 1; | |
| *time_stamp = pbi->last_time_stamp; | |
| *time_end_stamp = 0; | |
| sd->clrtype = pbi->common.clr_type; | |
| #if CONFIG_POSTPROC | |
| ret = vp8_post_proc_frame(&pbi->common, sd, flags); | |
| #else | |
| if (pbi->common.frame_to_show) | |
| { | |
| *sd = *pbi->common.frame_to_show; | |
| sd->y_width = pbi->common.Width; | |
| sd->y_height = pbi->common.Height; | |
| sd->uv_height = pbi->common.Height / 2; | |
| ret = 0; | |
| } | |
| else | |
| { | |
| ret = -1; | |
| } | |
| #endif /*!CONFIG_POSTPROC*/ | |
| vp8_clear_system_state(); | |
| return ret; | |
| } |