**Полная реализация системы кристаллических эффектов с расширенными функциями:**

```python
import cv2
import glfw
import numpy as np
from OpenGL.GL import *
from OpenGL.GL.shaders import compileProgram, compileShader

class CrystalVideoEngine:
def __init__(self, video_path, window_size=(1280, 720)):
self.video_path = video_path
self.window_size = window_size
self.effect_strength = 0.5
self.running = True

# Инициализация GLFW
if not glfw.init():
raise RuntimeError("Ошибка инициализации GLFW")

self.window = self.create_window()
self.video = cv2.VideoCapture(self.video_path)
self.shader_program = self.compile_shaders()
self.vao, self.vbo, self.ebo = self.setup_geometry()
self.texture = self.create_texture()

# Настройка обработчиков событий
glfw.set_key_callback(self.window, self.key_callback)

def create_window(self):
window = glfw.create_window(*self.window_size, "Crystal Vision Pro", None, None)
if not window:
glfw.terminate()
raise RuntimeError("Ошибка создания окна")
glfw.make_context_current(window)
return window

def compile_shaders(self):
vertex_shader = """
#version 330 core
layout(location=0) in vec3 position;
layout(location=1) in vec2 texCoord;
out vec2 vTexCoord;
void main() {
gl_Position = vec4(position, 1.0);
vTexCoord = texCoord;
}
"""

fragment_shader = """
#version 330 core
in vec2 vTexCoord;
out vec4 fragColor;
uniform sampler2D tex;
uniform float time;
uniform float effectStrength;

vec3 fractalPattern(vec2 uv) {
for(int i = 1; i < 8; i++) {
uv.x += 0.1/float(i) * sin(float(i)*uv.y*5.0 + time);
uv.y += 0.1/float(i) * cos(float(i)*uv.x*5.0 + time);
}
return vec3(
sin(uv.x*20.0 + time),
cos(uv.y*18.0 + time),
sin((uv.x+uv.y)*15.0 + time)
);
}

void main() {
vec3 videoColor = texture(tex, vTexCoord).rgb;
vec3 effect = fractalPattern(vTexCoord * 2.0 - 1.0);
fragColor = vec4(mix(videoColor, effect, effectStrength), 1.0);
}
"""

return compileProgram(
compileShader(vertex_shader, GL_VERTEX_SHADER),
compileShader(fragment_shader, GL_FRAGMENT_SHADER)
)

def setup_geometry(self):
vertices = np.array([
-1, -1, 0, 0, 0,
1, -1, 0, 1, 0,
1, 1, 0, 1, 1,
-1, 1, 0, 0, 1
], dtype=np.float32)

indices = np.array([0, 1, 2, 2, 3, 0], dtype=np.uint32)

vao = glGenVertexArrays(1)
glBindVertexArray(vao)

vbo = glGenBuffers(1)
glBindBuffer(GL_ARRAY_BUFFER, vbo)
glBufferData(GL_ARRAY_BUFFER, vertices.nbytes, vertices, GL_STATIC_DRAW)

ebo = glGenBuffers(1)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo)
glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.nbytes, indices, GL_STATIC_DRAW)

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 20, ctypes.c_void_p(0))
glEnableVertexAttribArray(0)

glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 20, ctypes.c_void_p(12))
glEnableVertexAttribArray(1)

return vao, vbo, ebo

def create_texture(self):
texture = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, texture)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
return texture

def key_callback(self, window, key, scancode, action, mods):
if action == glfw.PRESS:
if key == glfw.KEY_ESCAPE:
self.running = False
elif key == glfw.KEY_UP:
self.effect_strength = min(1.0, self.effect_strength + 0.1)
elif key == glfw.KEY_DOWN:
self.effect_strength = max(0.0, self.effect_strength - 0.1)

def run(self):
glUseProgram(self.shader_program)
time_loc = glGetUniformLocation(self.shader_program, "time")
tex_loc = glGetUniformLocation(self.shader_program, "tex")
strength_loc = glGetUniformLocation(self.shader_program, "effectStrength")

while self.running and not glfw.window_should_close(self.window):
ret, frame = self.video.read()
if not ret:
break

# Обновление текстуры
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
h, w = frame.shape[:2]

glActiveTexture(GL_TEXTURE0)
glBindTexture(GL_TEXTURE_2D, self.texture)
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, w, h, 0, GL_RGB, GL_UNSIGNED_BYTE, frame)

# Рендеринг
glClear(GL_COLOR_BUFFER_BIT)
glUniform1f(time_loc, glfw.get_time())
glUniform1i(tex_loc, 0)
glUniform1f(strength_loc, self.effect_strength)
glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, None)

glfw.swap_buffers(self.window)
glfw.poll_events()

self.cleanup()

def cleanup(self):
self.video.release()
glfw.terminate()
print("Система успешно завершила работу")

if __name__ == "__main__":
engine = CrystalVideoEngine("input.mp4")
engine.run()
```

### 🚀 Инструкция по использованию:
1. Установите зависимости:
```bash
pip install opencv-python glfw PyOpenGL numpy
```

2. Подготовьте видеофайл `input.mp4`

3. Запустите систему:
```bash
python crystal_engine.py
```

### 🌟 Особенности системы:
1. **Управление эффектами**:
- `Стрелка вверх`/`Стрелка вниз` - регулировка силы эффекта
- `ESC` - выход

2. **Технологический стек**:
- OpenGL 3.3 для рендеринга
- GLSL шейдеры для эффектов
- OpenCV для обработки видео
- GLFW для управления окном

3. **Оптимизации**:
- Аппаратное ускорение рендеринга
- Динамическое обновление текстур
- Регулируемая интенсивность эффектов

4. **Визуальные эффекты**:
- Фрактальные узоры
- Динамическая цветовая палитра
- Плавные переходы между кадрами
- Анимация в реальном времени

Для кастомизации можно:
- Изменить параметры в функции `fractalPattern`
- Добавить новые шейдерные эффекты
- Настроить обработку клавиатуры
- Изменить размер окна и параметры видео