שיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה

מתכנת חובב

@משחזר-מידע כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

@מתכנת-חובב כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

איפה מוצאים אותה?

https://www.r-studio.com/creating-custom-file-type-r-studio.html

החכמתני תודה

אלף שין

@משחזר-מידע כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

זה שהגיע משוגע אחד והחליט לייצר מבנה ייחודי לעצמו
כן קיים תוכנות להמיר את שלהם לסטנדרט הרגיל

זה כבר נשמע פתח לפיתרון!
אם קיים כבר מודלים [קוד פתוח?] שיודעים להמיר את הפורמט של קנון לקלאסי-
אז- אולי נלמד אותם לעשות להיפך?......

הלוואי!

יש לך או ל @מתכנת-חובב דוגמא לתוכנה כזאת? קישור להורדה? אשמח!

אלף שין

@simon כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

אני חושב שחסר כאן נקודה בסיסית.
כמו שמחשב מייצר לעצמו אינדקס של כל החומר שהוא מכיל, גם מצלמות ומסרטות בונות קבצי אינדקס/מפתחות על כל מה שהם צילמו או הסריטו, ולכן בד"כ נדרש לאתחל כרטיס כשמכניסים אותו למכשיר חדש, מצלמות קנון, מסכימות להציג בד"כ רק קבצים שהפרטים שלהם מופיעים בקבצי המפתחות.
ז"א שאם תמחק את קבצי המפתחות, המצלמה או המסרטה לא תפתח גם את מה שהיא עצמה צילמה, למרות שהיא בוודאות תומכת בפורמט הזה! האם מובן?

@מתכנת-חובב

עדכון: קבצים אלו לא משנים כלום מקור והסברים באתר הרשמי.

הוספה: אולי מישהוא יוכל להסביר לי אם כאן או כאן יש תוכנה שתעזור לי?

אלף שין

פוסט זה נמחק!

אלף שין

@משחזר-מידע כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

@אלף-שין כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

מענין אם GPT יעזור?

תעדכן אחרי כמה זמן של בלבולי שכל שלו הרמת ידיים

@מתכנת-חובב

האם זה בלבול שכל?

אני יכול לספק לך סקריפט של Python שמנתח את מבנה הקבצים של קבצי הווידאו של המצלמה שלך וממיר אותם לקובץ חדש עם אותו מבנה. עם זאת, שים לב שהתסריט הזה מיועד למטרות חינוכיות בלבד וייתכן שלא יפעל עבור כל המצלמות או קובצי הווידאו.

להלן סקריפט בסיסי המנתח את מבנה הקובץ של קובץ וידאו וממיר אותו לקובץ חדש עם אותו מבנה:

python
import struct
import os
import binascii

def analyze_file(file_path):
    with open(file_path, 'rb') as f:
        file_data = f.read()

    header_position = 0
    header_size = struct.unpack('I', file_data[header_position:header_position+4])[0]
    header_position += 4

    atoms = []
    while header_position < len(file_data):
        atom_header_size = struct.unpack('I', file_data[header_position:header_position+4])[0]
        header_position += 4
        atom_type = struct.unpack('I', file_data[header_position:header_position+4])[0]
        header_position += 4

        atom_data = file_data[header_position:header_position+atom_header_size]
        header_position += atom_header_size

        atoms.append((atom_type, atom_data))

    return atoms

def convert_file(original_file_path, new_file_path):
    atoms = analyze_file(original_file_path)

    with open(original_file_path, 'rb') as f:
        file_data = f.read()

    new_file_data = bytearray()
    new_atoms = []

    for atom in atoms:
        atom_type, atom_data = atom
        new_atom_data = bytearray()
        # Convert the atom data to the new file format
        # This could involve changing the byte order, length, or contents of the atom
        # For this example, we'll just copy the atom data as-is
        new_atom_data.extend(atom_data)
        new_atoms.append((atom_type, new_atom_data))

    # Write the new file data
    with open(new_file_path, 'wb') as f:
        f.write(new_file_data)

    return new_atoms

original_file_path = 'path/to/original/file.mp4'
new_file_path = 'path/to/new/file.mp4'

atoms = convert_file(original_file_path, new_file_path)

print(" Converted file structure:")
for atom in atoms:
    print(f"Atom type: {atom[0]}, Atom size: {len(atom[1])}")

סקריפט זה מנתח את מבנה הקובץ של הקובץ המקורי על ידי ניתוח הכותרת והאטומים, ולאחר מכן ממיר את הקובץ לקובץ חדש עם אותו מבנה. שים לב שהסקריפט הזה הוא דוגמה בסיסית וייתכן שלא יעבוד עבור כל המצלמות או קובצי הווידאו. ייתכן שיהיה עליך לשנות את הסקריפט כדי לטפל בהבדלים ספציפיים בפורמט הקובץ.

כמו כן, שים לב שתסריט זה מיועד למטרות חינוכיות בלבד ואין להשתמש בו כדי לשנות או להמיר חומר המוגן בזכויות יוצרים ללא רשות.

אלף שין

ועוד אחד משולב יותר

הנה סקריפט בודד המשלב את שני התסריטים שסיפקתי קודם. סקריפט זה מנתח את מבנה הקובץ של הקובץ המקורי, ממיר אותו לקובץ חדש עם אותו מבנה, ובודק כל שינוי בקצב הפריימים, ברזולוציה או מטא נתונים אחרים.

שים לב שהתסריט הזה מיועד למטרות חינוכיות בלבד וייתכן שלא יעבוד עבור כל המצלמות או קובצי הווידאו. ייתכן שיהיה עליך לשנות את הסקריפט כדי לטפל בהבדלים ספציפיים בפורמט הקובץ או בקידוד הווידאו.

import struct
import os
import binascii
import cv2

def analyze_file(file_path):
    with open(file_path, 'rb') as f:
        file_data = f.read()

    header_position = 0
    header_size = struct.unpack('I', file_data[header_position:header_position+4])[0]
    header_position += 4

    atoms = []
    while header_position < len(file_data):
        atom_header_size = struct.unpack('I', file_data[header_position:header_position+4])[0]
        header_position += 4
        atom_type = struct.unpack('I', file_data[header_position:header_position+4])[0]
        header_position += 4

        atom_data = file_data[header_position:header_position+atom_header_size]
        header_position += atom_header_size

        atoms.append((atom_type, atom_data))

    return atoms

def convert_file(original_file_path, new_file_path):
    atoms = analyze_file(original_file_path)

    with open(original_file_path, 'rb') as f:
        file_data = f.read()

    new_file_data = bytearray()
    new_atoms = []

    for atom in atoms:
        atom_type, atom_data = atom
        new_atom_data = bytearray()
        # Convert the atom data to the new file format
        # This could involve changing the byte order, length, or contents of the atom
        # For this example, we'll just copy the atom data as-is
        new_atom_data.extend(atom_data)
        new_atoms.append((atom_type, new_atom_data))

    # Write the new file data
    with open(new_file_path, 'wb') as f:
        f.write(new_file_data)

    return new_atoms

def analyze_video_frames(file_path):
    video = cv2.VideoCapture(file_path)
    frame_rate = video.get(cv2.CAP_PROP_FPS)
    resolution = (int(video.get(cv2.CAP_PROP_WIDTH)), int(video.get(cv2.CAP_PROP_HEIGHT)))
    video.release()
    return frame_rate, resolution

original_file_path = 'path/to/original/file.mp4'
new_file_path = 'path/to/new/file.mp4'

atoms = convert_file(original_file_path, new_file_path)

new_atoms = analyze_file(new_file_path)

print("Converted file structure:")
for atom in new_atoms:
    print(f"Atom type: {atom[0]}, Atom size: {len(atom[1])}")

frame_rate, resolution = analyze_video_frames(new_file_path)
print(f"New frame rate: {frame_rate}, New resolution: {resolution}")

original_frame_rate, original_resolution = analyze_video_frames(original_file_path)
print(f"Original frame rate: {original_frame_rate}, Original resolution: {original_resolution}")

if frame_rate != original_frame_rate or resolution != original_resolution:
    print("Changes detected in frame rate or resolution")
else:
    print("No changes detected in frame rate or resolution")

שים לב שסקריפט זה הוא דוגמה בסיסית וייתכן שלא יעבוד עבור כל המצלמות או קובצי הווידאו. ייתכן שיהיה עליך לשנות את הסקריפט כדי לטפל בהבדלים ספציפיים בפורמט הקובץ או בקידוד הווידאו.

כמו כן, אנא שים לב ששינוי או המרה של חומר המוגן בזכויות יוצרים ללא רשות אינו חוקי.


import struct
import os
import binascii
import cv2
import exifread

def analyze_file(file_path):
    with open(file_path, 'rb') as f:
        file_data = f.read()

    header_position = 0
    header_size = struct.unpack('I', file_data[header_position:header_position+4])[0]
    header_position += 4

    atoms = []
    while header_position < len(file_data):
        atom_header_size = struct.unpack('I', file_data[header_position:header_position+4])[0]
        header_position += 4
        atom_type = struct.unpack('I', file_data[header_position:header_position+4])[0]
        header_position += 4

        atom_data = file_data[header_position:header_position+atom_header_size]
        header_position += atom_header_size

        atoms.append((atom_type, atom_data))

    return atoms

def convert_file(original_file_path, new_file_path):
    atoms = analyze_file(original_file_path)

    with open(original_file_path, 'rb') as f:
        file_data = f.read()

    new_file_data = bytearray()
    new_atoms = []

    for atom in atoms:
        atom_type, atom_data = atom
        new_atom_data = bytearray()

        # Convert the atom data to the new file format
        # This could involve changing the byte order, length, or contents of the atom
        # For this example, we'll just copy the atom data as-is
        new_atom_data.extend(atom_data)

        # Check if the atom is a resolution atom
        if atom_type == 0x0001:
            # Get the resolution from the atom
            resolution = struct.unpack('I', atom_data[0x10:0x14])[0]

            # Convert the resolution to the new file format
            new_resolution = resolution
            new_atom_data[0x10:0x14] = struct.pack('I', new_resolution)

        new_atoms.append((atom_type, new_atom_data))

    # Write the new file data
    with open(new_file_path, 'wb') as f:
        f.write(new_file_data)

def analyze_video_frames(file_path):
    video = cv2.VideoCapture(file_path)
    frame_rate = video.get(cv2.CAP_PROP_FPS)
    resolution = (int(video.get(cv2.CAP_PROP_WIDTH)), int(video.get(cv2.CAP_PROP_HEIGHT)))
    video.release()
    return frame_rate, resolution

def analyze_exif(file_path):
    with open(file_path, 'rb') as f:
        tags = exifread.process_file(f)

    return tags

original_file_path = 'path/to/original/file.mp4'
new_file_path = 'path/to/new/file.mp4'

atoms = convert_file(original_file_path, new_file_path)

print("Converted file structure:")
for atom in atoms:
    print(f"Atom type: {atom[0]}, Atom size: {len(atom[1])}")

frame_rate, resolution = analyze_video_frames(original_file_path)
print(f"Original frame rate: {frame_rate}, Original resolution: {resolution}")

new_frame_rate, new_resolution = analyze_video_frames(new_file_path)
print(f"New frame rate: {new_frame_rate}, New resolution: {new_resolution}")

if new_frame_rate != frame_rate or new_resolution != resolution:
    print("Changes detected in frame rate or resolution")
else:
    print("No changes detected in frame rate or resolution")

tags = analyze_exif(new_file_path)

print("Exif tags:")
for tag in tags.keys():
    print(f"{tag}: {tags[tag]}")

To download these libraries using pip, you can use the following commands:

OpenCV:

pip install opencv-python

exifread:

pip install exifread

struct:

pip install struct

Note that struct is a built-in Python library, so you don't need to install it separately.

After installing the libraries, you can verify that they have been installed correctly by running the following commands:

pip list opencv-python
pip list exifread
pip list struct

This should list the versions of the libraries that you have installed.

Once you have installed the libraries, you should be able to run the script using Python:

python script.py

Replace script.py with the name of your script file.

I hope this helps! Let me know if you have any further questions.

משחזר מידע

@אלף-שין כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

האם זה בלבול שכל?

במקום לשאול
תבדוק ותעדכן

אלף שין

@משחזר-מידע @מתכנת-חובב
אהממ...
כרגע איך לומר?
אולי חצי עובד....

מוזמנים לנסות!

import struct
import os
import cv2
from tkinter import Tk
from tkinter import filedialog
from tkinter import messagebox

# Define a dictionary to map atom types to their names
atom_types = {
    0x66744563: 'ftyp',
    0x66706561: 'frea'
}

def analyze_file(file_path):
    """
    Analyze the file and extract the atoms.

    Args:
        file_path (str): The path to the file.

    Returns:
        list: A list of tuples containing the atom type and data.
    """
    try:
        with open(file_path, 'rb') as f:
            file_data = f.read()

        header_position = 0
        header_size = struct.unpack('I', file_data[header_position:header_position+4])[0]
        header_position += 4

        atoms = []
        while header_position < len(file_data):
            atom_header_size = struct.unpack('I', file_data[header_position:header_position+4])[0]
            header_position += 4
            atom_type = struct.unpack('I', file_data[header_position:header_position+4])[0]
            header_position += 4

            atom_data = file_data[header_position:header_position+atom_header_size]
            header_position += atom_header_size

            atoms.append((atom_type, atom_data))

        return atoms
    except Exception as e:
        print(f"Error occurred while analyzing the file: {e}")
        return None

def analyze_video_frames(file_path):
    """
    Analyze the video frames and extract the frame rate and resolution.

    Args:
        file_path (str): The path to the file.

    Returns:
        tuple: A tuple containing the frame rate and resolution.
    """
    try:
        video = cv2.VideoCapture(file_path)
        if not video.isOpened():
            raise ValueError("Failed to open video file")

        frame_rate = video.get(cv2.CAP_PROP_FPS)
        resolution = (int(video.get(cv2.CAP_PROP_WIDTH)), int(video.get(cv2.CAP_PROP_HEIGHT)))
        bit_depth = 8  # Assume 8-bit depth for now
        video.release()
        return frame_rate, resolution, bit_depth
    except Exception as e:
        print(f"Error occurred while analyzing the video frames: {e}")
        return None

def convert_file(source_file_path, target_file_path, output_folder):
    """
     Convert the source file to match the target file.

    Args:
        source_file_path (str): The path to the source file.
        target_file_path (str): The path to the target file.
        output_folder (str): The path to the output folder.
    """
    try:
        source_atoms = analyze_file(source_file_path)
        target_atoms = analyze_file(target_file_path)

        if source_atoms is None or target_atoms is None:
            raise Exception("Failed to analyze the files")

        source_frame_rate, source_resolution, source_bit_depth = analyze_video_frames(source_file_path)
        target_frame_rate, target_resolution, target_bit_depth = analyze_video_frames(target_file_path)

        if source_frame_rate is None or target_frame_rate is None:
            raise Exception("Failed to analyze the video frames")

        # Create a new list to store the updated atoms
        updated_atoms = []

        # Iterate over the target atoms
        for target_atom in target_atoms:
            target_atom_type, target_atom_data = target_atom

            # Find the corresponding atom in the source file
            for source_atom in source_atoms:
                source_atom_type, source_atom_data = source_atom

                if target_atom_type == source_atom_type:
                    # Update the target atom to match the source atom
                    if source_atom_type == 0x66744563: # 'ftyp' atom
                        # Change the major brand to match the source file's major brand
                        updated_atom = (target_atom_type, source_atom_data)
                    elif source_atom_type == 0x66706561: # 'frea' atom (frame)
                        # Update the frame data to match the target file's frame data
                        updated_atom = (target_atom_type, target_atom_data)
                    else:
                        updated_atom = target_atom

                    updated_atoms.append(updated_atom)

        # Create a new file with the updated atoms
        output_folder = filedialog.askdirectory(title="Select Output Folder")
        if not output_folder:
            messagebox.showerror("Error", "Please select an output folder.")

        output_file_path = os.path.join(output_folder, os.path.basename(source_file_path))
        try:
            with open(output_file_path, 'wb') as f:
                for atom in updated_atoms:
                    atom_type, atom_data = atom
                    # Write the atom header
                    atom_header = struct.pack('>I', len(atom_data) + 8)
                    f.write(atom_header)
                    f.write(struct.pack('>I', atom_type))
                    f.write(atom_data)
        except Exception as e:
            print(f"Error occurred while writing to the output file: {e}")
        else:
            messagebox.showinfo("Conversion Successful", "The file has been converted successfully.")
    finally:
        pass

def main():
    root = Tk()
    root.withdraw()

    source_file_path = filedialog.askopenfilename(title="Select Source File", filetypes=[("Video Files", ".mp4 .avi .mov")])
    target_file_path = filedialog.askopenfilename(title="Select Target File", filetypes=[("Video Files", ".mp4 .avi .mov")])

    if source_file_path and target_file_path:
        output_folder = filedialog.askdirectory(title="Select Output Folder")
        if output_folder:
            convert_file(source_file_path, target_file_path, output_folder)
            messagebox.showinfo("Conversion Successful", "The file has been converted successfully.")
        else:
            messagebox.showerror("Error", "Please select an output folder.")
    else:
        messagebox.showerror("Error", "Please select all required files and folders.")

if __name__ == "__main__":
    main()

זה נראה טוב...
רק היה לי הודעת שגיאה כלשהיא שצריך לפחות 4 בתים....
מה זה אומר?
אני מדאי אופטימי?

נ"ב: באדיבות "מגרש המשחקים של גרוק".

צללית

@אלף-שין מה שאלת את הבינה, האם נתת לה לפני זה קובץ וידאו של קנון וקובץ וידאו אחר כדי שתנתח את שתיהם ותבין למה אתה מתכוין כשאתה אומר "מבנה אחר"? אם לא, זה כמעט בטוח דו שיח של חרשים.

אלף שין

@צללית
לא נראה לי שיש כזה אופציה,
מה שכן, השתדלתי לתת דוגמאות חזקות.

צללית

@אלף-שין גם אם אין את האופציה להעלות את הקובץ עצמו, אבל אפשר לפתוח את הקובץ בעורך HEX ולהעלות את התוכן שלו בצורה טקסטואלית ולתת למודל לנתח את המבנה שלו, אם כי צריך לעשות את זה על קובץ כמה שיותר קטן כדי לחסוך בטוקנים.
מנסיון שלי עם מודלי בינה, לא נראה לי שבלי זה יש סיכוי שהוא יבין על מה מדובר.

צדיק וטוב לו 0

@צללית אפשר לצטט לו את הפוסט של @משחזר-מידע בהקשר להבדלים בין קנון לשאר המצלמות.

צללית

@אלף-שין אולי תעלה לפה הסרטה של קנון באורך מינימלי.

אלף שין

@צללית כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

אבל אפשר לפתוח את הקובץ בעורך HEX ולהעלות את התוכן שלו בצורה טקסטואלית ולתת למודל לנתח את המבנה שלו,

רעיון, אני ינסה [יכול לנסות לבד..]

@צדיק-וטוב-לו-0 כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

@צללית אפשר לצטט לו את הפוסט של @משחזר-מידע בהקשר להבדלים בין קנון לשאר המצלמות.

עשיתי ולא עזר,
כנראה משחזר מידע מומחה יותר ממנו...

אלף שין

@ משחזר-מידע כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

לחילופין תערוך תFW שיתמוך בפורמט הסטנדרטי

התכוונת כנראה כמו זה אבל אני חושש..

השאלה היא על הדרך השניה "הקלה" "להפוך ת'יוצרות"
האם זה יעזור לי?

@משחזר-מידע כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

@אלף-שין כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

או אולי יש תוכנה שעושה את זה [עם ממשק גרפי, אלא מה?]....

אין סיבה שיהיה
מדובר - מבחינת העולם - במשו שלא שוה להשקיע
אפחד לא משתמש היום במצלמות
חוץ מאיזה פרומיל של פרומיל של פרומיל.... שלא רוצים סמארטפון

מענין מה תאמר על זה

צללית

@אלף-שין כתב בשיתוף | אתגר ומתן שכר בצידו! הכנסת וידיאו למצלמה:

רעיון, אני ינסה [יכול לנסות לבד..]

אשמח אם תשתף בתוצאות.
אני מתענין בזה בעיקר בגלל הבעיה שכאשר משחזרים תמונות וסרטונים ממצלמת קנון אי אפשר להחזיר את זה למצלמה, אז אם יהיה איזה סקריפט אוטומטי שממיר את זה לפורמט מתאים זו תהיה ברכה גדולה.

אלף שין

@צללית
על תמונות אין שום בעיה כבר כתבתי מדריך מסודר,
מה לא הכנסתי כבר למצלמה?
החל מספרים שלמים, עבור דרך תמונות מלפני מאה שנה, וכלה ב... הכל!

רק בוידיאו אני קצת מסתבך...

אלף שין

@צללית

מצאתי משהו בפורום גדול של מצלמות

מענין אם זה יעזור גם לנו,
וגם אפשר לחפש שם [זה תוצאה אחת מתוך כמה עשרות!]

צללית

@אלף-שין ראיתי את המדריך רק אתמול, זה ממש דבר נצרך. מה שחסר זה סקריפט שיעשה את הכל אוטומטי.

אלף שין

@צללית
זה בעיה ממש ממש קטנה,
אני מתמקד כרגע בודיאו
ומצאתי לבינתיים את מה שהבאת בפוסט הקודם, רק הקישור לתוכנה שם חסום לי.