To save a branch.
Change-Id: Ifa2be7583e95c6991784731c654bbd4cce31e993
write_modes_b(cpi, xd, tile, w, tok, tok_end, mi_row, mi_col + bs,
max_mv_magnitude, interp_filter_selected);
break;
- case PARTITION_SPLIT:
+ default:
+ assert(partition == PARTITION_SPLIT);
write_modes_sb(cpi, xd, tile, w, tok, tok_end, mi_row, mi_col, subsize,
max_mv_magnitude, interp_filter_selected);
write_modes_sb(cpi, xd, tile, w, tok, tok_end, mi_row, mi_col + bs,
write_modes_sb(cpi, xd, tile, w, tok, tok_end, mi_row + bs, mi_col + bs,
subsize, max_mv_magnitude, interp_filter_selected);
break;
- default: assert(0);
}
}
return;
}
- case ONE_LOOP_REDUCED: {
+ default: {
int updates = 0;
int noupdates_before_first = 0;
+ assert(cpi->sf.use_fast_coef_updates == ONE_LOOP_REDUCED);
for (i = 0; i < PLANE_TYPES; ++i) {
for (j = 0; j < REF_TYPES; ++j) {
for (k = 0; k < COEF_BANDS; ++k) {
}
return;
}
- default: assert(0);
}
}
case PROFILE_0: vpx_wb_write_literal(wb, 0, 2); break;
case PROFILE_1: vpx_wb_write_literal(wb, 2, 2); break;
case PROFILE_2: vpx_wb_write_literal(wb, 1, 2); break;
- case PROFILE_3: vpx_wb_write_literal(wb, 6, 3); break;
- default: assert(0);
+ default:
+ assert(profile == PROFILE_3);
+ vpx_wb_write_literal(wb, 6, 3);
+ break;
}
}
node->split[i] = &vt->split[i].part_variances.none;
break;
}
- case BLOCK_4X4: {
+ default: {
v4x4 *vt = (v4x4 *)data;
+ assert(bsize == BLOCK_4X4);
node->part_variances = &vt->part_variances;
for (i = 0; i < 4; i++) node->split[i] = &vt->split[i];
break;
}
- default: {
- assert(0);
- break;
- }
}
}
set_block_size(cpi, x, xd, mi_row, mi_col, subsize);
set_block_size(cpi, x, xd, mi_row, mi_col + bs, subsize);
break;
- case PARTITION_SPLIT:
+ default:
+ assert(partition == PARTITION_SPLIT);
copy_partitioning_helper(cpi, x, xd, subsize, mi_row, mi_col);
copy_partitioning_helper(cpi, x, xd, subsize, mi_row + bs, mi_col);
copy_partitioning_helper(cpi, x, xd, subsize, mi_row, mi_col + bs);
copy_partitioning_helper(cpi, x, xd, subsize, mi_row + bs, mi_col + bs);
break;
- default: assert(0);
}
}
}
set_block_size(cpi, x, xd, mi_row_high, mi_col_high + bs_high,
subsize_high);
break;
- case PARTITION_SPLIT:
+ default:
+ assert(partition_high == PARTITION_SPLIT);
if (scale_partitioning_svc(cpi, x, xd, subsize_high, mi_row, mi_col,
mi_row_high, mi_col_high))
return 1;
mi_col_high + bs_high))
return 1;
break;
- default: assert(0);
}
}
prev_part[start_pos] = subsize;
if (mi_col + bs < cm->mi_cols) prev_part[start_pos + bs] = subsize;
break;
- case PARTITION_SPLIT:
+ default:
+ assert(partition == PARTITION_SPLIT);
update_partition_svc(cpi, subsize, mi_row, mi_col);
update_partition_svc(cpi, subsize, mi_row + bs, mi_col);
update_partition_svc(cpi, subsize, mi_row, mi_col + bs);
update_partition_svc(cpi, subsize, mi_row + bs, mi_col + bs);
break;
- default: assert(0);
}
}
}
prev_part[start_pos] = subsize;
if (mi_col + bs < cm->mi_cols) prev_part[start_pos + bs] = subsize;
break;
- case PARTITION_SPLIT:
+ default:
+ assert(partition == PARTITION_SPLIT);
update_prev_partition_helper(cpi, subsize, mi_row, mi_col);
update_prev_partition_helper(cpi, subsize, mi_row + bs, mi_col);
update_prev_partition_helper(cpi, subsize, mi_row, mi_col + bs);
update_prev_partition_helper(cpi, subsize, mi_row + bs, mi_col + bs);
break;
- default: assert(0);
}
}
}
subsize, &pc_tree->horizontal[1]);
}
break;
- case PARTITION_SPLIT:
+ default:
+ assert(partition == PARTITION_SPLIT);
if (bsize == BLOCK_8X8) {
encode_b(cpi, tile, td, tp, mi_row, mi_col, output_enabled, subsize,
pc_tree->leaf_split[0]);
subsize, pc_tree->split[3]);
}
break;
- default: assert(0 && "Invalid partition type."); break;
}
if (partition != PARTITION_SPLIT || bsize == BLOCK_8X8)
subsize, &pc_tree->horizontal[1]);
}
break;
- case PARTITION_SPLIT:
+ default:
+ assert(partition == PARTITION_SPLIT);
subsize = get_subsize(bsize, PARTITION_SPLIT);
encode_sb_rt(cpi, td, tile, tp, mi_row, mi_col, output_enabled, subsize,
pc_tree->split[0]);
encode_sb_rt(cpi, td, tile, tp, mi_row + hbs, mi_col + hbs,
output_enabled, subsize, pc_tree->split[3]);
break;
- default: assert(0 && "Invalid partition type."); break;
}
if (partition != PARTITION_SPLIT || bsize == BLOCK_8X8)
last_part_rdc.rdcost += tmp_rdc.rdcost;
}
break;
- case PARTITION_SPLIT:
+ default:
+ assert(partition == PARTITION_SPLIT);
if (bsize == BLOCK_8X8) {
rd_pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, &last_part_rdc,
subsize, pc_tree->leaf_split[0], INT64_MAX);
last_part_rdc.dist += tmp_rdc.dist;
}
break;
- default: assert(0); break;
}
pl = partition_plane_context(xd, mi_row, mi_col, bsize);
}
}
break;
- case PARTITION_SPLIT:
+ default:
+ assert(partition == PARTITION_SPLIT);
subsize = get_subsize(bsize, PARTITION_SPLIT);
nonrd_select_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col,
subsize, output_enabled, rd_cost,
rd_cost->dist += this_rdc.dist;
}
break;
- default: assert(0 && "Invalid partition type."); break;
}
}
output_enabled, subsize, &pc_tree->horizontal[1]);
}
break;
- case PARTITION_SPLIT:
+ default:
+ assert(partition == PARTITION_SPLIT);
subsize = get_subsize(bsize, PARTITION_SPLIT);
if (bsize == BLOCK_8X8) {
nonrd_pick_sb_modes(cpi, tile_data, x, mi_row, mi_col, dummy_cost,
dummy_cost, pc_tree->split[3]);
}
break;
- default: assert(0 && "Invalid partition type."); break;
}
if (partition != PARTITION_SPLIT || bsize == BLOCK_8X8)
nonrd_use_partition(cpi, td, tile_data, mi, tp, mi_row, mi_col,
BLOCK_64X64, 1, &dummy_rdc, td->pc_root);
break;
- case REFERENCE_PARTITION:
+ default:
+ assert(partition_search_type == REFERENCE_PARTITION);
x->sb_pickmode_part = 1;
set_offsets(cpi, tile_info, x, mi_row, mi_col, BLOCK_64X64);
// Use nonrd_pick_partition on scene-cut for VBR mode.
}
break;
- default: assert(0); break;
}
// Update ref_frame usage for inter frame if this group is ARF group.
&var16->sse, &var16->sum);
var16->var = variance_highbd(var16);
break;
- case VPX_BITS_12:
+ default:
+ assert(cm->bit_depth == VPX_BITS_12);
vpx_highbd_12_get16x16var(src, src_stride, last_src, last_stride,
&var16->sse, &var16->sum);
var16->var = variance_highbd(var16);
break;
- default:
- assert(0 &&
- "cm->bit_depth should be VPX_BITS_8, VPX_BITS_10"
- " or VPX_BITS_12");
- return -1;
}
} else {
vpx_get16x16var(src, src_stride, last_src, last_stride, &var16->sse,
p->quant_fp, qcoeff, dqcoeff, pd->dequant, eob,
scan_order->scan, scan_order->iscan);
break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
x->fwd_txfm4x4(src_diff, coeff, diff_stride);
vp9_highbd_quantize_fp(coeff, 16, x->skip_block, p->round_fp,
p->quant_fp, qcoeff, dqcoeff, pd->dequant, eob,
scan_order->scan, scan_order->iscan);
break;
- default: assert(0);
}
return;
}
p->round_fp, p->quant_fp, qcoeff, dqcoeff, pd->dequant,
eob, scan_order->scan, scan_order->iscan);
break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
x->fwd_txfm4x4(src_diff, coeff, diff_stride);
vp9_quantize_fp(coeff, 16, x->skip_block, p->round_fp, p->quant_fp,
qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan,
scan_order->iscan);
break;
- default: assert(0); break;
}
}
p->quant_fp[0], qcoeff, dqcoeff, pd->dequant[0],
eob);
break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
x->fwd_txfm4x4(src_diff, coeff, diff_stride);
vpx_highbd_quantize_dc(coeff, 16, x->skip_block, p->round,
p->quant_fp[0], qcoeff, dqcoeff, pd->dequant[0],
eob);
break;
- default: assert(0);
}
return;
}
vpx_quantize_dc(coeff, 64, x->skip_block, p->round, p->quant_fp[0],
qcoeff, dqcoeff, pd->dequant[0], eob);
break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
x->fwd_txfm4x4(src_diff, coeff, diff_stride);
vpx_quantize_dc(coeff, 16, x->skip_block, p->round, p->quant_fp[0],
qcoeff, dqcoeff, pd->dequant[0], eob);
break;
- default: assert(0); break;
}
}
pd->dequant, eob, scan_order->scan,
scan_order->iscan);
break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
x->fwd_txfm4x4(src_diff, coeff, diff_stride);
vpx_highbd_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round,
p->quant, p->quant_shift, qcoeff, dqcoeff,
pd->dequant, eob, scan_order->scan,
scan_order->iscan);
break;
- default: assert(0);
}
return;
}
p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob,
scan_order->scan, scan_order->iscan);
break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
x->fwd_txfm4x4(src_diff, coeff, diff_stride);
vpx_quantize_b(coeff, 16, x->skip_block, p->zbin, p->round, p->quant,
p->quant_shift, qcoeff, dqcoeff, pd->dequant, eob,
scan_order->scan, scan_order->iscan);
break;
- default: assert(0); break;
}
}
vp9_highbd_idct8x8_add(dqcoeff, dst16, pd->dst.stride, p->eobs[block],
xd->bd);
break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
// this is like vp9_short_idct4x4 but has a special case around eob<=1
// which is significant (not just an optimization) for the lossless
// case.
x->highbd_inv_txfm_add(dqcoeff, dst16, pd->dst.stride, p->eobs[block],
xd->bd);
break;
- default: assert(0 && "Invalid transform size");
}
return;
}
case TX_8X8:
vp9_idct8x8_add(dqcoeff, dst, pd->dst.stride, p->eobs[block]);
break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
// this is like vp9_short_idct4x4 but has a special case around eob<=1
// which is significant (not just an optimization) for the lossless
// case.
x->inv_txfm_add(dqcoeff, dst, pd->dst.stride, p->eobs[block]);
break;
- default: assert(0 && "Invalid transform size"); break;
}
}
xd->bd);
}
break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
if (!x->skip_recode) {
vpx_highbd_subtract_block(4, 4, src_diff, diff_stride, src,
src_stride, dst, dst_stride, xd->bd);
}
}
break;
- default: assert(0); return;
}
if (*eob) *(args->skip) = 0;
return;
if (!x->skip_encode && *eob)
vp9_iht8x8_add(tx_type, dqcoeff, dst, dst_stride, *eob);
break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
if (!x->skip_recode) {
vpx_subtract_block(4, 4, src_diff, diff_stride, src, src_stride, dst,
dst_stride);
vp9_iht4x4_16_add(dqcoeff, dst, dst_stride, tx_type);
}
break;
- default: assert(0); break;
}
if (*eob) *(args->skip) = 0;
}
*hr = 3;
*hs = 5;
break;
- case ONETWO:
- *hr = 1;
- *hs = 2;
- break;
default:
+ assert(mode == ONETWO);
*hr = 1;
- *hs = 1;
- assert(0);
+ *hs = 2;
break;
}
}
vpx_highbd_sad4x4x4d_bits10)
break;
- case VPX_BITS_12:
+ default:
+ assert(cm->bit_depth == VPX_BITS_12);
HIGHBD_BFP(BLOCK_32X16, vpx_highbd_sad32x16_bits12,
vpx_highbd_sad32x16_avg_bits12, vpx_highbd_12_variance32x16,
vpx_highbd_12_sub_pixel_variance32x16,
vpx_highbd_12_sub_pixel_avg_variance4x4,
vpx_highbd_sad4x4x4d_bits12)
break;
-
- default:
- assert(0 &&
- "cm->bit_depth should be VPX_BITS_8, "
- "VPX_BITS_10 or VPX_BITS_12");
}
}
}
case VPX_BITS_10:
dc_quant_devisor = 16.0;
break;
- case VPX_BITS_12:
- dc_quant_devisor = 64.0;
- break;
default:
- assert(0 && "bit_depth must be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12");
+ assert(cm->bit_depth == VPX_BITS_12);
+ dc_quant_devisor = 64.0;
break;
}
#else
switch (cm->bit_depth) {
case VPX_BITS_8: ret_val = thresh; break;
case VPX_BITS_10: ret_val = thresh << 4; break;
- case VPX_BITS_12: ret_val = thresh << 8; break;
default:
- assert(0 &&
- "cm->bit_depth should be VPX_BITS_8, "
- "VPX_BITS_10 or VPX_BITS_12");
+ assert(cm->bit_depth == VPX_BITS_12);
+ ret_val = thresh << 8;
+ break;
}
}
#else
switch (cm->bit_depth) {
case VPX_BITS_8: ret_val = UL_INTRA_THRESH; break;
case VPX_BITS_10: ret_val = UL_INTRA_THRESH << 2; break;
- case VPX_BITS_12: ret_val = UL_INTRA_THRESH << 4; break;
default:
- assert(0 &&
- "cm->bit_depth should be VPX_BITS_8, "
- "VPX_BITS_10 or VPX_BITS_12");
+ assert(cm->bit_depth == VPX_BITS_12);
+ ret_val = UL_INTRA_THRESH << 4;
+ break;
}
}
#else
switch (cm->bit_depth) {
case VPX_BITS_8: ret_val = SMOOTH_INTRA_THRESH; break;
case VPX_BITS_10: ret_val = SMOOTH_INTRA_THRESH << 4; break;
- case VPX_BITS_12: ret_val = SMOOTH_INTRA_THRESH << 8; break;
default:
- assert(0 &&
- "cm->bit_depth should be VPX_BITS_8, "
- "VPX_BITS_10 or VPX_BITS_12");
+ assert(cm->bit_depth == VPX_BITS_12);
+ ret_val = SMOOTH_INTRA_THRESH << 8;
+ break;
}
}
#else
switch (cm->bit_depth) {
case VPX_BITS_8: break;
case VPX_BITS_10: this_error >>= 4; break;
- case VPX_BITS_12: this_error >>= 8; break;
default:
- assert(0 &&
- "cm->bit_depth should be VPX_BITS_8, "
- "VPX_BITS_10 or VPX_BITS_12");
- return;
+ assert(cm->bit_depth == VPX_BITS_12);
+ this_error >>= 8;
+ break;
}
}
#endif // CONFIG_VP9_HIGHBITDEPTH
cpi->refresh_alt_ref_frame = 0;
cpi->rc.is_src_frame_alt_ref = 1;
break;
- case ARF_UPDATE:
+ default:
+ assert(twopass->gf_group.update_type[twopass->gf_group.index] ==
+ ARF_UPDATE);
cpi->refresh_last_frame = 0;
cpi->refresh_golden_frame = 0;
cpi->refresh_alt_ref_frame = 1;
break;
- default: assert(0); break;
}
}
var = bigdia_search(x, mvp_full, step_param, error_per_bit, 1, cost_list,
fn_ptr, 1, ref_mv, tmp_mv);
break;
- case NSTEP:
+ default:
+ assert(method == NSTEP);
var = full_pixel_diamond(cpi, x, mvp_full, step_param, error_per_bit,
MAX_MVSEARCH_STEPS - 1 - step_param, 1,
cost_list, fn_ptr, ref_mv, tmp_mv);
}
}
break;
- default: assert(0 && "Invalid search method.");
}
if (method != NSTEP && rd && var < var_max)
case VPX_BITS_10:
filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 4060632, 20);
break;
- case VPX_BITS_12:
+ default:
+ assert(cm->bit_depth == VPX_BITS_12);
filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 16242526, 22);
break;
- default:
- assert(0 &&
- "bit_depth should be VPX_BITS_8, VPX_BITS_10 "
- "or VPX_BITS_12");
- return;
}
#else
int filt_guess = ROUND_POWER_OF_TWO(q * 20723 + 1015158, 18);
qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan,
scan_order->iscan);
break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
x->fwd_txfm4x4(src_diff, coeff, diff_stride);
vp9_quantize_fp(coeff, 16, x->skip_block, p->round_fp, p->quant_fp,
qcoeff, dqcoeff, pd->dequant, eob, scan_order->scan,
scan_order->iscan);
break;
- default: assert(0); break;
}
*skippable &= (*eob == 0);
eob_cost += 1;
switch (bit_depth) {
case VPX_BITS_8: return q == 0 ? 64 : (quant < 148 ? 84 : 80);
case VPX_BITS_10: return q == 0 ? 64 : (quant < 592 ? 84 : 80);
- case VPX_BITS_12: return q == 0 ? 64 : (quant < 2368 ? 84 : 80);
default:
- assert(0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12");
- return -1;
+ assert(bit_depth == VPX_BITS_12);
+ return q == 0 ? 64 : (quant < 2368 ? 84 : 80);
}
#else
(void)bit_depth;
#define MAX_BPB_FACTOR 50
#if CONFIG_VP9_HIGHBITDEPTH
-#define ASSIGN_MINQ_TABLE(bit_depth, name) \
- do { \
- switch (bit_depth) { \
- case VPX_BITS_8: name = name##_8; break; \
- case VPX_BITS_10: name = name##_10; break; \
- case VPX_BITS_12: name = name##_12; break; \
- default: \
- assert(0 && \
- "bit_depth should be VPX_BITS_8, VPX_BITS_10" \
- " or VPX_BITS_12"); \
- name = NULL; \
- } \
+#define ASSIGN_MINQ_TABLE(bit_depth, name) \
+ do { \
+ switch (bit_depth) { \
+ case VPX_BITS_8: name = name##_8; break; \
+ case VPX_BITS_10: name = name##_10; break; \
+ default: \
+ assert(bit_depth == VPX_BITS_12); \
+ name = name##_12; \
+ break; \
+ } \
} while (0)
#else
#define ASSIGN_MINQ_TABLE(bit_depth, name) \
switch (bit_depth) {
case VPX_BITS_8: return vp9_ac_quant(qindex, 0, bit_depth) / 4.0;
case VPX_BITS_10: return vp9_ac_quant(qindex, 0, bit_depth) / 16.0;
- case VPX_BITS_12: return vp9_ac_quant(qindex, 0, bit_depth) / 64.0;
default:
- assert(0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12");
- return -1.0;
+ assert(bit_depth == VPX_BITS_12);
+ return vp9_ac_quant(qindex, 0, bit_depth) / 64.0;
}
#else
return vp9_ac_quant(qindex, 0, bit_depth) / 4.0;
switch (cpi->common.bit_depth) {
case VPX_BITS_8: rdmult = 88 * q * q / 24; break;
case VPX_BITS_10: rdmult = ROUND_POWER_OF_TWO(88 * q * q / 24, 4); break;
- case VPX_BITS_12: rdmult = ROUND_POWER_OF_TWO(88 * q * q / 24, 8); break;
default:
- assert(0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12");
- return -1;
+ assert(cpi->common.bit_depth == VPX_BITS_12);
+ rdmult = ROUND_POWER_OF_TWO(88 * q * q / 24, 8);
+ break;
}
#else
int64_t rdmult = 88 * q * q / 24;
switch (bit_depth) {
case VPX_BITS_8: q = vp9_dc_quant(qindex, 0, VPX_BITS_8) / 4.0; break;
case VPX_BITS_10: q = vp9_dc_quant(qindex, 0, VPX_BITS_10) / 16.0; break;
- case VPX_BITS_12: q = vp9_dc_quant(qindex, 0, VPX_BITS_12) / 64.0; break;
default:
- assert(0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12");
- return -1;
+ assert(bit_depth == VPX_BITS_12);
+ q = vp9_dc_quant(qindex, 0, VPX_BITS_12) / 64.0;
+ break;
}
#else
(void)bit_depth;
x->sadperbit16 = sad_per_bit16lut_10[qindex];
x->sadperbit4 = sad_per_bit4lut_10[qindex];
break;
- case VPX_BITS_12:
+ default:
+ assert(cpi->common.bit_depth == VPX_BITS_12);
x->sadperbit16 = sad_per_bit16lut_12[qindex];
x->sadperbit4 = sad_per_bit4lut_12[qindex];
break;
- default:
- assert(0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12");
}
#else
(void)cpi;
for (i = 0; i < num_4x4_h; i += 4)
t_left[i] = !!*(const uint32_t *)&left[i];
break;
- case TX_32X32:
+ default:
+ assert(tx_size == TX_32X32);
for (i = 0; i < num_4x4_w; i += 8)
t_above[i] = !!*(const uint64_t *)&above[i];
for (i = 0; i < num_4x4_h; i += 8)
t_left[i] = !!*(const uint64_t *)&left[i];
break;
- default: assert(0 && "Invalid transform size."); break;
}
}
case TX_16X16:
vp9_highbd_idct16x16_add(dqcoeff, recon16, 32, *eob, xd->bd);
break;
- case TX_32X32:
+ default:
+ assert(tx_size == TX_32X32);
vp9_highbd_idct32x32_add(dqcoeff, recon16, 32, *eob, xd->bd);
break;
- default: assert(0 && "Invalid transform size");
}
}
recon = CONVERT_TO_BYTEPTR(recon16);
case TX_32X32: vp9_idct32x32_add(dqcoeff, recon, 32, *eob); break;
case TX_16X16: vp9_idct16x16_add(dqcoeff, recon, 32, *eob); break;
case TX_8X8: vp9_idct8x8_add(dqcoeff, recon, 32, *eob); break;
- case TX_4X4:
+ default:
+ assert(tx_size == TX_4X4);
// this is like vp9_short_idct4x4 but has a special case around
// eob<=1, which is significant (not just an optimization) for
// the lossless case.
x->inv_txfm_add(dqcoeff, recon, 32, *eob);
break;
- default: assert(0 && "Invalid transform size"); break;
}
#if CONFIG_VP9_HIGHBITDEPTH
}
if (is_compound)
this_mv[1].as_int = frame_mv[mode][mi->ref_frame[1]].as_int;
break;
- case ZEROMV:
+ default:
+ assert(mode == ZEROMV);
this_mv[0].as_int = 0;
if (is_compound) this_mv[1].as_int = 0;
break;
- default: break;
}
mi->bmi[i].as_mv[0].as_int = this_mv[0].as_int;
projects / libvpx / commitdiff