// Avisynth C Interface Version 0.11 Examples File
// Copyright 2003 Kevin Atkinson
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.

#include "avisynth_c.h"

// Do Nothing

AVS_Value AVSC_CC do_nothing (AVS_ScriptEnvironment * env, AVS_Value args, void * dg)
{
  AVS_Value v;
  AVS_FilterInfo * fi;
  AVS_Clip * new_clip = avs_new_c_filter(env, &fi, avs_array_elt(args, 0), 1);
  v = avs_new_value_clip(new_clip);
  avs_release_clip(new_clip);
  return v;
}

//
// Duplicate N
//

AVS_VideoFrame * AVSC_CC dup_get_frame (AVS_FilterInfo * p, int n)
{
  AVS_VideoFrame * f;
  f = avs_get_frame(p->child, (int)p->user_data);
  return f;
}

int AVSC_CC dup_get_parity (AVS_FilterInfo * p, int n)
{
  return avs_get_parity(p->child, (int)p->user_data);
}

AVS_Value AVSC_CC duplicate_n (AVS_ScriptEnvironment * env, AVS_Value args, void * dg)
{
  AVS_Value v;
  AVS_FilterInfo * fi;
  AVS_Clip * new_clip = avs_new_c_filter(env, &fi, avs_array_elt(args, 0), 1);
  fi->get_frame = dup_get_frame;
  fi->get_parity = dup_get_parity;
  fi->user_data = (void *)avs_as_int(avs_array_elt(args, 1));
  v = avs_new_value_clip(new_clip);
  avs_release_clip(new_clip);
  return v;
}

//
// InvertLuma
// 
 
AVS_VideoFrame * AVSC_CC invert_get_frame (AVS_FilterInfo * p, int n)
{
  AVS_VideoFrame * src, * dest;
  int row_size, height, src_pitch, dest_pitch;
  const BYTE * src_data;
  BYTE * dest_data;
  int y, x;

  src = avs_get_frame(p->child, n);
  dest = avs_new_video_frame(p->env, &p->vi);
  row_size = avs_get_row_size(src);
  height = avs_get_height(src);
  src_data  = avs_get_read_ptr(src);
  dest_data = avs_get_write_ptr(dest);
  src_pitch = avs_get_pitch(src);
  dest_pitch = avs_get_pitch(dest);
  for (y = 0; y != height; ++y) {
    if (avs_is_yuy2(&p->vi))
      for (x = 0; x < row_size; x += 2) {
        dest_data[x]   = 255 - src_data[x];
        dest_data[x+1] = src_data[x+1];
      }
    else
      for (x = 0; x < row_size; x ++) {
        dest_data[x]   = 255 - src_data[x];
      }
    src_data += src_pitch;
    dest_data += dest_pitch;
  }
  if (avs_is_yv12(&p->vi)) {
    avs_bit_blt(p->env, avs_get_write_ptr_p(dest, AVS_PLANAR_U),
                        avs_get_pitch_p(dest, AVS_PLANAR_U),
                        avs_get_read_ptr_p(src, AVS_PLANAR_U),
                        avs_get_pitch_p(src, AVS_PLANAR_U),
                        avs_get_row_size_p(src, AVS_PLANAR_U),
                        avs_get_height_p(src, AVS_PLANAR_U));
    avs_bit_blt(p->env, avs_get_write_ptr_p(dest, AVS_PLANAR_V),
                        avs_get_pitch_p(dest, AVS_PLANAR_V),
                        avs_get_read_ptr_p(src, AVS_PLANAR_V),
                        avs_get_pitch_p(src, AVS_PLANAR_V),
                        avs_get_row_size_p(src, AVS_PLANAR_V),
                        avs_get_height_p(src, AVS_PLANAR_V));
  }
  avs_release_video_frame(src);
  return dest;
}

AVS_Value AVSC_CC invert_luma (AVS_ScriptEnvironment * env, AVS_Value args, void * dg)
{
  AVS_Value v;
  AVS_FilterInfo * fi;
  AVS_Clip * new_clip = avs_new_c_filter(env, &fi, avs_array_elt(args, 0), 1);
  if (avs_is_yuy2(&fi->vi) || avs_is_yv12(&fi->vi)) {
    fi->get_frame = invert_get_frame;
    v = avs_new_value_clip(new_clip);
  } else {
    v = avs_new_value_error("Video Must be YUY2 or YV12!");
  }
  avs_release_clip(new_clip);
  return v;
}

//
// InvertLumaInPlace
//

 
AVS_VideoFrame * AVSC_CC invert2_get_frame (AVS_FilterInfo * p, int n)
{
  AVS_VideoFrame * frame;
  int row_size, height, pitch;
  BYTE * data;
  int y, x;

  frame = avs_get_frame(p->child, n);
  avs_make_writable(p->env, &frame);
  row_size = avs_get_row_size(frame);
  height = avs_get_height(frame);
  pitch = avs_get_pitch(frame);
  data  = avs_get_write_ptr(frame);
  for (y = 0; y != height; ++y) {
    if (avs_is_yuy2(&p->vi))
      for (x = 0; x < row_size; x += 2) {
        data[x]   = 255 - data[x];}
    else
      for (x = 0; x < row_size; x ++) {
        data[x]   = 255 - data[x];}
    data += pitch;
  }
  return frame;
}

AVS_Value AVSC_CC invert_luma_in_place (AVS_ScriptEnvironment * env, 
                                        AVS_Value args, void * dg)
{
  AVS_Value v;
  AVS_FilterInfo * fi;
  AVS_Clip * new_clip = avs_new_c_filter(env, &fi, avs_array_elt(args, 0), 1);
  if (avs_is_yuy2(&fi->vi) || avs_is_yv12(&fi->vi)) {
    fi->get_frame = invert2_get_frame;
    v = avs_new_value_clip(new_clip);
  } else {
    v = avs_new_value_error("Video Must be YUY2 or YV12!");
  }
  avs_release_clip(new_clip);
  return v;
}


//
//
//

const char * AVSC_CC avisynth_c_plugin_init(AVS_ScriptEnvironment * env)
{
  avs_add_function(env, "DoNothing", "c", do_nothing, 0);
  avs_add_function(env, "DuplicateN", "ci", duplicate_n, 0);
  avs_add_function(env, "InvertLuma", "c", invert_luma, 0);
  avs_add_function(env, "InvertLumaInPlace", "c", invert_luma_in_place, 0);
  return "";
}