GH_J5

1
import subprocess
2
import json
3
import base64
4
import numpy as np
5
from scipy.spatial.distance import cosine, euclidean, cityblock
6
from scipy.stats import pearsonr
7
from scipy.interpolate import interp1d
8

9
def get_video_resolution(video_file):
10
    # Команда для получения информации о видео с помощью FFmpeg
11
    ffprobe_command = [
12
        'ffprobe',
13
        '-v', 'error',
14
        '-select_streams', 'v:0',
15
        '-show_entries', 'stream=width,height',
16
        '-of', 'json',
17
        video_file
18
    ]
19

20
    # Запускаем процесс FFprobe с указанной командой
21
    ffprobe_process = subprocess.Popen(ffprobe_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
22
    
23
    # Получаем вывод процесса
24
    output, error = ffprobe_process.communicate()
25

26
    # Если есть ошибки, выводим их
27
    if error:
28
        print("Ошибка при выполнении команды FFprobe:", error.decode())
29
        return None, None
30

31
    # Разбираем JSON-ответ, чтобы получить информацию о разрешении
32
    video_info = json.loads(output.decode())
33
    width = video_info['streams'][0]['width']
34
    height = video_info['streams'][0]['height']
35

36
    return width, height
37
  
38
def estimate_blur(image_array,height, width, threshold=7):
39
    # Преобразуем байты изображения в массив NumPy
40
    image_array = image_array.reshape(height, width, 3)
41
    # Конвертируем изображение в оттенки серого
42
    gray_image = np.mean(image_array, axis=2)
43

44
    # Вычисляем горизонтальные и вертикальные градиенты
45
    gradient_x = np.gradient(gray_image, axis=1)
46
    gradient_y = np.gradient(gray_image, axis=0)
47

48
    # Вычисляем общий градиент
49
    gradient_magnitude = np.sqrt(gradient_x**2 + gradient_y**2)
50

51
    # Вычисляем среднее значение градиента
52
    mean_gradient = np.mean(gradient_magnitude)
53

54
    # Возвращаем True, если среднее значение градиента меньше порогового значения
55
    #print(mean_gradient)
56
    return mean_gradient < threshold
57

58
def extract_i_frames(input_file,height, width):
59
    i_frames = []
60
    frame_timings = []
61
    ln = []
62
    # Получаем информацию о видео с помощью FFprobe
63
    ffprobe_command = [
64
        'ffprobe',
65
        '-show_entries', 'frame=pkt_pts_time,pict_type',
66
        '-select_streams', 'v:0',
67
        '-of', 'json',
68
        input_file
69
    ]
70
    ffprobe_process = subprocess.Popen(ffprobe_command, stdout=subprocess.PIPE)
71
    ffprobe_output, _ = ffprobe_process.communicate()
72
    video_info = json.loads(ffprobe_output)
73

74
    # Извлекаем I-кадры с помощью ffmpeg
75
    ffmpeg_command = [
76
        'ffmpeg',
77
        '-i', input_file,
78
        #'-vf', 'select=\'eq(pict_type\,I)\'',
79
        '-vsync', 'vfr',
80
        '-f', 'image2pipe',
81
        '-pix_fmt', 'rgb24',
82
        '-vcodec', 'rawvideo',
83
        '-'
84
    ]
85
    ffmpeg_process = subprocess.Popen(ffmpeg_command, stdout=subprocess.PIPE)
86
    #frame_bytes = ffmpeg_process.stdout.read()
87
    #print(len(frame_bytes))
88
    # Читаем кадры и их тайминг
89
    
90
    print(width, height)
91
    for frame_info in video_info['frames']:
92
        frame_type = frame_info['pict_type']
93
        frame_time = float(frame_info['pkt_pts_time'])
94
        #print(frame_info['pkt_pts_time'])
95
        frame_bytes = ffmpeg_process.stdout.read(width*height*3)
96
        #print(len(frame_bytes))
97
        if frame_bytes and frame_type == 'I':
98
            # Преобразуем байты в массив numpy
99
            numpy_array = np.frombuffer(frame_bytes, dtype=np.uint8)
100
            i_frames.append(numpy_array)
101
            ln.append(len(numpy_array))
102
            frame_timings.append(frame_time)
103

104
    ffmpeg_process.stdout.close()
105

106
    return i_frames, frame_timings, ln
107

108
input_file = '3.mp4'
109
width, height = get_video_resolution(input_file)
110
i_frames, frame_timings, ln = extract_i_frames(input_file,height,width)
111

112

113
# Вывод списка I-кадров и их тайминга
114
for i, (frame, timing,ln) in enumerate(zip(i_frames, frame_timings, ln)):
115
    array1 = i_frames[i]
116
    #ln1=len(first)
117
    #print(type(first),len(first))
118
    array2 = i_frames[i+1]
119
    #ln2=len(second)
120
    #print(type(second), len(second))
121
    #similarity = 1-cosine(array1, array2)
122
    #if similarity>0.1:
123
    #distance = euclidean(array1, array2)
124
    #jacard = jaccard_similarity(array1, array2)
125
    correlation, _ = pearsonr(array1, array2)
126
    es1 = estimate_blur(array1,height,width)
127
    if es1:
128
        print("++++++++++++++++++++++++")
129
        print(f"I-кадр {i+1}, Тайминг: {timing} секунд,{len(frame)} {ln}")
130
    #distance2 = cityblock(array1, array2)
131
    if correlation<0.75:
132
        print("----------------",correlation)
133
        print(f"I-кадр {i+1}, Тайминг: {timing} секунд,{len(frame)} {ln}")