paint_setup_GRAY8 (struct paintinfo * p, unsigned char * dest)
{
  int D.23003;
  int D.23004;
  int D.23005;
  int D.23006;
  int D.23007;
  int D.23008;
  sizetype D.23009;
  unsigned char * D.23010;

  p->yp = dest;
  D.23003 = p->width;
  D.23004 = D.23003 + 3;
  D.23005 = D.23004 & -4;
  p->ystride = D.23005;
  D.23006 = p->ystride;
  D.23007 = p->height;
  D.23008 = D.23006 * D.23007;
  D.23009 = (sizetype) D.23008;
  D.23010 = dest + D.23009;
  p->endptr = D.23010;
}


paint_setup_Y42B (struct paintinfo * p, unsigned char * dest)
{
  int D.23011;
  int D.23012;
  int D.23013;
  unsigned char * D.23014;
  int D.23015;
  int D.23016;
  int D.23017;
  sizetype D.23018;
  unsigned char * D.23019;
  int D.23020;
  int D.23021;
  int D.23022;
  unsigned char * D.23023;
  int D.23024;
  int D.23025;
  sizetype D.23026;
  unsigned char * D.23027;
  unsigned char * D.23028;
  int D.23029;
  int D.23030;
  sizetype D.23031;
  unsigned char * D.23032;

  p->yp = dest;
  D.23011 = p->width;
  D.23012 = D.23011 + 3;
  D.23013 = D.23012 & -4;
  p->ystride = D.23013;
  D.23014 = p->yp;
  D.23015 = p->ystride;
  D.23016 = p->height;
  D.23017 = D.23015 * D.23016;
  D.23018 = (sizetype) D.23017;
  D.23019 = D.23014 + D.23018;
  p->up = D.23019;
  D.23011 = p->width;
  D.23020 = D.23011 + 7;
  D.23021 = D.23020 & -8;
  D.23022 = D.23021 / 2;
  p->ustride = D.23022;
  D.23023 = p->up;
  D.23024 = p->ustride;
  D.23016 = p->height;
  D.23025 = D.23024 * D.23016;
  D.23026 = (sizetype) D.23025;
  D.23027 = D.23023 + D.23026;
  p->vp = D.23027;
  D.23011 = p->width;
  D.23020 = D.23011 + 7;
  D.23021 = D.23020 & -8;
  D.23022 = D.23021 / 2;
  p->vstride = D.23022;
  D.23028 = p->vp;
  D.23029 = p->vstride;
  D.23016 = p->height;
  D.23030 = D.23029 * D.23016;
  D.23031 = (sizetype) D.23030;
  D.23032 = D.23028 + D.23031;
  p->endptr = D.23032;
}


paint_setup_Y41B (struct paintinfo * p, unsigned char * dest)
{
  int D.23033;
  int D.23034;
  int D.23035;
  unsigned char * D.23036;
  int D.23037;
  int D.23038;
  int D.23039;
  sizetype D.23040;
  unsigned char * D.23041;
  int D.23042;
  int D.23043;
  int D.23044;
  unsigned char * D.23045;
  int D.23046;
  int D.23047;
  sizetype D.23048;
  unsigned char * D.23049;
  unsigned char * D.23050;
  int D.23051;
  int D.23052;
  sizetype D.23053;
  unsigned char * D.23054;

  p->yp = dest;
  D.23033 = p->width;
  D.23034 = D.23033 + 3;
  D.23035 = D.23034 & -4;
  p->ystride = D.23035;
  D.23036 = p->yp;
  D.23037 = p->ystride;
  D.23038 = p->height;
  D.23039 = D.23037 * D.23038;
  D.23040 = (sizetype) D.23039;
  D.23041 = D.23036 + D.23040;
  p->up = D.23041;
  D.23033 = p->width;
  D.23042 = D.23033 + 15;
  D.23043 = D.23042 & -16;
  D.23044 = D.23043 / 4;
  p->ustride = D.23044;
  D.23045 = p->up;
  D.23046 = p->ustride;
  D.23038 = p->height;
  D.23047 = D.23046 * D.23038;
  D.23048 = (sizetype) D.23047;
  D.23049 = D.23045 + D.23048;
  p->vp = D.23049;
  D.23033 = p->width;
  D.23042 = D.23033 + 15;
  D.23043 = D.23042 & -16;
  D.23044 = D.23043 / 4;
  p->vstride = D.23044;
  D.23050 = p->vp;
  D.23051 = p->vstride;
  D.23038 = p->height;
  D.23052 = D.23051 * D.23038;
  D.23053 = (sizetype) D.23052;
  D.23054 = D.23050 + D.23053;
  p->endptr = D.23054;
}


paint_setup_I420 (struct paintinfo * p, unsigned char * dest)
{
  int D.23055;
  int D.23056;
  int D.23057;
  unsigned char * D.23058;
  int D.23059;
  int D.23060;
  int D.23061;
  int D.23062;
  int D.23063;
  sizetype D.23064;
  unsigned char * D.23065;
  int D.23066;
  int D.23067;
  int D.23068;
  unsigned char * D.23069;
  int D.23070;
  int D.23071;
  int D.23072;
  sizetype D.23073;
  unsigned char * D.23074;
  int D.23075;
  int D.23076;
  int D.23077;
  unsigned char * D.23078;
  int D.23079;
  int D.23080;
  int D.23081;
  sizetype D.23082;
  unsigned char * D.23083;

  p->yp = dest;
  D.23055 = p->width;
  D.23056 = D.23055 + 3;
  D.23057 = D.23056 & -4;
  p->ystride = D.23057;
  D.23058 = p->yp;
  D.23059 = p->ystride;
  D.23060 = p->height;
  D.23061 = D.23060 + 1;
  D.23062 = D.23061 & -2;
  D.23063 = D.23059 * D.23062;
  D.23064 = (sizetype) D.23063;
  D.23065 = D.23058 + D.23064;
  p->up = D.23065;
  D.23055 = p->width;
  D.23066 = D.23055 + 7;
  D.23067 = D.23066 & -8;
  D.23068 = D.23067 / 2;
  p->ustride = D.23068;
  D.23069 = p->up;
  D.23070 = p->ustride;
  D.23060 = p->height;
  D.23061 = D.23060 + 1;
  D.23062 = D.23061 & -2;
  D.23071 = D.23070 * D.23062;
  D.23072 = D.23071 / 2;
  D.23073 = (sizetype) D.23072;
  D.23074 = D.23069 + D.23073;
  p->vp = D.23074;
  D.23059 = p->ystride;
  D.23075 = D.23059 + 7;
  D.23076 = D.23075 & -8;
  D.23077 = D.23076 / 2;
  p->vstride = D.23077;
  D.23078 = p->vp;
  D.23079 = p->vstride;
  D.23060 = p->height;
  D.23061 = D.23060 + 1;
  D.23062 = D.23061 & -2;
  D.23080 = D.23079 * D.23062;
  D.23081 = D.23080 / 2;
  D.23082 = (sizetype) D.23081;
  D.23083 = D.23078 + D.23082;
  p->endptr = D.23083;
}


paint_setup_YV12 (struct paintinfo * p, unsigned char * dest)
{
  int D.23084;
  int D.23085;
  int D.23086;
  unsigned char * D.23087;
  int D.23088;
  int D.23089;
  int D.23090;
  int D.23091;
  int D.23092;
  sizetype D.23093;
  unsigned char * D.23094;
  int D.23095;
  int D.23096;
  int D.23097;
  unsigned char * D.23098;
  int D.23099;
  int D.23100;
  int D.23101;
  sizetype D.23102;
  unsigned char * D.23103;
  unsigned char * D.23104;
  int D.23105;
  int D.23106;
  int D.23107;
  sizetype D.23108;
  unsigned char * D.23109;

  p->yp = dest;
  D.23084 = p->width;
  D.23085 = D.23084 + 3;
  D.23086 = D.23085 & -4;
  p->ystride = D.23086;
  D.23087 = p->yp;
  D.23088 = p->ystride;
  D.23089 = p->height;
  D.23090 = D.23089 + 1;
  D.23091 = D.23090 & -2;
  D.23092 = D.23088 * D.23091;
  D.23093 = (sizetype) D.23092;
  D.23094 = D.23087 + D.23093;
  p->vp = D.23094;
  D.23088 = p->ystride;
  D.23095 = D.23088 + 7;
  D.23096 = D.23095 & -8;
  D.23097 = D.23096 / 2;
  p->vstride = D.23097;
  D.23098 = p->vp;
  D.23099 = p->vstride;
  D.23089 = p->height;
  D.23090 = D.23089 + 1;
  D.23091 = D.23090 & -2;
  D.23100 = D.23099 * D.23091;
  D.23101 = D.23100 / 2;
  D.23102 = (sizetype) D.23101;
  D.23103 = D.23098 + D.23102;
  p->up = D.23103;
  D.23088 = p->ystride;
  D.23095 = D.23088 + 7;
  D.23096 = D.23095 & -8;
  D.23097 = D.23096 / 2;
  p->ustride = D.23097;
  D.23104 = p->up;
  D.23105 = p->ustride;
  D.23089 = p->height;
  D.23090 = D.23089 + 1;
  D.23091 = D.23090 & -2;
  D.23106 = D.23105 * D.23091;
  D.23107 = D.23106 / 2;
  D.23108 = (sizetype) D.23107;
  D.23109 = D.23104 + D.23108;
  p->endptr = D.23109;
}


paint_setup_YUV9 (struct paintinfo * p, unsigned char * dest)
{
  int D.23110;
  int D.23111;
  int D.23112;
  unsigned char * D.23113;
  int D.23114;
  int D.23115;
  int D.23116;
  sizetype D.23117;
  unsigned char * D.23118;
  int D.23119;
  int D.23120;
  int D.23121;
  unsigned char * D.23122;
  int D.23123;
  int D.23124;
  int D.23125;
  int D.23126;
  sizetype D.23127;
  unsigned char * D.23128;
  unsigned char * D.23129;
  int D.23130;
  int D.23131;
  sizetype D.23132;
  unsigned char * D.23133;

  p->yp = dest;
  D.23110 = p->width;
  D.23111 = D.23110 + 3;
  D.23112 = D.23111 & -4;
  p->ystride = D.23112;
  D.23113 = p->yp;
  D.23114 = p->ystride;
  D.23115 = p->height;
  D.23116 = D.23114 * D.23115;
  D.23117 = (sizetype) D.23116;
  D.23118 = D.23113 + D.23117;
  p->up = D.23118;
  D.23114 = p->ystride;
  D.23119 = D.23114 / 4;
  D.23120 = D.23119 + 3;
  D.23121 = D.23120 & -4;
  p->ustride = D.23121;
  D.23122 = p->up;
  D.23123 = p->ustride;
  D.23115 = p->height;
  D.23124 = D.23115 + 3;
  D.23125 = D.23124 >> 2;
  D.23126 = D.23123 * D.23125;
  D.23127 = (sizetype) D.23126;
  D.23128 = D.23122 + D.23127;
  p->vp = D.23128;
  D.23114 = p->ystride;
  D.23119 = D.23114 / 4;
  D.23120 = D.23119 + 3;
  D.23121 = D.23120 & -4;
  p->vstride = D.23121;
  D.23129 = p->vp;
  D.23130 = p->vstride;
  D.23115 = p->height;
  D.23124 = D.23115 + 3;
  D.23125 = D.23124 >> 2;
  D.23131 = D.23130 * D.23125;
  D.23132 = (sizetype) D.23131;
  D.23133 = D.23129 + D.23132;
  p->endptr = D.23133;
}


paint_setup_YVU9 (struct paintinfo * p, unsigned char * dest)
{
  int D.23134;
  int D.23135;
  int D.23136;
  unsigned char * D.23137;
  int D.23138;
  int D.23139;
  int D.23140;
  sizetype D.23141;
  unsigned char * D.23142;
  int D.23143;
  int D.23144;
  int D.23145;
  unsigned char * D.23146;
  int D.23147;
  int D.23148;
  int D.23149;
  int D.23150;
  sizetype D.23151;
  unsigned char * D.23152;
  unsigned char * D.23153;
  int D.23154;
  int D.23155;
  sizetype D.23156;
  unsigned char * D.23157;

  p->yp = dest;
  D.23134 = p->width;
  D.23135 = D.23134 + 3;
  D.23136 = D.23135 & -4;
  p->ystride = D.23136;
  D.23137 = p->yp;
  D.23138 = p->ystride;
  D.23139 = p->height;
  D.23140 = D.23138 * D.23139;
  D.23141 = (sizetype) D.23140;
  D.23142 = D.23137 + D.23141;
  p->vp = D.23142;
  D.23138 = p->ystride;
  D.23143 = D.23138 / 4;
  D.23144 = D.23143 + 3;
  D.23145 = D.23144 & -4;
  p->vstride = D.23145;
  D.23146 = p->vp;
  D.23147 = p->vstride;
  D.23139 = p->height;
  D.23148 = D.23139 + 3;
  D.23149 = D.23148 >> 2;
  D.23150 = D.23147 * D.23149;
  D.23151 = (sizetype) D.23150;
  D.23152 = D.23146 + D.23151;
  p->up = D.23152;
  D.23138 = p->ystride;
  D.23143 = D.23138 / 4;
  D.23144 = D.23143 + 3;
  D.23145 = D.23144 & -4;
  p->ustride = D.23145;
  D.23153 = p->up;
  D.23154 = p->ustride;
  D.23139 = p->height;
  D.23148 = D.23139 + 3;
  D.23149 = D.23148 >> 2;
  D.23155 = D.23154 * D.23149;
  D.23156 = (sizetype) D.23155;
  D.23157 = D.23153 + D.23156;
  p->endptr = D.23157;
}


paint_setup_IYU2 (struct paintinfo * p, unsigned char * dest)
{
  unsigned char * D.23158;
  unsigned char * D.23159;
  int D.23160;
  int D.23161;
  int D.23162;
  int D.23163;
  int D.23164;
  int D.23165;
  int D.23166;
  sizetype D.23167;
  unsigned char * D.23168;

  D.23158 = dest + 1;
  p->yp = D.23158;
  p->up = dest;
  D.23159 = dest + 2;
  p->vp = D.23159;
  D.23160 = p->width;
  D.23161 = D.23160 + 1;
  D.23162 = D.23161 * 3;
  D.23163 = D.23162 & -4;
  p->ystride = D.23163;
  D.23164 = p->ystride;
  D.23165 = p->height;
  D.23166 = D.23164 * D.23165;
  D.23167 = (sizetype) D.23166;
  D.23168 = dest + D.23167;
  p->endptr = D.23168;
}


paint_setup_AYUV (struct paintinfo * p, unsigned char * dest)
{
  unsigned char * D.23169;
  unsigned char * D.23170;
  unsigned char * D.23171;
  int D.23172;
  int D.23173;
  int D.23174;
  int D.23175;
  int D.23176;
  sizetype D.23177;
  unsigned char * D.23178;

  p->ap = dest;
  D.23169 = dest + 1;
  p->yp = D.23169;
  D.23170 = dest + 2;
  p->up = D.23170;
  D.23171 = dest + 3;
  p->vp = D.23171;
  D.23172 = p->width;
  D.23173 = D.23172 * 4;
  p->ystride = D.23173;
  D.23174 = p->ystride;
  D.23175 = p->height;
  D.23176 = D.23174 * D.23175;
  D.23177 = (sizetype) D.23176;
  D.23178 = dest + D.23177;
  p->endptr = D.23178;
}


paint_setup_YVYU (struct paintinfo * p, unsigned char * dest)
{
  unsigned char * D.23179;
  unsigned char * D.23180;
  int D.23181;
  int D.23182;
  int D.23183;
  int D.23184;
  int D.23185;
  int D.23186;
  int D.23187;
  sizetype D.23188;
  unsigned char * D.23189;

  p->yp = dest;
  D.23179 = dest + 3;
  p->up = D.23179;
  D.23180 = dest + 1;
  p->vp = D.23180;
  D.23181 = p->width;
  D.23182 = D.23181 + 1;
  D.23183 = D.23182 & -2;
  D.23184 = D.23183 * 2;
  p->ystride = D.23184;
  D.23185 = p->ystride;
  D.23186 = p->height;
  D.23187 = D.23185 * D.23186;
  D.23188 = (sizetype) D.23187;
  D.23189 = dest + D.23188;
  p->endptr = D.23189;
}


paint_setup_UYVY (struct paintinfo * p, unsigned char * dest)
{
  unsigned char * D.23190;
  unsigned char * D.23191;
  int D.23192;
  int D.23193;
  int D.23194;
  int D.23195;
  int D.23196;
  int D.23197;
  int D.23198;
  sizetype D.23199;
  unsigned char * D.23200;

  D.23190 = dest + 1;
  p->yp = D.23190;
  p->up = dest;
  D.23191 = dest + 2;
  p->vp = D.23191;
  D.23192 = p->width;
  D.23193 = D.23192 + 1;
  D.23194 = D.23193 & -2;
  D.23195 = D.23194 * 2;
  p->ystride = D.23195;
  D.23196 = p->ystride;
  D.23197 = p->height;
  D.23198 = D.23196 * D.23197;
  D.23199 = (sizetype) D.23198;
  D.23200 = dest + D.23199;
  p->endptr = D.23200;
}


paint_setup_YUY2 (struct paintinfo * p, unsigned char * dest)
{
  unsigned char * D.23201;
  unsigned char * D.23202;
  int D.23203;
  int D.23204;
  int D.23205;
  int D.23206;
  int D.23207;
  int D.23208;
  int D.23209;
  sizetype D.23210;
  unsigned char * D.23211;

  p->yp = dest;
  D.23201 = dest + 1;
  p->up = D.23201;
  D.23202 = dest + 3;
  p->vp = D.23202;
  D.23203 = p->width;
  D.23204 = D.23203 + 1;
  D.23205 = D.23204 & -2;
  D.23206 = D.23205 * 2;
  p->ystride = D.23206;
  D.23207 = p->ystride;
  D.23208 = p->height;
  D.23209 = D.23207 * D.23208;
  D.23210 = (sizetype) D.23209;
  D.23211 = dest + D.23210;
  p->endptr = D.23211;
}


fourcc_get_size (struct fourcc_list_struct * fourcc, int w, int h)
{
  void (*<T3b5d>) (struct paintinfo *, unsigned char *) D.23212;
  int D.23213;
  unsigned char * D.23214;
  long int D.23215;
  struct paintinfo pi;
  struct paintinfo * p;

  try
    {
      pi = {};
      p = &pi;
      p->width = w;
      p->height = h;
      D.23212 = fourcc->paint_setup;
      D.23212 (p, 0B);
      D.23214 = p->endptr;
      D.23215 = (long int) D.23214;
      D.23213 = (int) D.23215;
      return D.23213;
    }
  finally
    {
      pi = {CLOBBER};
    }
}


main (int argc, char * * argv)
{
  int D.23218;

  {
    struct Suite * s;

    gst_check_init (&argc, &argv);
    s = video_suite ();
    D.23218 = gst_check_run_suite (s, "video", "libs/video.c");
    return D.23218;
  }
  D.23218 = 0;
  return D.23218;
}


video_suite ()
{
  struct Suite * D.23220;
  struct Suite * s;
  struct TCase * tc_chain;

  s = suite_create ("video support library");
  tc_chain = tcase_create ("general");
  suite_add_tcase (s, tc_chain);
  __gst_tcase_add_test (tc_chain, test_video_formats, "test_video_formats", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_video_formats_rgb, "test_video_formats_rgb", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_video_formats_rgba_large_dimension, "test_video_formats_rgba_large_dimension", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_video_formats_all, "test_video_formats_all", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_video_formats_pack_unpack, "test_video_formats_pack_unpack", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_dar_calc, "test_dar_calc", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_parse_caps_rgb, "test_parse_caps_rgb", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_events, "test_events", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_convert_frame, "test_convert_frame", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_convert_frame_async, "test_convert_frame_async", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_video_size_from_caps, "test_video_size_from_caps", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_overlay_composition, "test_overlay_composition", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_overlay_composition_premultiplied_alpha, "test_overlay_composition_premultiplied_alpha", 0, 0, 0, 1);
  __gst_tcase_add_test (tc_chain, test_overlay_composition_global_alpha, "test_overlay_composition_global_alpha", 0, 0, 0, 1);
  D.23220 = s;
  return D.23220;
}


test_overlay_composition_global_alpha (int __i__)
{
  int D.22848;
  <unnamed type> _gst_debug_min.0;
  long int D.23226;
  long int D.23227;
  struct GstDebugCategory * check_debug.1;
  long unsigned int D.23231;
  _Bool D.23232;
  int D.23233;
  long unsigned int D.23234;
  _Bool D.23235;
  int D.23236;
  _Bool D.23237;
  _Bool D.23238;
  _Bool D.23239;
  int D.23240;
  _Bool D.23241;
  _Bool D.23242;
  _Bool D.23243;
  int D.23244;
  long unsigned int D.23245;
  _Bool D.23246;
  int D.23247;
  _Bool D.23248;
  int D.23249;
  long unsigned int D.23250;
  long unsigned int D.23251;
  _Bool D.23252;
  int D.23253;
  long unsigned int D.23254;
  guint8 * D.23255;
  int D.23256;
  _Bool D.23257;
  int D.23258;
  unsigned char D.23259;
  _Bool D.23260;
  int D.23261;
  guint8 * D.23262;
  unsigned char D.23263;
  _Bool D.23264;
  int D.23265;
  guint8 * D.23266;
  unsigned char D.23267;
  _Bool D.23268;
  int D.23269;
  guint8 * D.23270;
  unsigned char D.23271;
  _Bool D.23272;
  int D.23273;
  int iftmp.2;
  _Bool D.23277;
  _Bool D.23278;
  _Bool D.23279;
  long unsigned int D.23282;
  long unsigned int D.23283;
  _Bool D.23284;
  int D.23285;
  int D.23286;
  _Bool D.23287;
  int D.23288;
  unsigned char D.23289;
  _Bool D.23290;
  int D.23291;
  guint8 * D.23292;
  unsigned char D.23293;
  _Bool D.23294;
  int D.23295;
  guint8 * D.23296;
  unsigned char D.23297;
  _Bool D.23298;
  int D.23299;
  guint8 * D.23300;
  unsigned char D.23301;
  _Bool D.23302;
  int D.23303;
  double D.23304;
  double D.23305;
  _Bool D.23306;
  int D.23307;
  double D.23308;
  double D.23309;
  _Bool D.23310;
  int D.23311;
  _Bool D.23312;
  int D.23313;
  _Bool D.23314;
  int D.23315;
  unsigned char D.23316;
  _Bool D.23317;
  int D.23318;
  guint8 * D.23319;
  unsigned char D.23320;
  _Bool D.23321;
  int D.23322;
  guint8 * D.23323;
  unsigned char D.23324;
  _Bool D.23325;
  int D.23326;
  guint8 * D.23327;
  unsigned char D.23328;
  _Bool D.23329;
  int D.23330;
  _Bool D.23331;
  int D.23332;
  _Bool D.23333;
  int D.23334;
  _Bool D.23335;
  int D.23336;
  _Bool D.23337;
  int D.23338;
  double D.23339;
  double D.23340;
  _Bool D.23341;
  int D.23342;
  _Bool D.23343;
  int D.23344;
  _Bool D.23345;
  int D.23346;
  _Bool D.23347;
  int D.23348;
  _Bool D.23349;
  int D.23350;
  _Bool D.23351;
  int D.23352;
  _Bool D.23353;
  int D.23354;
  _Bool D.23355;
  int D.23356;
  _Bool D.23357;
  int D.23358;
  _Bool D.23359;
  int D.23360;
  _Bool D.23361;
  int D.23362;
  _Bool D.23363;
  int D.23364;
  _Bool D.23365;
  int D.23366;
  _Bool D.23367;
  int D.23368;
  _Bool D.23369;
  int D.23370;
  _Bool D.23371;
  int D.23372;
  _Bool D.23373;
  int D.23374;
  _Bool D.23375;
  int D.23376;
  _Bool D.23377;
  int D.23378;
  _Bool D.23379;
  int D.23380;
  _Bool D.23381;
  int D.23382;
  _Bool D.23383;
  int D.23384;
  _Bool D.23385;
  int D.23386;
  _Bool D.23387;
  int D.23388;
  _Bool D.23389;
  int D.23390;
  _Bool D.23391;
  int D.23392;
  _Bool D.23393;
  int D.23394;
  _Bool D.23395;
  int D.23396;
  _Bool D.23397;
  int D.23398;
  _Bool D.23399;
  int D.23400;
  _Bool D.23401;
  int D.23402;
  _Bool D.23403;
  int D.23404;
  _Bool D.23405;
  int D.23406;
  _Bool D.23407;
  int D.23408;
  _Bool D.23409;
  int D.23410;
  _Bool D.23411;
  int D.23412;
  _Bool D.23413;
  int D.23414;
  _Bool D.23415;
  int D.23416;
  _Bool D.23417;
  int D.23418;
  _Bool D.23419;
  int D.23420;
  int D.22991;
  long int D.23424;
  long int D.23425;
  static const char __PRETTY_FUNCTION__[38] = "test_overlay_composition_global_alpha";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.0 = _gst_debug_min;
      if (_gst_debug_min.0 > 4) goto <D.23223>; else goto <D.23224>;
      <D.23223>:
      _g_boolean_var_ = 1;
      goto <D.23225>;
      <D.23224>:
      _g_boolean_var_ = 0;
      <D.23225>:
    }
    D.22848 = _g_boolean_var_;
  }
  D.23226 = (long int) D.22848;
  D.23227 = __builtin_expect (D.23226, 0);
  if (D.23227 != 0) goto <D.23228>; else goto <D.23229>;
  <D.23228>:
  check_debug.1 = check_debug;
  gst_debug_log (check_debug.1, 5, "libs/video.c", &__PRETTY_FUNCTION__, 1302, 0B, "test start");
  <D.23229>:
  tcase_fn_start ("test_overlay_composition_global_alpha", "libs/video.c", 1302);
  {
    struct GstVideoOverlayRectangle * rect1;
    struct GstBuffer * pix1;
    struct GstBuffer * pix2;
    struct GstBuffer * pix3;
    struct GstBuffer * pix4;
    struct GstBuffer * pix5;
    struct GstVideoMeta * vmeta;
    guint8 * data2;
    guint8 * data4;
    guint8 * data5;
    guint w;
    guint h;
    guint w4;
    guint h4;
    guint seq1;
    guint seq2;
    gfloat ga1;
    gfloat ga2;
    GstVideoOverlayFormatFlags flags1;
    struct GstMapInfo map;

    try
      {
        pix1 = gst_buffer_new_allocate (0B, 40000, 0B);
        D.23231 = gst_buffer_get_size (pix1);
        gst_buffer_memset (pix1, 0, 128, D.23231);
        gst_buffer_add_video_meta (pix1, 0, 12, 200, 50);
        rect1 = gst_video_overlay_rectangle_new_raw (pix1, 600, 50, 300, 50, 0);
        gst_buffer_unref (pix1);
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 0);
        D.23232 = pix1 == pix2;
        D.23233 = (int) D.23232;
        _fail_unless (D.23233, "libs/video.c", 1326, "Assertion \'pix1 == pix2\' failed", 0B);
        D.23234 = gst_video_meta_api_get_type ();
        vmeta = gst_buffer_get_meta (pix2, D.23234);
        D.23235 = vmeta != 0B;
        D.23236 = (int) D.23235;
        _fail_unless (D.23236, "libs/video.c", 1329, "Assertion \'vmeta != NULL\' failed", 0B);
        w = vmeta->width;
        h = vmeta->height;
        pix3 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 0);
        D.23237 = pix3 != pix1;
        D.23238 = pix3 != pix2;
        D.23239 = D.23237 & D.23238;
        D.23240 = (int) D.23239;
        _fail_unless (D.23240, "libs/video.c", 1336, "Failure \'pix3 == pix1 || pix3 == pix2\' occured", 0B);
        pix4 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 1);
        D.23241 = pix4 != pix2;
        D.23242 = pix4 != pix3;
        D.23243 = D.23241 & D.23242;
        D.23244 = (int) D.23243;
        _fail_unless (D.23244, "libs/video.c", 1341, "Failure \'pix4 == pix2 || pix4 == pix3\' occured", 0B);
        D.23245 = gst_video_meta_api_get_type ();
        vmeta = gst_buffer_get_meta (pix4, D.23245);
        D.23235 = vmeta != 0B;
        D.23236 = (int) D.23235;
        _fail_unless (D.23236, "libs/video.c", 1343, "Assertion \'vmeta != NULL\' failed", 0B);
        w4 = vmeta->width;
        h4 = vmeta->height;
        {
          int first;
          int second;

          first = (int) w;
          second = (int) w4;
          D.23246 = first == second;
          D.23247 = (int) D.23246;
          _fail_unless (D.23247, "libs/video.c", 1346, "Assertion \'first == second\' failed", "\'w\' (%d) is not equal to \'w4\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          first = (int) h;
          second = (int) h4;
          D.23248 = first == second;
          D.23249 = (int) D.23248;
          _fail_unless (D.23249, "libs/video.c", 1347, "Assertion \'first == second\' failed", "\'h\' (%d) is not equal to \'h4\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23250 = gst_buffer_get_size (pix2);
          first = (int) D.23250;
          D.23251 = gst_buffer_get_size (pix4);
          second = (int) D.23251;
          D.23252 = first == second;
          D.23253 = (int) D.23252;
          _fail_unless (D.23253, "libs/video.c", 1349, "Assertion \'first == second\' failed", "\'gst_buffer_get_size (pix2)\' (%d) is not equal to \'gst_buffer_get_size (pix4)\' (%d)", first, second, 0B);
        }
        gst_buffer_map (pix4, &map, 1);
        D.23254 = map.size;
        D.23255 = map.data;
        D.23256 = gst_buffer_memcmp (pix1, 0, D.23255, D.23254);
        D.23257 = D.23256 != 0;
        D.23258 = (int) D.23257;
        _fail_unless (D.23258, "libs/video.c", 1351, "Failure \'gst_buffer_memcmp (pix1, 0, map.data, map.size) == 0\' occured", 0B);
        data4 = map.data;
        {
          int first;
          int second;

          D.23259 = *data4;
          first = (int) D.23259;
          second = 64;
          D.23260 = first == second;
          D.23261 = (int) D.23260;
          _fail_unless (D.23261, "libs/video.c", 1356, "Assertion \'first == second\' failed", "\'data4[0]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23262 = data4 + 1;
          D.23263 = *D.23262;
          first = (int) D.23263;
          second = 64;
          D.23264 = first == second;
          D.23265 = (int) D.23264;
          _fail_unless (D.23265, "libs/video.c", 1357, "Assertion \'first == second\' failed", "\'data4[1]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23266 = data4 + 2;
          D.23267 = *D.23266;
          first = (int) D.23267;
          second = 64;
          D.23268 = first == second;
          D.23269 = (int) D.23268;
          _fail_unless (D.23269, "libs/video.c", 1358, "Assertion \'first == second\' failed", "\'data4[2]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23270 = data4 + 3;
          D.23271 = *D.23270;
          first = (int) D.23271;
          second = 128;
          D.23272 = first == second;
          D.23273 = (int) D.23272;
          _fail_unless (D.23273, "libs/video.c", 1359, "Assertion \'first == second\' failed", "\'data4[3]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix4, &map);
        pix5 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 1);
        D.23277 = pix5 != pix2;
        D.23278 = pix5 != pix3;
        D.23279 = D.23277 & D.23278;
        if (D.23279 != 0) goto <D.23280>; else goto <D.23275>;
        <D.23280>:
        if (pix5 != pix4) goto <D.23281>; else goto <D.23275>;
        <D.23281>:
        iftmp.2 = 1;
        goto <D.23276>;
        <D.23275>:
        iftmp.2 = 0;
        <D.23276>:
        _fail_unless (iftmp.2, "libs/video.c", 1372, "Failure \'pix5 == pix2 || pix5 == pix3 || pix5 == pix4\' occured", 0B);
        {
          int first;
          int second;

          D.23282 = gst_buffer_get_size (pix5);
          first = (int) D.23282;
          D.23283 = gst_buffer_get_size (pix3);
          second = (int) D.23283;
          D.23284 = first == second;
          D.23285 = (int) D.23284;
          _fail_unless (D.23285, "libs/video.c", 1375, "Assertion \'first == second\' failed", "\'gst_buffer_get_size (pix5)\' (%d) is not equal to \'gst_buffer_get_size (pix3)\' (%d)", first, second, 0B);
        }
        gst_buffer_map (pix5, &map, 1);
        D.23254 = map.size;
        D.23255 = map.data;
        D.23286 = gst_buffer_memcmp (pix3, 0, D.23255, D.23254);
        D.23287 = D.23286 != 0;
        D.23288 = (int) D.23287;
        _fail_unless (D.23288, "libs/video.c", 1378, "Failure \'gst_buffer_memcmp (pix3, 0, map.data, map.size) == 0\' occured", 0B);
        data5 = map.data;
        {
          int first;
          int second;

          D.23289 = *data5;
          first = (int) D.23289;
          second = 64;
          D.23290 = first == second;
          D.23291 = (int) D.23290;
          _fail_unless (D.23291, "libs/video.c", 1383, "Assertion \'first == second\' failed", "\'data5[0]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23292 = data5 + 1;
          D.23293 = *D.23292;
          first = (int) D.23293;
          second = 64;
          D.23294 = first == second;
          D.23295 = (int) D.23294;
          _fail_unless (D.23295, "libs/video.c", 1384, "Assertion \'first == second\' failed", "\'data5[1]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23296 = data5 + 2;
          D.23297 = *D.23296;
          first = (int) D.23297;
          second = 64;
          D.23298 = first == second;
          D.23299 = (int) D.23298;
          _fail_unless (D.23299, "libs/video.c", 1385, "Assertion \'first == second\' failed", "\'data5[2]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23300 = data5 + 3;
          D.23301 = *D.23300;
          first = (int) D.23301;
          second = 128;
          D.23302 = first == second;
          D.23303 = (int) D.23302;
          _fail_unless (D.23303, "libs/video.c", 1386, "Assertion \'first == second\' failed", "\'data5[3]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix5, &map);
        ga1 = gst_video_overlay_rectangle_get_global_alpha (rect1);
        {
          double first;
          double second;

          first = (double) ga1;
          second = 1.0e+0;
          D.23304 = first - second;
          D.23305 = ABS_EXPR <D.23304>;
          D.23306 = D.23305 < 9.99999999999999954748111825886258685613938723690807819366e-8;
          D.23307 = (int) D.23306;
          _fail_unless (D.23307, "libs/video.c", 1398, "Assertion \'fabs (first - second) < 0.0000001\' failed", "\'ga1\' (%g) is not equal to \'1.0\' (%g)", first, second, 0B);
        }
        seq1 = gst_video_overlay_rectangle_get_seqnum (rect1);
        gst_video_overlay_rectangle_set_global_alpha (rect1, 5.0e-1);
        ga2 = gst_video_overlay_rectangle_get_global_alpha (rect1);
        {
          double first;
          double second;

          first = (double) ga2;
          second = 5.0e-1;
          D.23308 = first - second;
          D.23309 = ABS_EXPR <D.23308>;
          D.23310 = D.23309 < 9.99999999999999954748111825886258685613938723690807819366e-8;
          D.23311 = (int) D.23310;
          _fail_unless (D.23311, "libs/video.c", 1404, "Assertion \'fabs (first - second) < 0.0000001\' failed", "\'ga2\' (%g) is not equal to \'0.5\' (%g)", first, second, 0B);
        }
        seq2 = gst_video_overlay_rectangle_get_seqnum (rect1);
        D.23312 = seq1 < seq2;
        D.23313 = (int) D.23312;
        _fail_unless (D.23313, "libs/video.c", 1408, "Assertion \'seq1 < seq2\' failed", 0B);
        flags1 = gst_video_overlay_rectangle_get_flags (rect1);
        {
          int first;
          int second;

          first = (int) flags1;
          second = 2;
          D.23314 = first == second;
          D.23315 = (int) D.23314;
          _fail_unless (D.23315, "libs/video.c", 1412, "Assertion \'first == second\' failed", "\'flags1\' (%d) is not equal to \'GST_VIDEO_OVERLAY_FORMAT_FLAG_GLOBAL_ALPHA\' (%d)", first, second, 0B);
        }
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 2);
        D.23232 = pix2 == pix1;
        D.23233 = (int) D.23232;
        _fail_unless (D.23233, "libs/video.c", 1418, "Assertion \'pix2 == pix1\' failed", 0B);
        gst_buffer_map (pix2, &map, 1);
        data2 = map.data;
        {
          int first;
          int second;

          D.23316 = *data2;
          first = (int) D.23316;
          second = 128;
          D.23317 = first == second;
          D.23318 = (int) D.23317;
          _fail_unless (D.23318, "libs/video.c", 1424, "Assertion \'first == second\' failed", "\'data2[0]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23319 = data2 + 1;
          D.23320 = *D.23319;
          first = (int) D.23320;
          second = 128;
          D.23321 = first == second;
          D.23322 = (int) D.23321;
          _fail_unless (D.23322, "libs/video.c", 1425, "Assertion \'first == second\' failed", "\'data2[1]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23323 = data2 + 2;
          D.23324 = *D.23323;
          first = (int) D.23324;
          second = 128;
          D.23325 = first == second;
          D.23326 = (int) D.23325;
          _fail_unless (D.23326, "libs/video.c", 1426, "Assertion \'first == second\' failed", "\'data2[2]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23327 = data2 + 3;
          D.23328 = *D.23327;
          first = (int) D.23328;
          second = 128;
          D.23329 = first == second;
          D.23330 = (int) D.23329;
          _fail_unless (D.23330, "libs/video.c", 1427, "Assertion \'first == second\' failed", "\'data2[3]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix2, &map);
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 0);
        D.23232 = pix2 == pix1;
        D.23233 = (int) D.23232;
        _fail_unless (D.23233, "libs/video.c", 1441, "Assertion \'pix2 == pix1\' failed", 0B);
        gst_buffer_map (pix2, &map, 1);
        data2 = map.data;
        {
          int first;
          int second;

          D.23316 = *data2;
          first = (int) D.23316;
          second = 128;
          D.23331 = first == second;
          D.23332 = (int) D.23331;
          _fail_unless (D.23332, "libs/video.c", 1447, "Assertion \'first == second\' failed", "\'data2[0]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23319 = data2 + 1;
          D.23320 = *D.23319;
          first = (int) D.23320;
          second = 128;
          D.23333 = first == second;
          D.23334 = (int) D.23333;
          _fail_unless (D.23334, "libs/video.c", 1448, "Assertion \'first == second\' failed", "\'data2[1]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23323 = data2 + 2;
          D.23324 = *D.23323;
          first = (int) D.23324;
          second = 128;
          D.23335 = first == second;
          D.23336 = (int) D.23335;
          _fail_unless (D.23336, "libs/video.c", 1449, "Assertion \'first == second\' failed", "\'data2[2]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23327 = data2 + 3;
          D.23328 = *D.23327;
          first = (int) D.23328;
          second = 64;
          D.23337 = first == second;
          D.23338 = (int) D.23337;
          _fail_unless (D.23338, "libs/video.c", 1450, "Assertion \'first == second\' failed", "\'data2[3]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix2, &map);
        gst_video_overlay_rectangle_set_global_alpha (rect1, 2.5e-1);
        ga2 = gst_video_overlay_rectangle_get_global_alpha (rect1);
        {
          double first;
          double second;

          first = (double) ga2;
          second = 2.5e-1;
          D.23339 = first - second;
          D.23340 = ABS_EXPR <D.23339>;
          D.23341 = D.23340 < 9.99999999999999954748111825886258685613938723690807819366e-8;
          D.23342 = (int) D.23341;
          _fail_unless (D.23342, "libs/video.c", 1463, "Assertion \'fabs (first - second) < 0.0000001\' failed", "\'ga2\' (%g) is not equal to \'0.25\' (%g)", first, second, 0B);
        }
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 0);
        D.23232 = pix2 == pix1;
        D.23233 = (int) D.23232;
        _fail_unless (D.23233, "libs/video.c", 1467, "Assertion \'pix2 == pix1\' failed", 0B);
        gst_buffer_map (pix2, &map, 1);
        data2 = map.data;
        {
          int first;
          int second;

          D.23316 = *data2;
          first = (int) D.23316;
          second = 128;
          D.23343 = first == second;
          D.23344 = (int) D.23343;
          _fail_unless (D.23344, "libs/video.c", 1473, "Assertion \'first == second\' failed", "\'data2[0]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23319 = data2 + 1;
          D.23320 = *D.23319;
          first = (int) D.23320;
          second = 128;
          D.23345 = first == second;
          D.23346 = (int) D.23345;
          _fail_unless (D.23346, "libs/video.c", 1474, "Assertion \'first == second\' failed", "\'data2[1]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23323 = data2 + 2;
          D.23324 = *D.23323;
          first = (int) D.23324;
          second = 128;
          D.23347 = first == second;
          D.23348 = (int) D.23347;
          _fail_unless (D.23348, "libs/video.c", 1475, "Assertion \'first == second\' failed", "\'data2[2]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23327 = data2 + 3;
          D.23328 = *D.23327;
          first = (int) D.23328;
          second = 32;
          D.23349 = first == second;
          D.23350 = (int) D.23349;
          _fail_unless (D.23350, "libs/video.c", 1476, "Assertion \'first == second\' failed", "\'data2[3]\' (%d) is not equal to \'0x20\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix2, &map);
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 2);
        D.23232 = pix2 == pix1;
        D.23233 = (int) D.23232;
        _fail_unless (D.23233, "libs/video.c", 1490, "Assertion \'pix2 == pix1\' failed", 0B);
        gst_buffer_map (pix2, &map, 1);
        data2 = map.data;
        {
          int first;
          int second;

          D.23316 = *data2;
          first = (int) D.23316;
          second = 128;
          D.23351 = first == second;
          D.23352 = (int) D.23351;
          _fail_unless (D.23352, "libs/video.c", 1496, "Assertion \'first == second\' failed", "\'data2[0]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23319 = data2 + 1;
          D.23320 = *D.23319;
          first = (int) D.23320;
          second = 128;
          D.23353 = first == second;
          D.23354 = (int) D.23353;
          _fail_unless (D.23354, "libs/video.c", 1497, "Assertion \'first == second\' failed", "\'data2[1]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23323 = data2 + 2;
          D.23324 = *D.23323;
          first = (int) D.23324;
          second = 128;
          D.23355 = first == second;
          D.23356 = (int) D.23355;
          _fail_unless (D.23356, "libs/video.c", 1498, "Assertion \'first == second\' failed", "\'data2[2]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23327 = data2 + 3;
          D.23328 = *D.23327;
          first = (int) D.23328;
          second = 128;
          D.23357 = first == second;
          D.23358 = (int) D.23357;
          _fail_unless (D.23358, "libs/video.c", 1499, "Assertion \'first == second\' failed", "\'data2[3]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix2, &map);
        pix2 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 2);
        D.23359 = pix2 == pix3;
        D.23360 = (int) D.23359;
        _fail_unless (D.23360, "libs/video.c", 1514, "Assertion \'pix2 == pix3\' failed", 0B);
        gst_buffer_map (pix2, &map, 1);
        data2 = map.data;
        {
          int first;
          int second;

          D.23316 = *data2;
          first = (int) D.23316;
          second = 128;
          D.23361 = first == second;
          D.23362 = (int) D.23361;
          _fail_unless (D.23362, "libs/video.c", 1520, "Assertion \'first == second\' failed", "\'data2[0]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23319 = data2 + 1;
          D.23320 = *D.23319;
          first = (int) D.23320;
          second = 128;
          D.23363 = first == second;
          D.23364 = (int) D.23363;
          _fail_unless (D.23364, "libs/video.c", 1521, "Assertion \'first == second\' failed", "\'data2[1]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23323 = data2 + 2;
          D.23324 = *D.23323;
          first = (int) D.23324;
          second = 128;
          D.23365 = first == second;
          D.23366 = (int) D.23365;
          _fail_unless (D.23366, "libs/video.c", 1522, "Assertion \'first == second\' failed", "\'data2[2]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23327 = data2 + 3;
          D.23328 = *D.23327;
          first = (int) D.23328;
          second = 128;
          D.23367 = first == second;
          D.23368 = (int) D.23367;
          _fail_unless (D.23368, "libs/video.c", 1523, "Assertion \'first == second\' failed", "\'data2[3]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix2, &map);
        pix2 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 0);
        D.23359 = pix2 == pix3;
        D.23360 = (int) D.23359;
        _fail_unless (D.23360, "libs/video.c", 1538, "Assertion \'pix2 == pix3\' failed", 0B);
        gst_buffer_map (pix2, &map, 1);
        data2 = map.data;
        {
          int first;
          int second;

          D.23316 = *data2;
          first = (int) D.23316;
          second = 128;
          D.23369 = first == second;
          D.23370 = (int) D.23369;
          _fail_unless (D.23370, "libs/video.c", 1544, "Assertion \'first == second\' failed", "\'data2[0]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23319 = data2 + 1;
          D.23320 = *D.23319;
          first = (int) D.23320;
          second = 128;
          D.23371 = first == second;
          D.23372 = (int) D.23371;
          _fail_unless (D.23372, "libs/video.c", 1545, "Assertion \'first == second\' failed", "\'data2[1]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23323 = data2 + 2;
          D.23324 = *D.23323;
          first = (int) D.23324;
          second = 128;
          D.23373 = first == second;
          D.23374 = (int) D.23373;
          _fail_unless (D.23374, "libs/video.c", 1546, "Assertion \'first == second\' failed", "\'data2[2]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23327 = data2 + 3;
          D.23328 = *D.23327;
          first = (int) D.23328;
          second = 32;
          D.23375 = first == second;
          D.23376 = (int) D.23375;
          _fail_unless (D.23376, "libs/video.c", 1547, "Assertion \'first == second\' failed", "\'data2[3]\' (%d) is not equal to \'0x20\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix2, &map);
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 3);
        D.23377 = pix2 == pix4;
        D.23378 = (int) D.23377;
        _fail_unless (D.23378, "libs/video.c", 1564, "Assertion \'pix2 == pix4\' failed", 0B);
        gst_buffer_map (pix2, &map, 1);
        data2 = map.data;
        {
          int first;
          int second;

          D.23316 = *data2;
          first = (int) D.23316;
          second = 64;
          D.23379 = first == second;
          D.23380 = (int) D.23379;
          _fail_unless (D.23380, "libs/video.c", 1570, "Assertion \'first == second\' failed", "\'data2[0]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23319 = data2 + 1;
          D.23320 = *D.23319;
          first = (int) D.23320;
          second = 64;
          D.23381 = first == second;
          D.23382 = (int) D.23381;
          _fail_unless (D.23382, "libs/video.c", 1571, "Assertion \'first == second\' failed", "\'data2[1]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23323 = data2 + 2;
          D.23324 = *D.23323;
          first = (int) D.23324;
          second = 64;
          D.23383 = first == second;
          D.23384 = (int) D.23383;
          _fail_unless (D.23384, "libs/video.c", 1572, "Assertion \'first == second\' failed", "\'data2[2]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23327 = data2 + 3;
          D.23328 = *D.23327;
          first = (int) D.23328;
          second = 128;
          D.23385 = first == second;
          D.23386 = (int) D.23385;
          _fail_unless (D.23386, "libs/video.c", 1573, "Assertion \'first == second\' failed", "\'data2[3]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix2, &map);
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 1);
        D.23377 = pix2 == pix4;
        D.23378 = (int) D.23377;
        _fail_unless (D.23378, "libs/video.c", 1588, "Assertion \'pix2 == pix4\' failed", 0B);
        gst_buffer_map (pix2, &map, 1);
        data2 = map.data;
        {
          int first;
          int second;

          D.23316 = *data2;
          first = (int) D.23316;
          second = 15;
          D.23387 = first == second;
          D.23388 = (int) D.23387;
          _fail_unless (D.23388, "libs/video.c", 1598, "Assertion \'first == second\' failed", "\'data2[0]\' (%d) is not equal to \'0x0F\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23319 = data2 + 1;
          D.23320 = *D.23319;
          first = (int) D.23320;
          second = 15;
          D.23389 = first == second;
          D.23390 = (int) D.23389;
          _fail_unless (D.23390, "libs/video.c", 1599, "Assertion \'first == second\' failed", "\'data2[1]\' (%d) is not equal to \'0x0F\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23323 = data2 + 2;
          D.23324 = *D.23323;
          first = (int) D.23324;
          second = 15;
          D.23391 = first == second;
          D.23392 = (int) D.23391;
          _fail_unless (D.23392, "libs/video.c", 1600, "Assertion \'first == second\' failed", "\'data2[2]\' (%d) is not equal to \'0x0F\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23327 = data2 + 3;
          D.23328 = *D.23327;
          first = (int) D.23328;
          second = 32;
          D.23393 = first == second;
          D.23394 = (int) D.23393;
          _fail_unless (D.23394, "libs/video.c", 1601, "Assertion \'first == second\' failed", "\'data2[3]\' (%d) is not equal to \'0x20\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix2, &map);
        gst_video_overlay_rectangle_set_global_alpha (rect1, 7.5e-1);
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 1);
        D.23377 = pix2 == pix4;
        D.23378 = (int) D.23377;
        _fail_unless (D.23378, "libs/video.c", 1619, "Assertion \'pix2 == pix4\' failed", 0B);
        gst_buffer_map (pix2, &map, 1);
        data2 = map.data;
        {
          int first;
          int second;

          D.23316 = *data2;
          first = (int) D.23316;
          second = 44;
          D.23395 = first == second;
          D.23396 = (int) D.23395;
          _fail_unless (D.23396, "libs/video.c", 1628, "Assertion \'first == second\' failed", "\'data2[0]\' (%d) is not equal to \'0x2C\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23319 = data2 + 1;
          D.23320 = *D.23319;
          first = (int) D.23320;
          second = 44;
          D.23397 = first == second;
          D.23398 = (int) D.23397;
          _fail_unless (D.23398, "libs/video.c", 1629, "Assertion \'first == second\' failed", "\'data2[1]\' (%d) is not equal to \'0x2C\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23323 = data2 + 2;
          D.23324 = *D.23323;
          first = (int) D.23324;
          second = 44;
          D.23399 = first == second;
          D.23400 = (int) D.23399;
          _fail_unless (D.23400, "libs/video.c", 1630, "Assertion \'first == second\' failed", "\'data2[2]\' (%d) is not equal to \'0x2C\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23327 = data2 + 3;
          D.23328 = *D.23327;
          first = (int) D.23328;
          second = 96;
          D.23401 = first == second;
          D.23402 = (int) D.23401;
          _fail_unless (D.23402, "libs/video.c", 1631, "Assertion \'first == second\' failed", "\'data2[3]\' (%d) is not equal to \'0x60\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix2, &map);
        pix2 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 3);
        D.23403 = pix2 == pix5;
        D.23404 = (int) D.23403;
        _fail_unless (D.23404, "libs/video.c", 1648, "Assertion \'pix2 == pix5\' failed", 0B);
        gst_buffer_map (pix2, &map, 1);
        data2 = map.data;
        {
          int first;
          int second;

          D.23316 = *data2;
          first = (int) D.23316;
          second = 64;
          D.23405 = first == second;
          D.23406 = (int) D.23405;
          _fail_unless (D.23406, "libs/video.c", 1654, "Assertion \'first == second\' failed", "\'data2[0]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23319 = data2 + 1;
          D.23320 = *D.23319;
          first = (int) D.23320;
          second = 64;
          D.23407 = first == second;
          D.23408 = (int) D.23407;
          _fail_unless (D.23408, "libs/video.c", 1655, "Assertion \'first == second\' failed", "\'data2[1]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23323 = data2 + 2;
          D.23324 = *D.23323;
          first = (int) D.23324;
          second = 64;
          D.23409 = first == second;
          D.23410 = (int) D.23409;
          _fail_unless (D.23410, "libs/video.c", 1656, "Assertion \'first == second\' failed", "\'data2[2]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23327 = data2 + 3;
          D.23328 = *D.23327;
          first = (int) D.23328;
          second = 128;
          D.23411 = first == second;
          D.23412 = (int) D.23411;
          _fail_unless (D.23412, "libs/video.c", 1657, "Assertion \'first == second\' failed", "\'data2[3]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix2, &map);
        pix2 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 1);
        D.23403 = pix2 == pix5;
        D.23404 = (int) D.23403;
        _fail_unless (D.23404, "libs/video.c", 1672, "Assertion \'pix2 == pix5\' failed", 0B);
        gst_buffer_map (pix2, &map, 1);
        data2 = map.data;
        {
          int first;
          int second;

          D.23316 = *data2;
          first = (int) D.23316;
          second = 47;
          D.23413 = first == second;
          D.23414 = (int) D.23413;
          _fail_unless (D.23414, "libs/video.c", 1678, "Assertion \'first == second\' failed", "\'data2[0]\' (%d) is not equal to \'0x2F\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23319 = data2 + 1;
          D.23320 = *D.23319;
          first = (int) D.23320;
          second = 47;
          D.23415 = first == second;
          D.23416 = (int) D.23415;
          _fail_unless (D.23416, "libs/video.c", 1679, "Assertion \'first == second\' failed", "\'data2[1]\' (%d) is not equal to \'0x2F\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23323 = data2 + 2;
          D.23324 = *D.23323;
          first = (int) D.23324;
          second = 47;
          D.23417 = first == second;
          D.23418 = (int) D.23417;
          _fail_unless (D.23418, "libs/video.c", 1680, "Assertion \'first == second\' failed", "\'data2[2]\' (%d) is not equal to \'0x2F\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23327 = data2 + 3;
          D.23328 = *D.23327;
          first = (int) D.23328;
          second = 96;
          D.23419 = first == second;
          D.23420 = (int) D.23419;
          _fail_unless (D.23420, "libs/video.c", 1681, "Assertion \'first == second\' failed", "\'data2[3]\' (%d) is not equal to \'0x60\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix2, &map);
        gst_video_overlay_rectangle_unref (rect1);
      }
    finally
      {
        map = {CLOBBER};
      }
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.0 = _gst_debug_min;
      if (_gst_debug_min.0 > 5) goto <D.23421>; else goto <D.23422>;
      <D.23421>:
      _g_boolean_var_ = 1;
      goto <D.23423>;
      <D.23422>:
      _g_boolean_var_ = 0;
      <D.23423>:
    }
    D.22991 = _g_boolean_var_;
  }
  D.23424 = (long int) D.22991;
  D.23425 = __builtin_expect (D.23424, 0);
  if (D.23425 != 0) goto <D.23426>; else goto <D.23427>;
  <D.23426>:
  check_debug.1 = check_debug;
  gst_debug_log (check_debug.1, 6, "libs/video.c", &__PRETTY_FUNCTION__, 1694, 0B, "cleaning up tasks");
  <D.23427>:
  gst_task_cleanup_all ();
}


gst_buffer_unref (struct GstBuffer * buf)
{
  gst_mini_object_unref (buf);
}


gst_video_overlay_rectangle_unref (struct GstVideoOverlayRectangle * comp)
{
  gst_mini_object_unref (comp);
}


test_overlay_composition_premultiplied_alpha (int __i__)
{
  int D.22799;
  <unnamed type> _gst_debug_min.3;
  long int D.23432;
  long int D.23433;
  struct GstDebugCategory * check_debug.4;
  long unsigned int D.23437;
  _Bool D.23438;
  int D.23439;
  _Bool D.23440;
  _Bool D.23441;
  _Bool D.23442;
  int D.23443;
  _Bool D.23444;
  int D.23445;
  long unsigned int D.23446;
  _Bool D.23447;
  int D.23448;
  int iftmp.5;
  _Bool D.23452;
  _Bool D.23453;
  _Bool D.23454;
  long unsigned int D.23457;
  _Bool D.23458;
  int D.23459;
  _Bool D.23460;
  int D.23461;
  long unsigned int D.23462;
  long unsigned int D.23463;
  _Bool D.23464;
  int D.23465;
  long unsigned int D.23466;
  guint8 * D.23467;
  int D.23468;
  _Bool D.23469;
  int D.23470;
  unsigned char D.23471;
  _Bool D.23472;
  int D.23473;
  guint8 * D.23474;
  unsigned char D.23475;
  _Bool D.23476;
  int D.23477;
  guint8 * D.23478;
  unsigned char D.23479;
  _Bool D.23480;
  int D.23481;
  guint8 * D.23482;
  unsigned char D.23483;
  _Bool D.23484;
  int D.23485;
  _Bool D.23486;
  int D.23487;
  int iftmp.6;
  _Bool D.23491;
  _Bool D.23492;
  _Bool D.23493;
  _Bool D.23495;
  _Bool D.23496;
  _Bool D.23497;
  unsigned char D.23499;
  _Bool D.23500;
  int D.23501;
  guint8 * D.23502;
  unsigned char D.23503;
  _Bool D.23504;
  int D.23505;
  guint8 * D.23506;
  unsigned char D.23507;
  _Bool D.23508;
  int D.23509;
  guint8 * D.23510;
  unsigned char D.23511;
  _Bool D.23512;
  int D.23513;
  _Bool D.23514;
  int D.23515;
  _Bool D.23516;
  int D.23517;
  _Bool D.23518;
  int D.23519;
  int D.22843;
  long int D.23523;
  long int D.23524;
  static const char __PRETTY_FUNCTION__[45] = "test_overlay_composition_premultiplied_alpha";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.3 = _gst_debug_min;
      if (_gst_debug_min.3 > 4) goto <D.23429>; else goto <D.23430>;
      <D.23429>:
      _g_boolean_var_ = 1;
      goto <D.23431>;
      <D.23430>:
      _g_boolean_var_ = 0;
      <D.23431>:
    }
    D.22799 = _g_boolean_var_;
  }
  D.23432 = (long int) D.22799;
  D.23433 = __builtin_expect (D.23432, 0);
  if (D.23433 != 0) goto <D.23434>; else goto <D.23435>;
  <D.23434>:
  check_debug.4 = check_debug;
  gst_debug_log (check_debug.4, 5, "libs/video.c", &__PRETTY_FUNCTION__, 1175, 0B, "test start");
  <D.23435>:
  tcase_fn_start ("test_overlay_composition_premultiplied_alpha", "libs/video.c", 1175);
  {
    struct GstVideoOverlayRectangle * rect1;
    struct GstVideoMeta * vmeta;
    struct GstBuffer * pix1;
    struct GstBuffer * pix2;
    struct GstBuffer * pix3;
    struct GstBuffer * pix4;
    struct GstBuffer * pix5;
    struct GstBuffer * pix6;
    struct GstBuffer * pix7;
    struct GstBuffer * pix8;
    struct GstBuffer * pix9;
    struct GstBuffer * pix10;
    guint8 * data5;
    guint8 * data7;
    guint w;
    guint h;
    guint w2;
    guint h2;
    struct GstMapInfo map;

    try
      {
        pix1 = gst_buffer_new_allocate (0B, 40000, 0B);
        D.23437 = gst_buffer_get_size (pix1);
        gst_buffer_memset (pix1, 0, 128, D.23437);
        gst_buffer_add_video_meta (pix1, 0, 12, 200, 50);
        rect1 = gst_video_overlay_rectangle_new_raw (pix1, 600, 50, 300, 50, 0);
        gst_buffer_unref (pix1);
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 0);
        D.23438 = pix1 == pix2;
        D.23439 = (int) D.23438;
        _fail_unless (D.23439, "libs/video.c", 1197, "Assertion \'pix1 == pix2\' failed", 0B);
        pix3 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 0);
        D.23440 = pix3 != pix1;
        D.23441 = pix3 != pix2;
        D.23442 = D.23440 & D.23441;
        D.23443 = (int) D.23442;
        _fail_unless (D.23443, "libs/video.c", 1202, "Failure \'pix3 == pix1 || pix3 == pix2\' occured", 0B);
        pix4 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 0);
        D.23444 = pix4 == pix3;
        D.23445 = (int) D.23444;
        _fail_unless (D.23445, "libs/video.c", 1207, "Assertion \'pix4 == pix3\' failed", 0B);
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 0);
        D.23446 = gst_video_meta_api_get_type ();
        vmeta = gst_buffer_get_meta (pix2, D.23446);
        D.23447 = vmeta != 0B;
        D.23448 = (int) D.23447;
        _fail_unless (D.23448, "libs/video.c", 1214, "Assertion \'vmeta != NULL\' failed", 0B);
        w = vmeta->width;
        h = vmeta->height;
        pix5 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 1);
        D.23452 = pix5 != pix1;
        D.23453 = pix5 != pix2;
        D.23454 = D.23452 & D.23453;
        if (D.23454 != 0) goto <D.23455>; else goto <D.23450>;
        <D.23455>:
        if (pix5 != pix3) goto <D.23456>; else goto <D.23450>;
        <D.23456>:
        iftmp.5 = 1;
        goto <D.23451>;
        <D.23450>:
        iftmp.5 = 0;
        <D.23451>:
        _fail_unless (iftmp.5, "libs/video.c", 1221, "Failure \'pix5 == pix1 || pix5 == pix2 || pix5 == pix3\' occured", 0B);
        D.23457 = gst_video_meta_api_get_type ();
        vmeta = gst_buffer_get_meta (pix5, D.23457);
        D.23447 = vmeta != 0B;
        D.23448 = (int) D.23447;
        _fail_unless (D.23448, "libs/video.c", 1223, "Assertion \'vmeta != NULL\' failed", 0B);
        w2 = vmeta->width;
        h2 = vmeta->height;
        {
          int first;
          int second;

          first = (int) w;
          second = (int) w2;
          D.23458 = first == second;
          D.23459 = (int) D.23458;
          _fail_unless (D.23459, "libs/video.c", 1226, "Assertion \'first == second\' failed", "\'w\' (%d) is not equal to \'w2\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          first = (int) h;
          second = (int) h2;
          D.23460 = first == second;
          D.23461 = (int) D.23460;
          _fail_unless (D.23461, "libs/video.c", 1227, "Assertion \'first == second\' failed", "\'h\' (%d) is not equal to \'h2\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23462 = gst_buffer_get_size (pix2);
          first = (int) D.23462;
          D.23463 = gst_buffer_get_size (pix5);
          second = (int) D.23463;
          D.23464 = first == second;
          D.23465 = (int) D.23464;
          _fail_unless (D.23465, "libs/video.c", 1229, "Assertion \'first == second\' failed", "\'gst_buffer_get_size (pix2)\' (%d) is not equal to \'gst_buffer_get_size (pix5)\' (%d)", first, second, 0B);
        }
        gst_buffer_map (pix5, &map, 1);
        D.23466 = map.size;
        D.23467 = map.data;
        D.23468 = gst_buffer_memcmp (pix2, 0, D.23467, D.23466);
        D.23469 = D.23468 != 0;
        D.23470 = (int) D.23469;
        _fail_unless (D.23470, "libs/video.c", 1231, "Failure \'gst_buffer_memcmp (pix2, 0, map.data, map.size) == 0\' occured", 0B);
        data5 = map.data;
        {
          int first;
          int second;

          D.23471 = *data5;
          first = (int) D.23471;
          second = 64;
          D.23472 = first == second;
          D.23473 = (int) D.23472;
          _fail_unless (D.23473, "libs/video.c", 1236, "Assertion \'first == second\' failed", "\'data5[0]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23474 = data5 + 1;
          D.23475 = *D.23474;
          first = (int) D.23475;
          second = 64;
          D.23476 = first == second;
          D.23477 = (int) D.23476;
          _fail_unless (D.23477, "libs/video.c", 1237, "Assertion \'first == second\' failed", "\'data5[1]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23478 = data5 + 2;
          D.23479 = *D.23478;
          first = (int) D.23479;
          second = 64;
          D.23480 = first == second;
          D.23481 = (int) D.23480;
          _fail_unless (D.23481, "libs/video.c", 1238, "Assertion \'first == second\' failed", "\'data5[2]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23482 = data5 + 3;
          D.23483 = *D.23482;
          first = (int) D.23483;
          second = 128;
          D.23484 = first == second;
          D.23485 = (int) D.23484;
          _fail_unless (D.23485, "libs/video.c", 1239, "Assertion \'first == second\' failed", "\'data5[3]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix5, &map);
        pix6 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 1);
        D.23486 = pix6 == pix5;
        D.23487 = (int) D.23486;
        _fail_unless (D.23487, "libs/video.c", 1253, "Assertion \'pix6 == pix5\' failed", 0B);
        pix3 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 0);
        D.23444 = pix3 == pix4;
        D.23445 = (int) D.23444;
        _fail_unless (D.23445, "libs/video.c", 1258, "Assertion \'pix3 == pix4\' failed", 0B);
        pix7 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 1);
        D.23491 = pix7 != pix1;
        D.23492 = pix7 != pix2;
        D.23493 = D.23491 & D.23492;
        if (D.23493 != 0) goto <D.23494>; else goto <D.23489>;
        <D.23494>:
        D.23495 = pix7 != pix3;
        D.23496 = pix7 != pix5;
        D.23497 = D.23495 & D.23496;
        if (D.23497 != 0) goto <D.23498>; else goto <D.23489>;
        <D.23498>:
        iftmp.6 = 1;
        goto <D.23490>;
        <D.23489>:
        iftmp.6 = 0;
        <D.23490>:
        _fail_unless (iftmp.6, "libs/video.c", 1263, "Failure \'pix7 == pix1 || pix7 == pix2 || pix7 == pix3 || pix7 == pix5\' occured", 0B);
        gst_buffer_map (pix7, &map, 1);
        data7 = map.data;
        {
          int first;
          int second;

          D.23499 = *data7;
          first = (int) D.23499;
          second = 64;
          D.23500 = first == second;
          D.23501 = (int) D.23500;
          _fail_unless (D.23501, "libs/video.c", 1271, "Assertion \'first == second\' failed", "\'data7[0]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23502 = data7 + 1;
          D.23503 = *D.23502;
          first = (int) D.23503;
          second = 64;
          D.23504 = first == second;
          D.23505 = (int) D.23504;
          _fail_unless (D.23505, "libs/video.c", 1272, "Assertion \'first == second\' failed", "\'data7[1]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23506 = data7 + 2;
          D.23507 = *D.23506;
          first = (int) D.23507;
          second = 64;
          D.23508 = first == second;
          D.23509 = (int) D.23508;
          _fail_unless (D.23509, "libs/video.c", 1273, "Assertion \'first == second\' failed", "\'data7[2]\' (%d) is not equal to \'0x40\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23510 = data7 + 3;
          D.23511 = *D.23510;
          first = (int) D.23511;
          second = 128;
          D.23512 = first == second;
          D.23513 = (int) D.23512;
          _fail_unless (D.23513, "libs/video.c", 1274, "Assertion \'first == second\' failed", "\'data7[3]\' (%d) is not equal to \'0x80\' (%d)", first, second, 0B);
        }
        gst_buffer_unmap (pix7, &map);
        pix8 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 1);
        D.23514 = pix8 == pix7;
        D.23515 = (int) D.23514;
        _fail_unless (D.23515, "libs/video.c", 1287, "Assertion \'pix8 == pix7\' failed", 0B);
        pix9 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 0);
        D.23516 = pix9 == pix3;
        D.23517 = (int) D.23516;
        _fail_unless (D.23517, "libs/video.c", 1292, "Assertion \'pix9 == pix3\' failed", 0B);
        pix10 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 1);
        D.23518 = pix10 == pix5;
        D.23519 = (int) D.23518;
        _fail_unless (D.23519, "libs/video.c", 1295, "Assertion \'pix10 == pix5\' failed", 0B);
        gst_video_overlay_rectangle_unref (rect1);
      }
    finally
      {
        map = {CLOBBER};
      }
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.3 = _gst_debug_min;
      if (_gst_debug_min.3 > 5) goto <D.23520>; else goto <D.23521>;
      <D.23520>:
      _g_boolean_var_ = 1;
      goto <D.23522>;
      <D.23521>:
      _g_boolean_var_ = 0;
      <D.23522>:
    }
    D.22843 = _g_boolean_var_;
  }
  D.23523 = (long int) D.22843;
  D.23524 = __builtin_expect (D.23523, 0);
  if (D.23524 != 0) goto <D.23525>; else goto <D.23526>;
  <D.23525>:
  check_debug.4 = check_debug;
  gst_debug_log (check_debug.4, 6, "libs/video.c", &__PRETTY_FUNCTION__, 1300, 0B, "cleaning up tasks");
  <D.23526>:
  gst_task_cleanup_all ();
}


test_overlay_composition (int __i__)
{
  int D.22742;
  <unnamed type> _gst_debug_min.7;
  long int D.23531;
  long int D.23532;
  struct GstDebugCategory * check_debug.8;
  long unsigned int D.23536;
  unsigned int D.23537;
  _Bool D.23538;
  int D.23539;
  struct GstVideoOverlayRectangle * D.23540;
  _Bool D.23541;
  int D.23542;
  struct GstVideoOverlayRectangle * D.23543;
  _Bool D.23544;
  int D.23545;
  unsigned int seq1.9;
  unsigned int seq1.10;
  _Bool D.23548;
  int D.23549;
  int _gst_check_raised_critical.11;
  unsigned int D.23551;
  _Bool D.23552;
  int D.23553;
  struct GstVideoOverlayRectangle * D.23554;
  _Bool D.23555;
  int D.23556;
  struct GstVideoOverlayRectangle * D.23557;
  _Bool D.23558;
  int D.23559;
  unsigned int D.23560;
  _Bool D.23561;
  int D.23562;
  unsigned int D.23563;
  _Bool D.23564;
  int D.23565;
  unsigned int D.23566;
  _Bool D.23567;
  int D.23568;
  struct GstVideoOverlayRectangle * D.23569;
  _Bool D.23570;
  int D.23571;
  struct GstVideoOverlayRectangle * D.23572;
  _Bool D.23573;
  int D.23574;
  _Bool D.23575;
  int D.23576;
  _Bool D.23577;
  int D.23578;
  _Bool D.23579;
  int D.23580;
  unsigned int w.12;
  _Bool D.23582;
  int D.23583;
  unsigned int h.13;
  _Bool D.23585;
  int D.23586;
  unsigned int D.23587;
  unsigned int D.23588;
  unsigned int D.23589;
  unsigned int D.23590;
  unsigned int D.23591;
  long unsigned int D.23592;
  long unsigned int D.23593;
  long unsigned int D.23594;
  _Bool D.23595;
  int D.23596;
  unsigned char val.14;
  _Bool D.23598;
  int D.23599;
  _Bool D.23600;
  int D.23601;
  _Bool D.23602;
  int D.23603;
  _Bool D.23604;
  int D.23605;
  _Bool D.23606;
  int D.23607;
  long unsigned int D.23608;
  long unsigned int D.23609;
  _Bool D.23610;
  int D.23611;
  _Bool D.23612;
  int D.23613;
  _Bool D.23614;
  int D.23615;
  _Bool D.23616;
  int D.23617;
  long unsigned int D.23618;
  _Bool D.23619;
  int D.23620;
  unsigned int w.15;
  unsigned int h.16;
  _Bool D.23623;
  int D.23624;
  _Bool D.23625;
  int D.23626;
  <unnamed type> D.23627;
  _Bool D.23628;
  int D.23629;
  long unsigned int D.23630;
  unsigned int D.23631;
  unsigned int D.23632;
  long unsigned int D.23633;
  _Bool D.23634;
  int D.23635;
  _Bool D.23636;
  int D.23637;
  long unsigned int D.23638;
  _Bool D.23639;
  int D.23640;
  _Bool D.23641;
  int D.23642;
  long unsigned int D.23643;
  long unsigned int D.23644;
  _Bool D.23645;
  int D.23646;
  _Bool D.23647;
  int D.23648;
  long unsigned int D.23649;
  struct GstMeta * D.23650;
  _Bool D.23651;
  int D.23652;
  long unsigned int D.23653;
  _Bool D.23654;
  int D.23655;
  struct GstVideoOverlayComposition * D.23656;
  _Bool D.23657;
  int D.23658;
  int D.23659;
  long unsigned int D.23660;
  _Bool D.23661;
  int D.23662;
  int D.23663;
  long unsigned int D.23664;
  struct GstMeta * D.23665;
  _Bool D.23666;
  int D.23667;
  int D.22794;
  long int D.23671;
  long int D.23672;
  static const char __PRETTY_FUNCTION__[25] = "test_overlay_composition";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.7 = _gst_debug_min;
      if (_gst_debug_min.7 > 4) goto <D.23528>; else goto <D.23529>;
      <D.23528>:
      _g_boolean_var_ = 1;
      goto <D.23530>;
      <D.23529>:
      _g_boolean_var_ = 0;
      <D.23530>:
    }
    D.22742 = _g_boolean_var_;
  }
  D.23531 = (long int) D.22742;
  D.23532 = __builtin_expect (D.23531, 0);
  if (D.23532 != 0) goto <D.23533>; else goto <D.23534>;
  <D.23533>:
  check_debug.8 = check_debug;
  gst_debug_log (check_debug.8, 5, "libs/video.c", &__PRETTY_FUNCTION__, 980, 0B, "test start");
  <D.23534>:
  tcase_fn_start ("test_overlay_composition", "libs/video.c", 980);
  {
    struct GstVideoOverlayComposition * comp1;
    struct GstVideoOverlayComposition * comp2;
    struct GstVideoOverlayRectangle * rect1;
    struct GstVideoOverlayRectangle * rect2;
    struct GstVideoOverlayCompositionMeta * ometa;
    struct GstBuffer * pix1;
    struct GstBuffer * pix2;
    struct GstBuffer * buf;
    struct GstVideoMeta * vmeta;
    guint seq1;
    guint seq2;
    guint w;
    guint h;
    guint stride;
    gint x;
    gint y;
    guint8 val;

    try
      {
        pix1 = gst_buffer_new_allocate (0B, 40000, 0B);
        D.23536 = gst_buffer_get_size (pix1);
        gst_buffer_memset (pix1, 0, 0, D.23536);
        gst_buffer_add_video_meta (pix1, 0, 12, 200, 50);
        rect1 = gst_video_overlay_rectangle_new_raw (pix1, 600, 50, 300, 50, 0);
        gst_buffer_unref (pix1);
        pix1 = 0B;
        comp1 = gst_video_overlay_composition_new (rect1);
        D.23537 = gst_video_overlay_composition_n_rectangles (comp1);
        D.23538 = D.23537 == 1;
        D.23539 = (int) D.23538;
        _fail_unless (D.23539, "libs/video.c", 1004, "Assertion \'gst_video_overlay_composition_n_rectangles (comp1) == 1\' failed", 0B);
        D.23540 = gst_video_overlay_composition_get_rectangle (comp1, 0);
        D.23541 = D.23540 == rect1;
        D.23542 = (int) D.23541;
        _fail_unless (D.23542, "libs/video.c", 1005, "Assertion \'gst_video_overlay_composition_get_rectangle (comp1, 0) == rect1\' failed", 0B);
        D.23543 = gst_video_overlay_composition_get_rectangle (comp1, 1);
        D.23544 = D.23543 == 0B;
        D.23545 = (int) D.23544;
        _fail_unless (D.23545, "libs/video.c", 1006, "Assertion \'gst_video_overlay_composition_get_rectangle (comp1, 1) == NULL\' failed", 0B);
        seq1.9 = gst_video_overlay_rectangle_get_seqnum (rect1);
        seq1 = seq1.9;
        seq2 = gst_video_overlay_composition_get_seqnum (comp1);
        seq1.10 = seq1;
        D.23548 = seq1.10 < seq2;
        D.23549 = (int) D.23548;
        _fail_unless (D.23549, "libs/video.c", 1011, "Assertion \'seq1 < seq2\' failed", 0B);
        _gst_check_expecting_log = 1;
        _gst_check_raised_critical = 0;
        gst_video_overlay_rectangle_set_render_rectangle (rect1, 50, 600, 300, 50);
        _gst_check_raised_critical.11 = _gst_check_raised_critical;
        _fail_unless (_gst_check_raised_critical.11, "libs/video.c", 1015, "Expected g_critical, got nothing", 0B);
        _gst_check_expecting_log = 0;
        gst_video_overlay_rectangle_unref (rect1);
        gst_video_overlay_rectangle_set_render_rectangle (rect1, 50, 600, 300, 50);
        comp2 = gst_video_overlay_composition_new (rect1);
        D.23551 = gst_video_overlay_composition_n_rectangles (comp2);
        D.23552 = D.23551 == 1;
        D.23553 = (int) D.23552;
        _fail_unless (D.23553, "libs/video.c", 1022, "Assertion \'gst_video_overlay_composition_n_rectangles (comp2) == 1\' failed", 0B);
        D.23554 = gst_video_overlay_composition_get_rectangle (comp2, 0);
        D.23555 = D.23554 == rect1;
        D.23556 = (int) D.23555;
        _fail_unless (D.23556, "libs/video.c", 1023, "Assertion \'gst_video_overlay_composition_get_rectangle (comp2, 0) == rect1\' failed", 0B);
        D.23557 = gst_video_overlay_composition_get_rectangle (comp2, 1);
        D.23558 = D.23557 == 0B;
        D.23559 = (int) D.23558;
        _fail_unless (D.23559, "libs/video.c", 1024, "Assertion \'gst_video_overlay_composition_get_rectangle (comp2, 1) == NULL\' failed", 0B);
        D.23560 = gst_video_overlay_composition_get_seqnum (comp2);
        seq1.10 = seq1;
        D.23561 = D.23560 > seq1.10;
        D.23562 = (int) D.23561;
        _fail_unless (D.23562, "libs/video.c", 1026, "Assertion \'seq1 < gst_video_overlay_composition_get_seqnum (comp2)\' failed", 0B);
        D.23563 = gst_video_overlay_composition_get_seqnum (comp2);
        D.23564 = D.23563 > seq2;
        D.23565 = (int) D.23564;
        _fail_unless (D.23565, "libs/video.c", 1027, "Assertion \'seq2 < gst_video_overlay_composition_get_seqnum (comp2)\' failed", 0B);
        _gst_check_expecting_log = 1;
        _gst_check_raised_critical = 0;
        gst_video_overlay_rectangle_set_render_rectangle (rect1, 0, 0, 1, 1);
        _gst_check_raised_critical.11 = _gst_check_raised_critical;
        _fail_unless (_gst_check_raised_critical.11, "libs/video.c", 1031, "Expected g_critical, got nothing", 0B);
        _gst_check_expecting_log = 0;
        comp2 = gst_video_overlay_composition_make_writable (comp2);
        gst_video_overlay_rectangle_set_render_rectangle (rect1, 51, 601, 301, 51);
        rect2 = gst_video_overlay_composition_get_rectangle (comp2, 0);
        D.23566 = gst_video_overlay_composition_n_rectangles (comp2);
        D.23567 = D.23566 == 1;
        D.23568 = (int) D.23567;
        _fail_unless (D.23568, "libs/video.c", 1039, "Assertion \'gst_video_overlay_composition_n_rectangles (comp2) == 1\' failed", 0B);
        D.23569 = gst_video_overlay_composition_get_rectangle (comp2, 0);
        D.23570 = D.23569 == rect2;
        D.23571 = (int) D.23570;
        _fail_unless (D.23571, "libs/video.c", 1040, "Assertion \'gst_video_overlay_composition_get_rectangle (comp2, 0) == rect2\' failed", 0B);
        D.23572 = gst_video_overlay_composition_get_rectangle (comp2, 1);
        D.23573 = D.23572 == 0B;
        D.23574 = (int) D.23573;
        _fail_unless (D.23574, "libs/video.c", 1041, "Assertion \'gst_video_overlay_composition_get_rectangle (comp2, 1) == NULL\' failed", 0B);
        D.23575 = rect1 != rect2;
        D.23576 = (int) D.23575;
        _fail_unless (D.23576, "libs/video.c", 1042, "Assertion \'rect1 != rect2\' failed", 0B);
        gst_video_overlay_composition_add_rectangle (comp1, rect2);
        gst_video_overlay_composition_ref (comp1);
        _gst_check_expecting_log = 1;
        _gst_check_raised_critical = 0;
        gst_video_overlay_composition_add_rectangle (comp1, rect2);
        _gst_check_raised_critical.11 = _gst_check_raised_critical;
        _fail_unless (_gst_check_raised_critical.11, "libs/video.c", 1046, "Expected g_critical, got nothing", 0B);
        _gst_check_expecting_log = 0;
        gst_video_overlay_composition_unref (comp1);
        gst_video_overlay_rectangle_get_render_rectangle (rect1, &x, &y, &w, &h);
        {
          int first;
          int second;

          first = x;
          second = 51;
          D.23577 = first == second;
          D.23578 = (int) D.23577;
          _fail_unless (D.23578, "libs/video.c", 1051, "Assertion \'first == second\' failed", "\'x\' (%d) is not equal to \'51\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          first = y;
          second = 601;
          D.23579 = first == second;
          D.23580 = (int) D.23579;
          _fail_unless (D.23580, "libs/video.c", 1052, "Assertion \'first == second\' failed", "\'y\' (%d) is not equal to \'601\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          w.12 = w;
          first = (int) w.12;
          second = 301;
          D.23582 = first == second;
          D.23583 = (int) D.23582;
          _fail_unless (D.23583, "libs/video.c", 1053, "Assertion \'first == second\' failed", "\'w\' (%d) is not equal to \'301\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          h.13 = h;
          first = (int) h.13;
          second = 51;
          D.23585 = first == second;
          D.23586 = (int) D.23585;
          _fail_unless (D.23586, "libs/video.c", 1054, "Assertion \'first == second\' failed", "\'h\' (%d) is not equal to \'51\' (%d)", first, second, 0B);
        }
        pix1 = gst_video_overlay_rectangle_get_pixels_raw (rect1, 0);
        w.12 = w;
        stride = w.12 * 4;
        h.13 = h;
        D.23587 = h.13 + 4294967295;
        D.23588 = D.23587 * stride;
        w.12 = w;
        D.23589 = w.12 * 4;
        D.23590 = D.23588 + D.23589;
        D.23591 = D.23590 + 4294967295;
        D.23592 = gst_buffer_get_size (pix1);
        D.23593 = gst_buffer_get_size (pix1);
        h.13 = h;
        D.23587 = h.13 + 4294967295;
        D.23588 = D.23587 * stride;
        w.12 = w;
        D.23589 = w.12 * 4;
        D.23590 = D.23588 + D.23589;
        D.23591 = D.23590 + 4294967295;
        D.23594 = (long unsigned int) D.23591;
        D.23595 = D.23593 > D.23594;
        D.23596 = (int) D.23595;
        _fail_unless (D.23596, "libs/video.c", 1062, "Assertion \'gst_buffer_get_size (pix1) > ((h - 1) * stride + (w * 4) - 1)\' failed", "size %u vs. last pixel offset %u", D.23592, D.23591, 0B);
        h.13 = h;
        D.23587 = h.13 + 4294967295;
        D.23588 = D.23587 * stride;
        w.12 = w;
        D.23589 = w.12 * 4;
        D.23590 = D.23588 + D.23589;
        D.23591 = D.23590 + 4294967295;
        D.23594 = (long unsigned int) D.23591;
        gst_buffer_extract (pix1, D.23594, &val, 1);
        {
          int first;
          int second;

          val.14 = val;
          first = (int) val.14;
          second = 0;
          D.23598 = first == second;
          D.23599 = (int) D.23598;
          _fail_unless (D.23599, "libs/video.c", 1064, "Assertion \'first == second\' failed", "\'val\' (%d) is not equal to \'0\' (%d)", first, second, 0B);
        }
        gst_video_overlay_rectangle_get_render_rectangle (rect2, &x, &y, &w, &h);
        {
          int first;
          int second;

          first = x;
          second = 50;
          D.23600 = first == second;
          D.23601 = (int) D.23600;
          _fail_unless (D.23601, "libs/video.c", 1067, "Assertion \'first == second\' failed", "\'x\' (%d) is not equal to \'50\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          first = y;
          second = 600;
          D.23602 = first == second;
          D.23603 = (int) D.23602;
          _fail_unless (D.23603, "libs/video.c", 1068, "Assertion \'first == second\' failed", "\'y\' (%d) is not equal to \'600\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          w.12 = w;
          first = (int) w.12;
          second = 300;
          D.23604 = first == second;
          D.23605 = (int) D.23604;
          _fail_unless (D.23605, "libs/video.c", 1069, "Assertion \'first == second\' failed", "\'w\' (%d) is not equal to \'300\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          h.13 = h;
          first = (int) h.13;
          second = 50;
          D.23606 = first == second;
          D.23607 = (int) D.23606;
          _fail_unless (D.23607, "libs/video.c", 1070, "Assertion \'first == second\' failed", "\'h\' (%d) is not equal to \'50\' (%d)", first, second, 0B);
        }
        pix2 = gst_video_overlay_rectangle_get_pixels_raw (rect2, 0);
        w.12 = w;
        stride = w.12 * 4;
        h.13 = h;
        D.23587 = h.13 + 4294967295;
        D.23588 = D.23587 * stride;
        w.12 = w;
        D.23589 = w.12 * 4;
        D.23590 = D.23588 + D.23589;
        D.23591 = D.23590 + 4294967295;
        D.23608 = gst_buffer_get_size (pix1);
        D.23609 = gst_buffer_get_size (pix2);
        h.13 = h;
        D.23587 = h.13 + 4294967295;
        D.23588 = D.23587 * stride;
        w.12 = w;
        D.23589 = w.12 * 4;
        D.23590 = D.23588 + D.23589;
        D.23591 = D.23590 + 4294967295;
        D.23594 = (long unsigned int) D.23591;
        D.23610 = D.23609 > D.23594;
        D.23611 = (int) D.23610;
        _fail_unless (D.23611, "libs/video.c", 1078, "Assertion \'gst_buffer_get_size (pix2) > ((h - 1) * stride + (w * 4) - 1)\' failed", "size %u vs. last pixel offset %u", D.23608, D.23591, 0B);
        h.13 = h;
        D.23587 = h.13 + 4294967295;
        D.23588 = D.23587 * stride;
        w.12 = w;
        D.23589 = w.12 * 4;
        D.23590 = D.23588 + D.23589;
        D.23591 = D.23590 + 4294967295;
        D.23594 = (long unsigned int) D.23591;
        gst_buffer_extract (pix2, D.23594, &val, 1);
        {
          int first;
          int second;

          val.14 = val;
          first = (int) val.14;
          second = 0;
          D.23612 = first == second;
          D.23613 = (int) D.23612;
          _fail_unless (D.23613, "libs/video.c", 1080, "Assertion \'first == second\' failed", "\'val\' (%d) is not equal to \'0\' (%d)", first, second, 0B);
        }
        pix1 = gst_video_overlay_rectangle_get_pixels_raw (rect2, 0);
        D.23614 = pix1 == pix2;
        D.23615 = (int) D.23614;
        _fail_unless (D.23615, "libs/video.c", 1085, "Assertion \'pix1 == pix2\' failed", 0B);
        pix1 = gst_video_overlay_rectangle_get_pixels_ayuv (rect2, 0);
        D.23616 = pix1 != pix2;
        D.23617 = (int) D.23616;
        _fail_unless (D.23617, "libs/video.c", 1090, "Assertion \'pix1 != pix2\' failed", 0B);
        pix2 = gst_video_overlay_rectangle_get_pixels_ayuv (rect2, 0);
        D.23614 = pix1 == pix2;
        D.23615 = (int) D.23614;
        _fail_unless (D.23615, "libs/video.c", 1094, "Assertion \'pix1 == pix2\' failed", 0B);
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_ayuv (rect2, 0);
        D.23616 = pix1 != pix2;
        D.23617 = (int) D.23616;
        _fail_unless (D.23617, "libs/video.c", 1098, "Assertion \'pix1 != pix2\' failed", 0B);
        pix1 = gst_video_overlay_rectangle_get_pixels_unscaled_ayuv (rect2, 0);
        D.23614 = pix1 == pix2;
        D.23615 = (int) D.23614;
        _fail_unless (D.23615, "libs/video.c", 1102, "Assertion \'pix1 == pix2\' failed", 0B);
        D.23618 = gst_video_meta_api_get_type ();
        vmeta = gst_buffer_get_meta (pix1, D.23618);
        D.23619 = vmeta != 0B;
        D.23620 = (int) D.23619;
        _fail_unless (D.23620, "libs/video.c", 1105, "Assertion \'vmeta != NULL\' failed", 0B);
        w.15 = vmeta->width;
        w = w.15;
        h.16 = vmeta->height;
        h = h.16;
        {
          int first;
          int second;

          w.12 = w;
          first = (int) w.12;
          second = 200;
          D.23623 = first == second;
          D.23624 = (int) D.23623;
          _fail_unless (D.23624, "libs/video.c", 1108, "Assertion \'first == second\' failed", "\'w\' (%d) is not equal to \'200\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          h.13 = h;
          first = (int) h.13;
          second = 50;
          D.23625 = first == second;
          D.23626 = (int) D.23625;
          _fail_unless (D.23626, "libs/video.c", 1109, "Assertion \'first == second\' failed", "\'h\' (%d) is not equal to \'50\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          D.23627 = vmeta->format;
          first = (int) D.23627;
          second = 6;
          D.23628 = first == second;
          D.23629 = (int) D.23628;
          _fail_unless (D.23629, "libs/video.c", 1111, "Assertion \'first == second\' failed", "\'vmeta->format\' (%d) is not equal to \'GST_VIDEO_OVERLAY_COMPOSITION_FORMAT_YUV\' (%d)", first, second, 0B);
        }
        D.23630 = gst_buffer_get_size (pix1);
        w.12 = w;
        h.13 = h;
        D.23631 = w.12 * h.13;
        D.23632 = D.23631 * 4;
        D.23633 = (long unsigned int) D.23632;
        D.23634 = D.23630 == D.23633;
        D.23635 = (int) D.23634;
        _fail_unless (D.23635, "libs/video.c", 1112, "Assertion \'gst_buffer_get_size (pix1) == w * h * 4\' failed", 0B);
        gst_buffer_extract (pix1, 0, &seq1, 4);
        seq1.10 = seq1;
        D.23636 = seq1.10 != 0;
        D.23637 = (int) D.23636;
        _fail_unless (D.23637, "libs/video.c", 1114, "Assertion \'seq1 != 0\' failed", 0B);
        pix1 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect1, 0);
        pix2 = gst_video_overlay_rectangle_get_pixels_unscaled_raw (rect2, 0);
        D.23638 = gst_video_meta_api_get_type ();
        vmeta = gst_buffer_get_meta (pix2, D.23638);
        D.23619 = vmeta != 0B;
        D.23620 = (int) D.23619;
        _fail_unless (D.23620, "libs/video.c", 1123, "Assertion \'vmeta != NULL\' failed", 0B);
        w.15 = vmeta->width;
        w = w.15;
        h.16 = vmeta->height;
        h = h.16;
        D.23614 = pix1 == pix2;
        D.23615 = (int) D.23614;
        _fail_unless (D.23615, "libs/video.c", 1128, "Assertion \'pix1 == pix2\' failed", 0B);
        {
          int first;
          int second;

          w.12 = w;
          first = (int) w.12;
          second = 200;
          D.23639 = first == second;
          D.23640 = (int) D.23639;
          _fail_unless (D.23640, "libs/video.c", 1129, "Assertion \'first == second\' failed", "\'w\' (%d) is not equal to \'200\' (%d)", first, second, 0B);
        }
        {
          int first;
          int second;

          h.13 = h;
          first = (int) h.13;
          second = 50;
          D.23641 = first == second;
          D.23642 = (int) D.23641;
          _fail_unless (D.23642, "libs/video.c", 1130, "Assertion \'first == second\' failed", "\'h\' (%d) is not equal to \'50\' (%d)", first, second, 0B);
        }
        w.12 = w;
        stride = w.12 * 4;
        h.13 = h;
        D.23587 = h.13 + 4294967295;
        D.23588 = D.23587 * stride;
        w.12 = w;
        D.23589 = w.12 * 4;
        D.23590 = D.23588 + D.23589;
        D.23591 = D.23590 + 4294967295;
        D.23643 = gst_buffer_get_size (pix1);
        D.23644 = gst_buffer_get_size (pix1);
        h.13 = h;
        D.23587 = h.13 + 4294967295;
        D.23588 = D.23587 * stride;
        w.12 = w;
        D.23589 = w.12 * 4;
        D.23590 = D.23588 + D.23589;
        D.23591 = D.23590 + 4294967295;
        D.23594 = (long unsigned int) D.23591;
        D.23645 = D.23644 > D.23594;
        D.23646 = (int) D.23645;
        _fail_unless (D.23646, "libs/video.c", 1136, "Assertion \'gst_buffer_get_size (pix1) > ((h - 1) * stride + (w * 4) - 1)\' failed", "size %u vs. last pixel offset %u", D.23643, D.23591, 0B);
        h.13 = h;
        D.23587 = h.13 + 4294967295;
        D.23588 = D.23587 * stride;
        w.12 = w;
        D.23589 = w.12 * 4;
        D.23590 = D.23588 + D.23589;
        D.23591 = D.23590 + 4294967295;
        D.23594 = (long unsigned int) D.23591;
        gst_buffer_extract (pix1, D.23594, &val, 1);
        {
          int first;
          int second;

          val.14 = val;
          first = (int) val.14;
          second = 0;
          D.23647 = first == second;
          D.23648 = (int) D.23647;
          _fail_unless (D.23648, "libs/video.c", 1138, "Assertion \'first == second\' failed", "\'val\' (%d) is not equal to \'0\' (%d)", first, second, 0B);
        }
        buf = gst_buffer_new ();
        D.23649 = gst_video_overlay_composition_meta_api_get_type ();
        D.23650 = gst_buffer_get_meta (buf, D.23649);
        D.23651 = D.23650 == 0B;
        D.23652 = (int) D.23651;
        _fail_unless (D.23652, "libs/video.c", 1142, "Assertion \'gst_buffer_get_video_overlay_composition_meta (buf) == NULL\' failed", 0B);
        gst_buffer_ref (buf);
        gst_buffer_unref (buf);
        gst_buffer_add_video_overlay_composition_meta (buf, comp1);
        D.23653 = gst_video_overlay_composition_meta_api_get_type ();
        ometa = gst_buffer_get_meta (buf, D.23653);
        D.23654 = ometa != 0B;
        D.23655 = (int) D.23654;
        _fail_unless (D.23655, "libs/video.c", 1156, "Assertion \'ometa != NULL\' failed", 0B);
        D.23656 = ometa->overlay;
        D.23657 = D.23656 == comp1;
        D.23658 = (int) D.23657;
        _fail_unless (D.23658, "libs/video.c", 1157, "Assertion \'ometa->overlay == comp1\' failed", 0B);
        D.23659 = gst_buffer_remove_meta (buf, ometa);
        _fail_unless (D.23659, "libs/video.c", 1158, "Assertion \'gst_buffer_remove_video_overlay_composition_meta (buf, ometa)\' failed", 0B);
        gst_buffer_add_video_overlay_composition_meta (buf, comp2);
        D.23660 = gst_video_overlay_composition_meta_api_get_type ();
        ometa = gst_buffer_get_meta (buf, D.23660);
        D.23656 = ometa->overlay;
        D.23661 = D.23656 == comp2;
        D.23662 = (int) D.23661;
        _fail_unless (D.23662, "libs/video.c", 1161, "Assertion \'ometa->overlay == comp2\' failed", 0B);
        D.23663 = gst_buffer_remove_meta (buf, ometa);
        _fail_unless (D.23663, "libs/video.c", 1162, "Assertion \'gst_buffer_remove_video_overlay_composition_meta (buf, ometa)\' failed", 0B);
        D.23664 = gst_video_overlay_composition_meta_api_get_type ();
        D.23665 = gst_buffer_get_meta (buf, D.23664);
        D.23666 = D.23665 == 0B;
        D.23667 = (int) D.23666;
        _fail_unless (D.23667, "libs/video.c", 1163, "Assertion \'gst_buffer_get_video_overlay_composition_meta (buf) == NULL\' failed", 0B);
        gst_buffer_add_video_overlay_composition_meta (buf, comp2);
        gst_buffer_unref (buf);
        gst_video_overlay_composition_unref (comp2);
        gst_video_overlay_composition_unref (comp1);
      }
    finally
      {
        seq1 = {CLOBBER};
        w = {CLOBBER};
        h = {CLOBBER};
        x = {CLOBBER};
        y = {CLOBBER};
        val = {CLOBBER};
      }
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.7 = _gst_debug_min;
      if (_gst_debug_min.7 > 5) goto <D.23668>; else goto <D.23669>;
      <D.23668>:
      _g_boolean_var_ = 1;
      goto <D.23670>;
      <D.23669>:
      _g_boolean_var_ = 0;
      <D.23670>:
    }
    D.22794 = _g_boolean_var_;
  }
  D.23671 = (long int) D.22794;
  D.23672 = __builtin_expect (D.23671, 0);
  if (D.23672 != 0) goto <D.23673>; else goto <D.23674>;
  <D.23673>:
  check_debug.8 = check_debug;
  gst_debug_log (check_debug.8, 6, "libs/video.c", &__PRETTY_FUNCTION__, 1173, 0B, "cleaning up tasks");
  <D.23674>:
  gst_task_cleanup_all ();
}


gst_video_overlay_composition_ref (struct GstVideoOverlayComposition * comp)
{
  struct GstVideoOverlayComposition * D.23675;

  D.23675 = gst_mini_object_ref (comp);
  return D.23675;
}


gst_buffer_ref (struct GstBuffer * buf)
{
  struct GstBuffer * D.23677;

  D.23677 = gst_mini_object_ref (buf);
  return D.23677;
}


gst_video_overlay_composition_unref (struct GstVideoOverlayComposition * comp)
{
  gst_mini_object_unref (comp);
}


test_video_size_from_caps (int __i__)
{
  int D.22732;
  <unnamed type> _gst_debug_min.17;
  long int D.23683;
  long int D.23684;
  struct GstDebugCategory * check_debug.18;
  long unsigned int _gst_fraction_type.19;
  int D.23689;
  long unsigned int D.23690;
  _Bool D.23691;
  int D.23692;
  int D.22737;
  long int D.23696;
  long int D.23697;
  static const char __PRETTY_FUNCTION__[26] = "test_video_size_from_caps";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.17 = _gst_debug_min;
      if (_gst_debug_min.17 > 4) goto <D.23680>; else goto <D.23681>;
      <D.23680>:
      _g_boolean_var_ = 1;
      goto <D.23682>;
      <D.23681>:
      _g_boolean_var_ = 0;
      <D.23682>:
    }
    D.22732 = _g_boolean_var_;
  }
  D.23683 = (long int) D.22732;
  D.23684 = __builtin_expect (D.23683, 0);
  if (D.23684 != 0) goto <D.23685>; else goto <D.23686>;
  <D.23685>:
  check_debug.18 = check_debug;
  gst_debug_log (check_debug.18, 5, "libs/video.c", &__PRETTY_FUNCTION__, 961, 0B, "test start");
  <D.23686>:
  tcase_fn_start ("test_video_size_from_caps", "libs/video.c", 961);
  {
    struct GstVideoInfo vinfo;
    struct GstCaps * caps;

    try
      {
        _gst_fraction_type.19 = _gst_fraction_type;
        caps = gst_caps_new_simple ("video/x-raw", "format", 64, "YV12", "width", 24, 640, "height", 24, 480, "framerate", _gst_fraction_type.19, 25, 1, 0B);
        gst_video_info_init (&vinfo);
        D.23689 = gst_video_info_from_caps (&vinfo, caps);
        _fail_unless (D.23689, "libs/video.c", 972, "Assertion \'gst_video_info_from_caps (&vinfo, caps)\' failed", 0B);
        D.23690 = vinfo.size;
        D.23691 = D.23690 == 460800;
        D.23692 = (int) D.23691;
        _fail_unless (D.23692, "libs/video.c", 973, "Assertion \'GST_VIDEO_INFO_SIZE (&vinfo) == (640 * 480 * 12 / 8)\' failed", 0B);
        gst_caps_unref (caps);
      }
    finally
      {
        vinfo = {CLOBBER};
      }
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.17 = _gst_debug_min;
      if (_gst_debug_min.17 > 5) goto <D.23693>; else goto <D.23694>;
      <D.23693>:
      _g_boolean_var_ = 1;
      goto <D.23695>;
      <D.23694>:
      _g_boolean_var_ = 0;
      <D.23695>:
    }
    D.22737 = _g_boolean_var_;
  }
  D.23696 = (long int) D.22737;
  D.23697 = __builtin_expect (D.23696, 0);
  if (D.23697 != 0) goto <D.23698>; else goto <D.23699>;
  <D.23698>:
  check_debug.18 = check_debug;
  gst_debug_log (check_debug.18, 6, "libs/video.c", &__PRETTY_FUNCTION__, 978, 0B, "cleaning up tasks");
  <D.23699>:
  gst_task_cleanup_all ();
}


gst_caps_unref (struct GstCaps * caps)
{
  gst_mini_object_unref (caps);
}


test_convert_frame_async (int __i__)
{
  int D.22712;
  <unnamed type> _gst_debug_min.20;
  long int D.23704;
  long int D.23705;
  struct GstDebugCategory * check_debug.21;
  guint8 * D.23709;
  int D.23710;
  sizetype D.23711;
  guint8 * D.23712;
  sizetype D.23713;
  guint8 * D.23714;
  sizetype D.23715;
  guint8 * D.23716;
  sizetype D.23717;
  guint8 * D.23718;
  struct GMainLoop * D.23719;
  struct GstSample * D.23720;
  _Bool D.23721;
  int D.23722;
  struct GError * D.23723;
  _Bool D.23724;
  int D.23725;
  _Bool D.23726;
  int D.23727;
  _Bool D.23728;
  int D.23729;
  int D.22727;
  long int D.23733;
  long int D.23734;
  static const char __PRETTY_FUNCTION__[25] = "test_convert_frame_async";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.20 = _gst_debug_min;
      if (_gst_debug_min.20 > 4) goto <D.23701>; else goto <D.23702>;
      <D.23701>:
      _g_boolean_var_ = 1;
      goto <D.23703>;
      <D.23702>:
      _g_boolean_var_ = 0;
      <D.23703>:
    }
    D.22712 = _g_boolean_var_;
  }
  D.23704 = (long int) D.22712;
  D.23705 = __builtin_expect (D.23704, 0);
  if (D.23705 != 0) goto <D.23706>; else goto <D.23707>;
  <D.23706>:
  check_debug.21 = check_debug;
  gst_debug_log (check_debug.21, 5, "libs/video.c", &__PRETTY_FUNCTION__, 882, 0B, "test start");
  <D.23707>:
  tcase_fn_start ("test_convert_frame_async", "libs/video.c", 882);
  {
    struct GstVideoInfo vinfo;
    struct GstCaps * from_caps;
    struct GstCaps * to_caps;
    struct GstBuffer * from_buffer;
    struct GstSample * from_sample;
    gint i;
    struct GstMapInfo map;
    struct GMainLoop * loop;
    struct ConvertFrameContext cf_data;

    try
      {
        cf_data.loop = 0B;
        cf_data.sample = 0B;
        cf_data.error = 0B;
        gst_debug_set_threshold_for_name ("default", 0);
        from_buffer = gst_buffer_new_allocate (0B, 1228800, 0B);
        gst_buffer_map (from_buffer, &map, 2);
        i = 0;
        goto <D.22724>;
        <D.22723>:
        D.23709 = map.data;
        D.23710 = i * 4;
        D.23711 = (sizetype) D.23710;
        D.23712 = D.23709 + D.23711;
        *D.23712 = 0;
        D.23709 = map.data;
        D.23710 = i * 4;
        D.23711 = (sizetype) D.23710;
        D.23713 = D.23711 + 1;
        D.23714 = D.23709 + D.23713;
        *D.23714 = 255;
        D.23709 = map.data;
        D.23710 = i * 4;
        D.23711 = (sizetype) D.23710;
        D.23715 = D.23711 + 2;
        D.23716 = D.23709 + D.23715;
        *D.23716 = 0;
        D.23709 = map.data;
        D.23710 = i * 4;
        D.23711 = (sizetype) D.23710;
        D.23717 = D.23711 + 3;
        D.23718 = D.23709 + D.23717;
        *D.23718 = 0;
        i = i + 1;
        <D.22724>:
        if (i <= 307199) goto <D.22723>; else goto <D.22725>;
        <D.22725>:
        gst_buffer_unmap (from_buffer, &map);
        gst_video_info_init (&vinfo);
        gst_video_info_set_format (&vinfo, 9, 640, 470);
        vinfo.par_n = 1;
        vinfo.par_d = 1;
        vinfo.fps_n = 25;
        vinfo.fps_d = 1;
        from_caps = gst_video_info_to_caps (&vinfo);
        to_caps = gst_caps_from_string ("something/that, does=(string)not, exist=(boolean)FALSE");
        D.23719 = g_main_loop_new (0B, 0);
        cf_data.loop = D.23719;
        loop = cf_data.loop;
        from_sample = gst_sample_new (from_buffer, from_caps, 0B, 0B);
        gst_buffer_unref (from_buffer);
        gst_caps_unref (from_caps);
        gst_video_convert_sample_async (from_sample, to_caps, 18446744073709551615, convert_sample_async_callback, &cf_data, 0B);
        g_main_loop_run (loop);
        D.23720 = cf_data.sample;
        D.23721 = D.23720 == 0B;
        D.23722 = (int) D.23721;
        _fail_unless (D.23722, "libs/video.c", 931, "Failure \'cf_data.sample != NULL\' occured", 0B);
        D.23723 = cf_data.error;
        D.23724 = D.23723 != 0B;
        D.23725 = (int) D.23724;
        _fail_unless (D.23725, "libs/video.c", 932, "Assertion \'cf_data.error != NULL\' failed", 0B);
        D.23723 = cf_data.error;
        g_error_free (D.23723);
        cf_data.error = 0B;
        gst_caps_unref (to_caps);
        gst_video_info_init (&vinfo);
        gst_video_info_set_format (&vinfo, 2, 240, 320);
        vinfo.par_n = 1;
        vinfo.par_d = 2;
        vinfo.fps_n = 25;
        vinfo.fps_d = 1;
        to_caps = gst_video_info_to_caps (&vinfo);
        gst_video_convert_sample_async (from_sample, to_caps, 18446744073709551615, convert_sample_async_callback, &cf_data, 0B);
        g_main_loop_run (loop);
        D.23720 = cf_data.sample;
        D.23726 = D.23720 != 0B;
        D.23727 = (int) D.23726;
        _fail_unless (D.23727, "libs/video.c", 949, "Assertion \'cf_data.sample != NULL\' failed", 0B);
        D.23723 = cf_data.error;
        D.23728 = D.23723 == 0B;
        D.23729 = (int) D.23728;
        _fail_unless (D.23729, "libs/video.c", 950, "Assertion \'cf_data.error == NULL\' failed", 0B);
        D.23720 = cf_data.sample;
        gst_sample_unref (D.23720);
        gst_caps_unref (to_caps);
        gst_sample_unref (from_sample);
        g_main_loop_unref (loop);
      }
    finally
      {
        vinfo = {CLOBBER};
        map = {CLOBBER};
        cf_data = {CLOBBER};
      }
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.20 = _gst_debug_min;
      if (_gst_debug_min.20 > 5) goto <D.23730>; else goto <D.23731>;
      <D.23730>:
      _g_boolean_var_ = 1;
      goto <D.23732>;
      <D.23731>:
      _g_boolean_var_ = 0;
      <D.23732>:
    }
    D.22727 = _g_boolean_var_;
  }
  D.23733 = (long int) D.22727;
  D.23734 = __builtin_expect (D.23733, 0);
  if (D.23734 != 0) goto <D.23735>; else goto <D.23736>;
  <D.23735>:
  check_debug.21 = check_debug;
  gst_debug_log (check_debug.21, 6, "libs/video.c", &__PRETTY_FUNCTION__, 959, 0B, "cleaning up tasks");
  <D.23736>:
  gst_task_cleanup_all ();
}


convert_sample_async_callback (struct GstSample * sample, struct GError * err, struct ConvertFrameContext * cf_data)
{
  struct GMainLoop * D.23737;

  cf_data->sample = sample;
  cf_data->error = err;
  D.23737 = cf_data->loop;
  g_main_loop_quit (D.23737);
}


gst_sample_unref (struct GstSample * sample)
{
  gst_mini_object_unref (sample);
}


test_convert_frame (int __i__)
{
  int D.22682;
  <unnamed type> _gst_debug_min.22;
  long int D.23742;
  long int D.23743;
  struct GstDebugCategory * check_debug.23;
  guint8 * D.23747;
  int D.23748;
  sizetype D.23749;
  guint8 * D.23750;
  sizetype D.23751;
  guint8 * D.23752;
  sizetype D.23753;
  guint8 * D.23754;
  sizetype D.23755;
  guint8 * D.23756;
  _Bool D.23757;
  int D.23758;
  struct GError * error.24;
  _Bool D.23760;
  int D.23761;
  _Bool D.23762;
  int D.23763;
  _Bool D.23764;
  int D.23765;
  int D.22697;
  long int D.23769;
  long int D.23770;
  static const char __PRETTY_FUNCTION__[19] = "test_convert_frame";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.22 = _gst_debug_min;
      if (_gst_debug_min.22 > 4) goto <D.23739>; else goto <D.23740>;
      <D.23739>:
      _g_boolean_var_ = 1;
      goto <D.23741>;
      <D.23740>:
      _g_boolean_var_ = 0;
      <D.23741>:
    }
    D.22682 = _g_boolean_var_;
  }
  D.23742 = (long int) D.22682;
  D.23743 = __builtin_expect (D.23742, 0);
  if (D.23743 != 0) goto <D.23744>; else goto <D.23745>;
  <D.23744>:
  check_debug.23 = check_debug;
  gst_debug_log (check_debug.23, 5, "libs/video.c", &__PRETTY_FUNCTION__, 797, 0B, "test start");
  <D.23745>:
  tcase_fn_start ("test_convert_frame", "libs/video.c", 797);
  {
    struct GstVideoInfo vinfo;
    struct GstCaps * from_caps;
    struct GstCaps * to_caps;
    struct GstBuffer * from_buffer;
    struct GstSample * from_sample;
    struct GstSample * to_sample;
    struct GError * error;
    gint i;
    struct GstMapInfo map;

    try
      {
        error = 0B;
        gst_debug_set_threshold_for_name ("default", 0);
        from_buffer = gst_buffer_new_allocate (0B, 1228800, 0B);
        gst_buffer_map (from_buffer, &map, 2);
        i = 0;
        goto <D.22694>;
        <D.22693>:
        D.23747 = map.data;
        D.23748 = i * 4;
        D.23749 = (sizetype) D.23748;
        D.23750 = D.23747 + D.23749;
        *D.23750 = 0;
        D.23747 = map.data;
        D.23748 = i * 4;
        D.23749 = (sizetype) D.23748;
        D.23751 = D.23749 + 1;
        D.23752 = D.23747 + D.23751;
        *D.23752 = 255;
        D.23747 = map.data;
        D.23748 = i * 4;
        D.23749 = (sizetype) D.23748;
        D.23753 = D.23749 + 2;
        D.23754 = D.23747 + D.23753;
        *D.23754 = 0;
        D.23747 = map.data;
        D.23748 = i * 4;
        D.23749 = (sizetype) D.23748;
        D.23755 = D.23749 + 3;
        D.23756 = D.23747 + D.23755;
        *D.23756 = 0;
        i = i + 1;
        <D.22694>:
        if (i <= 307199) goto <D.22693>; else goto <D.22695>;
        <D.22695>:
        gst_buffer_unmap (from_buffer, &map);
        gst_video_info_init (&vinfo);
        gst_video_info_set_format (&vinfo, 9, 640, 480);
        vinfo.fps_n = 25;
        vinfo.fps_d = 1;
        vinfo.par_n = 1;
        vinfo.par_d = 1;
        from_caps = gst_video_info_to_caps (&vinfo);
        from_sample = gst_sample_new (from_buffer, from_caps, 0B, 0B);
        to_caps = gst_caps_from_string ("something/that, does=(string)not, exist=(boolean)FALSE");
        to_sample = gst_video_convert_sample (from_sample, to_caps, 18446744073709551615, &error);
        D.23757 = to_sample == 0B;
        D.23758 = (int) D.23757;
        _fail_unless (D.23758, "libs/video.c", 837, "Failure \'to_sample != NULL\' occured", 0B);
        error.24 = error;
        D.23760 = error.24 != 0B;
        D.23761 = (int) D.23760;
        _fail_unless (D.23761, "libs/video.c", 838, "Assertion \'error != NULL\' failed", 0B);
        error.24 = error;
        g_error_free (error.24);
        error = 0B;
        gst_caps_unref (to_caps);
        gst_video_info_set_format (&vinfo, 2, 240, 320);
        vinfo.fps_n = 25;
        vinfo.fps_d = 1;
        vinfo.par_n = 1;
        vinfo.par_d = 2;
        to_caps = gst_video_info_to_caps (&vinfo);
        to_sample = gst_video_convert_sample (from_sample, to_caps, 18446744073709551615, &error);
        D.23762 = to_sample != 0B;
        D.23763 = (int) D.23762;
        _fail_unless (D.23763, "libs/video.c", 853, "Assertion \'to_sample != NULL\' failed", 0B);
        error.24 = error;
        D.23764 = error.24 == 0B;
        D.23765 = (int) D.23764;
        _fail_unless (D.23765, "libs/video.c", 854, "Assertion \'error == NULL\' failed", 0B);
        gst_buffer_unref (from_buffer);
        gst_caps_unref (from_caps);
        gst_sample_unref (from_sample);
        gst_sample_unref (to_sample);
        gst_caps_unref (to_caps);
      }
    finally
      {
        vinfo = {CLOBBER};
        error = {CLOBBER};
        map = {CLOBBER};
      }
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.22 = _gst_debug_min;
      if (_gst_debug_min.22 > 5) goto <D.23766>; else goto <D.23767>;
      <D.23766>:
      _g_boolean_var_ = 1;
      goto <D.23768>;
      <D.23767>:
      _g_boolean_var_ = 0;
      <D.23768>:
    }
    D.22697 = _g_boolean_var_;
  }
  D.23769 = (long int) D.22697;
  D.23770 = __builtin_expect (D.23769, 0);
  if (D.23770 != 0) goto <D.23771>; else goto <D.23772>;
  <D.23771>:
  check_debug.23 = check_debug;
  gst_debug_log (check_debug.23, 6, "libs/video.c", &__PRETTY_FUNCTION__, 863, 0B, "cleaning up tasks");
  <D.23772>:
  gst_task_cleanup_all ();
}


test_events (int __i__)
{
  int D.22672;
  <unnamed type> _gst_debug_min.25;
  long int D.23777;
  long int D.23778;
  struct GstDebugCategory * check_debug.26;
  _Bool D.23782;
  int D.23783;
  int D.23784;
  int D.23785;
  int in_still.27;
  _Bool D.23787;
  int D.23788;
  int D.23789;
  int D.23790;
  _Bool D.23791;
  int D.23792;
  int D.22677;
  long int D.23796;
  long int D.23797;
  static const char __PRETTY_FUNCTION__[12] = "test_events";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.25 = _gst_debug_min;
      if (_gst_debug_min.25 > 4) goto <D.23774>; else goto <D.23775>;
      <D.23774>:
      _g_boolean_var_ = 1;
      goto <D.23776>;
      <D.23775>:
      _g_boolean_var_ = 0;
      <D.23776>:
    }
    D.22672 = _g_boolean_var_;
  }
  D.23777 = (long int) D.22672;
  D.23778 = __builtin_expect (D.23777, 0);
  if (D.23778 != 0) goto <D.23779>; else goto <D.23780>;
  <D.23779>:
  check_debug.26 = check_debug;
  gst_debug_log (check_debug.26, 5, "libs/video.c", &__PRETTY_FUNCTION__, 771, 0B, "test start");
  <D.23780>:
  tcase_fn_start ("test_events", "libs/video.c", 771);
  {
    struct GstEvent * e;
    gboolean in_still;

    try
      {
        e = gst_video_event_new_still_frame (1);
        D.23782 = e != 0B;
        D.23783 = (int) D.23782;
        _fail_unless (D.23783, "libs/video.c", 777, "Failure \'e == NULL\' occured", "Failed to create still frame event", 0B);
        D.23784 = gst_video_event_parse_still_frame (e, &in_still);
        _fail_unless (D.23784, "libs/video.c", 779, "Assertion \'gst_video_event_parse_still_frame (e, &in_still)\' failed", "Failed to parse still frame event", 0B);
        D.23785 = gst_video_event_parse_still_frame (e, 0B);
        _fail_unless (D.23785, "libs/video.c", 781, "Assertion \'gst_video_event_parse_still_frame (e, NULL)\' failed", "Failed to parse still frame event w/ in_still == NULL", 0B);
        in_still.27 = in_still;
        D.23787 = in_still.27 == 1;
        D.23788 = (int) D.23787;
        _fail_unless (D.23788, "libs/video.c", 782, "Assertion \'in_still == TRUE\' failed", 0B);
        gst_event_unref (e);
        e = gst_video_event_new_still_frame (0);
        D.23782 = e != 0B;
        D.23783 = (int) D.23782;
        _fail_unless (D.23783, "libs/video.c", 786, "Failure \'e == NULL\' occured", "Failed to create still frame event", 0B);
        D.23789 = gst_video_event_parse_still_frame (e, &in_still);
        _fail_unless (D.23789, "libs/video.c", 788, "Assertion \'gst_video_event_parse_still_frame (e, &in_still)\' failed", "Failed to parse still frame event", 0B);
        D.23790 = gst_video_event_parse_still_frame (e, 0B);
        _fail_unless (D.23790, "libs/video.c", 790, "Assertion \'gst_video_event_parse_still_frame (e, NULL)\' failed", "Failed to parse still frame event w/ in_still == NULL", 0B);
        in_still.27 = in_still;
        D.23791 = in_still.27 == 0;
        D.23792 = (int) D.23791;
        _fail_unless (D.23792, "libs/video.c", 791, "Assertion \'in_still == FALSE\' failed", 0B);
        gst_event_unref (e);
      }
    finally
      {
        in_still = {CLOBBER};
      }
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.25 = _gst_debug_min;
      if (_gst_debug_min.25 > 5) goto <D.23793>; else goto <D.23794>;
      <D.23793>:
      _g_boolean_var_ = 1;
      goto <D.23795>;
      <D.23794>:
      _g_boolean_var_ = 0;
      <D.23795>:
    }
    D.22677 = _g_boolean_var_;
  }
  D.23796 = (long int) D.22677;
  D.23797 = __builtin_expect (D.23796, 0);
  if (D.23797 != 0) goto <D.23798>; else goto <D.23799>;
  <D.23798>:
  check_debug.26 = check_debug;
  gst_debug_log (check_debug.26, 6, "libs/video.c", &__PRETTY_FUNCTION__, 795, 0B, "cleaning up tasks");
  <D.23799>:
  gst_task_cleanup_all ();
}


gst_event_unref (struct GstEvent * event)
{
  gst_mini_object_unref (event);
}


test_parse_caps_rgb (int __i__)
{
  int D.22642;
  <unnamed type> _gst_debug_min.28;
  long int D.23804;
  long int D.23805;
  struct GstDebugCategory * check_debug.29;
  const gchar * D.23824;
  long unsigned int _gst_fraction_type.30;
  int D.23826;
  int D.23827;
  int D.22653;
  int D.23828;
  long int D.23832;
  long int D.23833;
  int D.22656;
  long int D.23840;
  long int D.23841;
  int D.23844;
  const struct GstVideoFormatInfo * D.23845;
  <unnamed type> D.23846;
  <unnamed type> D.23847;
  _Bool D.23848;
  int D.23849;
  _Bool D.23850;
  int D.23851;
  _Bool D.23852;
  int D.23853;
  _Bool D.23854;
  int D.23855;
  int D.23856;
  unsigned int i.31;
  int D.22667;
  long int D.23861;
  long int D.23862;
  static const char __PRETTY_FUNCTION__[20] = "test_parse_caps_rgb";
  static const char __func__[20] = "test_parse_caps_rgb";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.28 = _gst_debug_min;
      if (_gst_debug_min.28 > 4) goto <D.23801>; else goto <D.23802>;
      <D.23801>:
      _g_boolean_var_ = 1;
      goto <D.23803>;
      <D.23802>:
      _g_boolean_var_ = 0;
      <D.23803>:
    }
    D.22642 = _g_boolean_var_;
  }
  D.23804 = (long int) D.22642;
  D.23805 = __builtin_expect (D.23804, 0);
  if (D.23805 != 0) goto <D.23806>; else goto <D.23807>;
  <D.23806>:
  check_debug.29 = check_debug;
  gst_debug_log (check_debug.29, 5, "libs/video.c", &__PRETTY_FUNCTION__, 705, 0B, "test start");
  <D.23807>:
  tcase_fn_start ("test_parse_caps_rgb", "libs/video.c", 705);
  {
    typedef struct 
  {
    const gchar * tmpl_caps_string;
    GstVideoFormat fmt;
  } struct struct 
  {
    const gchar * tmpl_caps_string;
    GstVideoFormat fmt;
  };
    struct 
  {
    const gchar * tmpl_caps_string;
    GstVideoFormat fmt;
  } formats[14];
    gint i;

    try
      {
        formats = *.LC14;
        i = 0;
        goto <D.22664>;
        <D.22663>:
        {
          struct GstVideoInfo vinfo;
          struct GstCaps * caps;
          struct GstCaps * caps2;

          try
            {
              D.23824 = formats[i].tmpl_caps_string;
              caps = gst_caps_from_string (D.23824);
              _gst_fraction_type.30 = _gst_fraction_type;
              _gst_fraction_type.30 = _gst_fraction_type;
              D.23826 = i + 1;
              D.23826 = i + 1;
              D.23827 = D.23826 * 2;
              gst_caps_set_simple (caps, "width", 24, D.23827, "height", 24, D.23826, "framerate", _gst_fraction_type.30, 15, 1, "pixel-aspect-ratio", _gst_fraction_type.30, 1, 1, "interlace-mode", 64, "progressive", "colorimetry", 64, "1:1:0:0", 0B);
              {
                int _g_boolean_var_;

                {
                  D.23828 = gst_caps_is_fixed (caps);
                  if (D.23828 != 0) goto <D.23829>; else goto <D.23830>;
                  <D.23829>:
                  _g_boolean_var_ = 1;
                  goto <D.23831>;
                  <D.23830>:
                  _g_boolean_var_ = 0;
                  <D.23831>:
                }
                D.22653 = _g_boolean_var_;
              }
              D.23832 = (long int) D.22653;
              D.23833 = __builtin_expect (D.23832, 1);
              if (D.23833 != 0) goto <D.23834>; else goto <D.23835>;
              <D.23834>:
              goto <D.23836>;
              <D.23835>:
              g_assertion_message_expr (0B, "libs/video.c", 747, &__func__, "gst_caps_is_fixed (caps)");
              <D.23836>:
              {
                int _g_boolean_var_;

                {
                  _gst_debug_min.28 = _gst_debug_min;
                  if (_gst_debug_min.28 > 4) goto <D.23837>; else goto <D.23838>;
                  <D.23837>:
                  _g_boolean_var_ = 1;
                  goto <D.23839>;
                  <D.23838>:
                  _g_boolean_var_ = 0;
                  <D.23839>:
                }
                D.22656 = _g_boolean_var_;
              }
              D.23840 = (long int) D.22656;
              D.23841 = __builtin_expect (D.23840, 0);
              if (D.23841 != 0) goto <D.23842>; else goto <D.23843>;
              <D.23842>:
              check_debug.29 = check_debug;
              gst_debug_log (check_debug.29, 5, "libs/video.c", &__PRETTY_FUNCTION__, 749, 0B, "testing caps: %p\7A", caps);
              <D.23843>:
              gst_video_info_init (&vinfo);
              D.23844 = gst_video_info_from_caps (&vinfo, caps);
              _fail_unless (D.23844, "libs/video.c", 752, "Assertion \'gst_video_info_from_caps (&vinfo, caps)\' failed", 0B);
              {
                int first;
                int second;

                D.23845 = vinfo.finfo;
                D.23846 = D.23845->format;
                first = (int) D.23846;
                D.23847 = formats[i].fmt;
                second = (int) D.23847;
                D.23848 = first == second;
                D.23849 = (int) D.23848;
                _fail_unless (D.23849, "libs/video.c", 753, "Assertion \'first == second\' failed", "\'GST_VIDEO_INFO_FORMAT (&vinfo)\' (%d) is not equal to \'formats[i].fmt\' (%d)", first, second, 0B);
              }
              {
                int first;
                int second;

                first = vinfo.width;
                D.23826 = i + 1;
                second = D.23826 * 2;
                D.23850 = first == second;
                D.23851 = (int) D.23850;
                _fail_unless (D.23851, "libs/video.c", 754, "Assertion \'first == second\' failed", "\'GST_VIDEO_INFO_WIDTH (&vinfo)\' (%d) is not equal to \'2 * (i + 1)\' (%d)", first, second, 0B);
              }
              {
                int first;
                int second;

                first = vinfo.height;
                second = i + 1;
                D.23852 = first == second;
                D.23853 = (int) D.23852;
                _fail_unless (D.23853, "libs/video.c", 755, "Assertion \'first == second\' failed", "\'GST_VIDEO_INFO_HEIGHT (&vinfo)\' (%d) is not equal to \'i + 1\' (%d)", first, second, 0B);
              }
              caps2 = gst_video_info_to_caps (&vinfo);
              D.23854 = caps != 0B;
              D.23855 = (int) D.23854;
              _fail_unless (D.23855, "libs/video.c", 759, "Assertion \'caps != NULL\' failed", 0B);
              D.23856 = gst_caps_is_equal (caps, caps2);
              _fail_unless (D.23856, "libs/video.c", 762, "Assertion \'gst_caps_is_equal (caps, caps2)\' failed", "caps [%p\7A] not equal to caps2 [%p\7A]", caps, caps2, 0B);
              gst_caps_unref (caps);
              gst_caps_unref (caps2);
            }
          finally
            {
              vinfo = {CLOBBER};
            }
        }
        i = i + 1;
        <D.22664>:
        i.31 = (unsigned int) i;
        if (i.31 <= 13) goto <D.22663>; else goto <D.22665>;
        <D.22665>:
      }
    finally
      {
        formats = {CLOBBER};
      }
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.28 = _gst_debug_min;
      if (_gst_debug_min.28 > 5) goto <D.23858>; else goto <D.23859>;
      <D.23858>:
      _g_boolean_var_ = 1;
      goto <D.23860>;
      <D.23859>:
      _g_boolean_var_ = 0;
      <D.23860>:
    }
    D.22667 = _g_boolean_var_;
  }
  D.23861 = (long int) D.22667;
  D.23862 = __builtin_expect (D.23861, 0);
  if (D.23862 != 0) goto <D.23863>; else goto <D.23864>;
  <D.23863>:
  check_debug.29 = check_debug;
  gst_debug_log (check_debug.29, 6, "libs/video.c", &__PRETTY_FUNCTION__, 769, 0B, "cleaning up tasks");
  <D.23864>:
  gst_task_cleanup_all ();
}


test_dar_calc (int __i__)
{
  int D.22632;
  <unnamed type> _gst_debug_min.32;
  long int D.23869;
  long int D.23870;
  struct GstDebugCategory * check_debug.33;
  int D.23874;
  int iftmp.34;
  unsigned int display_ratio_n.35;
  unsigned int display_ratio_d.36;
  int D.23882;
  int iftmp.37;
  int D.23888;
  int iftmp.38;
  int D.22637;
  long int D.23897;
  long int D.23898;
  static const char __PRETTY_FUNCTION__[14] = "test_dar_calc";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.32 = _gst_debug_min;
      if (_gst_debug_min.32 > 4) goto <D.23866>; else goto <D.23867>;
      <D.23866>:
      _g_boolean_var_ = 1;
      goto <D.23868>;
      <D.23867>:
      _g_boolean_var_ = 0;
      <D.23868>:
    }
    D.22632 = _g_boolean_var_;
  }
  D.23869 = (long int) D.22632;
  D.23870 = __builtin_expect (D.23869, 0);
  if (D.23870 != 0) goto <D.23871>; else goto <D.23872>;
  <D.23871>:
  check_debug.33 = check_debug;
  gst_debug_log (check_debug.33, 5, "libs/video.c", &__PRETTY_FUNCTION__, 681, 0B, "test start");
  <D.23872>:
  tcase_fn_start ("test_dar_calc", "libs/video.c", 681);
  {
    guint display_ratio_n;
    guint display_ratio_d;

    try
      {
        D.23874 = gst_video_calculate_display_ratio (&display_ratio_n, &display_ratio_d, 768, 576, 16, 15, 16, 15);
        _fail_unless (D.23874, "libs/video.c", 688, "Assertion \'gst_video_calculate_display_ratio (&display_ratio_n, &display_ratio_d, 768, 576, 16, 15, 16, 15)\' failed", 0B);
        display_ratio_n.35 = display_ratio_n;
        if (display_ratio_n.35 == 4) goto <D.23879>; else goto <D.23876>;
        <D.23879>:
        display_ratio_d.36 = display_ratio_d;
        if (display_ratio_d.36 == 3) goto <D.23881>; else goto <D.23876>;
        <D.23881>:
        iftmp.34 = 1;
        goto <D.23877>;
        <D.23876>:
        iftmp.34 = 0;
        <D.23877>:
        _fail_unless (iftmp.34, "libs/video.c", 689, "Assertion \'display_ratio_n == 4 && display_ratio_d == 3\' failed", 0B);
        D.23882 = gst_video_calculate_display_ratio (&display_ratio_n, &display_ratio_d, 720, 480, 32, 27, 1, 1);
        _fail_unless (D.23882, "libs/video.c", 693, "Assertion \'gst_video_calculate_display_ratio (&display_ratio_n, &display_ratio_d, 720, 480, 32, 27, 1, 1)\' failed", 0B);
        display_ratio_n.35 = display_ratio_n;
        if (display_ratio_n.35 == 16) goto <D.23886>; else goto <D.23884>;
        <D.23886>:
        display_ratio_d.36 = display_ratio_d;
        if (display_ratio_d.36 == 9) goto <D.23887>; else goto <D.23884>;
        <D.23887>:
        iftmp.37 = 1;
        goto <D.23885>;
        <D.23884>:
        iftmp.37 = 0;
        <D.23885>:
        _fail_unless (iftmp.37, "libs/video.c", 694, "Assertion \'display_ratio_n == 16 && display_ratio_d == 9\' failed", 0B);
        D.23888 = gst_video_calculate_display_ratio (&display_ratio_n, &display_ratio_d, 360, 288, 533333, 500000, 16, 15);
        _fail_unless (D.23888, "libs/video.c", 699, "Assertion \'gst_video_calculate_display_ratio (&display_ratio_n, &display_ratio_d, 360, 288, 533333, 500000, 16, 15)\' failed", 0B);
        display_ratio_n.35 = display_ratio_n;
        if (display_ratio_n.35 == 1599999) goto <D.23892>; else goto <D.23890>;
        <D.23892>:
        display_ratio_d.36 = display_ratio_d;
        if (display_ratio_d.36 == 1280000) goto <D.23893>; else goto <D.23890>;
        <D.23893>:
        iftmp.38 = 1;
        goto <D.23891>;
        <D.23890>:
        iftmp.38 = 0;
        <D.23891>:
        _fail_unless (iftmp.38, "libs/video.c", 700, "Assertion \'display_ratio_n == 1599999 && display_ratio_d == 1280000\' failed", 0B);
      }
    finally
      {
        display_ratio_n = {CLOBBER};
        display_ratio_d = {CLOBBER};
      }
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.32 = _gst_debug_min;
      if (_gst_debug_min.32 > 5) goto <D.23894>; else goto <D.23895>;
      <D.23894>:
      _g_boolean_var_ = 1;
      goto <D.23896>;
      <D.23895>:
      _g_boolean_var_ = 0;
      <D.23896>:
    }
    D.22637 = _g_boolean_var_;
  }
  D.23897 = (long int) D.22637;
  D.23898 = __builtin_expect (D.23897, 0);
  if (D.23898 != 0) goto <D.23899>; else goto <D.23900>;
  <D.23899>:
  check_debug.33 = check_debug;
  gst_debug_log (check_debug.33, 6, "libs/video.c", &__PRETTY_FUNCTION__, 703, 0B, "cleaning up tasks");
  <D.23900>:
  gst_task_cleanup_all ();
}


test_video_formats_pack_unpack (int __i__)
{
  int D.22492;
  <unnamed type> _gst_debug_min.39;
  long int D.23905;
  long int D.23906;
  struct GstDebugCategory * check_debug.40;
  const gchar * D.23910;
  _Bool D.23911;
  int D.23912;
  int D.22500;
  long int D.23916;
  long int D.23917;
  int D.22513;
  long int D.23923;
  long int D.23924;
  const gchar * D.23927;
  _Bool D.23928;
  int D.23929;
  <unnamed type> D.23930;
  _Bool D.23931;
  int D.23932;
  int D.22515;
  int D.23933;
  long int D.23937;
  long int D.23938;
  unsigned int D.23942;
  unsigned int D.23943;
  unsigned int D.23944;
  unsigned int D.23945;
  long unsigned int D.23946;
  void * D.23947;
  int D.23948;
  const struct GstVideoFormatInfo * D.23949;
  unsigned int D.23950;
  void (*<T36d4>) (const struct GstVideoFormatInfo *, GstVideoPackFlags, void *, void * const *, const gint *, gint, gint, gint) D.23951;
  void (*<T36dd>) (const struct GstVideoFormatInfo *, GstVideoPackFlags, void * const, gint, void * *, const gint *, GstVideoChromaSite, gint, gint) D.23952;
  int D.23953;
  int D.22524;
  long int D.23957;
  long int D.23958;
  static const char __PRETTY_FUNCTION__[31] = "test_video_formats_pack_unpack";
  static const char __func__[31] = "test_video_formats_pack_unpack";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.39 = _gst_debug_min;
      if (_gst_debug_min.39 > 4) goto <D.23902>; else goto <D.23903>;
      <D.23902>:
      _g_boolean_var_ = 1;
      goto <D.23904>;
      <D.23903>:
      _g_boolean_var_ = 0;
      <D.23904>:
    }
    D.22492 = _g_boolean_var_;
  }
  D.23905 = (long int) D.22492;
  D.23906 = __builtin_expect (D.23905, 0);
  if (D.23906 != 0) goto <D.23907>; else goto <D.23908>;
  <D.23907>:
  check_debug.40 = check_debug;
  gst_debug_log (check_debug.40, 5, "libs/video.c", &__PRETTY_FUNCTION__, 409, 0B, "test start");
  <D.23908>:
  tcase_fn_start ("test_video_formats_pack_unpack", "libs/video.c", 409);
  {
    guint n;
    guint num_formats;

    num_formats = 100;
    D.23910 = gst_video_format_to_string (num_formats);
    D.23911 = D.23910 == 0B;
    D.23912 = (int) D.23911;
    _fail_unless (D.23912, "libs/video.c", 414, "Assertion \'gst_video_format_to_string (num_formats) == NULL\' failed", 0B);
    goto <D.22497>;
    <D.22496>:
    num_formats = num_formats + 4294967295;
    <D.22497>:
    D.23910 = gst_video_format_to_string (num_formats);
    if (D.23910 == 0B) goto <D.22496>; else goto <D.22498>;
    <D.22498>:
    {
      int _g_boolean_var_;

      {
        _gst_debug_min.39 = _gst_debug_min;
        if (_gst_debug_min.39 > 3) goto <D.23913>; else goto <D.23914>;
        <D.23913>:
        _g_boolean_var_ = 1;
        goto <D.23915>;
        <D.23914>:
        _g_boolean_var_ = 0;
        <D.23915>:
      }
      D.22500 = _g_boolean_var_;
    }
    D.23916 = (long int) D.22500;
    D.23917 = __builtin_expect (D.23916, 0);
    if (D.23917 != 0) goto <D.23918>; else goto <D.23919>;
    <D.23918>:
    check_debug.40 = check_debug;
    gst_debug_log (check_debug.40, 4, "libs/video.c", &__PRETTY_FUNCTION__, 417, 0B, "number of known video formats: %d", num_formats);
    <D.23919>:
    n = 2;
    goto <D.22521>;
    <D.22520>:
    {
      const struct GstVideoFormatInfo * vfinfo;
      const struct GstVideoFormatInfo * unpackinfo;
      GstVideoFormat fmt;
      struct GstVideoInfo vinfo;
      void * data[4];
      gint stride[4];
      guint8 * vdata;
      guint8 * unpack_data;
      gsize vsize;
      gsize unpack_size;
      guint p;

      try
        {
          fmt = n;
          {
            int _g_boolean_var_;

            {
              _gst_debug_min.39 = _gst_debug_min;
              if (_gst_debug_min.39 > 3) goto <D.23920>; else goto <D.23921>;
              <D.23920>:
              _g_boolean_var_ = 1;
              goto <D.23922>;
              <D.23921>:
              _g_boolean_var_ = 0;
              <D.23922>:
            }
            D.22513 = _g_boolean_var_;
          }
          D.23923 = (long int) D.22513;
          D.23924 = __builtin_expect (D.23923, 0);
          if (D.23924 != 0) goto <D.23925>; else goto <D.23926>;
          <D.23925>:
          D.23927 = gst_video_format_to_string (fmt);
          check_debug.40 = check_debug;
          gst_debug_log (check_debug.40, 4, "libs/video.c", &__PRETTY_FUNCTION__, 429, 0B, "testing %s", D.23927);
          <D.23926>:
          vfinfo = gst_video_format_get_info (fmt);
          D.23928 = vfinfo != 0B;
          D.23929 = (int) D.23928;
          _fail_unless (D.23929, "libs/video.c", 432, "Assertion \'vfinfo != NULL\' failed", 0B);
          D.23930 = vfinfo->unpack_format;
          unpackinfo = gst_video_format_get_info (D.23930);
          D.23931 = unpackinfo != 0B;
          D.23932 = (int) D.23931;
          _fail_unless (D.23932, "libs/video.c", 435, "Assertion \'unpackinfo != NULL\' failed", 0B);
          gst_video_info_init (&vinfo);
          gst_video_info_set_format (&vinfo, fmt, 77, 20);
          vsize = vinfo.size;
          vdata = g_malloc (vsize);
          memset (vdata, 153, vsize);
          {
            int _g_boolean_var_;

            {
              D.23933 = vfinfo->pack_lines;
              if (D.23933 == 1) goto <D.23934>; else goto <D.23935>;
              <D.23934>:
              _g_boolean_var_ = 1;
              goto <D.23936>;
              <D.23935>:
              _g_boolean_var_ = 0;
              <D.23936>:
            }
            D.22515 = _g_boolean_var_;
          }
          D.23937 = (long int) D.22515;
          D.23938 = __builtin_expect (D.23937, 1);
          if (D.23938 != 0) goto <D.23939>; else goto <D.23940>;
          <D.23939>:
          goto <D.23941>;
          <D.23940>:
          g_assertion_message_expr (0B, "libs/video.c", 443, &__func__, "vfinfo->pack_lines == 1");
          <D.23941>:
          D.23942 = unpackinfo->bits;
          D.23943 = unpackinfo->n_components;
          D.23944 = D.23942 * D.23943;
          D.23945 = D.23944 * 80;
          unpack_size = (gsize) D.23945;
          unpack_data = g_malloc (unpack_size);
          p = 0;
          goto <D.22518>;
          <D.22517>:
          D.23946 = vinfo.offset[p];
          D.23947 = vdata + D.23946;
          data[p] = D.23947;
          D.23948 = vinfo.stride[p];
          stride[p] = D.23948;
          p = p + 1;
          <D.22518>:
          D.23949 = vinfo.finfo;
          D.23950 = D.23949->n_planes;
          if (D.23950 > p) goto <D.22517>; else goto <D.22519>;
          <D.22519>:
          D.23951 = vfinfo->unpack_func;
          D.23951 (vfinfo, 0, unpack_data, &data, &stride, 0, 0, 77);
          D.23952 = vfinfo->pack_func;
          D.23953 = (int) unpack_size;
          D.23952 (vfinfo, 0, unpack_data, D.23953, &data, &stride, 0, 0, 77);
          D.23951 = vfinfo->unpack_func;
          D.23951 (vfinfo, 0, unpack_data, &data, &stride, 0, 19, 77);
          D.23952 = vfinfo->pack_func;
          D.23953 = (int) unpack_size;
          D.23952 (vfinfo, 0, unpack_data, D.23953, &data, &stride, 0, 19, 77);
          g_free (unpack_data);
          g_free (vdata);
        }
      finally
        {
          vinfo = {CLOBBER};
          data = {CLOBBER};
          stride = {CLOBBER};
        }
    }
    n = n + 1;
    <D.22521>:
    if (n < num_formats) goto <D.22520>; else goto <D.22522>;
    <D.22522>:
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.39 = _gst_debug_min;
      if (_gst_debug_min.39 > 5) goto <D.23954>; else goto <D.23955>;
      <D.23954>:
      _g_boolean_var_ = 1;
      goto <D.23956>;
      <D.23955>:
      _g_boolean_var_ = 0;
      <D.23956>:
    }
    D.22524 = _g_boolean_var_;
  }
  D.23957 = (long int) D.22524;
  D.23958 = __builtin_expect (D.23957, 0);
  if (D.23958 != 0) goto <D.23959>; else goto <D.23960>;
  <D.23959>:
  check_debug.40 = check_debug;
  gst_debug_log (check_debug.40, 6, "libs/video.c", &__PRETTY_FUNCTION__, 478, 0B, "cleaning up tasks");
  <D.23960>:
  gst_task_cleanup_all ();
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.23963;
  int D.23968;
  void * D.23970;
  long unsigned int D.23971;

  D.23963 = __builtin_constant_p (__len);
  if (D.23963 != 0) goto <D.23964>; else goto <D.23965>;
  <D.23964>:
  if (__len == 0) goto <D.23966>; else goto <D.23967>;
  <D.23966>:
  D.23968 = __builtin_constant_p (__ch);
  if (D.23968 == 0) goto <D.23961>; else goto <D.23969>;
  <D.23969>:
  if (__ch != 0) goto <D.23961>; else goto <D.23962>;
  <D.23961>:
  __warn_memset_zero_len ();
  D.23970 = __dest;
  return D.23970;
  <D.23962>:
  <D.23967>:
  <D.23965>:
  D.23971 = __builtin_object_size (__dest, 0);
  D.23970 = __builtin___memset_chk (__dest, __ch, __len, D.23971);
  return D.23970;
}


test_video_formats_all (int __i__)
{
  int D.22460;
  <unnamed type> _gst_debug_min.41;
  long int D.23977;
  long int D.23978;
  struct GstDebugCategory * check_debug.42;
  const gchar * D.23982;
  _Bool D.23983;
  int D.23984;
  int D.22473;
  long int D.23988;
  long int D.23989;
  _Bool D.23992;
  int D.23993;
  int iftmp.43;
  long unsigned int D.23998;
  long unsigned int _gst_value_list_type.44;
  _Bool D.24001;
  int D.24002;
  gboolean D.22478;
  long unsigned int D.24006;
  int D.22480;
  long int D.24013;
  long int D.24014;
  <unnamed type> D.24017;
  _Bool D.24018;
  int D.24019;
  unsigned int D.24020;
  _Bool D.24021;
  int D.24022;
  int D.22487;
  long int D.24026;
  long int D.24027;
  static const char __PRETTY_FUNCTION__[23] = "test_video_formats_all";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.41 = _gst_debug_min;
      if (_gst_debug_min.41 > 4) goto <D.23974>; else goto <D.23975>;
      <D.23974>:
      _g_boolean_var_ = 1;
      goto <D.23976>;
      <D.23975>:
      _g_boolean_var_ = 0;
      <D.23976>:
    }
    D.22460 = _g_boolean_var_;
  }
  D.23977 = (long int) D.22460;
  D.23978 = __builtin_expect (D.23977, 0);
  if (D.23978 != 0) goto <D.23979>; else goto <D.23980>;
  <D.23979>:
  check_debug.42 = check_debug;
  gst_debug_log (check_debug.42, 5, "libs/video.c", &__PRETTY_FUNCTION__, 368, 0B, "test start");
  <D.23980>:
  tcase_fn_start ("test_video_formats_all", "libs/video.c", 368);
  {
    struct GstStructure * s;
    const struct GValue * val;
    const struct GValue * list_val;
    struct GstCaps * caps;
    guint num;
    guint n;
    guint num_formats;

    num_formats = 100;
    D.23982 = gst_video_format_to_string (num_formats);
    D.23983 = D.23982 == 0B;
    D.23984 = (int) D.23983;
    _fail_unless (D.23984, "libs/video.c", 376, "Assertion \'gst_video_format_to_string (num_formats) == NULL\' failed", 0B);
    goto <D.22470>;
    <D.22469>:
    num_formats = num_formats + 4294967295;
    <D.22470>:
    D.23982 = gst_video_format_to_string (num_formats);
    if (D.23982 == 0B) goto <D.22469>; else goto <D.22471>;
    <D.22471>:
    {
      int _g_boolean_var_;

      {
        _gst_debug_min.41 = _gst_debug_min;
        if (_gst_debug_min.41 > 3) goto <D.23985>; else goto <D.23986>;
        <D.23985>:
        _g_boolean_var_ = 1;
        goto <D.23987>;
        <D.23986>:
        _g_boolean_var_ = 0;
        <D.23987>:
      }
      D.22473 = _g_boolean_var_;
    }
    D.23988 = (long int) D.22473;
    D.23989 = __builtin_expect (D.23988, 0);
    if (D.23989 != 0) goto <D.23990>; else goto <D.23991>;
    <D.23990>:
    check_debug.42 = check_debug;
    gst_debug_log (check_debug.42, 4, "libs/video.c", &__PRETTY_FUNCTION__, 379, 0B, "number of known video formats: %d", num_formats);
    <D.23991>:
    caps = gst_caps_from_string ("video/x-raw, format={ I420, YV12, YUY2, UYVY, AYUV, RGBx, BGRx, xRGB, xBGR, RGBA, BGRA, ARGB, ABGR, RGB, BGR, Y41B, Y42B, YVYU, Y444, v210, v216, NV12, NV21, NV16, NV24, GRAY8, GRAY16_BE, GRAY16_LE, v308, RGB16, BGR16, RGB15, BGR15, UYVP, A420, RGB8P, YUV9, YVU9, IYU1, ARGB64, AYUV64, r210, I420_10LE, I420_10BE, I422_10LE, I422_10BE,  Y444_10LE, Y444_10BE, GBR, GBR_10LE, GBR_10BE, NV12_64Z32 }");
    s = gst_caps_get_structure (caps, 0);
    val = gst_structure_get_value (s, "format");
    D.23992 = val != 0B;
    D.23993 = (int) D.23992;
    _fail_unless (D.23993, "libs/video.c", 384, "Assertion \'val != NULL\' failed", 0B);
    if (val != 0B) goto <D.23997>; else goto <D.23995>;
    <D.23997>:
    D.23998 = MEM[(struct GValue *)val].g_type;
    _gst_value_list_type.44 = _gst_value_list_type;
    if (D.23998 == _gst_value_list_type.44) goto <D.24000>; else goto <D.23995>;
    <D.24000>:
    iftmp.43 = 1;
    goto <D.23996>;
    <D.23995>:
    iftmp.43 = 0;
    <D.23996>:
    _fail_unless (iftmp.43, "libs/video.c", 385, "Assertion \'GST_VALUE_HOLDS_LIST (val)\' failed", 0B);
    num = gst_value_list_get_size (val);
    D.24001 = num != 0;
    D.24002 = (int) D.24001;
    _fail_unless (D.24002, "libs/video.c", 387, "Assertion \'num > 0\' failed", 0B);
    n = 0;
    goto <D.22482>;
    <D.22481>:
    {
      const gchar * fmt_str;

      list_val = gst_value_list_get_value (val, n);
      {
        struct GValue * __val;
        GType __t;
        gboolean __r;

        __val = list_val;
        __t = 64;
        {
          if (__val == 0B) goto <D.24003>; else goto <D.24004>;
          <D.24003>:
          __r = 0;
          goto <D.24005>;
          <D.24004>:
          D.24006 = __val->g_type;
          if (D.24006 == __t) goto <D.24007>; else goto <D.24008>;
          <D.24007>:
          __r = 1;
          goto <D.24009>;
          <D.24008>:
          __r = g_type_check_value_holds (__val, __t);
          <D.24009>:
          <D.24005>:
        }
        D.22478 = __r;
      }
      _fail_unless (D.22478, "libs/video.c", 392, "Assertion \'G_VALUE_HOLDS_STRING (list_val)\' failed", 0B);
      fmt_str = g_value_get_string (list_val);
      {
        int _g_boolean_var_;

        {
          _gst_debug_min.41 = _gst_debug_min;
          if (_gst_debug_min.41 > 3) goto <D.24010>; else goto <D.24011>;
          <D.24010>:
          _g_boolean_var_ = 1;
          goto <D.24012>;
          <D.24011>:
          _g_boolean_var_ = 0;
          <D.24012>:
        }
        D.22480 = _g_boolean_var_;
      }
      D.24013 = (long int) D.22480;
      D.24014 = __builtin_expect (D.24013, 0);
      if (D.24014 != 0) goto <D.24015>; else goto <D.24016>;
      <D.24015>:
      check_debug.42 = check_debug;
      gst_debug_log (check_debug.42, 4, "libs/video.c", &__PRETTY_FUNCTION__, 394, 0B, "format: %s", fmt_str);
      <D.24016>:
      D.24017 = gst_video_format_from_string (fmt_str);
      D.24018 = D.24017 != 0;
      D.24019 = (int) D.24018;
      _fail_unless (D.24019, "libs/video.c", 396, "Failure \'gst_video_format_from_string (fmt_str) == GST_VIDEO_FORMAT_UNKNOWN\' occured", 0B);
    }
    n = n + 1;
    <D.22482>:
    if (n < num) goto <D.22481>; else goto <D.22483>;
    <D.22483>:
    {
      int first;
      int second;

      first = (int) num;
      D.24020 = num_formats + 4294967295;
      second = (int) D.24020;
      D.24021 = first == second;
      D.24022 = (int) D.24021;
      _fail_unless (D.24022, "libs/video.c", 399, "Assertion \'first == second\' failed", "\'num\' (%d) is not equal to \'num_formats - 1\' (%d)", first, second, 0B);
    }
    gst_caps_unref (caps);
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.41 = _gst_debug_min;
      if (_gst_debug_min.41 > 5) goto <D.24023>; else goto <D.24024>;
      <D.24023>:
      _g_boolean_var_ = 1;
      goto <D.24025>;
      <D.24024>:
      _g_boolean_var_ = 0;
      <D.24025>:
    }
    D.22487 = _g_boolean_var_;
  }
  D.24026 = (long int) D.22487;
  D.24027 = __builtin_expect (D.24026, 0);
  if (D.24027 != 0) goto <D.24028>; else goto <D.24029>;
  <D.24028>:
  check_debug.42 = check_debug;
  gst_debug_log (check_debug.42, 6, "libs/video.c", &__PRETTY_FUNCTION__, 404, 0B, "cleaning up tasks");
  <D.24029>:
  gst_task_cleanup_all ();
}


test_video_formats_rgba_large_dimension (int __i__)
{
  int D.22615;
  <unnamed type> _gst_debug_min.45;
  long int D.24034;
  long int D.24035;
  struct GstDebugCategory * check_debug.46;
  int D.24039;
  int D.24040;
  int D.24041;
  int D.24042;
  int width.47;
  _Bool D.24044;
  int D.24045;
  int height.48;
  _Bool D.24047;
  int D.24048;
  int framerate_n.49;
  _Bool D.24050;
  int D.24051;
  int framerate_d.50;
  _Bool D.24053;
  int D.24054;
  int par_n.51;
  _Bool D.24056;
  int D.24057;
  int par_d.52;
  _Bool D.24059;
  int D.24060;
  long unsigned int D.24061;
  _Bool D.24062;
  int D.24063;
  int D.22627;
  long int D.24067;
  long int D.24068;
  static const char __PRETTY_FUNCTION__[40] = "test_video_formats_rgba_large_dimension";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.45 = _gst_debug_min;
      if (_gst_debug_min.45 > 4) goto <D.24031>; else goto <D.24032>;
      <D.24031>:
      _g_boolean_var_ = 1;
      goto <D.24033>;
      <D.24032>:
      _g_boolean_var_ = 0;
      <D.24033>:
    }
    D.22615 = _g_boolean_var_;
  }
  D.24034 = (long int) D.22615;
  D.24035 = __builtin_expect (D.24034, 0);
  if (D.24035 != 0) goto <D.24036>; else goto <D.24037>;
  <D.24036>:
  check_debug.46 = check_debug;
  gst_debug_log (check_debug.46, 5, "libs/video.c", &__PRETTY_FUNCTION__, 645, 0B, "test start");
  <D.24037>:
  tcase_fn_start ("test_video_formats_rgba_large_dimension", "libs/video.c", 645);
  {
    struct GstVideoInfo vinfo;
    gint width;
    gint height;
    gint framerate_n;
    gint framerate_d;
    gint par_n;
    gint par_d;
    struct GstCaps * caps;
    struct GstStructure * structure;

    try
      {
        gst_video_info_init (&vinfo);
        gst_video_info_set_format (&vinfo, 11, 29700, 21000);
        vinfo.par_n = 1;
        vinfo.par_d = 1;
        vinfo.fps_n = 0;
        vinfo.fps_d = 1;
        caps = gst_video_info_to_caps (&vinfo);
        structure = gst_caps_get_structure (caps, 0);
        D.24039 = gst_structure_get_int (structure, "width", &width);
        _fail_unless (D.24039, "libs/video.c", 661, "Assertion \'gst_structure_get_int (structure, \"width\", &width)\' failed", 0B);
        D.24040 = gst_structure_get_int (structure, "height", &height);
        _fail_unless (D.24040, "libs/video.c", 662, "Assertion \'gst_structure_get_int (structure, \"height\", &height)\' failed", 0B);
        D.24041 = gst_structure_get_fraction (structure, "framerate", &framerate_n, &framerate_d);
        _fail_unless (D.24041, "libs/video.c", 664, "Assertion \'gst_structure_get_fraction (structure, \"framerate\", &framerate_n, &framerate_d)\' failed", 0B);
        D.24042 = gst_structure_get_fraction (structure, "pixel-aspect-ratio", &par_n, &par_d);
        _fail_unless (D.24042, "libs/video.c", 666, "Assertion \'gst_structure_get_fraction (structure, \"pixel-aspect-ratio\", &par_n, &par_d)\' failed", 0B);
        width.47 = width;
        D.24044 = width.47 == 29700;
        D.24045 = (int) D.24044;
        _fail_unless (D.24045, "libs/video.c", 668, "Assertion \'width == 29700\' failed", 0B);
        height.48 = height;
        D.24047 = height.48 == 21000;
        D.24048 = (int) D.24047;
        _fail_unless (D.24048, "libs/video.c", 669, "Assertion \'height == 21000\' failed", 0B);
        framerate_n.49 = framerate_n;
        D.24050 = framerate_n.49 == 0;
        D.24051 = (int) D.24050;
        _fail_unless (D.24051, "libs/video.c", 670, "Assertion \'framerate_n == 0\' failed", 0B);
        framerate_d.50 = framerate_d;
        D.24053 = framerate_d.50 == 1;
        D.24054 = (int) D.24053;
        _fail_unless (D.24054, "libs/video.c", 671, "Assertion \'framerate_d == 1\' failed", 0B);
        par_n.51 = par_n;
        D.24056 = par_n.51 == 1;
        D.24057 = (int) D.24056;
        _fail_unless (D.24057, "libs/video.c", 672, "Assertion \'par_n == 1\' failed", 0B);
        par_d.52 = par_d;
        D.24059 = par_d.52 == 1;
        D.24060 = (int) D.24059;
        _fail_unless (D.24060, "libs/video.c", 673, "Assertion \'par_d == 1\' failed", 0B);
        D.24061 = vinfo.size;
        D.24062 = D.24061 == 2494800000;
        D.24063 = (int) D.24062;
        _fail_unless (D.24063, "libs/video.c", 674, "Assertion \'vinfo.size == (gsize) 29700 * 21000 * 4\' failed", 0B);
        gst_caps_unref (caps);
      }
    finally
      {
        vinfo = {CLOBBER};
        width = {CLOBBER};
        height = {CLOBBER};
        framerate_n = {CLOBBER};
        framerate_d = {CLOBBER};
        par_n = {CLOBBER};
        par_d = {CLOBBER};
      }
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.45 = _gst_debug_min;
      if (_gst_debug_min.45 > 5) goto <D.24064>; else goto <D.24065>;
      <D.24064>:
      _g_boolean_var_ = 1;
      goto <D.24066>;
      <D.24065>:
      _g_boolean_var_ = 0;
      <D.24066>:
    }
    D.22627 = _g_boolean_var_;
  }
  D.24067 = (long int) D.22627;
  D.24068 = __builtin_expect (D.24067, 0);
  if (D.24068 != 0) goto <D.24069>; else goto <D.24070>;
  <D.24069>:
  check_debug.46 = check_debug;
  gst_debug_log (check_debug.46, 6, "libs/video.c", &__PRETTY_FUNCTION__, 679, 0B, "cleaning up tasks");
  <D.24070>:
  gst_task_cleanup_all ();
}


test_video_formats_rgb (int __i__)
{
  int D.22598;
  <unnamed type> _gst_debug_min.53;
  long int D.24075;
  long int D.24076;
  struct GstDebugCategory * check_debug.54;
  int D.24080;
  int D.24081;
  int D.24082;
  int D.24083;
  int width.55;
  _Bool D.24085;
  int D.24086;
  int height.56;
  _Bool D.24088;
  int D.24089;
  int framerate_n.57;
  _Bool D.24091;
  int D.24092;
  int framerate_d.58;
  _Bool D.24094;
  int D.24095;
  int par_n.59;
  _Bool D.24097;
  int D.24098;
  int par_d.60;
  _Bool D.24100;
  int D.24101;
  int D.22610;
  long int D.24105;
  long int D.24106;
  static const char __PRETTY_FUNCTION__[23] = "test_video_formats_rgb";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.53 = _gst_debug_min;
      if (_gst_debug_min.53 > 4) goto <D.24072>; else goto <D.24073>;
      <D.24072>:
      _g_boolean_var_ = 1;
      goto <D.24074>;
      <D.24073>:
      _g_boolean_var_ = 0;
      <D.24074>:
    }
    D.22598 = _g_boolean_var_;
  }
  D.24075 = (long int) D.22598;
  D.24076 = __builtin_expect (D.24075, 0);
  if (D.24076 != 0) goto <D.24077>; else goto <D.24078>;
  <D.24077>:
  check_debug.54 = check_debug;
  gst_debug_log (check_debug.54, 5, "libs/video.c", &__PRETTY_FUNCTION__, 609, 0B, "test start");
  <D.24078>:
  tcase_fn_start ("test_video_formats_rgb", "libs/video.c", 609);
  {
    struct GstVideoInfo vinfo;
    gint width;
    gint height;
    gint framerate_n;
    gint framerate_d;
    gint par_n;
    gint par_d;
    struct GstCaps * caps;
    struct GstStructure * structure;

    try
      {
        gst_video_info_init (&vinfo);
        gst_video_info_set_format (&vinfo, 15, 800, 600);
        vinfo.par_n = 1;
        vinfo.par_d = 1;
        vinfo.fps_n = 0;
        vinfo.fps_d = 1;
        caps = gst_video_info_to_caps (&vinfo);
        structure = gst_caps_get_structure (caps, 0);
        D.24080 = gst_structure_get_int (structure, "width", &width);
        _fail_unless (D.24080, "libs/video.c", 625, "Assertion \'gst_structure_get_int (structure, \"width\", &width)\' failed", 0B);
        D.24081 = gst_structure_get_int (structure, "height", &height);
        _fail_unless (D.24081, "libs/video.c", 626, "Assertion \'gst_structure_get_int (structure, \"height\", &height)\' failed", 0B);
        D.24082 = gst_structure_get_fraction (structure, "framerate", &framerate_n, &framerate_d);
        _fail_unless (D.24082, "libs/video.c", 628, "Assertion \'gst_structure_get_fraction (structure, \"framerate\", &framerate_n, &framerate_d)\' failed", 0B);
        D.24083 = gst_structure_get_fraction (structure, "pixel-aspect-ratio", &par_n, &par_d);
        _fail_unless (D.24083, "libs/video.c", 630, "Assertion \'gst_structure_get_fraction (structure, \"pixel-aspect-ratio\", &par_n, &par_d)\' failed", 0B);
        width.55 = width;
        D.24085 = width.55 == 800;
        D.24086 = (int) D.24085;
        _fail_unless (D.24086, "libs/video.c", 632, "Assertion \'width == 800\' failed", 0B);
        height.56 = height;
        D.24088 = height.56 == 600;
        D.24089 = (int) D.24088;
        _fail_unless (D.24089, "libs/video.c", 633, "Assertion \'height == 600\' failed", 0B);
        framerate_n.57 = framerate_n;
        D.24091 = framerate_n.57 == 0;
        D.24092 = (int) D.24091;
        _fail_unless (D.24092, "libs/video.c", 634, "Assertion \'framerate_n == 0\' failed", 0B);
        framerate_d.58 = framerate_d;
        D.24094 = framerate_d.58 == 1;
        D.24095 = (int) D.24094;
        _fail_unless (D.24095, "libs/video.c", 635, "Assertion \'framerate_d == 1\' failed", 0B);
        par_n.59 = par_n;
        D.24097 = par_n.59 == 1;
        D.24098 = (int) D.24097;
        _fail_unless (D.24098, "libs/video.c", 636, "Assertion \'par_n == 1\' failed", 0B);
        par_d.60 = par_d;
        D.24100 = par_d.60 == 1;
        D.24101 = (int) D.24100;
        _fail_unless (D.24101, "libs/video.c", 637, "Assertion \'par_d == 1\' failed", 0B);
        gst_caps_unref (caps);
      }
    finally
      {
        vinfo = {CLOBBER};
        width = {CLOBBER};
        height = {CLOBBER};
        framerate_n = {CLOBBER};
        framerate_d = {CLOBBER};
        par_n = {CLOBBER};
        par_d = {CLOBBER};
      }
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.53 = _gst_debug_min;
      if (_gst_debug_min.53 > 5) goto <D.24102>; else goto <D.24103>;
      <D.24102>:
      _g_boolean_var_ = 1;
      goto <D.24104>;
      <D.24103>:
      _g_boolean_var_ = 0;
      <D.24104>:
    }
    D.22610 = _g_boolean_var_;
  }
  D.24105 = (long int) D.22610;
  D.24106 = __builtin_expect (D.24105, 0);
  if (D.24106 != 0) goto <D.24107>; else goto <D.24108>;
  <D.24107>:
  check_debug.54 = check_debug;
  gst_debug_log (check_debug.54, 6, "libs/video.c", &__PRETTY_FUNCTION__, 642, 0B, "cleaning up tasks");
  <D.24108>:
  gst_task_cleanup_all ();
}


test_video_formats (int __i__)
{
  int D.22529;
  <unnamed type> _gst_debug_min.61;
  long int D.24113;
  long int D.24114;
  struct GstDebugCategory * check_debug.62;
  char D.24118;
  int D.24119;
  const gchar * D.24120;
  char D.24121;
  int D.24122;
  int D.24123;
  int D.24124;
  const gchar * D.24125;
  char D.24126;
  int D.24127;
  int D.24128;
  int D.24129;
  const gchar * D.24130;
  char D.24131;
  int D.24132;
  int D.24133;
  int D.24134;
  int D.22539;
  long int D.24140;
  long int D.24141;
  const char * D.24144;
  _Bool D.24145;
  int D.24146;
  <unnamed type> D.24147;
  _Bool D.24148;
  int D.24149;
  int D.22544;
  long int D.24153;
  long int D.24154;
  int D.24157;
  <unnamed type> D.24158;
  int D.24159;
  int D.24160;
  void (*<T3b5d>) (struct paintinfo *, unsigned char *) D.24161;
  unsigned char * D.24162;
  int D.24165;
  unsigned int D.24167;
  _Bool D.24168;
  int D.24169;
  int D.22558;
  long int D.24173;
  long int D.24174;
  int w.63;
  int h.64;
  const struct GstVideoFormatInfo * D.24179;
  unsigned int D.24180;
  _Bool D.24181;
  int D.24182;
  int D.24183;
  unsigned int D.24186;
  unsigned int D.24189;
  _Bool D.24190;
  int D.24191;
  unsigned int D.24192;
  _Bool D.24193;
  int D.24194;
  long unsigned int D.24195;
  long unsigned int D.24196;
  unsigned int D.24197;
  unsigned int D.24198;
  long unsigned int D.24199;
  unsigned int D.24200;
  unsigned int D.24201;
  long unsigned int D.24202;
  unsigned int D.24203;
  unsigned int D.24204;
  int D.22566;
  long int D.24208;
  long int D.24209;
  unsigned char * D.24212;
  long int D.24213;
  int D.24214;
  int D.22568;
  long int D.24218;
  long int D.24219;
  unsigned char * D.24222;
  long int D.24223;
  int D.24224;
  int D.22570;
  long int D.24228;
  long int D.24229;
  unsigned char * D.24232;
  long int D.24233;
  int D.24234;
  int D.22572;
  long int D.24238;
  long int D.24239;
  unsigned char * D.24242;
  long int D.24243;
  int D.24244;
  _Bool D.24245;
  int D.24246;
  _Bool D.24247;
  int D.24248;
  _Bool D.24249;
  int D.24250;
  _Bool D.24251;
  int D.24252;
  unsigned int D.24253;
  long unsigned int D.24254;
  unsigned int D.24255;
  unsigned int D.24256;
  unsigned char * D.24257;
  long int D.24258;
  _Bool D.24259;
  int D.24260;
  int D.24261;
  int D.24262;
  unsigned int D.24263;
  int D.24264;
  int D.24265;
  int D.24266;
  int D.24267;
  unsigned int D.24268;
  int D.24269;
  int D.24270;
  int D.24271;
  unsigned int D.24272;
  int D.24273;
  int D.24274;
  unsigned int D.24275;
  int D.24276;
  int D.24277;
  int D.24278;
  unsigned int D.24279;
  int D.24280;
  int D.24281;
  unsigned int D.24282;
  int D.24283;
  int D.24284;
  int D.24285;
  int D.24286;
  _Bool D.24289;
  int D.24290;
  <unnamed type> D.24291;
  unsigned int D.24292;
  unsigned int D.24295;
  int D.24296;
  int D.24297;
  int D.24298;
  _Bool D.24299;
  int D.24300;
  _Bool D.24301;
  int D.24302;
  _Bool D.24303;
  int D.24304;
  _Bool D.24305;
  int D.24306;
  unsigned int D.24307;
  unsigned int D.24308;
  unsigned int D.24309;
  _Bool D.24310;
  int D.24311;
  _Bool D.24313;
  int D.24314;
  int D.22593;
  long int D.24318;
  long int D.24319;
  static const char __PRETTY_FUNCTION__[19] = "test_video_formats";

  {
    int _g_boolean_var_;

    {
      _gst_debug_min.61 = _gst_debug_min;
      if (_gst_debug_min.61 > 4) goto <D.24110>; else goto <D.24111>;
      <D.24110>:
      _g_boolean_var_ = 1;
      goto <D.24112>;
      <D.24111>:
      _g_boolean_var_ = 0;
      <D.24112>:
    }
    D.22529 = _g_boolean_var_;
  }
  D.24113 = (long int) D.22529;
  D.24114 = __builtin_expect (D.24113, 0);
  if (D.24114 != 0) goto <D.24115>; else goto <D.24116>;
  <D.24115>:
  check_debug.62 = check_debug;
  gst_debug_log (check_debug.62, 5, "libs/video.c", &__PRETTY_FUNCTION__, 480, 0B, "test start");
  <D.24116>:
  tcase_fn_start ("test_video_formats", "libs/video.c", 480);
  {
    guint i;

    i = 0;
    goto <D.22590>;
    <D.22589>:
    {
      const struct GstVideoFormatInfo * vf_info;
      GstVideoFormat fmt;
      const gchar * s;
      guint32 fourcc;
      guint w;
      guint h;

      s = fourcc_list[i].fourcc;
      D.24118 = *s;
      D.24119 = (int) D.24118;
      D.24120 = s + 1;
      D.24121 = *D.24120;
      D.24122 = (int) D.24121;
      D.24123 = D.24122 << 8;
      D.24124 = D.24119 | D.24123;
      D.24125 = s + 2;
      D.24126 = *D.24125;
      D.24127 = (int) D.24126;
      D.24128 = D.24127 << 16;
      D.24129 = D.24124 | D.24128;
      D.24130 = s + 3;
      D.24131 = *D.24130;
      D.24132 = (int) D.24131;
      D.24133 = D.24132 << 24;
      D.24134 = D.24129 | D.24133;
      fourcc = (guint32) D.24134;
      fmt = gst_video_format_from_fourcc (fourcc);
      if (fmt == 0) goto <D.24135>; else goto <D.24136>;
      <D.24135>:
      {
        int _g_boolean_var_;

        {
          _gst_debug_min.61 = _gst_debug_min;
          if (_gst_debug_min.61 > 4) goto <D.24137>; else goto <D.24138>;
          <D.24137>:
          _g_boolean_var_ = 1;
          goto <D.24139>;
          <D.24138>:
          _g_boolean_var_ = 0;
          <D.24139>:
        }
        D.22539 = _g_boolean_var_;
      }
      D.24140 = (long int) D.22539;
      D.24141 = __builtin_expect (D.24140, 0);
      if (D.24141 != 0) goto <D.24142>; else goto <D.24143>;
      <D.24142>:
      D.24144 = fourcc_list[i].fourcc;
      check_debug.62 = check_debug;
      gst_debug_log (check_debug.62, 5, "libs/video.c", &__PRETTY_FUNCTION__, 496, 0B, "Unknown format %s, skipping tests", D.24144);
      <D.24143>:
      // predicted unlikely by continue predictor.
      goto <D.22540>;
      <D.24136>:
      vf_info = gst_video_format_get_info (fmt);
      D.24145 = vf_info != 0B;
      D.24146 = (int) D.24145;
      _fail_unless (D.24146, "libs/video.c", 501, "Assertion \'vf_info != NULL\' failed", 0B);
      {
        int first;
        int second;

        D.24147 = vf_info->format;
        first = (int) D.24147;
        second = (int) fmt;
        D.24148 = first == second;
        D.24149 = (int) D.24148;
        _fail_unless (D.24149, "libs/video.c", 503, "Assertion \'first == second\' failed", "\'GST_VIDEO_FORMAT_INFO_FORMAT (vf_info)\' (%d) is not equal to \'fmt\' (%d)", first, second, 0B);
      }
      {
        int _g_boolean_var_;

        {
          _gst_debug_min.61 = _gst_debug_min;
          if (_gst_debug_min.61 > 3) goto <D.24150>; else goto <D.24151>;
          <D.24150>:
          _g_boolean_var_ = 1;
          goto <D.24152>;
          <D.24151>:
          _g_boolean_var_ = 0;
          <D.24152>:
        }
        D.22544 = _g_boolean_var_;
      }
      D.24153 = (long int) D.22544;
      D.24154 = __builtin_expect (D.24153, 0);
      if (D.24154 != 0) goto <D.24155>; else goto <D.24156>;
      <D.24155>:
      D.24157 = video_format_is_packed (fmt);
      D.24144 = fourcc_list[i].fourcc;
      check_debug.62 = check_debug;
      gst_debug_log (check_debug.62, 4, "libs/video.c", &__PRETTY_FUNCTION__, 506, 0B, "Fourcc %s, packed=%d", D.24144, D.24157);
      <D.24156>:
      D.24158 = vf_info->flags;
      D.24159 = (int) D.24158;
      D.24160 = D.24159 & 1;
      _fail_unless (D.24160, "libs/video.c", 508, "Assertion \'GST_VIDEO_FORMAT_INFO_IS_YUV (vf_info)\' failed", 0B);
      {
        struct paintinfo paintinfo;

        try
          {
            paintinfo = {};
            D.24161 = fourcc_list[i].paint_setup;
            D.24161 (&paintinfo, s);
            D.24162 = paintinfo.ap;
            if (D.24162 != 0B) goto <D.24163>; else goto <D.24164>;
            <D.24163>:
            D.24158 = vf_info->flags;
            D.24159 = (int) D.24158;
            D.24165 = D.24159 & 8;
            _fail_unless (D.24165, "libs/video.c", 515, "Assertion \'GST_VIDEO_FORMAT_INFO_HAS_ALPHA (vf_info)\' failed", 0B);
            goto <D.24166>;
            <D.24164>:
            D.24158 = vf_info->flags;
            D.24167 = D.24158 & 8;
            D.24168 = D.24167 == 0;
            D.24169 = (int) D.24168;
            _fail_unless (D.24169, "libs/video.c", 517, "Failure \'GST_VIDEO_FORMAT_INFO_HAS_ALPHA (vf_info)\' occured", 0B);
            <D.24166>:
          }
        finally
          {
            paintinfo = {CLOBBER};
          }
      }
      w = 1;
      goto <D.22587>;
      <D.22586>:
      h = 1;
      goto <D.22584>;
      <D.22583>:
      {
        struct GstVideoInfo vinfo;
        struct paintinfo paintinfo;
        guint off0;
        guint off1;
        guint off2;
        guint off3;
        guint cs0;
        guint cs1;
        guint cs2;
        guint cs3;
        guint size;

        try
          {
            paintinfo = {};
            {
              int _g_boolean_var_;

              {
                _gst_debug_min.61 = _gst_debug_min;
                if (_gst_debug_min.61 > 5) goto <D.24170>; else goto <D.24171>;
                <D.24170>:
                _g_boolean_var_ = 1;
                goto <D.24172>;
                <D.24171>:
                _g_boolean_var_ = 0;
                <D.24172>:
              }
              D.22558 = _g_boolean_var_;
            }
            D.24173 = (long int) D.22558;
            D.24174 = __builtin_expect (D.24173, 0);
            if (D.24174 != 0) goto <D.24175>; else goto <D.24176>;
            <D.24175>:
            D.24144 = fourcc_list[i].fourcc;
            check_debug.62 = check_debug;
            gst_debug_log (check_debug.62, 6, "libs/video.c", &__PRETTY_FUNCTION__, 529, 0B, "%s, %dx%d", D.24144, w, h);
            <D.24176>:
            gst_video_info_init (&vinfo);
            gst_video_info_set_format (&vinfo, fmt, w, h);
            w.63 = (int) w;
            paintinfo.width = w.63;
            h.64 = (int) h;
            paintinfo.height = h.64;
            D.24161 = fourcc_list[i].paint_setup;
            D.24161 (&paintinfo, 0B);
            {
              int first;
              int second;

              D.24179 = vinfo.finfo;
              D.24180 = D.24179->plane[0];
              first = vinfo.stride[D.24180];
              second = paintinfo.ystride;
              D.24181 = first == second;
              D.24182 = (int) D.24181;
              _fail_unless (D.24182, "libs/video.c", 538, "Assertion \'first == second\' failed", "\'GST_VIDEO_INFO_COMP_STRIDE (&vinfo, 0)\' (%d) is not equal to \'paintinfo.ystride\' (%d)", first, second, 0B);
            }
            D.24183 = video_format_is_packed (fmt);
            if (D.24183 == 0) goto <D.24184>; else goto <D.24185>;
            <D.24184>:
            D.24179 = vinfo.finfo;
            D.24186 = D.24179->n_planes;
            if (D.24186 <= 2) goto <D.24187>; else goto <D.24188>;
            <D.24187>:
            {
              int first;
              int second;

              D.24179 = vinfo.finfo;
              D.24189 = D.24179->plane[1];
              first = vinfo.stride[D.24189];
              second = paintinfo.ustride;
              D.24190 = first == second;
              D.24191 = (int) D.24190;
              _fail_unless (D.24191, "libs/video.c", 543, "Assertion \'first == second\' failed", "\'GST_VIDEO_INFO_COMP_STRIDE (&vinfo, 1)\' (%d) is not equal to \'paintinfo.ustride\' (%d)", first, second, 0B);
            }
            {
              int first;
              int second;

              D.24179 = vinfo.finfo;
              D.24192 = D.24179->plane[2];
              first = vinfo.stride[D.24192];
              second = paintinfo.vstride;
              D.24193 = first == second;
              D.24194 = (int) D.24193;
              _fail_unless (D.24194, "libs/video.c", 545, "Assertion \'first == second\' failed", "\'GST_VIDEO_INFO_COMP_STRIDE (&vinfo, 2)\' (%d) is not equal to \'paintinfo.vstride\' (%d)", first, second, 0B);
            }
            <D.24188>:
            <D.24185>:
            D.24195 = vinfo.size;
            size = (guint) D.24195;
            D.24179 = vinfo.finfo;
            D.24180 = D.24179->plane[0];
            D.24196 = vinfo.offset[D.24180];
            D.24197 = (unsigned int) D.24196;
            D.24179 = vinfo.finfo;
            D.24198 = D.24179->poffset[0];
            off0 = D.24197 + D.24198;
            D.24179 = vinfo.finfo;
            D.24189 = D.24179->plane[1];
            D.24199 = vinfo.offset[D.24189];
            D.24200 = (unsigned int) D.24199;
            D.24179 = vinfo.finfo;
            D.24201 = D.24179->poffset[1];
            off1 = D.24200 + D.24201;
            D.24179 = vinfo.finfo;
            D.24192 = D.24179->plane[2];
            D.24202 = vinfo.offset[D.24192];
            D.24203 = (unsigned int) D.24202;
            D.24179 = vinfo.finfo;
            D.24204 = D.24179->poffset[2];
            off2 = D.24203 + D.24204;
            {
              int _g_boolean_var_;

              {
                _gst_debug_min.61 = _gst_debug_min;
                if (_gst_debug_min.61 > 3) goto <D.24205>; else goto <D.24206>;
                <D.24205>:
                _g_boolean_var_ = 1;
                goto <D.24207>;
                <D.24206>:
                _g_boolean_var_ = 0;
                <D.24207>:
              }
              D.22566 = _g_boolean_var_;
            }
            D.24208 = (long int) D.22566;
            D.24209 = __builtin_expect (D.24208, 0);
            if (D.24209 != 0) goto <D.24210>; else goto <D.24211>;
            <D.24210>:
            D.24212 = paintinfo.endptr;
            D.24213 = (long int) D.24212;
            D.24214 = (int) D.24213;
            check_debug.62 = check_debug;
            gst_debug_log (check_debug.62, 4, "libs/video.c", &__PRETTY_FUNCTION__, 554, 0B, "size %d <> %d", size, D.24214);
            <D.24211>:
            {
              int _g_boolean_var_;

              {
                _gst_debug_min.61 = _gst_debug_min;
                if (_gst_debug_min.61 > 3) goto <D.24215>; else goto <D.24216>;
                <D.24215>:
                _g_boolean_var_ = 1;
                goto <D.24217>;
                <D.24216>:
                _g_boolean_var_ = 0;
                <D.24217>:
              }
              D.22568 = _g_boolean_var_;
            }
            D.24218 = (long int) D.22568;
            D.24219 = __builtin_expect (D.24218, 0);
            if (D.24219 != 0) goto <D.24220>; else goto <D.24221>;
            <D.24220>:
            D.24222 = paintinfo.yp;
            D.24223 = (long int) D.24222;
            D.24224 = (int) D.24223;
            check_debug.62 = check_debug;
            gst_debug_log (check_debug.62, 4, "libs/video.c", &__PRETTY_FUNCTION__, 555, 0B, "off0 %d <> %d", off0, D.24224);
            <D.24221>:
            {
              int _g_boolean_var_;

              {
                _gst_debug_min.61 = _gst_debug_min;
                if (_gst_debug_min.61 > 3) goto <D.24225>; else goto <D.24226>;
                <D.24225>:
                _g_boolean_var_ = 1;
                goto <D.24227>;
                <D.24226>:
                _g_boolean_var_ = 0;
                <D.24227>:
              }
              D.22570 = _g_boolean_var_;
            }
            D.24228 = (long int) D.22570;
            D.24229 = __builtin_expect (D.24228, 0);
            if (D.24229 != 0) goto <D.24230>; else goto <D.24231>;
            <D.24230>:
            D.24232 = paintinfo.up;
            D.24233 = (long int) D.24232;
            D.24234 = (int) D.24233;
            check_debug.62 = check_debug;
            gst_debug_log (check_debug.62, 4, "libs/video.c", &__PRETTY_FUNCTION__, 556, 0B, "off1 %d <> %d", off1, D.24234);
            <D.24231>:
            {
              int _g_boolean_var_;

              {
                _gst_debug_min.61 = _gst_debug_min;
                if (_gst_debug_min.61 > 3) goto <D.24235>; else goto <D.24236>;
                <D.24235>:
                _g_boolean_var_ = 1;
                goto <D.24237>;
                <D.24236>:
                _g_boolean_var_ = 0;
                <D.24237>:
              }
              D.22572 = _g_boolean_var_;
            }
            D.24238 = (long int) D.22572;
            D.24239 = __builtin_expect (D.24238, 0);
            if (D.24239 != 0) goto <D.24240>; else goto <D.24241>;
            <D.24240>:
            D.24242 = paintinfo.vp;
            D.24243 = (long int) D.24242;
            D.24244 = (int) D.24243;
            check_debug.62 = check_debug;
            gst_debug_log (check_debug.62, 4, "libs/video.c", &__PRETTY_FUNCTION__, 557, 0B, "off2 %d <> %d", off2, D.24244);
            <D.24241>:
            {
              int first;
              int second;

              first = (int) size;
              D.24212 = paintinfo.endptr;
              D.24213 = (long int) D.24212;
              second = (int) D.24213;
              D.24245 = first == second;
              D.24246 = (int) D.24245;
              _fail_unless (D.24246, "libs/video.c", 559, "Assertion \'first == second\' failed", "\'size\' (%d) is not equal to \'(unsigned long) paintinfo.endptr\' (%d)", first, second, 0B);
            }
            {
              int first;
              int second;

              first = (int) off0;
              D.24222 = paintinfo.yp;
              D.24223 = (long int) D.24222;
              second = (int) D.24223;
              D.24247 = first == second;
              D.24248 = (int) D.24247;
              _fail_unless (D.24248, "libs/video.c", 560, "Assertion \'first == second\' failed", "\'off0\' (%d) is not equal to \'(unsigned long) paintinfo.yp\' (%d)", first, second, 0B);
            }
            {
              int first;
              int second;

              first = (int) off1;
              D.24232 = paintinfo.up;
              D.24233 = (long int) D.24232;
              second = (int) D.24233;
              D.24249 = first == second;
              D.24250 = (int) D.24249;
              _fail_unless (D.24250, "libs/video.c", 561, "Assertion \'first == second\' failed", "\'off1\' (%d) is not equal to \'(unsigned long) paintinfo.up\' (%d)", first, second, 0B);
            }
            {
              int first;
              int second;

              first = (int) off2;
              D.24242 = paintinfo.vp;
              D.24243 = (long int) D.24242;
              second = (int) D.24243;
              D.24251 = first == second;
              D.24252 = (int) D.24251;
              _fail_unless (D.24252, "libs/video.c", 562, "Assertion \'first == second\' failed", "\'off2\' (%d) is not equal to \'(unsigned long) paintinfo.vp\' (%d)", first, second, 0B);
            }
            D.24179 = vinfo.finfo;
            D.24253 = D.24179->plane[3];
            D.24254 = vinfo.offset[D.24253];
            D.24255 = (unsigned int) D.24254;
            D.24179 = vinfo.finfo;
            D.24256 = D.24179->poffset[3];
            off3 = D.24255 + D.24256;
            {
              int first;
              int second;

              first = (int) off3;
              D.24257 = paintinfo.ap;
              D.24258 = (long int) D.24257;
              second = (int) D.24258;
              D.24259 = first == second;
              D.24260 = (int) D.24259;
              _fail_unless (D.24260, "libs/video.c", 566, "Assertion \'first == second\' failed", "\'off3\' (%d) is not equal to \'(unsigned long) paintinfo.ap\' (%d)", first, second, 0B);
            }
            D.24261 = vinfo.width;
            D.24262 = -D.24261;
            D.24179 = vinfo.finfo;
            D.24263 = D.24179->w_sub[0];
            D.24264 = (int) D.24263;
            D.24265 = D.24262 >> D.24264;
            D.24266 = vinfo.height;
            D.24267 = -D.24266;
            D.24179 = vinfo.finfo;
            D.24268 = D.24179->h_sub[0];
            D.24269 = (int) D.24268;
            D.24270 = D.24267 >> D.24269;
            D.24271 = D.24265 * D.24270;
            cs0 = (guint) D.24271;
            D.24261 = vinfo.width;
            D.24262 = -D.24261;
            D.24179 = vinfo.finfo;
            D.24272 = D.24179->w_sub[1];
            D.24273 = (int) D.24272;
            D.24274 = D.24262 >> D.24273;
            D.24266 = vinfo.height;
            D.24267 = -D.24266;
            D.24179 = vinfo.finfo;
            D.24275 = D.24179->h_sub[1];
            D.24276 = (int) D.24275;
            D.24277 = D.24267 >> D.24276;
            D.24278 = D.24274 * D.24277;
            cs1 = (guint) D.24278;
            D.24261 = vinfo.width;
            D.24262 = -D.24261;
            D.24179 = vinfo.finfo;
            D.24279 = D.24179->w_sub[2];
            D.24280 = (int) D.24279;
            D.24281 = D.24262 >> D.24280;
            D.24266 = vinfo.height;
            D.24267 = -D.24266;
            D.24179 = vinfo.finfo;
            D.24282 = D.24179->h_sub[2];
            D.24283 = (int) D.24282;
            D.24284 = D.24267 >> D.24283;
            D.24285 = D.24281 * D.24284;
            cs2 = (guint) D.24285;
            D.24286 = video_format_is_packed (fmt);
            if (D.24286 == 0) goto <D.24287>; else goto <D.24288>;
            <D.24287>:
            D.24289 = cs0 <= off1;
            D.24290 = (int) D.24289;
            _fail_unless (D.24290, "libs/video.c", 579, "Assertion \'cs0 <= off1\' failed", 0B);
            <D.24288>:
            D.24179 = vinfo.finfo;
            D.24291 = D.24179->flags;
            D.24292 = D.24291 & 8;
            if (D.24292 != 0) goto <D.24293>; else goto <D.24294>;
            <D.24293>:
            D.24261 = vinfo.width;
            D.24262 = -D.24261;
            D.24179 = vinfo.finfo;
            D.24295 = D.24179->w_sub[3];
            D.24296 = (int) D.24295;
            D.24297 = D.24262 >> D.24296;
            D.24266 = vinfo.height;
            D.24267 = -D.24266;
            D.24179 = vinfo.finfo;
            D.24282 = D.24179->h_sub[2];
            D.24283 = (int) D.24282;
            D.24284 = D.24267 >> D.24283;
            D.24298 = D.24297 * D.24284;
            cs3 = (guint) D.24298;
            D.24299 = cs3 < size;
            D.24300 = (int) D.24299;
            _fail_unless (D.24300, "libs/video.c", 584, "Assertion \'cs3 < size\' failed", 0B);
            D.24301 = cs1 <= cs0;
            D.24302 = (int) D.24301;
            _fail_unless (D.24302, "libs/video.c", 586, "Failure \'cs1 > cs0\' occured", "cs1 (%d) should be <= cs0 (%d)", cs1, cs0, 0B);
            D.24303 = cs2 <= cs0;
            D.24304 = (int) D.24303;
            _fail_unless (D.24304, "libs/video.c", 587, "Failure \'cs2 > cs0\' occured", "cs2 (%d) should be <= cs0 (%d)", cs2, cs0, 0B);
            D.24305 = cs3 <= cs0;
            D.24306 = (int) D.24305;
            _fail_unless (D.24306, "libs/video.c", 588, "Failure \'cs3 > cs0\' occured", "cs3 (%d) should be <= cs0 (%d)", cs3, cs0, 0B);
            D.24307 = cs0 + cs1;
            D.24308 = D.24307 + cs2;
            D.24309 = D.24308 + cs3;
            D.24310 = D.24309 <= size;
            D.24311 = (int) D.24310;
            _fail_unless (D.24311, "libs/video.c", 591, "Assertion \'cs0 + cs1 + cs2 + cs3 <= size\' failed", 0B);
            goto <D.24312>;
            <D.24294>:
            D.24301 = cs1 <= cs0;
            D.24302 = (int) D.24301;
            _fail_unless (D.24302, "libs/video.c", 594, "Failure \'cs1 > cs0\' occured", "cs1 (%d) should be <= cs0 (%d)", cs1, cs0, 0B);
            D.24303 = cs2 <= cs0;
            D.24304 = (int) D.24303;
            _fail_unless (D.24304, "libs/video.c", 595, "Failure \'cs2 > cs0\' occured", "cs2 (%d) should be <= cs0 (%d)", cs2, cs0, 0B);
            D.24307 = cs0 + cs1;
            D.24308 = D.24307 + cs2;
            D.24313 = D.24308 <= size;
            D.24314 = (int) D.24313;
            _fail_unless (D.24314, "libs/video.c", 600, "Assertion \'cs0 + cs1 + cs2 <= size\' failed", "cs0 (%d) + cs1 (%d) + cs2 (%d) should be <= size (%d)", cs0, cs1, cs2, size, 0B);
            <D.24312>:
          }
        finally
          {
            vinfo = {CLOBBER};
            paintinfo = {CLOBBER};
          }
      }
      h = h + 1;
      <D.22584>:
      if (h <= 65) goto <D.22583>; else goto <D.22585>;
      <D.22585>:
      w = w + 1;
      <D.22587>:
      if (w <= 65) goto <D.22586>; else goto <D.22588>;
      <D.22588>:
    }
    <D.22540>:
    i = i + 1;
    <D.22590>:
    if (i <= 13) goto <D.22589>; else goto <D.22591>;
    <D.22591>:
  }
  {
    int _g_boolean_var_;

    {
      _gst_debug_min.61 = _gst_debug_min;
      if (_gst_debug_min.61 > 5) goto <D.24315>; else goto <D.24316>;
      <D.24315>:
      _g_boolean_var_ = 1;
      goto <D.24317>;
      <D.24316>:
      _g_boolean_var_ = 0;
      <D.24317>:
    }
    D.22593 = _g_boolean_var_;
  }
  D.24318 = (long int) D.22593;
  D.24319 = __builtin_expect (D.24318, 0);
  if (D.24319 != 0) goto <D.24320>; else goto <D.24321>;
  <D.24320>:
  check_debug.62 = check_debug;
  gst_debug_log (check_debug.62, 6, "libs/video.c", &__PRETTY_FUNCTION__, 607, 0B, "cleaning up tasks");
  <D.24321>:
  gst_task_cleanup_all ();
}


video_format_is_packed (GstVideoFormat fmt)
{
  gboolean D.24322;
  static const char __func__[23] = "video_format_is_packed";

  switch (fmt) <default: <D.22454>, case 2: <D.22431>, case 3: <D.22432>, case 4: <D.22439>, case 5: <D.22441>, case 6: <D.22442>, case 7: <D.22443>, case 8: <D.22444>, case 9: <D.22445>, case 10: <D.22446>, case 11: <D.22447>, case 12: <D.22448>, case 13: <D.22449>, case 14: <D.22450>, case 15: <D.22451>, case 16: <D.22452>, case 17: <D.22433>, case 18: <D.22434>, case 19: <D.22440>, case 25: <D.22435>, case 35: <D.22453>, case 36: <D.22436>, case 37: <D.22437>, case 38: <D.22438>>
  <D.22431>:
  <D.22432>:
  <D.22433>:
  <D.22434>:
  <D.22435>:
  <D.22436>:
  <D.22437>:
  D.24322 = 0;
  return D.24322;
  <D.22438>:
  <D.22439>:
  <D.22440>:
  <D.22441>:
  <D.22442>:
  <D.22443>:
  <D.22444>:
  <D.22445>:
  <D.22446>:
  <D.22447>:
  <D.22448>:
  <D.22449>:
  <D.22450>:
  <D.22451>:
  <D.22452>:
  <D.22453>:
  D.24322 = 1;
  return D.24322;
  <D.22454>:
  g_log (0B, 8, "file %s: line %d (%s): should not be reached", "libs/video.c", 363, &__func__);
  D.24322 = 0;
  return D.24322;
  D.24322 = 0;
  return D.24322;
}


__gst_tcase_add_test (struct TCase * tc, void (*TFun) (int) tf, const char * fname, int signal, int allowed_exit_value, int start, int end)
{
  int D.24324;

  D.24324 = _gst_check_run_test_func (fname);
  if (D.24324 != 0) goto <D.24325>; else goto <D.24326>;
  <D.24325>:
  _tcase_add_test (tc, tf, fname, signal, allowed_exit_value, start, end);
  <D.24326>:
}


