Also write it to opsnr.stt when internal stats is enabled.
Removed some redundant code in vpxenc.c and vp9cx_set_ref.c
Change-Id: I3700137fff0be92a23e4ab75713db72da1dc4076
}
}
+#if CONFIG_DECODERS
+static void test_decode(vpx_codec_ctx_t *encoder, vpx_codec_ctx_t *decoder,
+ const int frames_out, int *mismatch_seen) {
+ vpx_image_t enc_img, dec_img;
+ struct vp9_ref_frame ref_enc, ref_dec;
+ if (*mismatch_seen) return;
+ /* Get the internal reference frame */
+ ref_enc.idx = 0;
+ ref_dec.idx = 0;
+ vpx_codec_control(encoder, VP9_GET_REFERENCE, &ref_enc);
+ enc_img = ref_enc.img;
+ vpx_codec_control(decoder, VP9_GET_REFERENCE, &ref_dec);
+ dec_img = ref_dec.img;
+#if CONFIG_VP9_HIGHBITDEPTH
+ if ((enc_img.fmt & VPX_IMG_FMT_HIGHBITDEPTH) !=
+ (dec_img.fmt & VPX_IMG_FMT_HIGHBITDEPTH)) {
+ if (enc_img.fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
+ vpx_img_alloc(&enc_img, enc_img.fmt - VPX_IMG_FMT_HIGHBITDEPTH,
+ enc_img.d_w, enc_img.d_h, 16);
+ vpx_img_truncate_16_to_8(&enc_img, &ref_enc.img);
+ }
+ if (dec_img.fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
+ vpx_img_alloc(&dec_img, dec_img.fmt - VPX_IMG_FMT_HIGHBITDEPTH,
+ dec_img.d_w, dec_img.d_h, 16);
+ vpx_img_truncate_16_to_8(&dec_img, &ref_dec.img);
+ }
+ }
+#endif
+
+ if (!compare_img(&enc_img, &dec_img)) {
+ int y[4], u[4], v[4];
+#if CONFIG_VP9_HIGHBITDEPTH
+ if (enc_img.fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
+ find_mismatch_high(&enc_img, &dec_img, y, u, v);
+ } else {
+ find_mismatch(&enc_img, &dec_img, y, u, v);
+ }
+#else
+ find_mismatch(&enc_img, &dec_img, y, u, v);
+#endif
+ decoder->err = 1;
+ printf(
+ "Encode/decode mismatch on frame %d at"
+ " Y[%d, %d] {%d/%d},"
+ " U[%d, %d] {%d/%d},"
+ " V[%d, %d] {%d/%d}\n",
+ frames_out, y[0], y[1], y[2], y[3], u[0], u[1], u[2], u[3], v[0], v[1],
+ v[2], v[3]);
+ *mismatch_seen = frames_out;
+ }
+
+ vpx_img_free(&enc_img);
+ vpx_img_free(&dec_img);
+}
+#endif
+
#if OUTPUT_RC_STATS
static void svc_output_rc_stats(
vpx_codec_ctx_t *codec, vpx_codec_enc_cfg_t *enc_cfg,
AppInput app_input;
VpxVideoWriter *writer = NULL;
VpxVideoInfo info;
- vpx_codec_ctx_t codec;
+ vpx_codec_ctx_t encoder;
vpx_codec_enc_cfg_t enc_cfg;
SvcContext svc_ctx;
vpx_svc_frame_drop_t svc_drop_frame;
#endif
struct vpx_usec_timer timer;
int64_t cx_time = 0;
+#if CONFIG_INTERNAL_STATS
+ FILE *f = fopen("opsnr.stt", "a");
+#endif
+#if CONFIG_DECODERS
+ int mismatch_seen = 0;
+ vpx_codec_ctx_t decoder;
+#endif
memset(&svc_ctx, 0, sizeof(svc_ctx));
memset(&app_input, 0, sizeof(AppInput));
memset(&info, 0, sizeof(VpxVideoInfo));
}
// Initialize codec
- if (vpx_svc_init(&svc_ctx, &codec, vpx_codec_vp9_cx(), &enc_cfg) !=
+ if (vpx_svc_init(&svc_ctx, &encoder, vpx_codec_vp9_cx(), &enc_cfg) !=
VPX_CODEC_OK)
die("Failed to initialize encoder\n");
+#if CONFIG_DECODERS
+ if (vpx_codec_dec_init(
+ &decoder, get_vpx_decoder_by_name("vp9")->codec_interface(), NULL, 0))
+ die("Failed to initialize decoder\n");
+#endif
#if OUTPUT_RC_STATS
rc.window_count = 1;
read_frame(&app_input.input_ctx, &raw);
if (svc_ctx.speed != -1)
- vpx_codec_control(&codec, VP8E_SET_CPUUSED, svc_ctx.speed);
+ vpx_codec_control(&encoder, VP8E_SET_CPUUSED, svc_ctx.speed);
if (svc_ctx.threads) {
- vpx_codec_control(&codec, VP9E_SET_TILE_COLUMNS, get_msb(svc_ctx.threads));
+ vpx_codec_control(&encoder, VP9E_SET_TILE_COLUMNS,
+ get_msb(svc_ctx.threads));
if (svc_ctx.threads > 1)
- vpx_codec_control(&codec, VP9E_SET_ROW_MT, 1);
+ vpx_codec_control(&encoder, VP9E_SET_ROW_MT, 1);
else
- vpx_codec_control(&codec, VP9E_SET_ROW_MT, 0);
+ vpx_codec_control(&encoder, VP9E_SET_ROW_MT, 0);
}
if (svc_ctx.speed >= 5 && svc_ctx.aqmode == 1)
- vpx_codec_control(&codec, VP9E_SET_AQ_MODE, 3);
+ vpx_codec_control(&encoder, VP9E_SET_AQ_MODE, 3);
if (svc_ctx.speed >= 5)
- vpx_codec_control(&codec, VP8E_SET_STATIC_THRESHOLD, 1);
- vpx_codec_control(&codec, VP8E_SET_MAX_INTRA_BITRATE_PCT, 900);
+ vpx_codec_control(&encoder, VP8E_SET_STATIC_THRESHOLD, 1);
+ vpx_codec_control(&encoder, VP8E_SET_MAX_INTRA_BITRATE_PCT, 900);
- vpx_codec_control(&codec, VP9E_SET_SVC_INTER_LAYER_PRED,
+ vpx_codec_control(&encoder, VP9E_SET_SVC_INTER_LAYER_PRED,
app_input.inter_layer_pred);
- vpx_codec_control(&codec, VP9E_SET_NOISE_SENSITIVITY, 0);
+ vpx_codec_control(&encoder, VP9E_SET_NOISE_SENSITIVITY, 0);
- vpx_codec_control(&codec, VP9E_SET_TUNE_CONTENT, app_input.tune_content);
+ vpx_codec_control(&encoder, VP9E_SET_TUNE_CONTENT, app_input.tune_content);
svc_drop_frame.framedrop_mode = FULL_SUPERFRAME_DROP;
for (sl = 0; sl < (unsigned int)svc_ctx.spatial_layers; ++sl)
svc_drop_frame.framedrop_thresh[sl] = enc_cfg.rc_dropframe_thresh;
svc_drop_frame.max_consec_drop = INT_MAX;
- vpx_codec_control(&codec, VP9E_SET_SVC_FRAME_DROP_LAYER, &svc_drop_frame);
+ vpx_codec_control(&encoder, VP9E_SET_SVC_FRAME_DROP_LAYER, &svc_drop_frame);
// Encode frames
while (!end_of_stream) {
layer_id.spatial_layer_id = 1;
}
}
- vpx_codec_control(&codec, VP9E_SET_SVC_LAYER_ID, &layer_id);
+ vpx_codec_control(&encoder, VP9E_SET_SVC_LAYER_ID, &layer_id);
// TODO(jianj): Fix the parameter passing for "is_key_frame" in
// set_frame_flags_bypass_model() for case of periodic key frames.
if (example_pattern == 0) {
ref_frame_config.duration[0] = frame_duration * 1;
ref_frame_config.duration[1] = frame_duration * 1;
- vpx_codec_control(&codec, VP9E_SET_SVC_REF_FRAME_CONFIG,
+ vpx_codec_control(&encoder, VP9E_SET_SVC_REF_FRAME_CONFIG,
&ref_frame_config);
// Keep track of input frames, to account for frame drops in rate control
// stats/metrics.
vpx_usec_timer_start(&timer);
res = vpx_svc_encode(
- &svc_ctx, &codec, (end_of_stream ? NULL : &raw), pts, frame_duration,
+ &svc_ctx, &encoder, (end_of_stream ? NULL : &raw), pts, frame_duration,
svc_ctx.speed >= 5 ? VPX_DL_REALTIME : VPX_DL_GOOD_QUALITY);
vpx_usec_timer_mark(&timer);
cx_time += vpx_usec_timer_elapsed(&timer);
fflush(stdout);
if (res != VPX_CODEC_OK) {
- die_codec(&codec, "Failed to encode frame");
+ die_codec(&encoder, "Failed to encode frame");
}
- while ((cx_pkt = vpx_codec_get_cx_data(&codec, &iter)) != NULL) {
+ while ((cx_pkt = vpx_codec_get_cx_data(&encoder, &iter)) != NULL) {
switch (cx_pkt->kind) {
case VPX_CODEC_CX_FRAME_PKT: {
SvcInternal_t *const si = (SvcInternal_t *)svc_ctx.internal;
cx_pkt->data.frame.pts);
#if OUTPUT_RC_STATS
if (svc_ctx.output_rc_stat) {
- svc_output_rc_stats(&codec, &enc_cfg, &layer_id, cx_pkt, &rc,
+ svc_output_rc_stats(&encoder, &enc_cfg, &layer_id, cx_pkt, &rc,
outfile, frame_cnt, framerate);
}
#endif
if (enc_cfg.ss_number_layers == 1 && enc_cfg.ts_number_layers == 1)
si->bytes_sum[0] += (int)cx_pkt->data.frame.sz;
++frames_received;
+#if CONFIG_DECODERS
+ if (vpx_codec_decode(&decoder, cx_pkt->data.frame.buf,
+ (unsigned int)cx_pkt->data.frame.sz, NULL, 0))
+ die_codec(&decoder, "Failed to decode frame.");
+#endif
break;
}
case VPX_CODEC_STATS_PKT: {
}
default: { break; }
}
+
+#if CONFIG_DECODERS
+ vpx_codec_control(&encoder, VP9E_GET_SVC_LAYER_ID, &layer_id);
+ // Don't look for mismatch on top spatial and top temporal layers as they
+ // are non reference frames.
+ if (!(layer_id.temporal_layer_id > 0 &&
+ layer_id.temporal_layer_id == (int)enc_cfg.ts_number_layers - 1 &&
+ cx_pkt->data.frame
+ .spatial_layer_encoded[enc_cfg.ss_number_layers - 1])) {
+ test_decode(&encoder, &decoder, frame_cnt, &mismatch_seen);
+ }
+#endif
}
if (!end_of_stream) {
printf("\n");
}
#endif
- if (vpx_codec_destroy(&codec)) die_codec(&codec, "Failed to destroy codec");
+ if (vpx_codec_destroy(&encoder))
+ die_codec(&encoder, "Failed to destroy codec");
if (app_input.passes == 2) stats_close(&app_input.rc_stats, 1);
if (writer) {
vpx_video_writer_close(writer);
}
}
#endif
+#if CONFIG_INTERNAL_STATS
+ if (mismatch_seen) {
+ fprintf(f, "First mismatch occurred in frame %d\n", mismatch_seen);
+ } else {
+ fprintf(f, "No mismatch detected in recon buffers\n");
+ }
+ fclose(f);
+#endif
printf("Frame cnt and encoding time/FPS stats for encoding: %d %f %f \n",
frame_cnt, 1000 * (float)cx_time / (double)(frame_cnt * 1000000),
1000000 * (double)frame_cnt / (double)cx_time);
exit(EXIT_FAILURE);
}
-static int compare_img(const vpx_image_t *const img1,
- const vpx_image_t *const img2) {
- uint32_t l_w = img1->d_w;
- uint32_t c_w = (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
- const uint32_t c_h =
- (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
- uint32_t i;
- int match = 1;
-
- match &= (img1->fmt == img2->fmt);
- match &= (img1->d_w == img2->d_w);
- match &= (img1->d_h == img2->d_h);
-
- for (i = 0; i < img1->d_h; ++i)
- match &= (memcmp(img1->planes[VPX_PLANE_Y] + i * img1->stride[VPX_PLANE_Y],
- img2->planes[VPX_PLANE_Y] + i * img2->stride[VPX_PLANE_Y],
- l_w) == 0);
-
- for (i = 0; i < c_h; ++i)
- match &= (memcmp(img1->planes[VPX_PLANE_U] + i * img1->stride[VPX_PLANE_U],
- img2->planes[VPX_PLANE_U] + i * img2->stride[VPX_PLANE_U],
- c_w) == 0);
-
- for (i = 0; i < c_h; ++i)
- match &= (memcmp(img1->planes[VPX_PLANE_V] + i * img1->stride[VPX_PLANE_V],
- img2->planes[VPX_PLANE_V] + i * img2->stride[VPX_PLANE_V],
- c_w) == 0);
-
- return match;
-}
-
-#define mmin(a, b) ((a) < (b) ? (a) : (b))
-static void find_mismatch(const vpx_image_t *const img1,
- const vpx_image_t *const img2, int yloc[4],
- int uloc[4], int vloc[4]) {
- const uint32_t bsize = 64;
- const uint32_t bsizey = bsize >> img1->y_chroma_shift;
- const uint32_t bsizex = bsize >> img1->x_chroma_shift;
- const uint32_t c_w =
- (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
- const uint32_t c_h =
- (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
- int match = 1;
- uint32_t i, j;
- yloc[0] = yloc[1] = yloc[2] = yloc[3] = -1;
- for (i = 0, match = 1; match && i < img1->d_h; i += bsize) {
- for (j = 0; match && j < img1->d_w; j += bsize) {
- int k, l;
- const int si = mmin(i + bsize, img1->d_h) - i;
- const int sj = mmin(j + bsize, img1->d_w) - j;
- for (k = 0; match && k < si; ++k) {
- for (l = 0; match && l < sj; ++l) {
- if (*(img1->planes[VPX_PLANE_Y] +
- (i + k) * img1->stride[VPX_PLANE_Y] + j + l) !=
- *(img2->planes[VPX_PLANE_Y] +
- (i + k) * img2->stride[VPX_PLANE_Y] + j + l)) {
- yloc[0] = i + k;
- yloc[1] = j + l;
- yloc[2] = *(img1->planes[VPX_PLANE_Y] +
- (i + k) * img1->stride[VPX_PLANE_Y] + j + l);
- yloc[3] = *(img2->planes[VPX_PLANE_Y] +
- (i + k) * img2->stride[VPX_PLANE_Y] + j + l);
- match = 0;
- break;
- }
- }
- }
- }
- }
-
- uloc[0] = uloc[1] = uloc[2] = uloc[3] = -1;
- for (i = 0, match = 1; match && i < c_h; i += bsizey) {
- for (j = 0; match && j < c_w; j += bsizex) {
- int k, l;
- const int si = mmin(i + bsizey, c_h - i);
- const int sj = mmin(j + bsizex, c_w - j);
- for (k = 0; match && k < si; ++k) {
- for (l = 0; match && l < sj; ++l) {
- if (*(img1->planes[VPX_PLANE_U] +
- (i + k) * img1->stride[VPX_PLANE_U] + j + l) !=
- *(img2->planes[VPX_PLANE_U] +
- (i + k) * img2->stride[VPX_PLANE_U] + j + l)) {
- uloc[0] = i + k;
- uloc[1] = j + l;
- uloc[2] = *(img1->planes[VPX_PLANE_U] +
- (i + k) * img1->stride[VPX_PLANE_U] + j + l);
- uloc[3] = *(img2->planes[VPX_PLANE_U] +
- (i + k) * img2->stride[VPX_PLANE_U] + j + l);
- match = 0;
- break;
- }
- }
- }
- }
- }
- vloc[0] = vloc[1] = vloc[2] = vloc[3] = -1;
- for (i = 0, match = 1; match && i < c_h; i += bsizey) {
- for (j = 0; match && j < c_w; j += bsizex) {
- int k, l;
- const int si = mmin(i + bsizey, c_h - i);
- const int sj = mmin(j + bsizex, c_w - j);
- for (k = 0; match && k < si; ++k) {
- for (l = 0; match && l < sj; ++l) {
- if (*(img1->planes[VPX_PLANE_V] +
- (i + k) * img1->stride[VPX_PLANE_V] + j + l) !=
- *(img2->planes[VPX_PLANE_V] +
- (i + k) * img2->stride[VPX_PLANE_V] + j + l)) {
- vloc[0] = i + k;
- vloc[1] = j + l;
- vloc[2] = *(img1->planes[VPX_PLANE_V] +
- (i + k) * img1->stride[VPX_PLANE_V] + j + l);
- vloc[3] = *(img2->planes[VPX_PLANE_V] +
- (i + k) * img2->stride[VPX_PLANE_V] + j + l);
- match = 0;
- break;
- }
- }
- }
- }
- }
-}
-
static void testing_decode(vpx_codec_ctx_t *encoder, vpx_codec_ctx_t *decoder,
unsigned int frame_out, int *mismatch_seen) {
vpx_image_t enc_img, dec_img;
}
}
#endif // CONFIG_VP9_HIGHBITDEPTH
+
+int compare_img(const vpx_image_t *const img1, const vpx_image_t *const img2) {
+ uint32_t l_w = img1->d_w;
+ uint32_t c_w = (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
+ const uint32_t c_h =
+ (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
+ uint32_t i;
+ int match = 1;
+
+ match &= (img1->fmt == img2->fmt);
+ match &= (img1->d_w == img2->d_w);
+ match &= (img1->d_h == img2->d_h);
+#if CONFIG_VP9_HIGHBITDEPTH
+ if (img1->fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
+ l_w *= 2;
+ c_w *= 2;
+ }
+#endif
+
+ for (i = 0; i < img1->d_h; ++i)
+ match &= (memcmp(img1->planes[VPX_PLANE_Y] + i * img1->stride[VPX_PLANE_Y],
+ img2->planes[VPX_PLANE_Y] + i * img2->stride[VPX_PLANE_Y],
+ l_w) == 0);
+
+ for (i = 0; i < c_h; ++i)
+ match &= (memcmp(img1->planes[VPX_PLANE_U] + i * img1->stride[VPX_PLANE_U],
+ img2->planes[VPX_PLANE_U] + i * img2->stride[VPX_PLANE_U],
+ c_w) == 0);
+
+ for (i = 0; i < c_h; ++i)
+ match &= (memcmp(img1->planes[VPX_PLANE_V] + i * img1->stride[VPX_PLANE_V],
+ img2->planes[VPX_PLANE_V] + i * img2->stride[VPX_PLANE_V],
+ c_w) == 0);
+
+ return match;
+}
+
+#define mmin(a, b) ((a) < (b) ? (a) : (b))
+
+#if CONFIG_VP9_HIGHBITDEPTH
+void find_mismatch_high(const vpx_image_t *const img1,
+ const vpx_image_t *const img2, int yloc[4], int uloc[4],
+ int vloc[4]) {
+ uint16_t *plane1, *plane2;
+ uint32_t stride1, stride2;
+ const uint32_t bsize = 64;
+ const uint32_t bsizey = bsize >> img1->y_chroma_shift;
+ const uint32_t bsizex = bsize >> img1->x_chroma_shift;
+ const uint32_t c_w =
+ (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
+ const uint32_t c_h =
+ (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
+ int match = 1;
+ uint32_t i, j;
+ yloc[0] = yloc[1] = yloc[2] = yloc[3] = -1;
+ plane1 = (uint16_t *)img1->planes[VPX_PLANE_Y];
+ plane2 = (uint16_t *)img2->planes[VPX_PLANE_Y];
+ stride1 = img1->stride[VPX_PLANE_Y] / 2;
+ stride2 = img2->stride[VPX_PLANE_Y] / 2;
+ for (i = 0, match = 1; match && i < img1->d_h; i += bsize) {
+ for (j = 0; match && j < img1->d_w; j += bsize) {
+ int k, l;
+ const int si = mmin(i + bsize, img1->d_h) - i;
+ const int sj = mmin(j + bsize, img1->d_w) - j;
+ for (k = 0; match && k < si; ++k) {
+ for (l = 0; match && l < sj; ++l) {
+ if (*(plane1 + (i + k) * stride1 + j + l) !=
+ *(plane2 + (i + k) * stride2 + j + l)) {
+ yloc[0] = i + k;
+ yloc[1] = j + l;
+ yloc[2] = *(plane1 + (i + k) * stride1 + j + l);
+ yloc[3] = *(plane2 + (i + k) * stride2 + j + l);
+ match = 0;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ uloc[0] = uloc[1] = uloc[2] = uloc[3] = -1;
+ plane1 = (uint16_t *)img1->planes[VPX_PLANE_U];
+ plane2 = (uint16_t *)img2->planes[VPX_PLANE_U];
+ stride1 = img1->stride[VPX_PLANE_U] / 2;
+ stride2 = img2->stride[VPX_PLANE_U] / 2;
+ for (i = 0, match = 1; match && i < c_h; i += bsizey) {
+ for (j = 0; match && j < c_w; j += bsizex) {
+ int k, l;
+ const int si = mmin(i + bsizey, c_h - i);
+ const int sj = mmin(j + bsizex, c_w - j);
+ for (k = 0; match && k < si; ++k) {
+ for (l = 0; match && l < sj; ++l) {
+ if (*(plane1 + (i + k) * stride1 + j + l) !=
+ *(plane2 + (i + k) * stride2 + j + l)) {
+ uloc[0] = i + k;
+ uloc[1] = j + l;
+ uloc[2] = *(plane1 + (i + k) * stride1 + j + l);
+ uloc[3] = *(plane2 + (i + k) * stride2 + j + l);
+ match = 0;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ vloc[0] = vloc[1] = vloc[2] = vloc[3] = -1;
+ plane1 = (uint16_t *)img1->planes[VPX_PLANE_V];
+ plane2 = (uint16_t *)img2->planes[VPX_PLANE_V];
+ stride1 = img1->stride[VPX_PLANE_V] / 2;
+ stride2 = img2->stride[VPX_PLANE_V] / 2;
+ for (i = 0, match = 1; match && i < c_h; i += bsizey) {
+ for (j = 0; match && j < c_w; j += bsizex) {
+ int k, l;
+ const int si = mmin(i + bsizey, c_h - i);
+ const int sj = mmin(j + bsizex, c_w - j);
+ for (k = 0; match && k < si; ++k) {
+ for (l = 0; match && l < sj; ++l) {
+ if (*(plane1 + (i + k) * stride1 + j + l) !=
+ *(plane2 + (i + k) * stride2 + j + l)) {
+ vloc[0] = i + k;
+ vloc[1] = j + l;
+ vloc[2] = *(plane1 + (i + k) * stride1 + j + l);
+ vloc[3] = *(plane2 + (i + k) * stride2 + j + l);
+ match = 0;
+ break;
+ }
+ }
+ }
+ }
+ }
+}
+#endif // CONFIG_VP9_HIGHBITDEPTH
+
+void find_mismatch(const vpx_image_t *const img1, const vpx_image_t *const img2,
+ int yloc[4], int uloc[4], int vloc[4]) {
+ const uint32_t bsize = 64;
+ const uint32_t bsizey = bsize >> img1->y_chroma_shift;
+ const uint32_t bsizex = bsize >> img1->x_chroma_shift;
+ const uint32_t c_w =
+ (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
+ const uint32_t c_h =
+ (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
+ int match = 1;
+ uint32_t i, j;
+ yloc[0] = yloc[1] = yloc[2] = yloc[3] = -1;
+ for (i = 0, match = 1; match && i < img1->d_h; i += bsize) {
+ for (j = 0; match && j < img1->d_w; j += bsize) {
+ int k, l;
+ const int si = mmin(i + bsize, img1->d_h) - i;
+ const int sj = mmin(j + bsize, img1->d_w) - j;
+ for (k = 0; match && k < si; ++k) {
+ for (l = 0; match && l < sj; ++l) {
+ if (*(img1->planes[VPX_PLANE_Y] +
+ (i + k) * img1->stride[VPX_PLANE_Y] + j + l) !=
+ *(img2->planes[VPX_PLANE_Y] +
+ (i + k) * img2->stride[VPX_PLANE_Y] + j + l)) {
+ yloc[0] = i + k;
+ yloc[1] = j + l;
+ yloc[2] = *(img1->planes[VPX_PLANE_Y] +
+ (i + k) * img1->stride[VPX_PLANE_Y] + j + l);
+ yloc[3] = *(img2->planes[VPX_PLANE_Y] +
+ (i + k) * img2->stride[VPX_PLANE_Y] + j + l);
+ match = 0;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ uloc[0] = uloc[1] = uloc[2] = uloc[3] = -1;
+ for (i = 0, match = 1; match && i < c_h; i += bsizey) {
+ for (j = 0; match && j < c_w; j += bsizex) {
+ int k, l;
+ const int si = mmin(i + bsizey, c_h - i);
+ const int sj = mmin(j + bsizex, c_w - j);
+ for (k = 0; match && k < si; ++k) {
+ for (l = 0; match && l < sj; ++l) {
+ if (*(img1->planes[VPX_PLANE_U] +
+ (i + k) * img1->stride[VPX_PLANE_U] + j + l) !=
+ *(img2->planes[VPX_PLANE_U] +
+ (i + k) * img2->stride[VPX_PLANE_U] + j + l)) {
+ uloc[0] = i + k;
+ uloc[1] = j + l;
+ uloc[2] = *(img1->planes[VPX_PLANE_U] +
+ (i + k) * img1->stride[VPX_PLANE_U] + j + l);
+ uloc[3] = *(img2->planes[VPX_PLANE_U] +
+ (i + k) * img2->stride[VPX_PLANE_U] + j + l);
+ match = 0;
+ break;
+ }
+ }
+ }
+ }
+ }
+ vloc[0] = vloc[1] = vloc[2] = vloc[3] = -1;
+ for (i = 0, match = 1; match && i < c_h; i += bsizey) {
+ for (j = 0; match && j < c_w; j += bsizex) {
+ int k, l;
+ const int si = mmin(i + bsizey, c_h - i);
+ const int sj = mmin(j + bsizex, c_w - j);
+ for (k = 0; match && k < si; ++k) {
+ for (l = 0; match && l < sj; ++l) {
+ if (*(img1->planes[VPX_PLANE_V] +
+ (i + k) * img1->stride[VPX_PLANE_V] + j + l) !=
+ *(img2->planes[VPX_PLANE_V] +
+ (i + k) * img2->stride[VPX_PLANE_V] + j + l)) {
+ vloc[0] = i + k;
+ vloc[1] = j + l;
+ vloc[2] = *(img1->planes[VPX_PLANE_V] +
+ (i + k) * img1->stride[VPX_PLANE_V] + j + l);
+ vloc[3] = *(img2->planes[VPX_PLANE_V] +
+ (i + k) * img2->stride[VPX_PLANE_V] + j + l);
+ match = 0;
+ break;
+ }
+ }
+ }
+ }
+ }
+}
void vpx_img_truncate_16_to_8(vpx_image_t *dst, vpx_image_t *src);
#endif
+int compare_img(const vpx_image_t *const img1, const vpx_image_t *const img2);
+#if CONFIG_VP9_HIGHBITDEPTH
+void find_mismatch_high(const vpx_image_t *const img1,
+ const vpx_image_t *const img2, int yloc[4], int uloc[4],
+ int vloc[4]);
+#endif
+void find_mismatch(const vpx_image_t *const img1, const vpx_image_t *const img2,
+ int yloc[4], int uloc[4], int vloc[4]);
+
#ifdef __cplusplus
} /* extern "C" */
#endif
exit(EXIT_FAILURE);
}
-#define mmin(a, b) ((a) < (b) ? (a) : (b))
-
-#if CONFIG_VP9_HIGHBITDEPTH
-static void find_mismatch_high(const vpx_image_t *const img1,
- const vpx_image_t *const img2, int yloc[4],
- int uloc[4], int vloc[4]) {
- uint16_t *plane1, *plane2;
- uint32_t stride1, stride2;
- const uint32_t bsize = 64;
- const uint32_t bsizey = bsize >> img1->y_chroma_shift;
- const uint32_t bsizex = bsize >> img1->x_chroma_shift;
- const uint32_t c_w =
- (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
- const uint32_t c_h =
- (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
- int match = 1;
- uint32_t i, j;
- yloc[0] = yloc[1] = yloc[2] = yloc[3] = -1;
- plane1 = (uint16_t *)img1->planes[VPX_PLANE_Y];
- plane2 = (uint16_t *)img2->planes[VPX_PLANE_Y];
- stride1 = img1->stride[VPX_PLANE_Y] / 2;
- stride2 = img2->stride[VPX_PLANE_Y] / 2;
- for (i = 0, match = 1; match && i < img1->d_h; i += bsize) {
- for (j = 0; match && j < img1->d_w; j += bsize) {
- int k, l;
- const int si = mmin(i + bsize, img1->d_h) - i;
- const int sj = mmin(j + bsize, img1->d_w) - j;
- for (k = 0; match && k < si; ++k) {
- for (l = 0; match && l < sj; ++l) {
- if (*(plane1 + (i + k) * stride1 + j + l) !=
- *(plane2 + (i + k) * stride2 + j + l)) {
- yloc[0] = i + k;
- yloc[1] = j + l;
- yloc[2] = *(plane1 + (i + k) * stride1 + j + l);
- yloc[3] = *(plane2 + (i + k) * stride2 + j + l);
- match = 0;
- break;
- }
- }
- }
- }
- }
-
- uloc[0] = uloc[1] = uloc[2] = uloc[3] = -1;
- plane1 = (uint16_t *)img1->planes[VPX_PLANE_U];
- plane2 = (uint16_t *)img2->planes[VPX_PLANE_U];
- stride1 = img1->stride[VPX_PLANE_U] / 2;
- stride2 = img2->stride[VPX_PLANE_U] / 2;
- for (i = 0, match = 1; match && i < c_h; i += bsizey) {
- for (j = 0; match && j < c_w; j += bsizex) {
- int k, l;
- const int si = mmin(i + bsizey, c_h - i);
- const int sj = mmin(j + bsizex, c_w - j);
- for (k = 0; match && k < si; ++k) {
- for (l = 0; match && l < sj; ++l) {
- if (*(plane1 + (i + k) * stride1 + j + l) !=
- *(plane2 + (i + k) * stride2 + j + l)) {
- uloc[0] = i + k;
- uloc[1] = j + l;
- uloc[2] = *(plane1 + (i + k) * stride1 + j + l);
- uloc[3] = *(plane2 + (i + k) * stride2 + j + l);
- match = 0;
- break;
- }
- }
- }
- }
- }
-
- vloc[0] = vloc[1] = vloc[2] = vloc[3] = -1;
- plane1 = (uint16_t *)img1->planes[VPX_PLANE_V];
- plane2 = (uint16_t *)img2->planes[VPX_PLANE_V];
- stride1 = img1->stride[VPX_PLANE_V] / 2;
- stride2 = img2->stride[VPX_PLANE_V] / 2;
- for (i = 0, match = 1; match && i < c_h; i += bsizey) {
- for (j = 0; match && j < c_w; j += bsizex) {
- int k, l;
- const int si = mmin(i + bsizey, c_h - i);
- const int sj = mmin(j + bsizex, c_w - j);
- for (k = 0; match && k < si; ++k) {
- for (l = 0; match && l < sj; ++l) {
- if (*(plane1 + (i + k) * stride1 + j + l) !=
- *(plane2 + (i + k) * stride2 + j + l)) {
- vloc[0] = i + k;
- vloc[1] = j + l;
- vloc[2] = *(plane1 + (i + k) * stride1 + j + l);
- vloc[3] = *(plane2 + (i + k) * stride2 + j + l);
- match = 0;
- break;
- }
- }
- }
- }
- }
-}
-#endif
-
-static void find_mismatch(const vpx_image_t *const img1,
- const vpx_image_t *const img2, int yloc[4],
- int uloc[4], int vloc[4]) {
- const uint32_t bsize = 64;
- const uint32_t bsizey = bsize >> img1->y_chroma_shift;
- const uint32_t bsizex = bsize >> img1->x_chroma_shift;
- const uint32_t c_w =
- (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
- const uint32_t c_h =
- (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
- int match = 1;
- uint32_t i, j;
- yloc[0] = yloc[1] = yloc[2] = yloc[3] = -1;
- for (i = 0, match = 1; match && i < img1->d_h; i += bsize) {
- for (j = 0; match && j < img1->d_w; j += bsize) {
- int k, l;
- const int si = mmin(i + bsize, img1->d_h) - i;
- const int sj = mmin(j + bsize, img1->d_w) - j;
- for (k = 0; match && k < si; ++k) {
- for (l = 0; match && l < sj; ++l) {
- if (*(img1->planes[VPX_PLANE_Y] +
- (i + k) * img1->stride[VPX_PLANE_Y] + j + l) !=
- *(img2->planes[VPX_PLANE_Y] +
- (i + k) * img2->stride[VPX_PLANE_Y] + j + l)) {
- yloc[0] = i + k;
- yloc[1] = j + l;
- yloc[2] = *(img1->planes[VPX_PLANE_Y] +
- (i + k) * img1->stride[VPX_PLANE_Y] + j + l);
- yloc[3] = *(img2->planes[VPX_PLANE_Y] +
- (i + k) * img2->stride[VPX_PLANE_Y] + j + l);
- match = 0;
- break;
- }
- }
- }
- }
- }
-
- uloc[0] = uloc[1] = uloc[2] = uloc[3] = -1;
- for (i = 0, match = 1; match && i < c_h; i += bsizey) {
- for (j = 0; match && j < c_w; j += bsizex) {
- int k, l;
- const int si = mmin(i + bsizey, c_h - i);
- const int sj = mmin(j + bsizex, c_w - j);
- for (k = 0; match && k < si; ++k) {
- for (l = 0; match && l < sj; ++l) {
- if (*(img1->planes[VPX_PLANE_U] +
- (i + k) * img1->stride[VPX_PLANE_U] + j + l) !=
- *(img2->planes[VPX_PLANE_U] +
- (i + k) * img2->stride[VPX_PLANE_U] + j + l)) {
- uloc[0] = i + k;
- uloc[1] = j + l;
- uloc[2] = *(img1->planes[VPX_PLANE_U] +
- (i + k) * img1->stride[VPX_PLANE_U] + j + l);
- uloc[3] = *(img2->planes[VPX_PLANE_U] +
- (i + k) * img2->stride[VPX_PLANE_U] + j + l);
- match = 0;
- break;
- }
- }
- }
- }
- }
- vloc[0] = vloc[1] = vloc[2] = vloc[3] = -1;
- for (i = 0, match = 1; match && i < c_h; i += bsizey) {
- for (j = 0; match && j < c_w; j += bsizex) {
- int k, l;
- const int si = mmin(i + bsizey, c_h - i);
- const int sj = mmin(j + bsizex, c_w - j);
- for (k = 0; match && k < si; ++k) {
- for (l = 0; match && l < sj; ++l) {
- if (*(img1->planes[VPX_PLANE_V] +
- (i + k) * img1->stride[VPX_PLANE_V] + j + l) !=
- *(img2->planes[VPX_PLANE_V] +
- (i + k) * img2->stride[VPX_PLANE_V] + j + l)) {
- vloc[0] = i + k;
- vloc[1] = j + l;
- vloc[2] = *(img1->planes[VPX_PLANE_V] +
- (i + k) * img1->stride[VPX_PLANE_V] + j + l);
- vloc[3] = *(img2->planes[VPX_PLANE_V] +
- (i + k) * img2->stride[VPX_PLANE_V] + j + l);
- match = 0;
- break;
- }
- }
- }
- }
- }
-}
-
-static int compare_img(const vpx_image_t *const img1,
- const vpx_image_t *const img2) {
- uint32_t l_w = img1->d_w;
- uint32_t c_w = (img1->d_w + img1->x_chroma_shift) >> img1->x_chroma_shift;
- const uint32_t c_h =
- (img1->d_h + img1->y_chroma_shift) >> img1->y_chroma_shift;
- uint32_t i;
- int match = 1;
-
- match &= (img1->fmt == img2->fmt);
- match &= (img1->d_w == img2->d_w);
- match &= (img1->d_h == img2->d_h);
-#if CONFIG_VP9_HIGHBITDEPTH
- if (img1->fmt & VPX_IMG_FMT_HIGHBITDEPTH) {
- l_w *= 2;
- c_w *= 2;
- }
-#endif
-
- for (i = 0; i < img1->d_h; ++i)
- match &= (memcmp(img1->planes[VPX_PLANE_Y] + i * img1->stride[VPX_PLANE_Y],
- img2->planes[VPX_PLANE_Y] + i * img2->stride[VPX_PLANE_Y],
- l_w) == 0);
-
- for (i = 0; i < c_h; ++i)
- match &= (memcmp(img1->planes[VPX_PLANE_U] + i * img1->stride[VPX_PLANE_U],
- img2->planes[VPX_PLANE_U] + i * img2->stride[VPX_PLANE_U],
- c_w) == 0);
-
- for (i = 0; i < c_h; ++i)
- match &= (memcmp(img1->planes[VPX_PLANE_V] + i * img1->stride[VPX_PLANE_V],
- img2->planes[VPX_PLANE_V] + i * img2->stride[VPX_PLANE_V],
- c_w) == 0);
-
- return match;
-}
-
#define NELEMENTS(x) (sizeof(x) / sizeof(x[0]))
#if CONFIG_VP9_ENCODER
#define ARG_CTRL_CNT_MAX NELEMENTS(vp9_arg_ctrl_map)
projects / platform / upstream / libvpx.git / commitdiff