yuvscaler_resample.c

Motion JPEG编解码器源代码

      if (interlaced == Y4M_ILACE_NONE)
	{
	  mjpeg_debug ("Non-interlaced downscaling");
	  for (out_line_slice = 0; out_line_slice < local_out_nb_line_slice;
	       out_line_slice++)
	    {
	      input_line_p[0] =
		input + (4 * out_line_slice + 0) * local_input_width;
	      input_line_p[1] =
		input + (4 * out_line_slice + 1) * local_input_width;
	      input_line_p[2] =
		input + (4 * out_line_slice + 2) * local_input_width;
	      input_line_p[3] =
		input + (4 * out_line_slice + 3) * local_input_width;
	      output_line_p[0] =
		output + 3 * out_line_slice * local_output_width;
	      output_line_p[1] = output_line_p[0] + local_output_width;
	      output_line_p[2] = output_line_p[1] + local_output_width;
	      for (out_col = 0; out_col < local_output_active_width;
		   out_col++)
		{
		  *(output_line_p[0]++) =
		    divide[3 * (*input_line_p[0]++) + (*input_line_p[1])];
		  *(output_line_p[1]++) =
		    divide[2 * (*input_line_p[1]++) + 2 * (*input_line_p[2])];
		  *(output_line_p[2]++) =
		    divide[(*input_line_p[2]++) + 3 * (*input_line_p[3]++)];
		}
	    }
	}
      else
	{
	  mjpeg_debug ("Interlaced downscaling");
	  for (out_line_slice = 0; out_line_slice < local_out_nb_line_slice;
	       out_line_slice++)
	    {
	      u_c_p =
		input +
		((out_line_slice & ~(unsigned int) 1) * input_height_slice +
		 (out_line_slice % 2)) * local_input_width;
	      for (in_line = 0; in_line < input_height_slice; in_line++)
		{
		  input_line_p[in_line] = u_c_p;
		  u_c_p += 2 * local_input_width;
		}
	      u_c_p =
		output +
		((out_line_slice & ~(unsigned int) 1) *
		 output_height_slice +
		 (out_line_slice % 2)) * local_output_width;
	      for (out_line = 0; out_line < output_height_slice; out_line++)
		{
		  output_line_p[out_line] = u_c_p;
		  u_c_p += 2 * local_output_width;
		}

	      for (out_col = 0; out_col < local_output_active_width;
		   out_col++)
		{
		  *(output_line_p[0]++) =
		    divide[3 * (*input_line_p[0]++) + (*input_line_p[1])];
		  *(output_line_p[1]++) =
		    divide[2 * (*input_line_p[1]++) + 2 * (*input_line_p[2])];
		  *(output_line_p[2]++) =
		    divide[(*input_line_p[2]++) + 3 * (*input_line_p[3]++)];
		}
	    }
	}
    }


  if (specific == 8)
    {
      // Special FASTWIDE2VCD mode: 2 to 1 for width, and 8 to 3 for height
      // *8 is replaced by <<3 and 2* by <<1
      // Drawback: slight distortion on width
      // Coefficient for horizontal downscaling : (3,3,2), (1,3,3,1), (2,3,3)
      treatment = 8;
      if (interlaced == Y4M_ILACE_NONE)
	{
	  mjpeg_debug ("Non-interlaced downscaling");
	  for (out_line_slice = 0; out_line_slice < local_out_nb_line_slice;
	       out_line_slice++)
	    {
	      input_line_p[0] =
		input + (8 * out_line_slice + 0) * local_input_width;
	      input_line_p[1] =
		input + (8 * out_line_slice + 1) * local_input_width;
	      input_line_p[2] =
		input + (8 * out_line_slice + 2) * local_input_width;
	      input_line_p[3] =
		input + (8 * out_line_slice + 3) * local_input_width;
	      input_line_p[4] =
		input + (8 * out_line_slice + 4) * local_input_width;
	      input_line_p[5] =
		input + (8 * out_line_slice + 5) * local_input_width;
	      input_line_p[6] =
		input + (8 * out_line_slice + 6) * local_input_width;
	      input_line_p[7] =
		input + (8 * out_line_slice + 7) * local_input_width;
	      output_line_p[0] =
		output + out_line_slice * 3 * local_output_width;
	      output_line_p[1] = output_line_p[0] + local_output_width;
	      output_line_p[2] = output_line_p[1] + local_output_width;
	      for (out_col = 0; out_col < local_output_active_width;
		   out_col++)
		{
		  *(output_line_p[0]++) =
		    divide[3 * (*input_line_p[0] + (*input_line_p[0] + 1)) +
			   3 * (*input_line_p[1] + (*input_line_p[1] + 1)) +
			   2 * (*input_line_p[2] + (*input_line_p[2] + 1))];
		  input_line_p[0] += 2;
		  input_line_p[1] += 2;
		  *(output_line_p[1]++) = divide[(*input_line_p[2] +
						  (*input_line_p[2] + 1)) +
						 3 * (*input_line_p[3] +
						      (*input_line_p[3] +
						       1)) +
						 3 * (*input_line_p[4] +
						      (*input_line_p[4] +
						       1)) +
						 (*input_line_p[5] +
						  (*input_line_p[5] + 1))];
		  input_line_p[2] += 2;
		  input_line_p[3] += 2;
		  input_line_p[4] += 2;
		  *(output_line_p[2]++) =
		    divide[2 * (*input_line_p[5] + (*input_line_p[5] + 1)) +
			   3 * (*input_line_p[6] + (*input_line_p[6] + 1)) +
			   3 * (*input_line_p[7] + (*input_line_p[7] + 1))];
		  input_line_p[5] += 2;
		  input_line_p[6] += 2;
		  input_line_p[7] += 2;
		}
	    }
	}
      else
	{
	  mjpeg_debug ("Interlaced downscaling");
	  for (out_line_slice = 0; out_line_slice < local_out_nb_line_slice;
	       out_line_slice++)
	    {
	      input_line_p[0] =
		input + (((out_line_slice & ~(unsigned int) 1) << 3) +
			 (out_line_slice % 2)) * local_input_width;
	      input_line_p[1] = input_line_p[0] + (local_input_width << 1);
	      input_line_p[2] = input_line_p[1] + (local_input_width << 1);
	      input_line_p[3] = input_line_p[2] + (local_input_width << 1);
	      input_line_p[4] = input_line_p[3] + (local_input_width << 1);
	      input_line_p[5] = input_line_p[4] + (local_input_width << 1);
	      input_line_p[6] = input_line_p[5] + (local_input_width << 1);
	      input_line_p[7] = input_line_p[6] + (local_input_width << 1);
	      output_line_p[0] =
		output + ((out_line_slice & ~(unsigned int) 1) * 3 +
			  (out_line_slice % 2)) * local_output_width;
	      output_line_p[1] = output_line_p[0] + (local_output_width << 1);
	      output_line_p[2] = output_line_p[1] + (local_output_width << 1);
	      for (out_col = 0; out_col < local_output_active_width;
		   out_col++)
		{
		  *(output_line_p[0]++) =
		    divide[3 * (*input_line_p[0] + (*input_line_p[0] + 1)) +
			   3 * (*input_line_p[1] + (*input_line_p[1] + 1)) +
			   2 * (*input_line_p[2] + (*input_line_p[2] + 1))];
		  input_line_p[0] += 2;
		  input_line_p[1] += 2;
		  *(output_line_p[1]++) = divide[(*input_line_p[2] +
						  (*input_line_p[2] + 1)) +
						 3 * (*input_line_p[3] +
						      (*input_line_p[3] +
						       1)) +
						 3 * (*input_line_p[4] +
						      (*input_line_p[4] +
						       1)) +
						 (*input_line_p[5] +
						  (*input_line_p[5] + 1))];
		  input_line_p[2] += 2;
		  input_line_p[3] += 2;
		  input_line_p[4] += 2;
		  *(output_line_p[2]++) =
		    divide[2 * (*input_line_p[5] + (*input_line_p[5] + 1)) +
			   3 * (*input_line_p[6] + (*input_line_p[6] + 1)) +
			   3 * (*input_line_p[7] + (*input_line_p[7] + 1))];
		  input_line_p[5] += 2;
		  input_line_p[6] += 2;
		  input_line_p[7] += 2;
		}
	    }
	}
    }

  if (specific == 9)
    {
      // Special WIDE2VCD, on height : 8->3
      treatment = 9;
      if (interlaced == Y4M_ILACE_NONE)
	{
	  mjpeg_debug ("Non-interlaced downscaling");
	  // input frames are not interlaced, as are output frames.
	  // So, we average input_height_slice following lines into output_height_slice lines
	  for (out_line_slice = 0; out_line_slice < local_out_nb_line_slice;
	       out_line_slice++)
	    {
	      for (in_line = 0; in_line < input_height_slice; in_line++)
		{
		  number = out_line_slice * input_height_slice + in_line;
		  input_line_p[in_line] = input + number * local_input_width;
		}
	      u_c_p =
		output +
		out_line_slice * output_height_slice * local_output_width;
	      for (out_line = 0; out_line < output_height_slice; out_line++)
		{
		  output_line_p[out_line] = u_c_p;
		  u_c_p += local_output_width;
		}
	      for (out_col_slice = 0;
		   out_col_slice < local_out_nb_col_slice; out_col_slice++)
		{
		  W = width_coeff;
		  for (out_col = 0; out_col < output_width_slice; out_col++)
		    {
		      nb_W = *W;
		      value1 = value2 = value3 = 0;
		      W_var = W + 1;
		      for (j = 0; j < nb_W - 1; j++)
			{
			  value1 +=
			    (*W_var) * (3 * (*input_line_p[0]++) +
					3 * (*input_line_p[1]++) +
					2 * (*input_line_p[2]));
			  value2 +=
			    (*W_var) * ((*input_line_p[2]++) +
					3 * (*input_line_p[3]++) +
					3 * (*input_line_p[4]++) +
					(*input_line_p[5]));
			  value3 +=
			    (*W_var++) * (2 * (*input_line_p[5]++) +
					  3 * (*input_line_p[6]++) +
					  3 * (*input_line_p[7]++));
			}
		      value1 +=
			(*W_var) * (3 * (*input_line_p[0]) +
				    3 * (*input_line_p[1]) +
				    2 * (*input_line_p[2]));
		      value2 +=
			(*W_var) * ((*input_line_p[2]) +
				    3 * (*input_line_p[3]) +
				    3 * (*input_line_p[4]) +
				    (*input_line_p[5]));
		      value3 +=
			(*W_var) * (2 * (*input_line_p[5]) +
				    3 * (*input_line_p[6]) +
				    3 * (*input_line_p[7]));
		      *(output_line_p[0]++) = divide[value1];
		      *(output_line_p[1]++) = divide[value2];
		      *(output_line_p[2]++) = divide[value3];
		      W += nb_W + 1;
		    }
		  input_line_p[0]++;
		  input_line_p[1]++;
		  input_line_p[2]++;
		  input_line_p[3]++;
		  input_line_p[4]++;
		  input_line_p[5]++;
		  input_line_p[6]++;
		  input_line_p[7]++;
		}
	    }

	}
      else
	{
	  mjpeg_debug ("Interlaced downscaling");
	  for (out_line_slice = 0; out_line_slice < local_out_nb_line_slice;
	       out_line_slice++)
	    {
	      u_c_p =
		input +
		((out_line_slice & ~(unsigned int) 1) * input_height_slice +
		 (out_line_slice % 2)) * local_input_width;
	      for (in_line = 0; in_line < input_height_slice; in_line++)
		{
		  input_line_p[in_line] = u_c_p;
		  u_c_p += 2 * local_input_width;
		}
	      u_c_p =
		output +
		((out_line_slice & ~(unsigned int) 1) *
		 output_height_slice +
		 (out_line_slice % 2)) * local_output_width;
	      for (out_line = 0; out_line < output_height_slice; out_line++)
		{
		  output_line_p[out_line] = u_c_p;
		  u_c_p += 2 * local_output_width;
		}

	      for (out_col_slice = 0;
		   out_col_slice < local_out_nb_col_slice; out_col_slice++)
		{
		  H = height_coeff;
		  first_line = 0;
		  for (out_line = 0; out_line < output_height_slice;
		       out_line++)
		    {
		      nb_H = *H;
		      W = width_coeff;
		      for (out_col = 0; out_col < output_width_slice;
			   out_col++)
			{
			  H_var = H + 1;
			  nb_W = *W;
			  value = 0;
			  last_line = first_line + nb_H;
			  for (current_line = first_line;
			       current_line < last_line; current_line++)
			    {
			      W_var = W + 1;
			      // we average nb_W columns of input : we increment input_line_p[current_line] and W_var each time, except for the last value where 
			      // input_line_p[current_line] and W_var do not need to be incremented, but H_var does
			      for (j = 0; j < nb_W - 1; j++)
				value +=
				  (*H_var) * (*W_var++) *
				  (*input_line_p[current_line]++);
			      value +=
				(*H_var++) * (*W_var) *
				(*input_line_p[current_line]);
			    }
			  //                Straiforward implementation is 
			  //                *(output_line_p[out_line]++)=value/diviseur;
			  //                round_off_error=value%diviseur;
			  //                Here, we speed up things but using the pretabulated integral parts
			  *(output_line_p[out_line]++) = divide[value];
			  W += nb_W + 1;
			}
		      H += nb_H + 1;
		      first_line += nb_H - 1;
		      input_line_p[first_line] -= input_width_slice - 1;
		      // If last line of input is to be reused in next loop, 
		      // make the pointer points at the correct place
		    }
		  input_line_p[first_line] += input_width_slice - 1;
		  for (in_line = 0; in_line < input_height_slice; in_line++)
		    input_line_p[in_line]++;
		}
	    }
	}
    }



  if (treatment == 0)
    mjpeg_error_exit1 ("Unknown specific downscaling treatment %u",
		       specific);

  mjpeg_debug ("End of average_specific");
  return (0);
}