Update model files

.env.template

@@ -0,0 +1,10 @@
+BUCKET_TYPE="type of bucket. one of: backblaze, amazon_s3, cloudflare, or hippius"
+BUCKET_NAME="buckent name"
+BUCKET_COMPATIBLE_ENDPOINT="bucket endpoint"
+BUCKET_COMPATIBLE_ACCESS_KEY="bucket personal access key"
+BUCKET_COMPATIBLE_SECRET_KEY="bucket personal secret key"
+
+
+#validators only
+PEXELS_API_KEY="Your Pexels account api key"
+WANDB_API_KEY="Your wandb api key"

.gitattributes

@@ -1,35 +1,9 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+docs/images/banner.png filter=lfs diff=lfs merge=lfs -text
+docs/images/graph1.png filter=lfs diff=lfs merge=lfs -text
+docs/images/graph2.png filter=lfs diff=lfs merge=lfs -text
+docs/images/graph3.png filter=lfs diff=lfs merge=lfs -text
+docs/images/graph4.png filter=lfs diff=lfs merge=lfs -text
+docs/images/graph5.png filter=lfs diff=lfs merge=lfs -text
+services/compress/models/preprocessing_pipeline.pkl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,33 @@
+__pycache__/
+note.txt
+*.log
+*.db
+*.mp4
+*.lock
+*.hevc
+*.y4m
+*.egg-info
+*.pyc
+*.mp3
+*.js
+*.xml 
+*.txt
+.DS_Store
+*.json
+.env
+venv/
+.venv/
+video2x/
+logs/
+videos/
+wandb/
+IQA-PyTorch/
+MDTVSFA/
+output/
+MANIQA/
+frames/
+tmp/
+vmaf/
+services/scoring/vmaf
+services/upscaling/models/
+tmp_scene/

.python-version

@@ -0,0 +1 @@
+3.12

README.md

@@ -0,0 +1,106 @@
+<div align="center">
+
+# **Vidaio Subnet**: Revolutionizing Video Processing with AI-Driven Decentralization <!-- omit in toc -->
+
+
+Please check our [Tweet](https://x.com/vidaio_τ) to follow us.
+[Website](https://vidaio.io)
+[![vidAio](./docs/images/banner.png)](https://vidaio.io)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) 
+
+---
+
+</div>
+
+## **Table of Contents**
+
+1. [Introduction](#1-introduction)
+2. [Subnet Architecture](#2-subnet-architecture)
+   - [Overview](#21-overview)
+   - [Miners](#22-miners)
+   - [Validators](#23-validators)
+   - [Synapses](#24-synapses)
+     - [Synthetic Query](#241-synthetic-query)
+     - [Organic Query](#242-organic-query)
+3. [Setup](#3-setup)
+4. [Roadmap](#4-roadmap)
+5. [Appendix](#5-appendix)
+   - [Technical Glossary](#a-technical-glossary)
+   - [References](#b-references)
+   - [Contact Information](#c-contact-information)
+
+## **1. Introduction**
+Vidaio's mission is to democratise video enhancement through decentralisation, artificial intelligence, and blockchain technology. Leveraging the Bittensor ecosystem, Vidaio provides creators, businesses, and developers with scalable, affordable, and high-quality video processing solutions including upscaling and compression, while ensuring full ownership and control over their content.
+
+
+## 2. Subnet Architecture
+
+### 2.1 Overview
+- **Miners**: Handle video processing tasks including upscaling and compression, optimizing models to ensure high-quality outputs.
+- **Validators**: Assess miner performance using predefined metrics to maintain network integrity across all video processing workflows.
+
+### 2.2 Miners
+Miners enhance video quality and optimize file sizes using AI-driven processing techniques. They can:
+- Optimise open-source models or develop proprietary ones for superior upscaling and compression results.
+- Handle video upscaling and compression requests from validators and end-users.
+- Process both upscaling tasks (enhancing video quality) and compression tasks (reducing file size while maintaining quality).
+
+### 2.3 Validators
+Validators ensure miners deliver consistent, high-quality results by evaluating performance through synthetic and organic queries for both upscaling and compression workflows.
+
+### 2.4 Synapses
+#### 2.4.1 Synthetic Query
+Validators benchmark miner performance using controlled datasets:
+- **Upscaling**: Downscale a high-resolution video to low-resolution, then miners upscale it back to high resolution.
+- **Compression**: Provide high-quality videos for miners to compress while maintaining optimal quality-to-size ratios.
+
+- Validators assess the processed outputs using metrics VMAF and PieAPP for quality evaluation.
+
+#### 2.4.2 Organic Query
+Real-world video data uploaded by users is processed as follows:
+- Videos are chunked and queued for miners.
+- Miners process and apply upscaling or compression based on user requirements.
+- Results are aggregated and delivered back to users.
+
+### 2.5 Incentive mechanism
+- [Incetive Mechanism Guide](docs/incentive_mechanism.md)
+
+## 3. Setup
+- [Validator Setup Guide](docs/validator_setup.md)
+- [Miner Setup Guide](docs/miner_setup.md)
+
+## 4. Roadmap
+
+### Phase 1: Implementing the Video Processing Synapses
+- Launch the subnet with AI-powered video upscaling and compression capabilities.
+- Focus on real-time processing of videos for both quality enhancement and size optimization.
+
+### Phase 2: Developing Advanced Video Processing Models
+- Build AI models for adaptive bitrate streaming and intelligent compression.
+- Optimize bandwidth usage while maintaining video quality across different use cases.
+
+### Phase 3: Implementing the Transcode Optimization Synapse
+- Introduce AI-driven transcoding for compatibility across devices.
+- Evaluate miners on speed, quality, and efficiency for all processing workflows.
+
+### Phase 4: On-Demand Streaming Architecture
+- Enable decentralized on-demand video streaming with integrated storage.
+- Utilize peer-to-peer (P2P) models for redundancy and high availability.
+
+### Phase 5: Live Streaming Through the Subnet
+- Introduce live streaming with real-time AI-powered upscaling, compression, and transcoding.
+- Integrate adaptive bitrate streaming for smooth playback.
+
+### Phase 6: Subnet API for Real-World Integration
+- Develop a RESTful API for seamless integration with external platforms.
+- Include features for uploading, processing, and retrieving videos with multiple processing options.
+
+## 5. Appendix
+
+### A. Technical Glossary
+- **VMAF**: [Video Multimethod Assessment Fusion](https://github.com/vidaio-subnet/vmaf)
+- **Video2x**: [Vidio upscaling model](https://github.com/vidaio-subnet/video2x)
+- **TOPIQ**: [Top-down Image Quality Assessment](https://arxiv.org/pdf/2308.03060v1)
+- **LPIPS**: [Learned Perceptual Image Patch Similarity](https://github.com/richzhang/PerceptualSimilarity)
+- **Bittensor Subnet**: [Decentralized AI Framework](https://docs.bittensor.com)

analyze_result.csv

@@ -0,0 +1,113 @@
+file_name,metrics_resolution_width,metrics_resolution_height,metrics_frame_rate,metrics_bit_depth,input_codec,input_bitrate_kbps,bits_per_pixel,metrics_avg_motion,metrics_avg_edge_density,metrics_avg_texture,metrics_avg_color_complexity,metrics_avg_motion_variance,metrics_avg_grain_noise,metrics_avg_spatial_information,metrics_avg_temporal_information,metrics_avg_psnr,quality_noise_level,quality_sharpness,quality_contrast,quality_brightness,quality_color_saturation,quality_motion_blur,quality_compression_artifacts,quality_text_content,quality_edge_density,quality_temporal_consistency,quality_psnr
+691de276-7b47-4015-bc54-da4343889084.mp4,4208,2040,25.0,8,h264,17985.092,0.08380438753448147,0.04384737944001503,0.005426638335942742,6.8855719566345215,7.156955718994141,7.524673709889497e-05,1.1901419162750244,26.9073429107666,22.757010920983905,20.114583549810607,0.02833493985235691,0.015084956772625446,0.14730598471266507,0.46570451798664747,0.47825197173603406,0.007945261437908496,0.004781483206897974,0.5164016097567037,0.013443464362931484,0.9986614345096869,19.556071543951166
+5533624b-8b2f-476e-93c3-26ecc8abbbfc.mp4,3816,2216,29.97,8,h264,40848.835,0.16118135782046936,0.05624176500156784,0.026415047037365004,6.792716026306152,7.042492866516113,9.488612387943008e-06,2.512382745742798,38.068580627441406,17.092482685057654,21.17046433272484,0.14134825766086578,0.05944013595581055,0.1886964347338915,0.40776378246190087,0.22834675684838993,0.0767561909194802,0.014388006490965685,0.6034597344262048,0.13276803587781638,0.9937148534950766,20.368462730755084
+eeb92086-2c5a-47b1-911a-9f23c3c51a83.mp4,1776,1136,24.0,8,h264,2672.796,0.055199262863215325,0.03173686158973804,0.0013392573911940107,6.271199703216553,6.502370357513428,8.143292527477933e-06,0.9688636064529419,16.720378875732422,15.422695223979982,23.325329066984917,0.01851261407136917,0.008041225373744965,0.2702982078458706,0.47260835685519825,0.49105042089002837,0.002524366355792412,0.004669796365002791,0.6441920573742758,0.0038926195121177514,0.9936521870358345,22.560553496084836
+fcd1e637-3ac0-49af-920e-6bc5ae2e32cf.mp4,3696,2256,25.0,8,h264,39087.017,0.18750871653464737,0.016150920847465354,0.01093951482914249,3.45924711227417,3.2307815551757812,2.0072982843731174e-07,2.5420711040496826,50.68205261230469,16.757298690354837,23.392093338873003,0.12434706836938858,0.057585906237363815,0.4032672850400358,0.07724540338647816,0.3632161264328427,0.012838099523604844,0.005424946701774995,0.6764255555811407,0.021723695925823586,0.9999686643274331,23.093613988739953
+a5f32e7e-a5f3-4a7e-b7fd-dc0fb551e243.mp4,1896,1120,29.97,8,h264,23338.264,0.3667122768740209,0.061917931399880624,0.09050651748040987,7.628411769866943,7.722901821136475,4.143976236350943e-06,4.869390487670898,82.86348724365234,25.48501617108024,18.59554961507288,0.4847494661808014,0.2182989865541458,0.10021196512715723,0.4154083440689919,0.31292339984517015,0.13150884694595139,0.016520978262027104,0.2850421313039984,0.19162546149789028,0.9980037344579182,18.556904219657582
+59bb4aa2-724b-490a-944c-eaae28496192.mp4,3632,2096,24.0,8,h264,69412.382,0.3799168785064342,0.05599570354663959,0.04387347832666375,6.056894779205322,6.095084190368652,5.721938383188476e-07,4.240983963012695,80.17750549316406,31.89957463627171,17.26237240761681,0.36625877022743225,0.16681808233261108,0.2566843861128125,0.2162887687259836,0.4824837299832892,0.05429285100772326,0.017838669940829277,0.5918705022362714,0.09003080652890338,0.9984225156964289,17.10664600652759
+64e41231-4092-46c3-906d-5170de857162.mp4,2280,1264,23.976,8,h264,23777.783,0.34412221401855625,0.06413068881366671,0.06563721407950254,6.899465084075928,6.884190559387207,1.840766088924721e-05,3.9509806632995605,52.393699645996094,20.247946697586123,19.842513662545336,0.35146045684814453,0.1335129588842392,0.16689629522158192,0.26620844908768154,0.4625996798249243,0.13319604060256127,0.02110528325041135,0.575414307128581,0.20663741533422164,0.9915836759698328,18.958802985591056
+ea63ccc6-22fa-4b9b-91eb-67da4241ed6d.mp4,4304,2328,23.976,8,h264,43452.978,0.18087876209446968,0.1394414925377527,0.020270283217721227,7.215000152587891,7.374978542327881,0.002333856738159803,2.0605454444885254,46.671119689941406,51.1518810685618,12.604765054991669,0.08702545613050461,0.04784707725048065,0.1353242805091566,0.4523556977557734,0.30124959418556235,0.030720643467596676,0.008035152995338043,0.14340332336897502,0.054066424264489835,0.9066783540598498,10.662733148504527
+2b4b64a6-a07f-4bce-93eb-0b3ce53e0575.mp4,3784,2008,29.97,8,h264,38360.653,0.16845519635715442,0.05625774827874177,0.028772252427920454,6.830992221832275,7.0621795654296875,1.0617354107425008e-05,2.7690491676330566,41.869808197021484,17.13586170732713,21.158016507670354,0.16543090343475342,0.06936812400817871,0.1945907355813904,0.40093583679074135,0.19673515344582784,0.08179026318966559,0.01480244193226099,0.9143815857079082,0.14012449146332218,0.9930504353683388,20.31808044588177
+0ea244ef-3544-428f-9fff-61478f587f35.mp4,3944,2208,25.0,8,h264,12865.465,0.059094832179498485,0.11012237717646367,0.0002517583120204604,6.680722713470459,6.933882713317871,0.00017665350417377763,0.6035935878753662,8.824653625488281,28.863994801312817,16.080064259744987,0.00619066646322608,0.0023995821829885244,0.2047775009718129,0.3565399725466467,0.43710182121189506,0.0004759415635319595,0.0027012270875275135,0.2223476956374754,0.0005275395390540024,0.9722050198948968,15.090727575904303
+620bbe9f-f29d-49f4-a6bc-9f8131e754ff.mp4,2112,1200,25.0,8,h264,9701.962,0.15312440025252524,0.02665024749641018,0.011701467803030304,7.390368461608887,7.473071098327637,7.221126922539258e-07,1.7604080438613892,33.12004089355469,14.255431724624623,24.171731641019242,0.06621285527944565,0.030513504520058632,0.10253218572419898,0.4184056754225259,0.3524694452696904,0.02344039351851852,0.0073311009133855505,0.06284248737373738,0.0384597932449495,0.9987974335883343,23.30514680986035
+99010e5d-5200-4ef1-b624-88c69622c407.mp4,3944,2208,25.0,8,h264,12865.465,0.059094832179498485,0.11012237717646367,0.0002517583120204604,6.680722713470459,6.933882713317871,0.00017665350417377763,0.6035935878753662,8.824653625488281,28.863994801312817,16.080064259744987,0.00619066646322608,0.0023995821829885244,0.2047775009718129,0.3565399725466467,0.43710182121189506,0.0004759415635319595,0.0027012270875275135,0.2223476956374754,0.0005275395390540024,0.9722050198948968,15.090727575904303
+0e4ce3ab-c7c1-4dd6-9d9d-983eabf8acf3.mp4,2176,1312,29.97,8,h264,12034.455,0.1406523388637023,0.03684070183764189,0.004346403671987088,6.438337802886963,6.428807258605957,3.48921061212562e-05,1.674142837524414,29.440975189208984,15.898470576627409,22.83817060754813,0.04417116567492485,0.019086694344878197,0.27141317766616685,0.5323091666051284,0.1473271014321708,0.01067878799766858,0.0052575784890602035,0.5868236919386657,0.021302758193597563,0.9938409873174072,22.136717544720863
+708b5e08-9d59-4b41-9dba-f7735682a9b4.mp4,4032,2320,29.97,8,h264,22724.011,0.08105685321222518,0.04181160450590676,0.0013245330459770114,6.826323509216309,6.934536933898926,0.00012277416719666518,0.9263733625411987,16.907251358032227,21.607056072394094,20.696646810375498,0.01667613349854946,0.007195150945335627,0.2228156889157377,0.39245652413663423,0.7564402887392186,0.002196544027093596,0.003596095290655891,0.5808692813811348,0.003489219861795293,0.9858591746085408,19.987420021489257
+dd477309-fa8a-4317-94ff-d8b54bc3cad1.mp4,3944,2168,25.0,8,h264,18113.648,0.08473634574073935,0.13552349128483232,0.005636896252329663,7.531042575836182,7.696881294250488,0.0003072400958021315,1.3717228174209595,31.410131454467773,42.14882312955888,13.435164381319346,0.03994758427143097,0.022566335275769234,0.09825435672437731,0.4887902318051936,0.4495643316600509,0.009923211554630761,0.006664993241429329,0.16810516355670657,0.018782968477504245,0.964893394653431,12.38130718901219
+8b6d7852-7f21-47df-aa03-fc8c0f29e6d3.mp4,4216,2472,25.0,8,h264,30733.787,0.1179578911896735,0.14168876190277946,0.004752718108853313,6.274033546447754,6.732527732849121,0.0004122308285955512,1.4978402853012085,33.24341583251953,54.00886169112629,11.911389710325768,0.03861694410443306,0.022224539890885353,0.15351031888166186,0.5920864945591565,0.2681580551402431,0.008266845468743922,0.005113481233517329,0.13570151413733886,0.015360606151323666,0.9985361279804811,11.7227002191702
+ac12840e-397e-4d7e-ab6f-e43091e014fc.mp4,3840,2160,29.97002997002997,8,h264,14730.141,0.059256330138406636,0.08866558526140009,0.005286048418209876,7.256598472595215,7.234145164489746,0.00016839457810677365,0.8481879234313965,21.269725799560547,27.460039181811666,17.16618146535135,0.013288619928061962,0.009028784930706024,0.1450372010687532,0.30018618010797427,0.5296609669395022,0.011812829539609054,0.003580046041558186,0.22758680555555555,0.021873613522376545,0.9926868678702191,14.919262283403194
+d2b97603-9f13-4042-a901-0ebe567b36d4.mp4,3840,2160,29.97002997002997,8,h264,14730.141,0.059256330138406636,0.08866558526140009,0.005286048418209876,7.256598472595215,7.234145164489746,0.00016839457810677365,0.8481879234313965,21.269725799560547,27.460039181811666,17.16618146535135,0.013288619928061962,0.009028784930706024,0.1450372010687532,0.30018618010797427,0.5296609669395022,0.011812829539609054,0.003580046041558186,0.22758680555555555,0.021873613522376545,0.9926868678702191,14.919262283403194
+5e800829-24b2-4ca7-bac4-89a02199fbec.mp4,1928,1144,29.97,8,h264,7670.417,0.11603771761102329,0.05360339340557336,0.01584053912892087,7.499912261962891,7.669247627258301,3.0794927409911567e-06,1.919191598892212,37.07494354248047,23.266718409618136,19.513456136493758,0.07946397364139557,0.04009568318724632,0.11794912686657971,0.5208322161695057,0.2232629198900251,0.03020419241892271,0.012287287972867489,0.263849394036116,0.052798925659402834,0.9977240688080937,18.971216361292488
+66a24ee2-bdd0-4c76-82c0-9bbad7d24301.mp4,3960,2120,25.0,8,h264,11641.273,0.05546632837812083,0.06259769366341925,0.004200971983990852,3.4773783683776855,3.5694053173065186,1.093904618691676e-05,1.755215048789978,40.48407745361328,46.313463127672705,14.334369893453339,0.050556451082229614,0.029183844104409218,0.32478808327863545,0.20282036653998362,0.11656953273018755,0.004839035004129344,0.002967640214289228,0.3960360682294645,0.008121783876500858,0.998263455401219,13.03948355272954
+1fda2da4-b877-415b-a0b2-9643e8c19343.mp4,3784,2008,29.97,8,h264,35429.582,0.15558382680977573,0.054290184688844834,0.012602681241208526,6.694496154785156,6.919416904449463,6.802361220513092e-05,2.3386123180389404,34.62127685546875,17.733186253125023,21.161139783311604,0.11751548200845718,0.04617464542388916,0.16985528248036963,0.47733727290811884,0.17626277868806386,0.041349226069646715,0.011168087211747965,0.7232348793690635,0.07039515037103172,0.9971271971765552,19.74997773179496
+61a7d453-d120-440f-abfe-fa05714179b4.mp4,3456,2104,24.0,8,h264,17260.798,0.0989077128038011,0.0727313055577991,0.002759624524714829,6.432045936584473,6.439814567565918,0.0001275077932272746,1.2637557983398438,24.746780395507812,31.690624780635517,16.873166012287463,0.028985248878598213,0.01408995222300291,0.2357989120564686,0.19393517288886405,0.6341521050899118,0.004715903423226776,0.005453494377434254,0.6904527457987139,0.008170132837804534,0.9847355475512977,16.241323427262568
+f11482e6-3485-46a8-9ade-92b46a803067.mp4,2016,1184,30.0,8,h264,14361.645,0.20055832897629772,0.028791556212856766,0.022591480989918488,7.037728786468506,7.124327182769775,7.288890164255228e-07,2.6167094707489014,42.61678695678711,14.121280569674624,24.095855414292735,0.13105686008930206,0.05644969269633293,0.20156533900233317,0.5128782488502158,0.26388842777476357,0.05298239087301587,0.008641775387028853,0.5257810824217074,0.08510191273863149,0.9993833200979341,23.873213487190434
+a201f3de-fd3d-40c5-98c8-106b4ebb66ab.mp4,4008,2224,29.97,8,h264,14194.301,0.05313305309909823,0.006167030205529131,0.0025307523442323985,6.775632381439209,7.032013893127441,1.0845960374904866e-06,0.975328266620636,19.8259220123291,5.08622773136614,33.988931964386175,0.017742745578289032,0.00878979917615652,0.24839167533013198,0.4332490194001896,0.6622677167940415,0.003750816711899941,0.0044474839232862,0.4396791698377825,0.005154259825672396,0.9987883521995367,32.68039384243157
+424df265-1080-4edf-8cfc-b05f62acfffc.mp4,3744,2176,29.97,8,h264,78212.749,0.3203288662187934,0.044290915204812126,0.05802588062468578,7.5659027099609375,7.705513954162598,1.0996226667551192e-06,4.917513847351074,77.87395477294922,24.95601362652544,19.381304863013963,0.5003300309181213,0.20496885478496552,0.09013898324527037,0.40636702643876493,0.2718818422945892,0.08350865469718871,0.015887831648190815,0.2587865257614798,0.11370963148881347,0.9993580352362319,18.992862809167306
+ed1f86d1-17f2-462c-b82f-2d216774d941.mp4,3944,2208,25.0,8,h264,12849.851,0.059023112524620044,0.09063094842518908,0.00021101581562160096,6.528778076171875,6.836049556732178,0.00026608133723672546,0.6988304257392883,9.258260726928711,24.62951147116612,17.672909244450967,0.010030598379671574,0.0036405890714377165,0.2560277151441734,0.33395559014754445,0.4541880383818087,0.0008360939015786224,0.003517815455173453,0.29770278769928754,0.0017992497317517713,0.9728774016790624,17.639947833500877
+2efd6ba4-b102-4009-b197-da0cdaa634dc.mp4,4176,2264,25.0,8,h264,20832.096,0.08813655009950855,0.13059464685199518,0.0005394488783287979,7.103693962097168,7.16506814956665,0.001146094109949705,0.9840006828308105,15.54456615447998,39.08756451032873,14.196888635731524,0.01746043749153614,0.00722542405128479,0.17444827832782725,0.3013473596598065,0.2914109880184468,0.000796836993262301,0.004156547986591856,0.7164728393557441,0.0004970667824215101,0.9454958452824559,14.345898901049
+12dd2d2b-24f3-4c31-b873-fa4e53803778.mp4,3720,2000,24.0,8,h264,11168.197,0.06254590613799284,0.07419144172991776,0.001096532258064516,7.326708793640137,7.03421688079834,0.001104908264344367,0.7990032434463501,13.855031967163086,29.186652483284004,17.709958092816727,0.012685537338256836,0.00547337532043457,0.14025580058292889,0.34718295628645723,0.7360188973223698,0.0018994175627240143,0.003929015016183257,0.03343413978494622,0.0028954301075268815,0.9861516260805397,16.066609960586902
+12cb34d6-c1d8-4b85-8f0e-60afaf26ffc9.mp4,3992,2128,29.97,8,h264,82020.534,0.322161540486348,0.19442412024402633,0.031029399023611133,7.5067291259765625,7.659872531890869,0.0004892454112115741,2.5568833351135254,51.4112548828125,47.859217215903854,11.412570567182874,0.14925998449325562,0.07771322876214981,0.10661558367184167,0.4059681511346936,0.39410029608826963,0.05666945576616892,0.01621010371794303,0.1896969848217739,0.09928256418852743,0.9999994889713084,11.553677315658312
+918a9d77-727b-4255-bf27-d67c73ab109e.mp4,3848,2352,23.976,8,h264,44989.268,0.20732888701303545,0.10167412079176785,0.02935350725529297,7.006922721862793,7.049823760986328,0.00012149487561601138,2.5566444396972656,58.17711639404297,41.720730871253046,14.345926883977612,0.13242904841899872,0.0732438713312149,0.15790827165681595,0.29049045727091943,0.4459472019345969,0.044000461411175695,0.009885285670558611,0.3789205217776646,0.07739791277737706,0.977604551435959,13.299115682322263
+acfbb4ee-70e5-45bf-8aa8-349e388499ed.mp4,3840,2160,29.97002997002997,8,h264,14730.141,0.059256330138406636,0.08866558526140009,0.005286048418209876,7.256598472595215,7.234145164489746,0.00016839457810677365,0.8481879234313965,21.269725799560547,27.460039181811666,17.16618146535135,0.013288619928061962,0.009028784930706024,0.1450372010687532,0.30018618010797427,0.5296609669395022,0.011812829539609054,0.003580046041558186,0.22758680555555555,0.021873613522376545,0.9926868678702191,14.919262283403194
+bdc6f64e-fe6c-4f98-b37d-a8405f0674a6.mp4,3840,2160,29.97002997002997,8,h264,14730.141,0.059256330138406636,0.08866558526140009,0.005286048418209876,7.256598472595215,7.234145164489746,0.00016839457810677365,0.8481879234313965,21.269725799560547,27.460039181811666,17.16618146535135,0.013288619928061962,0.009028784930706024,0.1450372010687532,0.30018618010797427,0.5296609669395022,0.011812829539609054,0.003580046041558186,0.22758680555555555,0.021873613522376545,0.9926868678702191,14.919262283403194
+17434ca5-7913-4355-95b4-a002b59756b8.mp4,3696,1816,24.0,8,h264,30840.548,0.1914533799686608,0.09403842515430282,0.00045524867936762206,6.87848424911499,7.145921230316162,0.0005040077409196204,1.1077892780303955,15.351152420043945,25.374898278246885,17.40825033016248,0.023234063759446144,0.009360809810459614,0.2048374967811586,0.41752296928427396,0.2840800078207762,0.001776139303672343,0.008505044815440973,0.09504590031847744,0.0028014271888170566,0.9861948653276555,17.26781125231009
+cee06fa7-1a4d-4fe2-bf89-72bb8aba00cb.mp4,2008,1112,25.0,8,h264,12181.487,0.2182186183324257,0.04550726201907,0.028817553526899596,7.058570861816406,7.43195104598999,7.610834804144257e-07,2.839144229888916,46.980247497558594,20.172486329717614,20.7952804170892,0.16278205811977386,0.06897910684347153,0.17154791186967153,0.4820452520102503,0.3098746465681919,0.05630953404606992,0.011344536518057188,0.1670079275225238,0.09294991795408294,0.9987712448976839,20.14113077880257
+da4c28f0-dce4-49b6-b992-df633c640d41.mp4,3880,2200,29.97,8,h264,106895.356,0.41784738502951563,0.12358454021721155,0.14118765229615743,7.390982151031494,7.575097560882568,4.107447877914606e-06,5.464156150817871,84.04344177246094,32.18738204100126,15.05805100501491,0.6543295979499817,0.29104089736938477,0.13737582217231528,0.5046602271961581,0.38149802344242917,0.19782860824742268,0.03251042154928049,0.4851184786004373,0.29476563964386127,0.9992652571806605,14.78405775820291
+40949702-a809-4464-9d14-481e76abd967.mp4,1992,1080,25.0,8,h264,9412.376,0.17500327234865387,0.032604545360089596,0.03276494868362338,7.598055362701416,7.5778489112854,1.475981234591597e-07,3.0299410820007324,64.2403335571289,25.126574892633183,19.677779473362378,0.17224721610546112,0.09297648817300797,0.1250032341526129,0.3511127182416424,0.38581022650271873,0.04277542267836779,0.014354931811491648,0.16483495711240023,0.0433976647330061,0.9995155513120019,19.673463950479913
+0cb873d6-4c3a-4ced-84e9-87939b08565d.mp4,3928,2176,25.0,8,h264,16372.595,0.07662088081795855,0.0655690748284945,0.00997179469420151,7.153440952301025,7.235421657562256,0.00026610638080850317,1.4226818084716797,38.33115768432617,37.17439902946259,16.020326652970137,0.036770280450582504,0.025037065148353577,0.1093549868154569,0.49416280431220255,0.2712272513396657,0.013138959918234097,0.0052625991714497404,0.04287055167026075,0.024374108493320952,0.99460809731599,14.191413000600473
+04d651c3-3b08-4de9-befe-af12b3b3555b.mp4,1928,952,25.0,8,h264,9760.685,0.21271411572927926,0.14567895058316224,0.027217868475190903,7.379861354827881,7.489706516265869,0.00013466543611205162,2.472189426422119,50.065956115722656,45.60677688392366,12.756305164144322,0.14299236238002777,0.07285106182098389,0.12647779103585507,0.3213473471114912,0.3275197079482676,0.05156266344712159,0.016033847195406754,0.13787563780699003,0.09244841608842708,0.989902800881153,12.372051285756838
+249c9213-36ad-4280-a900-306b96685c0e.mp4,4352,2512,25.0,8,h264,47129.108,0.17244106231266393,0.023663026379807144,0.0075284772796459344,7.559027671813965,7.671954154968262,1.689348490249105e-08,1.852216124534607,30.534713745117188,10.00865205155331,26.776982325943163,0.07633254677057266,0.032172251492738724,0.11798659075028768,0.48566255651266843,0.1818267550762109,0.03302835116928937,0.00833408534526825,0.22812887844230054,0.05521717264483421,0.9998370150268331,26.456385705685307
+9ebd5e08-2435-46d7-8e11-92081982e848.mp4,4424,2264,29.97,8,h264,33097.411,0.11025942904567794,0.08548973267964877,0.015146562438098646,7.627282619476318,7.660618782043457,0.00014808484929126182,2.1128036975860596,39.34710693359375,34.54669112188891,15.952876977581399,0.07846289873123169,0.03848755359649658,0.0661154613354953,0.5784150388398565,0.3487781411412055,0.02954914381774537,0.006871931720525026,0.07993548148337477,0.054171871705250514,0.9848161683267036,14.44176895583773
+dcc6663d-5979-4b94-8780-8f08f1459367.mp4,3992,2272,29.97,8,h264,45433.897,0.16714538369717863,0.023237782027220693,0.07615909636173757,7.42056131362915,7.560868740081787,7.731473646370793e-06,4.520887851715088,91.29413604736328,11.91958356243395,25.684373716053614,0.37042751908302307,0.20396246016025543,0.13353506631010406,0.339642842742698,0.3444164673070249,0.10233517210477293,0.02325626400609811,0.3504134883616999,0.13692911791893647,0.9939171225978607,23.759774352151624
+58628666-a50b-4b53-86f3-9bce954fd87a.mp4,3656,2064,25.0,8,h264,14674.839,0.07778886888707953,0.017275690657986773,0.002144610961274235,4.755399227142334,4.147421360015869,7.62657340612031e-08,1.6233251094818115,30.24703598022461,20.98089051055077,21.510398834978275,0.043102558702230453,0.019970102235674858,0.3801464858933288,0.13324564785684487,0.611579316008798,0.0024631645124081896,0.002573372796177864,0.6121459220339367,0.003477677662714366,0.9973595402976382,21.254861574329713
+2884fdc7-6b49-4008-ae33-54956784cf22.mp4,4136,2528,29.97,8,h264,96794.101,0.3088904973261177,0.199906057559813,0.03463755264059937,7.677958011627197,7.735160827636719,0.00022584952147722116,2.6518115997314453,55.998802185058594,53.27854414451389,10.790513990351288,0.1351182460784912,0.07386935502290726,0.07412626065180299,0.43634340055791515,0.3657297264831183,0.04920470995641848,0.013960901958247026,0.09381975389499625,0.09218259363599637,0.9924948222041553,10.641904721237971
+bb85c24e-dfb2-4e74-a538-7b88444ba7a2.mp4,2064,1136,29.97,8,h264,6202.448,0.08826496730016038,0.012213032049264733,0.0028290138115514797,5.526223659515381,5.956391334533691,4.203832669183327e-08,1.2413911819458008,19.35202407836914,5.566881250909669,32.03723612534702,0.03160261735320091,0.012331601232290268,0.36391833500018755,0.4339056100931475,0.6477346277180488,0.006277124959056666,0.005463352271666129,0.8203375209265932,0.010636523842668414,0.9998206337412681,31.55410760665986
+f0bab96c-7918-40b7-8e75-470ee67f2ce4.mp4,3912,2280,25.0,8,h264,42667.338,0.19134708319879454,0.018852291477169207,0.01145851271840132,3.321286678314209,3.2959964275360107,5.20539861462992e-07,2.6433749198913574,53.428077697753906,17.742542955666103,22.845592024866512,0.13821403682231903,0.06435994058847427,0.4485925112259545,0.05237976378738391,0.36296210795276146,0.013614579222425526,0.006106317198524873,0.8541742905320562,0.023815273741613747,0.9990574532561204,22.65985438616542
+d863f7e4-dceb-4f47-8a78-dd6d1e4e880d.mp4,2200,1240,59.94,8,h264,24399.684,0.14921864679929195,0.05437209332413317,0.026887829912023466,7.528630256652832,7.624697685241699,1.1223690996102738e-05,2.919034004211426,34.91337203979492,15.516372340225086,21.779762544291827,0.1871851682662964,0.06431771069765091,0.1103539881428786,0.3952507633258582,0.3379617215801276,0.06735056207233626,0.012368634343147278,0.28846700879765397,0.10835392228739002,0.9977341311597953,20.767000095983466
+ce34e0c1-7378-4fc8-96c7-44ddcbbf1487.mp4,4360,2352,59.94,8,h264,126287.219,0.2054560121788351,0.09277246707169107,0.05140101338700618,7.024899959564209,7.290508270263672,0.0001558291963913309,3.5155029296875,59.61481857299805,30.760610209878767,16.37874440928109,0.30129268765449524,0.12735895812511444,0.19224018761074277,0.5702624508009116,0.17240642905990122,0.085398268634671,0.016718280191222828,0.30273506573883374,0.15168595534544094,0.9744751753912574,15.8732601360474
+4df1a23d-73f2-4cab-b43c-5538b566a458.mp4,3840,2160,29.97002997002997,8,h264,14730.141,0.059256330138406636,0.08866558526140009,0.005286048418209876,7.256598472595215,7.234145164489746,0.00016839457810677365,0.8481879234313965,21.269725799560547,27.460039181811666,17.16618146535135,0.013288619928061962,0.009028784930706024,0.1450372010687532,0.30018618010797427,0.5296609669395022,0.011812829539609054,0.003580046041558186,0.22758680555555555,0.021873613522376545,0.9926868678702191,14.919262283403194
+d69e637f-ced7-4a94-b11f-7e3a7fc584c5.mp4,3864,2416,30.0,8,h264,35921.109,0.12826094454842116,0.02301661213602439,0.009748609168689071,7.3477983474731445,7.533846855163574,1.3443314194611425e-06,1.5714272260665894,32.717960357666016,17.222614996056663,22.955994719305767,0.048455942422151566,0.02490154840052128,0.12732583616434356,0.43533010538412503,0.41831419187872226,0.017358825908710733,0.005998436671992143,0.2724476860040493,0.028833130664445452,0.99976134757579,21.705490783403683
+e7f5193f-e47b-4376-977d-feb98314b110.mp4,1976,1112,29.97,8,h264,15888.659,0.24127302758345293,0.11828014829741351,0.04825368450179128,7.395143032073975,7.48813009262085,2.0638003672822308e-05,3.874429225921631,70.99330139160156,40.35615202717711,14.08389671485215,0.2872275412082672,0.13475967943668365,0.12244732204030821,0.450834061852685,0.40473016799706213,0.06874262735560539,0.01605181209743023,0.2834111253507316,0.11797573580811463,0.989530204248128,13.702267426394744
+be4a76cd-c69a-433b-b55c-9dfd478c9594.mp4,4200,2128,59.94,8,h264,76809.881,0.14337698369392188,0.10147443451064636,0.04369175170068027,7.535388946533203,7.552706718444824,0.00010668694178254137,3.557075023651123,75.94049835205078,39.92224579659751,14.607808994386144,0.2657359540462494,0.13470318913459778,0.10662796044874044,0.4325665933039882,0.5377423675610595,0.05649175020885547,0.01610845203200976,0.19080513784461153,0.09768808181167205,0.9839293682385235,13.14202322363013
+d31d550a-bebb-4124-bd43-8b60d0e18de8.mp4,2256,1208,23.976,8,h264,14792.29,0.22638760914445671,0.04817584689252386,0.0726737529942229,7.142242431640625,7.410560607910156,6.98028072093307e-06,4.173787593841553,85.20892333984375,21.70381119343126,20.200777240953116,0.32179033756256104,0.17825736105442047,0.1331180156782398,0.34578490073208995,0.3365648953207698,0.09813797985846916,0.02062916321059068,0.42634162713509616,0.15032264953501479,0.9993916711217388,18.366078180220182
+8fb42072-b53c-4ee3-b54d-4c2e1cf6d1ea.mp4,2032,1048,59.94,8,h264,23215.269,0.18187457664883735,0.09169163344208574,0.06755152296087034,7.2440505027771,7.581101894378662,0.00015709599938584044,4.340128421783447,69.27568817138672,32.185418920775575,16.1816205304785,0.4326435327529907,0.18270862102508545,0.1589946302332441,0.48114556349026766,0.26464688149808624,0.1195052192903368,0.0232531875371933,0.48419154845625206,0.19298147577688285,0.9696954825913656,15.691813835264224
+7fb26377-5336-45c3-8648-14c7df0d1822.mp4,2112,1080,25.0,8,h264,6974.183,0.12230259189113356,0.06908184513985167,0.015561517957351289,7.259411811828613,7.45736837387085,0.0040572175292709475,1.9812953472137451,46.00967025756836,30.231063424849967,18.777326329420777,0.07225863635540009,0.04395774379372597,0.12630594757500477,0.5686536038260235,0.377071315116488,0.02405580691170969,0.009015806329747042,0.5724709479049758,0.03894938973063973,0.9592674120012764,18.98384660344204
+6084559b-4f79-480c-ae41-bdb3d0a6987c.mp4,3864,2176,24.0,8,h264,7392.491,0.036633933606277654,0.007060472180133776,0.0033822768237729874,6.447038173675537,6.402669429779053,4.679335826993654e-07,1.1656887531280518,21.539216995239258,7.748514322343443,30.126523878507157,0.022850245237350464,0.010489453561604023,0.20668072131675053,0.23095527002449887,0.2557928800116594,0.003746998119900134,0.002171670629953345,0.6112707197915398,0.005819234963006942,0.9988106814283685,28.143217609294314
+39c98272-d26f-4139-afbf-d870b7553fab.mp4,1912,1152,29.97,8,h264,9800.944,0.1484707142443854,0.039509684100133544,0.005349891765457927,6.316155910491943,6.450854301452637,3.7880130015596525e-05,1.5432862043380737,27.982141494750977,16.21058546361702,22.550528458925847,0.037944767624139786,0.01664702780544758,0.29896926714339833,0.568221517441918,0.16585721322902708,0.014577158879590886,0.005653653138627608,0.511477219897722,0.030219638031729425,0.9934711756986034,21.820869112944806
+c6b21693-9149-46a7-8062-b4e36d861374.mp4,1800,1040,25.0,8,h264,5696.982,0.12173038461538462,0.01285861980475951,0.02749284188034188,6.882208824157715,6.9071173667907715,2.307484042479586e-05,2.7927966117858887,39.489967346191406,3.6518314388026685,34.61616402154644,0.17552293837070465,0.06558234244585037,0.18862381126808184,0.37493412518853697,0.47208936651583705,0.06163301282051282,0.012805463746190071,0.32623967236467233,0.044903044871794875,0.9997276437070555,34.748478048384115
+b2b4e988-b71d-4d6f-a5dd-8db222348faa.mp4,1992,1232,25.0,8,h264,6935.385,0.11303957713972775,0.050860870829255396,0.006131669535283993,7.336886405944824,7.4586381912231445,3.8484092229019065e-05,1.7237539291381836,31.403980255126953,23.852990816751063,19.455405851878844,0.05761508271098137,0.02627158723771572,0.09626810904856715,0.5841186732542597,0.19463759939597114,0.010529401154401154,0.006394967902451754,0.13623840600497225,0.01848343047514734,0.9897579143924821,18.269961000639935
+b803a998-c442-4979-b250-eae2183f1ba1.mp4,3840,2160,29.97002997002997,8,h264,14730.141,0.059256330138406636,0.08866558526140009,0.005286048418209876,7.256598472595215,7.234145164489746,0.00016839457810677365,0.8481879234313965,21.269725799560547,27.460039181811666,17.16618146535135,0.013288619928061962,0.009028784930706024,0.1450372010687532,0.30018618010797427,0.5296609669395022,0.011812829539609054,0.003580046041558186,0.22758680555555555,0.021873613522376545,0.9926868678702191,14.919262283403194
+10e3a5e7-dda1-496d-84bb-f826e6567d82.mp4,2024,1160,29.97,8,h264,10593.035,0.15054459472875265,0.04069250301319929,0.005925275998364453,6.370438575744629,6.699704170227051,2.612764599108834e-05,1.745764970779419,30.442712783813477,16.2956588347572,22.448618378947685,0.06587354838848114,0.027121203020215034,0.20759801889914262,0.5772056769075355,0.15383775358310148,0.016580488165008404,0.007409828715026379,0.25078142746808413,0.027405402412430148,0.9977600003474199,21.799876719192074
+b82a043d-d96b-4c3c-bd88-36673c8734fe.mp4,4272,2384,29.97,8,h264,31535.814,0.10331890801013918,0.011293258112761733,0.009357463458009703,2.474804639816284,2.908219337463379,1.0601571477324355e-07,2.572373390197754,50.87281036376953,17.336855145358008,23.234466595816986,0.11729395389556885,0.05357654020190239,0.39416468191624854,0.12791683318994926,0.19959534213405927,0.010275209155501931,0.004424559107671182,0.6027152379785335,0.014619496314380514,0.9996167497583706,23.97460201814576
+f67fdc5d-c16c-434f-88b6-2885b6e16244.mp4,1704,936,29.97,8,h264,4124.463,0.08628498537862125,0.14167440865586234,0.0021714868985995748,6.9421491622924805,7.07874059677124,9.026881105823313e-05,1.47042715549469,24.149051666259766,48.281956539549896,12.537837268101267,0.03727716580033302,0.015906894579529762,0.11302669985011486,0.5849823456829463,0.23623558451241874,0.0032554956997445255,0.005870988437285026,0.34440038856118665,0.0038838354199269695,0.9677222326473224,12.12852561266281
+a8fb16e1-2992-4ab7-95b7-47d48938f465.mp4,4416,2512,25.0,8,h264,47626.46,0.17173530820179084,0.024266345674041102,0.008263884081048648,7.565223693847656,7.665775299072266,4.3365062148095007e-07,1.8574262857437134,31.593847274780273,10.497816387919835,26.415430650927703,0.07536498457193375,0.032022129744291306,0.10909541513361631,0.5430451944241572,0.15671558099694924,0.03231884298363027,0.007478163422395785,0.2131279520139081,0.055001346796247574,0.9987616523664529,25.996976327787028
+cf64e339-3346-4871-9275-ae8d71e69299.mp4,2224,1224,30.0,8,h264,15362.231,0.1881121450878513,0.06601673786403403,0.028416090656886255,7.328147888183594,7.462838172912598,5.204401908026663e-05,2.646209478378296,54.8980827331543,28.458309405125572,17.763753460185995,0.13267822563648224,0.06757838279008865,0.1174268615084031,0.39672566301053735,0.268810764056959,0.03962761163618125,0.011698253452777863,0.1732410640115359,0.06870165632200123,0.9941397876508482,17.797069126857515
+43a9cd6b-81bc-438d-819c-6352d7193145.mp4,3784,2008,29.97,8,h264,36206.249,0.1589944463315321,0.054590670708535086,0.02001489285985024,6.582436561584473,6.803387641906738,6.757863391028719e-05,2.5635905265808105,38.959495544433594,18.689710073875673,20.818489665846208,0.13612745702266693,0.0552828311920166,0.17039050492755023,0.45392823078893096,0.18310380040864058,0.05806890478958023,0.012364944132665793,0.731457977111989,0.10490970841791397,0.9815015737117856,19.175683075370202
+b7340fda-e72e-4b12-9029-316dbd0c9ce8.mp4,3856,1936,23.976,8,h264,14123.499,0.07890839236174724,0.013572721019411503,0.011638537987380406,7.1876540184021,6.9774322509765625,0.0002915820148605531,1.9975744485855103,37.95682907104492,7.40499957796313,36.933488581518844,0.07592128217220306,0.03492182120680809,0.1509332493571397,0.3837449406136722,0.3531127043688376,0.016453866394042272,0.005977872293442488,0.0796282384863345,0.018695976111073008,0.9611574445177921,30.707378416224845
+c7d92eab-29ca-490c-ab85-e18229efdf96.mp4,4344,2512,29.97,8,h264,81522.02,0.24927500735458025,0.1000569803131514,0.03622233903414623,7.442636013031006,7.571652412414551,9.676651968898144e-05,2.972356081008911,65.53794860839844,41.86743263941248,14.34625876647874,0.19248835742473602,0.10125032812356949,0.09619653533017665,0.48763471764711247,0.2784021018853362,0.04904026663421348,0.01487108568350474,0.13413356832568926,0.08725383353274449,0.9874909332758101,13.507726959867174
+70b2de9e-3c32-4b01-8505-8a78d5bccd59.mp4,4128,2344,59.94,8,h264,31615.423,0.054511102054488995,0.014116425747134979,0.004135806909278514,7.5224289894104,7.6964850425720215,1.6491528859753852e-07,1.345127820968628,23.74616241455078,10.07343460190578,27.54507604897654,0.03602388873696327,0.015233230777084827,0.12069503858303476,0.511027495028049,0.29980149562955943,0.007821250143309434,0.0043184760337074595,0.282369536052244,0.013587026169404978,0.9988060480115135,26.282205403914354
+a3fa72da-8a4e-466c-9a11-fc2a67863b9e.mp4,4064,2328,29.97,8,h264,55651.917,0.19627126001383585,0.1697815446090767,0.01374202620613145,7.539480686187744,7.7134599685668945,0.0003595651628055783,1.936773657798767,40.06705093383789,45.708446787003915,12.175698271848955,0.0872727632522583,0.04557924345135689,0.09998841819431721,0.42120852938015224,0.39739355828828454,0.026862722217712475,0.01140574086457491,0.0736418196597848,0.052145853204399704,0.9822594713112537,11.54028731617105
+34e7d8b9-5fd5-44d6-ba9c-194d4e2078ae.mp4,1864,1112,25.0,8,h264,7053.062,0.1361090483836107,0.054158667984824466,0.016409361780961498,7.490847587585449,7.695387840270996,0.00029081383222468306,1.8844280242919922,49.36473083496094,27.493341599677112,18.712213241512394,0.07012951374053955,0.04689024016261101,0.11799043690058277,0.49315103837152446,0.3031222125304049,0.022825677226459177,0.009728438220918179,0.2783456711026029,0.04091823108037175,0.9759738649373356,17.535968238489765
+9d860f37-78b5-4e91-bbff-91bbfaaaa32a.mp4,2176,1128,23.976,8,h264,20564.598,0.3494423229093194,0.06460805954402254,0.06740179782019191,6.886200904846191,6.995933532714844,1.7384923576114026e-05,3.990297794342041,52.721641540527344,20.567321337157345,19.73471317473215,0.3589254915714264,0.13616614043712616,0.16749243576081677,0.2623429547776905,0.49264839289256585,0.1339137300531915,0.021455286691586178,0.4039163537755528,0.20700700908687944,0.991671204099078,18.815549968769943
+81e87893-da5e-4db2-afd1-b1bb11a03de7.mp4,1848,1080,29.97,8,h264,10031.907,0.16771466231342774,0.13550930690738697,0.010763087221420555,7.5518693923950195,7.611828804016113,0.0004041885873757899,2.7923357486724854,59.45957565307617,39.83156659420939,13.715216440202253,0.15859724581241608,0.08018888533115387,0.07077146702152066,0.4440622167310621,0.42761248822387166,0.013438953022286357,0.009651358239352703,0.2976868553257442,0.019547659130992462,0.9545209309874343,12.184221110468258
+329f1c4c-f5df-453d-9cfc-6f2cbef5142b.mp4,3840,2160,29.97002997002997,8,h264,14730.141,0.059256330138406636,0.08866558526140009,0.005286048418209876,7.256598472595215,7.234145164489746,0.00016839457810677365,0.8481879234313965,21.269725799560547,27.460039181811666,17.16618146535135,0.013288619928061962,0.009028784930706024,0.1450372010687532,0.30018618010797427,0.5296609669395022,0.011812829539609054,0.003580046041558186,0.22758680555555555,0.021873613522376545,0.9926868678702191,14.919262283403194
+0d0496e7-fe16-443b-9c16-369aa386bb4e.mp4,3824,2080,29.97,8,h264,76672.191,0.3216398955481069,0.042603158777894,0.053163999637914384,7.49969482421875,7.679389953613281,4.4176801376596195e-07,4.726040840148926,73.43344116210938,24.73622180177029,19.5001879954157,0.4522957503795624,0.18221168220043182,0.12557819123761416,0.39036642367224755,0.32774845807932124,0.07771807276579766,0.014697935121754805,0.1534577499731789,0.10635309382040553,0.9972791267899178,19.181592760557905
+e199cb9b-752f-4aa1-a4b9-1885fa53a026.mp4,3704,2192,24.0,8,h264,56749.399,0.2912316005367381,0.06223628419301381,0.05104786598823918,7.1486663818359375,7.31646728515625,1.790032174237729e-06,4.499476909637451,75.83165740966797,23.24094136818146,19.14477134501647,0.3928792476654053,0.17057494819164276,0.14824753398203114,0.3366086798822518,0.15801827706509972,0.07917789934469477,0.016016355405251186,0.3772218204295481,0.1360922079700777,0.9976828925927231,18.97621105248905
+4cf5400c-d443-4509-8128-dfdcd50a9fcf.mp4,4272,2384,29.97,8,h264,31535.814,0.10331890801013918,0.011293258112761733,0.009357463458009703,2.474804639816284,2.908219337463379,1.0601571477324355e-07,2.572373390197754,50.87281036376953,17.336855145358008,23.234466595816986,0.11729395389556885,0.05357654020190239,0.39416468191624854,0.12791683318994926,0.19959534213405927,0.010275209155501931,0.004424559107671182,0.6027152379785335,0.014619496314380514,0.9996167497583706,23.97460201814576
+e4bb727c-b404-4141-bfbe-af71df54c3ff.mp4,3840,2160,29.97002997002997,8,h264,14730.141,0.059256330138406636,0.08866558526140009,0.005286048418209876,7.256598472595215,7.234145164489746,0.00016839457810677365,0.8481879234313965,21.269725799560547,27.460039181811666,17.16618146535135,0.013288619928061962,0.009028784930706024,0.1450372010687532,0.30018618010797427,0.5296609669395022,0.011812829539609054,0.003580046041558186,0.22758680555555555,0.021873613522376545,0.9926868678702191,14.919262283403194
+abcae1d5-f557-46b6-8704-3b34ecdb3855.mp4,2128,1080,23.976,8,h264,9758.537,0.17709757077345611,0.06317856101992454,0.021328842940685044,7.17816162109375,7.319029808044434,6.02598328172642e-05,2.1986310482025146,35.48875045776367,21.518270390254973,19.59833060833165,0.11287132650613785,0.04843633249402046,0.16474877279461442,0.3239840455350431,0.46334531351526964,0.0428242191125963,0.013388105357686678,0.34700553467000833,0.08521303258145363,0.9898198109653218,18.315084527253653
+93495912-fd6c-435a-9fcb-c9cc978c122e.mp4,2008,1248,29.545,8,h264,12599.66,0.17017530504579095,0.09179893751414653,0.026034882904280316,7.28030252456665,7.439886569976807,2.6556406274797802e-05,2.5419487953186035,45.587520599365234,28.28280527215062,16.845219875476445,0.1255028247833252,0.05773575231432915,0.14505126243363076,0.5325459562996547,0.2646494876660611,0.045352377881635854,0.007195856577406327,0.08977498127149526,0.07977624757380733,0.9939426353785461,15.28308285240923
+e2dd775b-6dbe-49fd-876e-3e9b4a2e80cd.mp4,3912,2208,23.976,8,h264,44342.566,0.21411454779604497,0.09509652238055057,0.029812093410094543,6.707069396972656,7.182584285736084,0.00012590194600901514,2.597018003463745,58.731727600097656,40.9387849600393,14.626761505678672,0.1354481726884842,0.07431226223707199,0.1634576248055144,0.3116403942588515,0.4550657866970771,0.04392097151833082,0.00971723503122727,0.11038838752062285,0.07683003662087667,0.9770803141912644,13.593667907575028
+a508a47e-295b-4be0-ab3f-4b6478dacc65.mp4,4360,2352,59.94,8,h264,126287.219,0.2054560121788351,0.09277246707169107,0.05140101338700618,7.024899959564209,7.290508270263672,0.0001558291963913309,3.5155029296875,59.61481857299805,30.760610209878767,16.37874440928109,0.30129268765449524,0.12735895812511444,0.19224018761074277,0.5702624508009116,0.17240642905990122,0.085398268634671,0.016718280191222828,0.30273506573883374,0.15168595534544094,0.9744751753912574,15.8732601360474
+733704b4-12f7-4977-b920-6896bc9ca77c.mp4,3632,2112,25.0,8,h264,35757.395,0.18646018451308236,0.023405982271658993,0.0114293402082499,7.527238368988037,7.664534568786621,4.917982302283578e-07,1.9592946767807007,32.69782638549805,10.107730053748933,26.739501253563247,0.08349424600601196,0.03576952591538429,0.12351014467901057,0.5205489246068594,0.23741459897574257,0.04216461663718685,0.008015718931953112,0.1772868761958795,0.06795654785742891,0.9985238316412702,26.44615321681865
+07484eba-7a60-4754-ba0b-f9c0744af11b.mp4,3744,2320,29.97,8,h264,42375.281,0.16278036697297554,0.04680557474334414,0.021254674145299142,7.1397528648376465,7.319797515869141,0.00018653402036211456,2.0145583152770996,38.731197357177734,20.055538777924156,20.979329955462454,0.09581049531698227,0.04451819881796837,0.14676288494422374,0.3145919473712218,0.5450120102012216,0.04606807673887415,0.010496880548695723,0.3294798113763631,0.07769488653109342,0.9906222568234485,20.052267598182596
+026fe674-d8c4-40a4-96c5-0cb6f1fb7c06.mp4,4080,2152,29.97,8,h264,18497.378,0.07029444373790415,0.015048249600882703,0.006021302573073839,7.39658260345459,7.519859313964844,5.888028856840528e-08,1.1937366724014282,29.523151397705078,9.507835113867262,27.918117677847636,0.0281049907207489,0.016799675300717354,0.1342756832257432,0.3967183437811308,0.33484082860371595,0.010203382778142237,0.004288815738012393,0.2226463602789319,0.017361243986442162,0.9997948641607675,26.13181026051079
+af18139c-acaf-4c43-977a-9a86fb3f3602.mp4,3920,2208,24.0,8,h264,12827.599,0.061751711271012026,0.08963311173654244,0.0007833296362023069,7.278562068939209,6.828987121582031,0.0003169389877970123,0.9030637741088867,14.510713577270508,32.08218969560803,16.33525454985052,0.015057296492159367,0.006208827253431082,0.14356219282733998,0.3124642683160221,0.8005967936691585,0.0014279398353544317,0.0033351377739260593,0.0207769520851819,0.0021434117125110914,0.988551496232551,14.702759137373825
+fd4e4b88-600d-4a77-acdc-a1315ce301cc.mp4,4568,2672,24.0,8,h264,17424.241,0.05948124889122805,0.09230391342392479,0.0007026391612571703,7.3348565101623535,7.044018745422363,0.0003478555279513488,0.9210092425346375,14.63671588897705,32.29689578650071,16.21557571299345,0.01604432426393032,0.006564124953001738,0.13583912832934256,0.3137757971488773,0.7292011663634032,0.0011647567387117186,0.0032998408811787763,0.12096363315400722,0.0016134270425873297,0.9884601788362083,14.531413968873947
+a75909eb-460b-4eb8-ab69-1f81413fde39.mp4,3504,2216,24.0,8,h264,12771.349,0.06853172723523125,0.07632779644608449,0.0006379764024199265,7.036263465881348,7.020784854888916,0.00013900804781572326,0.7060607075691223,11.723587036132812,27.328210487867413,17.65899654426508,0.009950431063771248,0.0039873127825558186,0.18371826557134377,0.32048653231465507,0.7251103568436426,0.000994694390869778,0.0028258475164572396,0.043288330613388736,0.0012447738943013038,0.9744050005001919,17.147321929463487
+d4346f5c-0084-437f-a2ab-3eaedfc55c11.mp4,3616,2064,29.97,8,h264,18160.488,0.08119002157127286,0.01640264128993163,0.0017206311741098993,7.56039571762085,7.616456508636475,1.0569616206471612e-07,1.204588532447815,17.363248825073242,6.7892021762389385,30.0987914517863,0.03240012750029564,0.01197904348373413,0.08993872157304633,0.4335584335421187,0.3625504576623417,0.005593768579497382,0.005058024854709704,0.10961778400905531,0.010008743975955272,0.9993855382951184,29.301524936051145
+a3a1e82b-d8da-433a-bffc-fe9aa6c0d6b8.mp4,1904,1080,24.0,8,h264,3517.439,0.07127293336316008,0.037792377435723744,0.0050058356676003736,4.719388008117676,4.7925543785095215,4.7425856449873786e-07,1.670793890953064,34.762107849121094,28.021119450221647,18.698712076808796,0.04882233217358589,0.025018975138664246,0.32413395355304236,0.16579031467343655,0.3141739777792017,0.006094382197323373,0.003943651216104627,0.4692836393816786,0.009816808667911608,0.997371655361491,17.778837999654417
+5fe0ff99-37a3-4760-81a4-f441876cb867.mp4,3840,2160,29.97002997002997,8,h264,14730.141,0.059256330138406636,0.08866558526140009,0.005286048418209876,7.256598472595215,7.234145164489746,0.00016839457810677365,0.8481879234313965,21.269725799560547,27.460039181811666,17.16618146535135,0.013288619928061962,0.009028784930706024,0.1450372010687532,0.30018618010797427,0.5296609669395022,0.011812829539609054,0.003580046041558186,0.22758680555555555,0.021873613522376545,0.9926868678702191,14.919262283403194
+221cab7a-eb1a-4b14-9568-9ac4a4ec9330.mp4,1672,1096,29.97,8,h264,25545.608,0.46513891276344854,0.1205145017267201,0.11582920057276569,7.7315778732299805,7.773962497711182,1.0196675601302348e-05,6.703019618988037,100.35294342041016,41.351868413868374,13.893107574016607,0.9161150455474854,0.37918129563331604,0.05437708776697476,0.5162277035227647,0.293133004869604,0.15879368502543684,0.02824004056553046,0.3147559197429539,0.24483168459469842,0.9938609909003939,12.963095414146789
+3e9e0378-5364-4b63-89a4-c8be5c4b826e.mp4,3840,2160,29.97002997002997,8,h264,14730.141,0.059256330138406636,0.08866558526140009,0.005286048418209876,7.256598472595215,7.234145164489746,0.00016839457810677365,0.8481879234313965,21.269725799560547,27.460039181811666,17.16618146535135,0.013288619928061962,0.009028784930706024,0.1450372010687532,0.30018618010797427,0.5296609669395022,0.011812829539609054,0.003580046041558186,0.22758680555555555,0.021873613522376545,0.9926868678702191,14.919262283403194
+494e83e7-548e-408f-af3d-d702cc6ae594.mp4,1752,944,23.976,8,h264,5610.42,0.14148570006040403,0.07415588328242063,0.010378574607228542,7.490828037261963,7.702061653137207,7.470712731646609e-05,1.761763334274292,34.92809295654297,32.01824093913225,16.73719571119993,0.06444501131772995,0.03184501454234123,0.12185876870481349,0.5155074374479302,0.34469482376058025,0.02067350791992364,0.008139917006095251,0.39447451500141884,0.038919201300208955,0.9925388100348878,15.28414787432056
+814a4743-06ee-4a4b-9e77-e11bee77ceeb.mp4,1752,1064,23.976,8,h264,4392.675,0.09828259450871203,0.032987469576270786,0.0056733228619493935,7.031918525695801,6.870492458343506,1.6726312174518266e-05,1.5741097927093506,26.83880615234375,14.938224865451867,23.5008968614912,0.04748789593577385,0.02055317908525467,0.1985460133073029,0.22976535062474882,0.7212429583505275,0.010479251782424098,0.007446895043055217,0.7969974880122681,0.018379102722559826,0.9985523841836662,22.36412702479837
+2b8983b8-2396-4020-a6db-35b19bb2d287.mp4,4008,2088,29.97,8,h264,40148.403,0.160074931521024,0.05797263642180743,0.02584557895702847,6.822464942932129,7.055733680725098,7.172180051108346e-06,2.4900307655334473,36.52580261230469,17.285564280269153,20.99822895336429,0.14220792055130005,0.058163028210401535,0.20122307188328248,0.3787347649628497,0.2031581901056525,0.07335659938105908,0.014992917577425638,0.7752869102153293,0.12570052662873488,0.9969557560560646,20.24408139521997
+e0ece203-f76b-40b9-8285-cb9fd999c5c4.mp4,3912,2192,24.0,8,h264,40776.066,0.19813202848618514,0.09945711239804685,0.03496622315017987,7.536346435546875,7.638005256652832,1.6951137484897176e-05,2.46947979927063,53.10587692260742,32.36660032537817,15.852002036949575,0.12401280552148819,0.06782073527574539,0.10089832206280241,0.3571532536652205,0.37619714213386257,0.053949238788629665,0.012217029929161072,0.2409559114385085,0.09947692762676698,0.9933512871772088,15.267127113506389
+b872dec9-a527-443e-807b-8a650fb44aa5.mp4,3672,2200,29.97,8,h264,26838.802,0.11085391359538055,0.043140750910683145,0.007107075658546247,7.114101409912109,7.103025913238525,1.4296802407989588e-05,1.8586738109588623,30.439306259155273,17.2225639439719,21.915730799124205,0.07348591089248657,0.0299688708037138,0.12240659163278807,0.34816310030977465,0.42257273296854225,0.020484997029114677,0.008512660240133604,0.083881626724764,0.03608437314319667,0.9853751111654803,20.685591731501987
+8f0464f5-2e81-4d50-b4bb-0667fadd55b6.mp4,1944,1000,30.0,8,h264,28629.622,0.49090572702331964,0.092782616194626,0.10684485596707818,7.022085666656494,7.256712436676025,1.2697564529638103e-05,6.1641411781311035,106.89842224121094,36.91257181957464,15.29488864155018,0.7986264824867249,0.35498401522636414,0.15702301984755945,0.5378053457597031,0.22792991675408159,0.1251349451303155,0.03104855741063754,0.33499417009602195,0.18092052469135803,0.986462531267651,14.750361283262205
+890c5911-8ee1-4faa-a801-c605f0dde8e0.mp4,3840,2160,29.97002997002997,8,h264,14730.141,0.059256330138406636,0.08866558526140009,0.005286048418209876,7.256598472595215,7.234145164489746,0.00016839457810677365,0.8481879234313965,21.269725799560547,27.460039181811666,17.16618146535135,0.013288619928061962,0.009028784930706024,0.1450372010687532,0.30018618010797427,0.5296609669395022,0.011812829539609054,0.003580046041558186,0.22758680555555555,0.021873613522376545,0.9926868678702191,14.919262283403194
+ac024e5d-540e-4905-810d-f1b33b0aa5c9.mp4,4264,2488,24.0,8,h264,18365.504,0.07213134615887341,0.012953859447246502,0.0136907625646254,7.144860744476318,7.201314449310303,3.7654594462563302e-06,1.621660828590393,41.49378204345703,13.670468671451426,25.199696043170125,0.048048000782728195,0.03361654654145241,0.18680149284170744,0.24222968787254692,0.3719897684756554,0.023478016555765358,0.009723028168082237,0.4041484805616051,0.018766062088644633,0.9968599666509461,23.98313975966201
+31f7bc2c-838f-43c2-9cf8-745cc9ce27ab.mp4,4072,1984,25.0,8,h264,19146.36,0.09479747607579694,0.04550693960812429,0.0067543045741174975,7.1837944984436035,7.262981414794922,3.760470042574669e-05,1.2780088186264038,28.892736434936523,25.865269563431205,19.12290828994152,0.03580651804804802,0.018519092351198196,0.14137635115849687,0.45802809033771,0.30936963102122994,0.012009179196505905,0.005717673959831397,0.43970724538944167,0.021449097693136444,0.9821693564696935,17.673464012040057
+2b0347f7-dc82-40d1-a16f-1e835c93471d.mp4,4312,2080,24.0,8,h264,25544.905,0.11867273816213549,0.2003347633852492,0.0045769855144855145,7.405059814453125,7.60549259185791,0.00036262674436563104,1.1897826194763184,28.893930435180664,54.28900251775701,10.69149180162558,0.028370706364512444,0.016952944919466972,0.11795479119000803,0.48218439867205626,0.5729273339580588,0.006566275985918843,0.0061726671022673445,0.2979950109414395,0.012031774029541887,0.9680268523493314,11.099574128495348
+5cbb381b-c803-4c00-9f7c-eb34a93f0f11.mp4,3784,2008,29.97,8,h264,36618.783,0.16080602904817673,0.06542768694838852,0.019816163464535096,6.789691925048828,7.012326717376709,2.6450260263097307e-05,2.542257785797119,37.257537841796875,20.466320563078575,19.71761871395306,0.15050595998764038,0.060365621000528336,0.1814356638339386,0.42071156347264976,0.1782449488412061,0.0653040586070096,0.013540097512304783,0.8411135233554857,0.11950388193526107,0.9788613655686915,17.629037236788477
+6f22e710-af89-4704-8e14-022222e9748b.mp4,3720,2272,59.94,8,h264,22322.13,0.044062347122982445,0.015392131575294059,0.008948607640466455,7.460536956787109,7.5750732421875,4.295919040300286e-06,1.6437866687774658,32.09257507324219,11.993583547762306,26.12937973756229,0.04855892062187195,0.023132318630814552,0.11537393971455372,0.46319905696831204,0.3847542499002731,0.013721311966782774,0.0031315109226852655,0.18334130004038562,0.02164215129486597,0.9949059255782428,25.658407466420066
+f4f67a32-a8f5-43ac-93fb-6a41a45696de.mp4,3920,2072,24.0,8,h264,41024.51,0.21045359203044153,0.021401841745385414,0.11354254491371837,7.544743537902832,7.687009334564209,7.526890999826134e-07,5.495125770568848,111.36131286621094,8.965509817871082,27.70741804902253,0.5899763107299805,0.32699307799339294,0.12487122837721032,0.4635716519555055,0.31847648325739564,0.1427197012975074,0.030318242808183033,0.24108341212933046,0.10722546982113308,0.9999854710223858,27.01278655262587
+ec818c60-f6b6-4272-8688-db52a71f64c7.mp4,4016,2304,24.0,8,h264,25400.055,0.11437924787395556,0.20554661131905522,0.003539487881806109,7.454084873199463,7.498093605041504,0.0008068909499226956,1.0435192584991455,25.511754989624023,54.08541538015693,10.652868069190628,0.01988261751830578,0.01239417027682066,0.11179273230338858,0.4369010138639342,0.533342198844871,0.005289785591430574,0.005997409888853629,0.2147454741220304,0.009756330580455953,0.9224177695196881,10.56287084864626
+9a049c4c-bb40-4692-8b95-cb2ca94d339f.mp4,2072,1168,29.97,8,h264,6455.45,0.08900352041009824,0.009832887361719956,0.005371522452001904,7.566030025482178,7.583876132965088,2.1056042965511564e-06,1.864336609840393,31.31435775756836,4.709945760801032,33.683942863294355,0.05904766917228699,0.02554207108914852,0.07794002734583987,0.45699018562132987,0.46636608009240965,0.009612979540205567,0.004641825954119365,0.04973108504786589,0.013096381300576505,0.9963151955987875,32.48977789954205
+bd22f174-e591-4d7a-a5fa-40447e18191e.mp4,1840,1008,59.94,8,h264,12423.375,0.11174922010519837,0.05327088904704394,0.005766369047619048,7.4864821434021,7.577877044677734,7.612468171226111e-06,2.7005228996276855,32.72980499267578,16.431595009157522,21.566036022415087,0.172185018658638,0.058717746287584305,0.09891754670975317,0.413866736610103,0.3300058145238772,0.04619978577179664,0.011242882038156191,0.050635136300897145,0.07710570867839889,0.9926592185787358,19.394910594585504
+223c0d7d-c60b-4ce0-b867-a6292c9aa465.mp4,3784,2008,29.97,8,h264,38253.751,0.16798575186148923,0.0678976499847726,0.0288653262215409,6.804425239562988,7.0386223793029785,1.0396655579733884e-05,2.766972064971924,40.70533752441406,21.01144195852966,19.44021486807754,0.1735588163137436,0.07103276997804642,0.1924423491662839,0.38597894122497145,0.1846702573626785,0.08510461325943582,0.01528609481950601,0.9235667442983527,0.1461225657623207,0.9917693076510441,18.361035670056648
+992adda7-c2d9-4447-904a-e8d8157adde8.mp4,4112,2280,25.0,8,h264,23346.907,0.09960964485630419,0.05243066451869163,0.0065050302068400566,6.603093147277832,6.729841709136963,0.00026400312456757177,1.3120918273925781,33.72609329223633,31.345461426843613,17.721685776054223,0.030552295967936516,0.0189980436116457,0.22162180790489205,0.21826521987045897,0.41920875111598327,0.009328815106833232,0.005134458498408397,0.5314387216419778,0.016115487831933922,0.9950573907373722,17.40613349465314
+4ed3e002-a64d-4ab2-ac0a-3c46c2fcee77.mp4,3640,1920,25.0,8,h264,18403.842,0.10533334478021979,0.0518306550985779,0.007591288919413919,6.731770992279053,6.858646392822266,0.0002865738990085321,1.6696780920028687,39.051395416259766,31.16924249517514,17.799405625266896,0.04685891792178154,0.02683914639055729,0.20264662050472868,0.283926594970253,0.4202275605487922,0.010581978785103785,0.005136539849142234,0.20384500915750914,0.018152472527472527,0.995746789821698,17.49948355615558
+c9895c78-cafb-424c-88c4-3959e7f51de5.mp4,3640,1920,25.0,8,h264,16884.299,0.0966363266941392,0.04825374240240968,0.007400927197802198,6.651494026184082,6.790753364562988,8.290628547042521e-05,1.619092583656311,38.700714111328125,28.234399211131237,18.456720883807584,0.04381901025772095,0.025941243395209312,0.21331411486039786,0.2665905835892049,0.4055052751068376,0.008540426587301588,0.004679830279201269,0.23979681776556774,0.014388307005494507,0.9819162065467213,18.323213503240172

docker/Dockerfile

@@ -0,0 +1,11 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY ../requirements/common_requirements.txt /app/
+
+RUN pip install --no-cache-dir -r common_requirements.txt
+
+COPY ../services/ /app/services/
+
+CMD ["python", "--version"]

docker/docker-compose-vali.yml

@@ -0,0 +1,33 @@
+version: '3.9'
+services:
+  redis:
+    image: redis:latest
+    container_name: redis
+    ports:
+      - "6379:6379"
+  scoring_server:
+    build:
+      context: ./  
+      dockerfile: Docker/Dockerfile
+    container_name: vali_scoring_server
+    command: ["python", "services/scoring/server.py"]
+    volumes:
+      - ../services:/app/services
+
+  video_scheduler_worker:
+    build:
+      context: ./  
+      dockerfile: Docker/Dockerfile
+    container_name: vali_video_scheduler_worker
+    command: ["python", "services/video_scheduler/worker.py"]
+    volumes:
+      - ../services:/app/services
+
+  video_scheduler_server:
+    build:
+      context: ./  
+      dockerfile: Docker/Dockerfile
+    container_name: vali_video_scheduler_server
+    command: ["python", "services/video_scheduler/server.py"]
+    volumes:
+      - ../services:/app/services

docs/incentive_mechanism.md

@@ -0,0 +1,734 @@
+ # VIDAIO Subnet Validation & Incentive Mechanism
+
+## Table of Contents
+- [Overview](#overview)
+- [Task Types](#task-types)
+  - [Upscaling Tasks](#upscaling-tasks)
+  - [Compression Tasks](#compression-tasks)
+- [Quality Validation Metrics](#quality-validation-metrics)
+  - [VMAF (Video Multi-Method Assessment Fusion)](#vmaf-video-multi-method-assessment-fusion)
+  - [PIE-APP (Perceptual Image-Error Assessment)](#pie-app-perceptual-image-error-assessment-through-pairwise-preference)
+- [Upscaling System](#upscaling-system)
+  - [Upscaling Scoring](#upscaling-scoring)
+  - [Content Length Scoring](#content-length-scoring)
+  - [Upscaling Final Score](#upscaling-final-score)
+  - [Upscaling Penalty & Bonus System](#upscaling-penalty--bonus-system)
+- [Compression System](#compression-system)
+  - [Compression Scoring](#compression-scoring)
+  - [Compression Penalty & Bonus System](#compression-penalty--bonus-system)
+- [Implementation Guidelines](#implementation-guidelines)
+- [Technical Specifications](#technical-specifications)
+- [Mathematical Properties](#mathematical-properties)
+
+---
+
+## Overview
+
+The VIDAIO subnet validation mechanism ensures quality and reliability of miners' contributions through comprehensive assessment systems for different video processing tasks. The mechanism evaluates video processing performance using industry-standard **VMAF** and **PIE-APP** metrics, combined with advanced scoring systems that reward consistency and penalize poor performance.
+
+**Key Features:**
+- 🎯 **Multi-task support** for upscaling and compression operations
+- 📊 **Quality validation** using industry-standard VMAF and PIE-APP metrics
+- 🏆 **Performance-based incentive systems** with exponential rewards
+- 📈 **Historical performance tracking** with rolling 10-round windows
+- ⚖️ **Balanced penalty/bonus multipliers** encouraging sustained excellence
+- 📦 **Dynamic content processing** (5s to 320s capability)
+
+---
+
+## Task Types
+
+### Upscaling Tasks
+
+Upscaling tasks require miners to enhance video quality by increasing resolution while maintaining or improving visual fidelity. These tasks focus on **quality improvement** as the primary objective.
+
+**Key Characteristics:**
+- **Primary Goal**: Quality enhancement and resolution improvement
+- **Quality Metrics**: PIE-APP for scoring, VMAF for threshold validation
+- **Content Length**: Dynamic processing durations (5s to 320s)
+- **Scoring Focus**: Quality improvement with content length consideration
+
+### Compression Tasks
+
+Compression tasks require miners to reduce video file sizes while maintaining quality above specified VMAF thresholds. These tasks focus on **efficiency optimization** balancing file size reduction with quality preservation.
+
+**Key Characteristics:**
+- **Primary Goal**: File size reduction with quality maintenance
+- **Quality Metrics**: VMAF for both scoring and threshold validation
+- **Compression Rate**: File size reduction efficiency measurement
+- **Scoring Focus**: Compression efficiency with quality threshold compliance
+
+---
+
+## Quality Validation Metrics
+
+### VMAF (Video Multi-Method Assessment Fusion)
+
+VMAF serves as the foundational video quality assessment metric, comparing frame-by-frame quality between original and processed videos. This metric provides objective measurement of subjective video quality as perceived by humans.
+
+#### Key Characteristics
+- **Purpose**: Frame-by-frame quality comparison
+- **Range**: 0-100 (higher values indicate better quality)
+- **Usage**: Threshold validation and quality scoring
+- **Industry Standard**: Widely adopted in professional video processing
+
+#### Mathematical Implementation
+
+**Harmonic Mean Calculation:**
+```
+H = n / (1/S_1 + 1/S_2 + ... + 1/S_n)
+```
+
+**Where:**
+- `S_i`: VMAF score for frame `i` (i = 1, 2, ..., n)
+- `n`: Total number of frames in the video
+- `H`: Harmonic mean emphasizing poor-quality frame impact
+
+#### Why Harmonic Mean?
+
+The harmonic mean approach provides several critical advantages:
+
+| Advantage | Description | Impact |
+|-----------|-------------|---------|
+| **Sensitivity to Low Values** | Heavily penalizes poor-quality frames | Ensures consistent quality |
+| **Quality Consistency** | Prevents miners from neglecting frame quality | Maintains processing standards |
+| **Threshold Function** | Validates authentic processing processes | Prevents gaming attempts |
+
+> **Note**: VMAF scores are calculated using 5 random frames for both upscaling and compression tasks.
+
+---
+
+### PIE-APP (Perceptual Image-Error Assessment through Pairwise Preference)
+
+PIE-APP provides deep learning-based perceptual similarity assessment between original and processed video frames, serving as the primary quality scoring mechanism for upscaling tasks.
+
+#### Technical Specifications
+
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| **Scale Range** | (-∞, ∞) | Theoretical range |
+| **Practical Range** | 0 to 5+ | Positive values (lower = better) |
+| **Processing Interval** | Every frame | Default frame sampling rate |
+| **Implementation** | Deep learning-based | Advanced perceptual assessment |
+
+#### Calculation Process
+
+**Step 1: Raw PIE-APP Score**
+```
+PIE-APP_score = (Σ abs(d(F_i, F'_i))) / n
+```
+
+**Where:**
+- `F_i`: Frame `i` from original video
+- `F'_i`: Corresponding frame `i` from processed video  
+- `d(F_i, F'_i)`: Perceptual difference between frames
+- `n`: Number of processed frames (4 random frames)
+
+**Step 2: Score Normalization**
+```
+1. Cap values: max(Average_PIE-APP, 2.0)
+2. Sigmoid normalization: normalized_score = 1/(1+exp(-Average_PIE-APP))
+3. Final transformation: Convert "lower is better" to "higher is better" (0-1 range)
+```
+
+#### Visual Score Transformation
+
+The PIE-APP scoring system uses sophisticated mathematical transformations:
+
+- *Sigmoid normalization function for PIE-APP scores*
+!<img src="./images/graph2.png" alt="Sigmoid Function" width="1200" height="800">
+
+- *Final score transformation converting to 0-1 range*
+!<img src="./images/graph1.png" alt="Final Score Function" width="1200" height="800">
+
+---
+
+## Upscaling System
+
+### Upscaling Scoring
+
+#### Quality Score Calculation
+
+**VMAF Threshold Validation:**
+```
+If VMAF_score < VMAF_threshold:
+    S_Q = 0 (Zero score for quality violation)
+Else:
+    S_Q = PIE-APP_Final_Score
+```
+
+**Where:**
+- `S_Q`: Quality score for upscaling
+- `VMAF_score`: Achieved VMAF quality score
+- `VMAF_threshold`: Minimum required VMAF score
+- `PIE-APP_Final_Score`: Normalized PIE-APP score (0-1 range)
+
+#### Metric Integration
+
+| Metric | Range | Primary Function | Usage |
+|--------|-------|------------------|-------|
+| **VMAF** | 0-100 | Threshold validation | Upscaling verification |
+| **PIE-APP** | 0-1 (final) | Quality scoring | Performance evaluation |
+
+---
+
+### Content Length Scoring
+
+#### Dynamic Content Length Requests
+
+Miners actively request content processing durations within 35-second evaluation windows, enabling optimized resource allocation and performance assessment.
+
+#### Available Processing Durations
+
+| Duration | Status | Availability |
+|----------|--------|--------------|
+| 5s | ✅ Default | Currently Available |
+| 10s | ✅ Available | Currently Available |
+| 20s | 🔄 Coming Soon | Future Release |
+| 40s | 🔄 Coming Soon | Future Release |
+| 80s | 🔄 Coming Soon | Future Release |
+| 160s | 🔄 Coming Soon | Future Release |
+| 320s | 🔄 Coming Soon | Future Release |
+
+> **Current Limitation**: Processing durations up to 10 seconds are currently supported.
+
+#### Length Score Mathematical Model
+
+**Formula:**
+```
+S_L = log(1 + content_length) / log(1 + 320)
+```
+
+**Parameters:**
+- `content_length`: Processing duration in seconds
+- `S_L`: Normalized length score (0 to 1)
+
+#### Performance Analysis Table
+
+| Duration (s) | S_L Score | Percentage | Improvement | Performance Tier |
+|--------------|-----------|------------|-------------|------------------|
+| 5 | 0.3105 | 31.05% | Baseline | Default |
+| 10 | 0.4155 | 41.55% | +33% | Significant Gain |
+| 20 | 0.5275 | 52.75% | +27% | Strong Performance |
+| 40 | 0.6434 | 64.34% | +22% | High Capability |
+| 80 | 0.7614 | 76.14% | +18% | Advanced Processing |
+| 160 | 0.8804 | 88.04% | +16% | Expert Level |
+| 320 | 1.0000 | 100.00% | +14% | Maximum Score |
+
+#### Logarithmic Scaling Benefits
+
+| Benefit | Description | Impact |
+|---------|-------------|---------|
+| **Fair Distribution** | Balanced scoring across duration ranges | Equitable competition |
+| **Diminishing Returns** | Reduced gains for extreme durations | Prevents over-optimization |
+| **Normalized Output** | Consistent 0-1 scoring range | Standardized evaluation |
+| **Capacity Recognition** | Rewards longer processing capabilities | Incentivizes advancement |
+
+**Strategic Insights:**
+- **Optimal Entry Point**: 10s processing provides largest relative improvement (+33%)
+- **Scaling Pattern**: Each duration doubling yields progressively smaller benefits
+- **Maximum Achievement**: 320s processing represents theoretical performance ceiling
+
+---
+
+### Upscaling Final Score
+
+#### Score Component Architecture
+
+The comprehensive upscaling scoring system integrates two fundamental metrics:
+
+| Component | Symbol | Description | Weight |
+|-----------|--------|-------------|--------|
+| **Quality Score** | S_Q | Processing accuracy and output quality | W1 = 0.5 |
+| **Length Score** | S_L | Content processing capacity | W2 = 0.5 |
+
+#### Preliminary Score Calculation
+
+**Formula:**
+```
+S_pre = S_Q × W1 + S_L × W2
+```
+
+**Current Configuration:**
+- `W1 = 0.5` (Quality weight)
+- `W2 = 0.5` (Length weight)
+
+> **Dynamic Adjustment**: Weights are continuously optimized based on real-world performance data and network requirements.
+
+#### Final Score Transformation
+
+The preliminary score undergoes exponential transformation for enhanced performance differentiation:
+
+**Formula:**
+```
+S_F = 0.1 × e^(6.979 × (S_pre - 0.5))
+```
+
+**Parameters:**
+- `S_F`: Final upscaling score
+- `S_pre`: Preliminary combined score
+- `e`: Euler's number (≈2.718)
+
+#### Performance Tier Analysis
+
+| S_pre | S_F Score | Multiplier | Performance Tier | Reward Category |
+|-------|-----------|------------|------------------|-----------------|
+| 0.30 | 0.0248 | 0.25× | Poor Performance | Significant Penalty |
+| 0.36 | 0.0376 | 0.38× | Below Average | Moderate Penalty |
+| 0.42 | 0.0572 | 0.57× | Low Average | Minor Penalty |
+| 0.48 | 0.0870 | 0.87× | Near Average | Slight Penalty |
+| 0.54 | 0.1322 | 1.32× | Above Average | Moderate Reward |
+| 0.60 | 0.2010 | 2.01× | Good Performance | Strong Reward |
+| 0.66 | 0.3055 | 3.05× | High Performance | Major Reward |
+| 0.72 | 0.4643 | 4.64× | Very High Performance | Excellent Reward |
+| 0.78 | 0.7058 | 7.06× | Excellent Performance | Outstanding Reward |
+| 0.84 | 1.0728 | 10.73× | Outstanding Performance | Elite Reward |
+| 0.90 | 1.6307 | 16.31× | Elite Performance | Maximum Reward |
+
+#### Exponential Function Characteristics
+
+**System Benefits:**
+| Feature | Description | Strategic Impact |
+|---------|-------------|------------------|
+| **Enhanced Differentiation** | Clear performance tier separation | Competitive advantage clarity |
+| **Reward Amplification** | 16× multiplier difference (top vs bottom) | Strong performance incentives |
+| **Competitive Optimization** | Non-linear improvement rewards | Encourages continuous advancement |
+| **Exponential Scaling** | Small S_pre gains yield large S_F improvements | High-performance focus |
+
+**Strategic Performance Guidelines:**
+- **Minimum Target**: Achieve S_pre > 0.6 for meaningful reward activation
+- **Optimization Focus**: Exponential curve creates powerful excellence incentives
+- **High-Performance Strategy**: Small quality improvements at elevated levels yield disproportionate benefits
+
+#### Graph Analysis
+
+!<img src="./images/graph3.png" alt="Length Score Analysis" width="1200" height="1000">
+
+---
+
+### Upscaling Penalty & Bonus System
+
+#### Historical Performance Multiplier Architecture
+
+The advanced upscaling scoring system incorporates a **rolling 10-round historical performance window** to evaluate consistency patterns and apply dynamic multipliers based on sustained performance trends.
+
+#### System Formula
+
+```
+Final Adjusted Score = S_F × Performance Multiplier
+Performance Multiplier = Bonus Multiplier × S_F Penalty × S_Q Penalty
+```
+
+---
+
+#### Bonus System (Excellence Rewards)
+
+**Activation Criteria:** `S_F > 0.32` in mining round
+
+**Mathematical Model:**
+```python
+bonus_multiplier = 1.0 + (bonus_count / 10) × 0.15
+```
+
+**System Characteristics:**
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| **Maximum Bonus** | +15% | All 10 rounds achieve S_F > 0.32 |
+| **Scaling Method** | Linear | Based on consistency frequency |
+| **Primary Purpose** | Sustained excellence reward | Long-term performance incentive |
+
+**Example Calculation:** 7/10 rounds with S_F > 0.32 → 1.105× multiplier (+10.5% bonus)
+
+---
+
+#### S_F Penalty System (Performance Penalties)
+
+**Activation Criteria:** `S_F < 0.20` in mining round
+
+**Mathematical Model:**
+```python
+penalty_f_multiplier = 1.0 - (penalty_f_count / 10) × 0.20
+```
+
+**System Characteristics:**
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| **Maximum Penalty** | -20% | All 10 rounds achieve S_F < 0.20 |
+| **Scaling Method** | Linear | Based on poor performance frequency |
+| **Primary Purpose** | Performance consistency enforcement | Discourages sustained poor results |
+
+**Example Calculation:** 4/10 rounds with S_F < 0.20 → 0.92× multiplier (-8% penalty)
+
+---
+
+#### S_Q Penalty System (Quality Penalties)
+
+**Activation Criteria:** `S_Q < 0.25` in mining round
+
+**Mathematical Model:**
+```python
+penalty_q_multiplier = 1.0 - (penalty_q_count / 10) × 0.25
+```
+
+**System Characteristics:**
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| **Maximum Penalty** | -25% | All 10 rounds achieve S_Q < 0.25 |
+| **Scaling Method** | Linear | Based on quality failure frequency |
+| **Primary Purpose** | Quality standard enforcement | Strongest penalty (quality is critical) |
+
+**Example Calculation:** 3/10 rounds with S_Q < 0.25 → 0.925× multiplier (-7.5% penalty)
+
+---
+
+#### Performance Multiplier Case Studies
+
+| Miner Category | Avg S_F | Avg S_Q | Bonus Rate | S_F Penalty | S_Q Penalty | **Final Multiplier** | **Net Effect** |
+|----------------|---------|---------|------------|-------------|-------------|---------------------|----------------|
+| **Elite Miner** | 0.854 | 0.717 | 10/10 | 0/10 | 0/10 | **1.150×** | **+15.0%** |
+| **Good Miner** | 0.653 | 0.571 | 0/10 | 0/10 | 0/10 | **1.000×** | **±0.0%** |
+| **Average Miner** | 0.511 | 0.505 | 0/10 | 0/10 | 3/10 | **0.925×** | **-7.5%** |
+| **Poor Miner** | 0.311 | 0.411 | 0/10 | 10/10 | 10/10 | **0.600×** | **-40.0%** |
+
+#### Penalty Analysis
+
+!<img src="./images/graph4.png" alt="Length Score Analysis" width="1200" height="800">
+
+---
+
+#### System Benefits & Strategic Impact
+
+**Core System Benefits:**
+
+| Benefit | Description | Strategic Impact |
+|---------|-------------|------------------|
+| 🎯 **Consistency Rewards** | Elite miners maintain sustained +15% bonus | Long-term competitive advantage |
+| ⚡ **Responsive Penalties** | Poor performance accumulates immediate penalties | Rapid feedback mechanism |
+| 🔄 **Recovery Incentive** | Miners can improve multipliers over 10 rounds | Encourages continuous improvement |
+| ⚖️ **Balanced Impact** | Quality penalties are strongest (-25% max) | Emphasizes quality importance |
+| 📈 **Progressive Scaling** | Linear scaling prevents extreme swings | Maintains system stability |
+
+---
+
+## Compression System
+
+### Compression Scoring
+
+#### Task Parameters
+
+Each compression task includes specific requirements:
+
+| Parameter | Description | Range | Impact |
+|-----------|-------------|-------|---------|
+| **VMAF Threshold** | Minimum acceptable quality score | 0-100 | Quality validation |
+| **Original File Size** | Baseline for compression calculation | Variable | Compression rate baseline |
+| **Target Optimization** | Balance between compression and quality | Dynamic | Performance strategy |
+
+#### Compression Rate Calculation
+
+**Formula:**
+```
+C = compressed_file_size / original_file_size
+```
+
+**Where:**
+- `C`: Compression rate (0 < C ≤ 1)
+- `compressed_file_size`: Size of processed video file
+- `original_file_size`: Size of original video file
+
+**Characteristics:**
+- **Lower C values** indicate better compression (smaller files)
+- **C = 1.0** means no compression achieved
+- **C < 1.0** indicates successful compression
+
+#### VMAF Quality Assessment
+
+**Implementation:**
+```
+VMAF_score = Harmonic_Mean(VMAF_frame_1, VMAF_frame_2, ..., VMAF_frame_n)
+```
+
+**Where:**
+- `VMAF_frame_i`: VMAF score for frame `i`
+- `n`: Number of sampled frames (5 random frames)
+- `Harmonic_Mean`: Emphasizes poor-quality frame impact
+
+#### Final Compression Score Calculation
+
+**Threshold Validation:**
+```
+If VMAF_score < VMAF_threshold:
+    S_f = 0 (Zero score for quality violation)
+Else:
+    S_f = w_c × (1 - C^1.5) + w_vmaf × (VMAF_score - VMAF_threshold) / (100 - VMAF_threshold)
+```
+
+**Parameters:**
+- `S_f`: Final compression score
+- `w_c`: Weight for compression rate (default: 0.8)
+- `w_vmaf`: Weight for VMAF score (default: 0.2)
+- `C`: Compression rate
+- `VMAF_score`: Achieved VMAF quality score
+- `VMAF_threshold`: Minimum required VMAF score
+
+#### Mathematical Properties
+
+**Compression Rate Component:**
+- **Formula**: `w_c × (1 - C^1.5)`
+- **Range**: [0, w_c] (0 when C = 1, w_c when C = 0)
+- **Curve**: Concave function emphasizing compression efficiency
+- **Exponent 1.5**: Provides balanced reward for compression achievements
+
+**VMAF Quality Component:**
+- **Formula**: `w_vmaf × (VMAF_score - VMAF_threshold) / (100 - VMAF_threshold)`
+- **Range**: [0, w_vmaf] (0 at threshold, w_vmaf at maximum quality)
+- **Normalization**: Scales quality improvement relative to achievable range
+- **Linear scaling**: Direct correlation between quality improvement and score
+
+#### Graph Analysis
+
+!<img src="./images/graph5.png" alt="Scoring impact" width="1200" height="600">
+
+---
+
+#### Performance Analysis Examples
+
+| Scenario | C | VMAF_score | VMAF_threshold | S_f | Performance Tier |
+|----------|---|------------|----------------|-----|------------------|
+| **Excellent** | 0.3 | 85 | 70 | 0.669 + 0.100 = **0.769** | Outstanding |
+| **Good** | 0.5 | 80 | 70 | 0.517 + 0.067 = **0.584** | Strong |
+| **Average** | 0.7 | 75 | 70 | 0.331 + 0.033 = **0.364** | Acceptable |
+| **Poor Quality** | 0.4 | 65 | 70 | **0.000** | Failed |
+| **No Compression** | 1.0 | 90 | 70 | 0.000 + 0.133 = **0.133** | Inefficient |
+
+#### Strategic Guidelines
+
+| Miner Strategy | Focus Area | Target Metrics | Expected Outcome |
+|----------------|------------|---------------|------------------|
+| **Quality-First** | Maintain high VMAF scores | VMAF_score >> VMAF_threshold | Consistent moderate scores |
+| **Compression-First** | Maximize file size reduction | C << 1.0 | Variable scores based on quality |
+| **Balanced Approach** | Optimize both factors | Moderate C + Good VMAF | Optimal long-term performance |
+| **Threshold Gaming** | Minimal quality compliance | VMAF_score ≈ VMAF_threshold | Low scores, high risk |
+
+---
+
+### Compression Penalty & Bonus System
+
+#### Historical Performance Multiplier Architecture
+
+The compression scoring system incorporates a **rolling 10-round historical performance window** to evaluate consistency patterns and apply dynamic multipliers based on sustained performance trends.
+
+#### System Formula
+
+```
+Final Adjusted Compression Score = S_f × Performance Multiplier
+Performance Multiplier = Bonus Multiplier × S_f Penalty × VMAF Penalty
+```
+
+---
+
+#### Bonus System (Excellence Rewards)
+
+**Activation Criteria:** `S_f > 0.74` in compression mining round
+
+**Mathematical Model:**
+```python
+bonus_multiplier = 1.0 + (bonus_count / 10) × 0.15
+```
+
+**System Characteristics:**
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| **Maximum Bonus** | +15% | All 10 rounds achieve S_f > 0.74 |
+| **Scaling Method** | Linear | Based on consistency frequency |
+| **Primary Purpose** | Sustained excellence reward | Long-term performance incentive |
+
+**Example Calculation:** 7/10 rounds with S_f > 0.74 → 1.105× multiplier (+10.5% bonus)
+
+---
+
+#### S_f Penalty System (Performance Penalties)
+
+**Activation Criteria:** `S_f < 0.4` in compression mining round
+
+**Mathematical Model:**
+```python
+penalty_f_multiplier = 1.0 - (penalty_f_count / 10) × 0.20
+```
+
+**System Characteristics:**
+| Parameter | Value | Description |
+|-----------|-------|-------------|
+| **Maximum Penalty** | -20% | All 10 rounds achieve S_f < 0.4 |
+| **Scaling Method** | Linear | Based on poor performance frequency |
+| **Primary Purpose** | Performance consistency enforcement | Discourages sustained poor results |
+
+**Example Calculation:** 4/10 rounds with S_f < 0.4 → 0.92× multiplier (-8% penalty)
+
+---
+
+#### Compression Performance Multiplier Case Studies
+
+| Miner Category | Avg S_f | Avg VMAF Margin | Bonus Rate | S_f Penalty | **Final Multiplier** | **Net Effect** |
+|----------------|---------|-----------------|------------|-------------|---------------|---------------------|----------------|
+| **Elite Compressor** | 0.654 | +15 | 10/10 | 0/10 | **1.150×** | **+15.0%** |
+| **Good Compressor** | 0.453 | +8 | 0/10 | 0/10 | **1.000×** | **±0.0%** |
+| **Average Compressor** | 0.311 | +3 | 0/10 | 0/10 | **0.910×** | **-9.0%** |
+| **Poor Compressor** | 0.211 | -2 | 0/10 | 10/10 | **0.490×** | **-51.0%** |
+
+#### Compression Penalty Analysis
+
+**Strategic Impact:**
+- **Quality-first approach** strongly incentivized through higher penalties
+- **Consistency rewards** for miners maintaining quality above threshold
+- **Immediate feedback** through zero-score for quality violations
+- **Balanced optimization** encouraged through dual-factor scoring
+
+---
+
+## Implementation Guidelines
+
+### Performance Monitoring
+
+**Real-time Operations:**
+- ✅ Scores calculated in real-time during mining operations
+- ✅ Historical performance data maintained for trend analysis and multiplier calculation
+- ✅ Weight adjustments implemented based on network-wide performance metrics
+- ✅ Performance multipliers updated after each mining round
+
+### Scoring Strategy Recommendations
+
+**Upscaling Performance-Based Guidelines:**
+
+| Miner Category | Primary Focus | Strategic Recommendations |
+|----------------|---------------|---------------------------|
+| **New Miners** | Foundation Building | Focus on achieving consistent S_pre > 0.5 before optimizing for length |
+| **Established Miners** | Quality Optimization | Prioritize quality improvements when S_pre > 0.6 to avoid S_Q penalties |
+| **Elite Miners** | Consistency Maintenance | Maintain consistency above S_F > 0.32 to secure maximum bonus multipliers |
+| **Recovery Phase** | Systematic Improvement | Focus on quality (S_Q > 0.25) first, then performance (S_F > 0.20) to restore multipliers |
+
+**Compression Performance-Based Guidelines:**
+
+| Miner Category | Primary Focus | Strategic Recommendations |
+|----------------|---------------|---------------------------|
+| **New Compressors** | Quality Compliance | Focus on maintaining VMAF_score > VMAF_threshold + 5 |
+| **Established Compressors** | Balanced Optimization | Optimize both compression rate and quality maintenance |
+| **Elite Compressors** | Consistency Excellence | Maintain S_f > 0.74 consistently for bonus multipliers |
+| **Recovery Phase** | Quality Restoration | Focus on VMAF compliance first, then compression optimization |
+
+### Future Enhancement Roadmap
+
+**Planned Developments:**
+
+- [ ] **Extended Content Length Support** - Processing durations up to 320s
+- [ ] **Dynamic Weight Adjustment Algorithms** - Automated optimization based on network performance
+- [ ] **Advanced Quality Metrics Integration** - Additional assessment parameters
+- [ ] **Multi-dimensional Scoring Parameters** - Enhanced evaluation criteria
+- [ ] **Adaptive Difficulty Scaling** - Network performance-based adjustments
+- [ ] **Advanced Penalty/Bonus Optimization** - Network-wide performance distribution analysis
+- [ ] **Seasonal Performance Multiplier Adjustments** - Time-based optimization cycles
+- [ ] **Cross-Task Performance Integration** - Unified scoring across upscaling and compression
+
+---
+
+## Technical Specifications
+
+### Core System Parameters
+
+| Parameter | Current Value | Configurable Range | Implementation Notes |
+|-----------|---------------|-------------------|---------------------|
+| **Default Content Length** | 5s | 5s - 10s | Actively configurable by miners |
+| **Quality Weight (W1)** | 0.5 | 0.0 - 1.0 | Dynamically adjusted based on network data |
+| **Length Weight (W2)** | 0.5 | 0.0 - 1.0 | Dynamically adjusted based on network data |
+
+### Compression System Parameters
+
+| Parameter | Current Value | Configurable Range | Implementation Notes |
+|-----------|---------------|-------------------|---------------------|
+| **Compression Rate Weight (w_c)** | 0.8 | 0.6 - 0.9 | Balances compression efficiency vs quality |
+| **VMAF Score Weight (w_vmaf)** | 0.2 | 0.1 - 0.4 | Balances quality maintenance vs compression |
+| **Compression Rate Exponent** | 1.5 | 1.2 - 2.0 | Controls compression reward curve steepness |
+| **VMAF Safety Margin** | +5 | +3 - +10 | Quality buffer above threshold |
+| **Zero-Score Threshold** | VMAF_score < VMAF_threshold | Fixed | Immediate penalty for quality violations |
+
+### Performance Multiplier System Parameters
+
+| Parameter | Current Value | Configurable Range | System Impact |
+|-----------|---------------|-------------------|---------------|
+| **Performance History Window** | 10 rounds | 5-10 rounds | Configurable for different network conditions |
+| **Upscaling Bonus Threshold** | S_F > 0.32 | 0.3-0.4 | Adjustable based on network performance |
+| **Upscaling S_F Penalty Threshold** | S_F < 0.20 | 0.15-0.25 | Adjustable based on network performance |
+| **Upscaling S_Q Penalty Threshold** | S_Q < 0.25 | 0.2-0.3 | Adjustable based on network performance |
+| **Compression Bonus Threshold** | S_f > 0.74 | 0.7-0.8 | Lower threshold reflecting compression difficulty |
+| **Compression S_f Penalty Threshold** | S_f < 0.4 | 0.35-0.45 | Penalty for poor compression performance |
+| **VMAF Penalty Threshold** | VMAF_score < VMAF_threshold + 5 | +3 to +10 | Quality safety margin enforcement |
+| **Maximum Bonus** | +15% | 10%-20% | Scalable reward system |
+| **Maximum S_F Penalty** | -20% | 15%-25% | Scalable penalty system |
+| **Maximum S_Q Penalty** | -25% | 20%-30% | Strongest penalty for quality issues |
+
+---
+
+## Mathematical Properties
+
+### Upscaling Length Score Function Properties
+
+**Mathematical Characteristics:**
+- **Domain**: [5, 320] seconds
+- **Range**: [0.3105, 1.0000]
+- **Function Type**: Logarithmic (concave)
+- **Growth Rate**: Decreasing marginal returns
+- **Optimization Point**: Balanced between processing capability and diminishing returns
+
+### Upscaling Final Score Function Properties
+
+**Mathematical Characteristics:**
+- **Domain**: [0, 1] (S_pre values)
+- **Range**: [0.0025, 40.43] (theoretical maximum)
+- **Function Type**: Exponential (convex)
+- **Critical Point**: S_pre = 0.5 (inflection point for reward/penalty)
+- **Scaling Behavior**: Exponential amplification of performance differences
+
+### Compression Score Function Properties
+
+**Mathematical Characteristics:**
+- **Domain**: [0, 1] (compression rate C values)
+- **Range**: [0, w_c] (compression component score)
+- **Function Type**: Concave (1 - C^1.5)
+- **Critical Point**: C = 1 (no compression = zero score)
+- **Optimization**: Lower C values yield higher scores with diminishing returns
+
+### Compression VMAF Component Properties
+
+**Mathematical Characteristics:**
+- **Domain**: [VMAF_threshold, 100] (achievable quality range)
+- **Range**: [0, w_vmaf] (quality component score)
+- **Function Type**: Linear normalization
+- **Zero Point**: VMAF_score = VMAF_threshold
+- **Maximum Point**: VMAF_score = 100
+- **Quality Buffer**: +5 margin for penalty system
+
+### Performance Multiplier Properties
+
+**Mathematical Characteristics:**
+- **Domain**: [0.55, 1.15] (practical operational range)
+- **Function Type**: Linear combination of historical performance frequencies
+- **Update Frequency**: After each mining round completion
+- **Memory System**: Rolling 10-round window with automatic history management
+- **Convergence**: Stabilizes after 10 rounds of consistent performance patterns
+
+---
+
+## Conclusion
+
+The VIDAIO subnet validation and incentive mechanism represents a comprehensive, mathematically-grounded approach to ensuring high-quality video processing while maintaining fair competition and encouraging continuous improvement. Through the integration of industry-standard metrics (VMAF and PIE-APP), dynamic scoring systems, and sophisticated penalty/bonus mechanisms, the system creates a robust environment that rewards excellence and consistency while providing clear pathways for improvement.
+
+The system now supports both **upscaling** and **compression** tasks, each with specialized scoring mechanisms:
+- **Upscaling tasks** focus on quality improvement using PIE-APP scoring with VMAF threshold validation
+- **Compression tasks** balance file size reduction with quality maintenance using dual-factor scoring
+- **Unified penalty systems** ensure consistent quality standards across all task types
+
+These metrics together ensure that miners maintain high-quality video processing standards while meeting demands for fast and efficient processing, creating a sustainable and competitive ecosystem for video enhancement and optimization services.
+
+---
+
+*This documentation is continuously updated to reflect the latest scoring mechanisms, performance optimizations, and system enhancements.*

docs/miner_setup.md

@@ -0,0 +1,273 @@
+# Running Miner
+
+A high-performance decentralized video processing miner that leverages **Video2X** for AI-powered video upscaling. This guide provides detailed instructions to set up, configure, and run the miner effectively
+
+---
+
+## Machine Requirements
+
+To achieve optimal results, we recommend the following setup:
+
+- **Operating System**: Ubuntu 24.04 LTS or higher  
+  [Learn more about Ubuntu 24.04 LTS](https://ubuntu.com/blog/tag/ubuntu-24-04-lts)
+- **GPU**: NVIDIA RTX 4090 or higher  
+  (Required for efficient video upscaling using Video2X)
+
+---
+
+## Install PM2 (Process Manager)
+
+**PM2** is used to manage and monitor the miner process. If you haven’t installed PM2 yet, follow these steps:
+
+1. Install `npm` and PM2:
+   ```bash
+   sudo apt update
+   sudo apt install npm -y
+   sudo npm install pm2 -g
+   pm2 update
+   ```
+
+2. For more details, refer to the [PM2 Documentation](https://pm2.io/docs/runtime/guide/installation/).
+
+---
+
+## Install Redis
+
+1. Install 'redis'
+   ```bash
+   sudo apt update
+   sudo apt install redis-server
+   sudo systemctl start redis
+   sudo systemctl enable redis-server
+   sudo systemctl status redis
+   ```
+
+## Install Project Dependencies
+
+### Prerequisites
+
+- **Python**: Version 3.10 or higher
+- **pip**: Python package manager
+- **virtualenv** (optional): For dependency isolation
+
+---
+
+### 1. Clone the Repository
+
+Clone the project repository to your local machine:
+```bash
+git clone https://github.com/vidaio-subnet/vidaio-subnet.git
+cd vidaio-subnet
+```
+
+---
+
+### 2. Set Up a Virtual Environment (Recommended)
+
+Create and activate a virtual environment to isolate project dependencies:
+```bash
+python3 -m venv venv
+source venv/bin/activate  
+```
+
+---
+
+### 3. Install the Package and Dependencies
+
+Install the project and its dependencies using `pip`:
+```bash
+pip install -e .
+```
+
+---
+
+### 4. Configure Environment Variables
+
+To configure environment variables, follow these steps:
+
+1. Create a `.env` file in the project root directory by referencing the provided `.env.template` file:
+   ```bash
+   cp .env.template .env
+   ```
+
+2. Set up a bucket in cloud storage. The base miner code utilizes MinIO to connect with cloud storage services, so you'll need to prepare your bucket using a platform that supports MinIO integration, such as Backblaze. Alternatively, you can modify the code to suit your specific requirements.
+3. Add the required variables to the `.env` file. For example:
+   ```env
+   BUCKET_NAME="S3 buckent name"
+   BUCKET_COMPATIBLE_ENDPOINT="S3 bucket endpoint"
+   BUTKET_COMPATIBLE_ACCESS_KEY="S3 bucket personal access key"
+   BUCKET_COMPATIBLE_SECRET_KEY="S3 bucket personal secret key"
+   PEXELS_API_KEY="Your Pexels account api key"
+   WANDB_API_KEY="Your WANDB account api key"
+   ```
+
+4. Ensure that the bucket is configured with the appropriate permissions to allow file uploads and enable public access for downloads via presigned URLs.
+
+5. Once the `.env` file is properly configured, the application will use the specified credentials for S3 bucket and Pexels.
+
+
+---
+
+## Install Video2X
+
+The miner requires **Video2X** for AI-powered video upscaling. Follow the steps below to install and configure Video2X.
+
+---
+
+### Step 1: Install FFMPEG
+
+FFMPEG is required for processing video files. Install it using the following commands:
+```bash
+sudo apt update
+sudo apt install ffmpeg -y
+```
+
+For more details, refer to the [FFMPEG Documentation](https://www.ffmpeg.org/download.html#build-linux).
+
+---
+
+### Step 2: Install CUDA and NVCC
+
+Ensure your CUDA drivers and NVCC (NVIDIA Compiler) are properly installed and configured to support GPU acceleration.
+
+1. Verify your CUDA installation:
+   ```bash
+   nvcc --version
+   ```
+
+2. Ensure you CUDA driver is installed correctly
+   <!-- Install or update the CUDA drivers if they are not already installed:
+   ```bash
+   sudo apt update
+   sudo apt install nvidia-cuda-toolkit -y
+   ``` -->
+
+For more information, refer to the [CUDA Toolkit Installation Guide](https://developer.nvidia.com/cuda-toolkit).
+
+---
+
+### Step 3: Install Video2X
+
+---
+
+### Option 1: Install Video2X by downloading Debian Package:
+
+
+1. **Download the Video2X `.deb` package**:
+   ```bash
+   wget -P services/upscaling/models https://github.com/k4yt3x/video2x/releases/download/6.3.1/video2x-linux-ubuntu2404-amd64.deb
+   ```
+
+2. **Install the package using `dpkg`**:
+   ```bash
+   sudo dpkg -i services/upscaling/models/video2x-linux-ubuntu2404-amd64.deb
+   ```
+
+3. **Resolve dependencies** (if any):
+   ```bash
+   sudo apt-get install -f
+   ```
+
+### Option 2: Install Video2X by Building Debian Package:
+
+1. Install Cargo
+Cargo is required to build the Video2X package:
+```bash
+sudo apt-get update
+sudo apt-get install cargo -y
+cargo install just --version=1.39.0
+```
+
+2. Clone the Video2X Repository
+you can clone this repository within the current vidaio-subnet package
+```bash
+git clone --recurse-submodules https://github.com/vidAio-subnet/video2x
+cd video2x
+```
+
+3. Build the Video2X Project
+Before building, ensure `~/.cargo/bin` is included in your `PATH` environment variable:
+```bash
+export PATH="$HOME/.cargo/bin:$PATH"
+```
+
+Run the following command to build the package:
+```bash
+just ubuntu2404
+```
+
+Once the build is complete, the `.deb` package will be located in the current directory.
+
+4. Install the Built Package
+Install the `.deb` package using:
+```bash
+sudo dpkg -i video2x-linux-ubuntu-amd64.deb
+```
+
+---
+For additional details, refer to the [Video2X Documentation](https://docs.video2x.org/building/linux.html).
+
+## Running the Video Upscaling Endpoint
+
+You can run the video upscaling endpoint using **PM2** to manage the process:
+
+```bash
+pm2 start "python services/upscaling/server.py" --name video-upscaler
+```
+
+### Notes:
+- The `video-upscaler` process will handle video upscaling requests.
+- Use the following PM2 commands to manage the process:
+  - **View Logs**: `pm2 logs video-upscaler`
+  - **Restart**: `pm2 restart video-upscaler`
+  - **Stop**: `pm2 stop video-upscaler`
+
+---
+
+## Running the Video Compression Endpoint
+
+You can also run the video Compression endpoint using **PM2** to manage the process:
+
+```bash
+pm2 start "python services/compress/server.py" --name video-compressor
+```
+
+---
+
+## Running the file deletion process
+
+You can run the file deletion process using **PM2** to manage the process:
+
+```bash
+pm2 start "python services/miner_utilities/file_deletion_server.py" --name video-deleter
+```
+
+## Running the Miner with PM2
+
+To run the miner, use the following command:
+
+```bash
+pm2 start "python3 neurons/miner.py --wallet.name [Your_Wallet_Name] --wallet.hotkey [Your_Hotkey_Name] --subtensor.network finney --netuid 85 --axon.port [port] --logging.debug" --name video-miner
+```
+
+### Parameters:
+- **`--wallet.name`**: Replace `[Your_Wallet_Name]` with your wallet name.
+- **`--wallet.hotkey`**: Replace `[Your_Hotkey_Name]` with your hotkey name.
+- **`--subtensor.network`**: Specify the target network (e.g., `finney`).
+- **`--netuid`**: Specify the network UID (e.g., `292`).
+- **`--axon.port`**: Replace `[port]` with the desired port number.
+- **`--logging.debug`**: Enables debug-level logging for detailed output.
+
+### Managing the Miner Process:
+- **Start the Miner**: The above command will start the miner as a PM2 process named `video-miner`.
+- **View Logs**: Use `pm2 logs video-miner` to monitor miner logs in real time.
+- **Restart the Miner**: Use `pm2 restart video-miner` to restart the process.
+- **Stop the Miner**: Use `pm2 stop video-miner` to stop the process.
+
+---
+
+## Additional Notes
+
+- Ensure all dependencies are installed and configured correctly before running the miner.
+- Use a high-performance GPU and sufficient system resources for optimal performance.
+- For troubleshooting and debugging, refer to the logs available in PM2.

docs/validator_setup.md

@@ -0,0 +1,241 @@
+# Running Validator
+
+---
+
+## Machine Requirements
+
+To achieve optimal results, we recommend the following setup:
+
+- **Operating System**: Ubuntu 24.04 LTS or higher
+  [Learn more about Ubuntu 24.04 LTS](https://ubuntu.com/blog/tag/ubuntu-24-04-lts)
+- **GPU**: NVIDIA RTX A6000 with 48GB VRAM and 30 CPU Cores
+
+---
+
+## Install PM2 (Process Manager)
+
+**PM2** is used to manage and monitor the validator process. If you haven’t installed PM2 yet, follow these steps:
+
+1. Install `npm` and PM2:
+   ```bash
+   sudo apt update
+   sudo apt install npm -y
+   sudo npm install pm2 -g
+   pm2 update
+   ```
+
+2. For more details, refer to the [PM2 Documentation](https://pm2.io/docs/runtime/guide/installation/).
+
+---
+
+## Install Redis
+
+1. Install 'redis'
+   ```bash
+   sudo apt update
+   sudo apt install redis-server
+   sudo systemctl start redis
+   sudo systemctl enable redis-server
+   sudo systemctl status redis
+   ```
+
+
+## Install Project Dependencies
+
+### Prerequisites
+
+- **Python**: Version 3.10 or higher
+- **pip**: Python package manager
+- **virtualenv** (optional): For dependency isolation
+
+---
+
+### 1. Clone the Repository
+
+Clone the project repository to your local machine:
+```bash
+git clone https://github.com/vidaio-subnet/vidaio-subnet.git
+cd vidaio-subnet
+```
+
+---
+
+### 2. Set Up a Virtual Environment (Recommended)
+
+Create and activate a virtual environment to isolate project dependencies:
+```bash
+python3 -m venv venv
+source venv/bin/activate  
+```
+
+---
+
+### 3. Install the Package and Dependencies
+
+Install the project and its dependencies using `pip`:
+```bash
+pip install -e .
+```
+
+---
+
+### 4. Configure Environment Variables
+
+To configure environment variables, follow these steps:
+
+1. Create a `.env` file in the project root directory by referencing the provided `.env.template` file:
+   ```bash
+   cp .env.template .env
+   ```
+2. Set up a bucket in cloud storage. The base miner code utilizes MinIO to connect with cloud storage services, so you'll need to prepare your bucket using a platform that supports MinIO integration, such as Backblaze. Alternatively, you can modify the code to suit your specific requirements. *IMPORTANT*: Note that currently the `region` of the storage is hardcoded, and must be adjusted in `vidaio_subnet_core/utilities/storage_client.py` for corresponding storage, such as AWS.
+3. Add the required variables to the `.env` file. For example:
+   ```env
+   BUCKET_NAME="S3 buckent name"
+   BUCKET_COMPATIBLE_ENDPOINT="S3 bucket endpoint"
+   BUTKET_COMPATIBLE_ACCESS_KEY="S3 bucket personal access key"
+   BUCKET_COMPATIBLE_SECRET_KEY="S3 bucket personal secret key"
+   PEXELS_API_KEY="Your Pexels account api key"
+   WANDB_API_KEY="Your WANDB account api key"
+   ```
+
+4. Ensure that the bucket is configured with the appropriate permissions to allow file uploads and enable public access for downloads via presigned URLs.
+
+5. Create your Pexels API key and replace it. (https://www.pexels.com/)
+6. Once the `.env` file is properly configured, the application will use the specified credentials for S3 bucket, Pexels and Wandb.
+
+
+---
+
+## Install FFMPEG
+
+FFMPEG is required for processing video files. Install it using the following commands:
+```bash
+sudo apt update
+sudo apt install ffmpeg -y
+```
+
+For more details, refer to the [FFMPEG Documentation](https://www.ffmpeg.org/download.html#build-linux).
+
+---
+
+## Install VMAF
+
+To enable video quality validation, install **VMAF** by following the steps below to set up a clean virtual environment, install dependencies, and compile the tool.
+
+---
+
+Clone the VMAF repository into the working root directory of your `vidaio-subnet` package. If the `vidaio-subnet` virtual environment is currently active, deactivate it first:
+
+```bash
+git clone https://github.com/vidAio-subnet/vmaf.git
+cd vmaf
+```
+
+---
+
+### Step 1: Set Up a Virtual Environment in VMAF directory
+
+1. Install `venv` if it’s not already installed:
+   ```bash
+   python3 -m venv vmaf-venv
+   ```
+
+2. Activate the virtual environment:
+   ```bash
+   source vmaf-venv/bin/activate
+   ```
+
+---
+
+### Step 2: Install Dependencies
+
+1. Install `meson`:
+   ```bash
+   pip install meson
+   ```
+
+2. Install system dependencies:
+   ```bash
+   sudo apt-get update
+   sudo apt-get install nasm ninja-build doxygen xxd
+   ```
+   For Ninja, verify whether the package name is `ninja` or `ninja-build` before running the install command.
+
+---
+
+### Step 3: Compile VMAF
+
+
+1. Set up the build environment:
+   ```bash
+   cd libvmaf
+   meson setup build --buildtype release -Denable_avx512=true
+   ```
+
+2. Optional flags:
+   - Use `-Denable_float=true` to enable floating-point feature extractors.
+   - Use `-Denable_avx512=true` to enable AVX-512 SIMD instructions for faster processing on supported CPUs.  
+   - Use `-Denable_cuda=true` to build with CUDA support (requires `nvcc` and CUDA >= 11).  
+     **Note:** To enable CUDA successfully, ensure `nvcc` and the CUDA driver are installed. Refer to the [CUDA and NVCC setup guide](miner_setup.md#step-2-install-cuda-and-nvcc).
+   - Use `-Denable_nvtx=true` to enable NVTX marker support for profiling with Nsight Systems.
+   - **Recommendation:**
+   We recommend adding `-Denable_avx512=true` to enhance validation speed. If CUDA is available, include the flag `-Denable_cuda=true` But At present, VMAF does not include support for CUDA integration.
+
+3. Build the project:
+   ```bash
+   ninja -vC build
+   ```
+
+---
+
+### Step 4: Test the Build
+
+Run tests to verify the build:
+```bash
+ninja -vC build test
+```
+
+---
+
+### Step 5: Install VMAF
+
+Install the library, headers, and the command-line tool:
+```bash
+ninja -vC build install
+```
+
+---
+
+### Step 6: Generate Documentation
+
+Generate HTML documentation:
+```bash
+ninja -vC build doc/html
+```
+
+### Step 7: Deactivate vmaf-venv, activate project venv
+
+```bash
+deactivate
+cd ..
+cd ..
+source venv/bin/activate
+```
+
+## Running the Validator with PM2
+
+To run the validator, use the following command:
+
+```bash
+pm2 start run.sh --name vidaio_v_autoupdater -- --wallet.name [Your_Wallet_Name] --wallet.hotkey [Your_Hotkey_Name] --subtensor.network finney --netuid 85 --axon.port [port] --logging.debug
+```
+
+### Parameters:
+- **`--wallet.name`**: Replace `[Your_Wallet_Name]` with your wallet name.
+- **`--wallet.hotkey`**: Replace `[Your_Hotkey_Name]` with your hotkey name.
+- **`--subtensor.network`**: Specify the target network (e.g., `finney`).
+- **`--netuid`**: Specify the network UID (e.g., `85`).
+- **`--axon.port`**: Replace `[port]` with the desired port number.
+- **`--logging.debug`**: Enables debug-level logging for detailed output.
+
+---

iqf_scores.csv

@@ -0,0 +1,53 @@
+file_name,input_size,output_size,final_compression,final_score,psnr_values,scene_type,luma_qp,metrics_resolution_width,metrics_resolution_height,metrics_frame_rate,quality_noise_level,quality_sharpness,quality_contrast,quality_brightness,quality_color_saturation,quality_motion_blur,quality_compression_artifacts,quality_text_content,quality_edge_density,quality_temporal_consistency,chroma,preset
+04d651c3-3b08-4de9-befe-af12b3b3555b.mp4,11.63755702972412,2.962747573852539,0.2545850100914842,93.50666666666666,12.372051285756838,Glacier,36,1928,952,25.0,0.1429923623800277,0.0728510618209838,0.126477791035855,0.3213473471114912,0.3275197079482676,0.0515626634471215,0.0160338471954067,0.13787563780699,0.092448416088427,0.989902800881153,1,6
+07484eba-7a60-4754-ba0b-f9c0744af11b.mp4,50.56832885742188,6.884061813354492,0.1361338602421329,88.56666666666666,20.0522675981826,Sea,36,3744,2320,29.97,0.0958104953169822,0.0445181988179683,0.1467628849442237,0.3145919473712218,0.5450120102012216,0.0460680767388741,0.0104968805486957,0.3294798113763631,0.0776948865310934,0.9906222568234484,2,8
+0cb873d6-4c3a-4ced-84e9-87939b08565d.mp4,19.441584587097168,1.3194904327392578,0.0678694901039583,94.21666666666664,14.191413000600472,Street,36,3928,2176,25.0,0.0367702804505825,0.0250370651483535,0.1093549868154569,0.4941628043122025,0.2712272513396657,0.013138959918234,0.0052625991714497,0.0428705516702607,0.0243741084933209,0.99460809731599,1,7
+0d0496e7-fe16-443b-9c16-369aa386bb4e.mp4,91.49424362182616,35.15753650665283,0.3842595459007206,89.8,19.181592760557905,Sea,36,3824,2080,29.97,0.4522957503795624,0.1822116822004318,0.1255781912376141,0.3903664236722475,0.3277484580793212,0.0777180727657976,0.0146979351217548,0.1534577499731789,0.1063530938204055,0.9972791267899178,2,6
+0e4ce3ab-c7c1-4dd6-9d9d-983eabf8acf3.mp4,14.362677574157717,2.4586334228515625,0.1711821079431108,86.85000000000001,22.136717544720863,Glacier,36,2176,1312,29.97,0.0441711656749248,0.0190866943448781,0.2714131776661668,0.5323091666051284,0.1473271014321708,0.0106787879976685,0.0052575784890602,0.5868236919386657,0.0213027581935975,0.9938409873174072,1,8
+10e3a5e7-dda1-496d-84bb-f826e6567d82.mp4,12.642633438110352,2.115780830383301,0.1673528573568718,86.82666666666667,21.79987671919208,Sea,36,2024,1160,29.97,0.0658735483884811,0.027121203020215,0.2075980188991426,0.5772056769075355,0.1538377535831014,0.0165804881650084,0.0074098287150263,0.2507814274680841,0.0274054024124301,0.99776000034742,2,8
+12cb34d6-c1d8-4b85-8f0e-60afaf26ffc9.mp4,97.8766794204712,32.654263496398926,0.3336265971602751,99.62,11.553677315658312,Sea,36,3992,2128,29.97,0.1492599844932556,0.0777132287621498,0.1066155836718416,0.4059681511346936,0.3941002960882696,0.0566694557661689,0.016210103717943,0.1896969848217739,0.0992825641885274,0.9999994889713084,2,6
+12dd2d2b-24f3-4c31-b873-fa4e53803778.mp4,13.259980201721191,1.2535648345947266,0.0945374589949997,92.54,16.066609960586902,Buildings,36,3720,2000,24.0,0.0126855373382568,0.0054733753204345,0.1402558005829288,0.3471829562864572,0.7360188973223698,0.001899417562724,0.0039290150161832,0.0334341397849462,0.0028954301075268,0.9861516260805396,1,7
+221cab7a-eb1a-4b14-9568-9ac4a4ec9330.mp4,30.4854040145874,8.698417663574219,0.2853305686685992,93.10666666666668,12.963095414146787,Sea,36,1672,1096,29.97,0.9161150455474854,0.379181295633316,0.0543770877669747,0.5162277035227647,0.293133004869604,0.1587936850254368,0.0282400405655304,0.3147559197429539,0.2448316845946984,0.993860990900394,2,6
+249c9213-36ad-4280-a900-306b96685c0e.mp4,56.18430137634277,6.00376033782959,0.1068583250259574,85.86,26.456385705685307,Sea,36,4352,2512,25.0,0.0763325467705726,0.0321722514927387,0.1179865907502876,0.4856625565126684,0.1818267550762109,0.0330283511692893,0.0083340853452682,0.2281288784423005,0.0552171726448342,0.9998370150268332,2,8
+2884fdc7-6b49-4008-ae33-54956784cf22.mp4,115.50566577911376,39.40678596496582,0.3411675583111658,99.77666666666666,10.641904721237973,Sea,36,4136,2528,29.97,0.1351182460784912,0.0738693550229072,0.0741262606518029,0.4363434005579151,0.3657297264831183,0.0492047099564184,0.013960901958247,0.0938197538949962,0.0921825936359963,0.9924948222041552,2,6
+2efd6ba4-b102-4009-b197-da0cdaa634dc.mp4,24.736478805541992,2.1472091674804688,0.0868033475726305,96.65666666666668,14.345898901049,Street,36,4176,2264,25.0,0.0174604374915361,0.0072254240512847,0.1744482783278272,0.3013473596598065,0.2914109880184468,0.0007968369932623,0.0041565479865918,0.7164728393557441,0.0004970667824215,0.945495845282456,1,7
+31f7bc2c-838f-43c2-9cf8-745cc9ce27ab.mp4,22.826221466064453,1.773118019104004,0.0776789983283077,91.56666666666666,17.673464012040057,Glacier,36,4072,1984,25.0,0.035806518048048,0.0185190923511981,0.1413763511584968,0.45802809033771,0.3093696310212299,0.0120091791965059,0.0057176739598313,0.4397072453894416,0.0214490976931364,0.9821693564696936,2,7
+329f1c4c-f5df-453d-9cfc-6f2cbef5142b.mp4,9.611075401306152,1.6033363342285156,0.1668217413017716,91.58,14.919262283403194,Buildings,36,3840,2160,29.97002997002997,0.0132886199280619,0.009028784930706,0.1450372010687532,0.3001861801079742,0.5296609669395022,0.011812829539609,0.0035800460415581,0.2275868055555555,0.0218736135223765,0.9926868678702192,1,7
+34e7d8b9-5fd5-44d6-ba9c-194d4e2078ae.mp4,8.409784317016602,1.186915397644043,0.1411350580350085,93.26666666666668,17.535968238489765,Street,36,1864,1112,25.0,0.0701295137405395,0.046890240162611,0.1179904369005827,0.4931510383715244,0.3031222125304049,0.0228256772264591,0.0097284382209181,0.2783456711026029,0.0409182310803717,0.9759738649373356,2,7
+39c98272-d26f-4139-afbf-d870b7553fab.mp4,11.697440147399902,2.2339115142822266,0.1909743915021252,85.91333333333334,21.82086911294481,Glacier,36,1912,1152,29.97,0.0379447676241397,0.0166470278054475,0.2989692671433983,0.568221517441918,0.165857213229027,0.0145771588795908,0.0056536531386276,0.511477219897722,0.0302196380317294,0.9934711756986034,1,8
+40949702-a809-4464-9d14-481e76abd967.mp4,11.222305297851562,4.060033798217773,0.3617825117442707,95.78666666666668,19.67346395047992,Street,36,1992,1080,25.0,0.1722472161054611,0.0929764881730079,0.1250032341526129,0.3511127182416424,0.3858102265027187,0.0427754226783677,0.0143549318114916,0.1648349571124002,0.0433976647330061,0.999515551312002,1,6
+424df265-1080-4edf-8cfc-b05f62acfffc.mp4,93.02153778076172,38.198049545288086,0.4106366166007205,90.03666666666668,18.992862809167303,Sea,36,3744,2176,29.97,0.5003300309181213,0.2049688547849655,0.0901389832452703,0.4063670264387649,0.2718818422945892,0.0835086546971887,0.0158878316481908,0.2587865257614798,0.1137096314888134,0.999358035236232,2,6
+59bb4aa2-724b-490a-944c-eaae28496192.mp4,82.74820232391357,38.806517601013184,0.4689711257908306,95.3,17.10664600652759,Sea,36,3632,2096,24.0,0.3662587702274322,0.166818082332611,0.2566843861128125,0.2162887687259836,0.4824837299832892,0.0542928510077232,0.0178386699408292,0.5918705022362714,0.0900308065289033,0.9984225156964288,2,6
+5e800829-24b2-4ca7-bac4-89a02199fbec.mp4,9.155067443847656,1.3330106735229492,0.1456035885807431,90.11333333333334,18.971216361292488,Buildings,36,1928,1144,29.97,0.0794639736413955,0.0400956831872463,0.1179491268665797,0.5208322161695057,0.2232629198900251,0.0302041924189227,0.0122872879728674,0.263849394036116,0.0527989256594028,0.9977240688080936,1,7
+6084559b-4f79-480c-ae41-bdb3d0a6987c.mp4,8.81439208984375,0.454263687133789,0.0515365872658657,94.17,28.143217609294314,Buildings,36,3864,2176,24.0,0.0228502452373504,0.010489453561604,0.2066807213167505,0.2309552700244988,0.2557928800116594,0.0037469981199001,0.0021716706299533,0.6112707197915398,0.0058192349630069,0.9988106814283684,1,8
+61a7d453-d120-440f-abfe-fa05714179b4.mp4,20.49268341064453,2.590888023376465,0.1264299053207778,92.07,16.241323427262568,Buildings,36,3456,2104,24.0,0.0289852488785982,0.0140899522230029,0.2357989120564686,0.193935172888864,0.6341521050899118,0.0047159034232267,0.0054534943774342,0.6904527457987139,0.0081701328378045,0.9847355475512976,1,7
+64e41231-4092-46c3-906d-5170de857162.mp4,28.37565803527832,4.181161880493164,0.1473503055081539,88.35000000000001,18.958802985591056,Mountain,36,2280,1264,23.976,0.3514604568481445,0.1335129588842392,0.1668962952215819,0.2662084490876815,0.4625996798249243,0.1331960406025612,0.0211052832504113,0.575414307128581,0.2066374153342216,0.9915836759698328,1,6
+691de276-7b47-4015-bc54-da4343889084.mp4,21.35616779327393,2.661280632019043,0.1246141469658806,92.38666666666668,19.55607154395117,Glacier,36,4208,2040,25.0,0.0283349398523569,0.0150849567726254,0.147305984712665,0.4657045179866474,0.478251971736034,0.0079452614379084,0.0047814832068979,0.5164016097567037,0.0134434643629314,0.9986614345096868,2,7
+733704b4-12f7-4977-b920-6896bc9ca77c.mp4,42.62840366363525,4.617931365966797,0.1083299154808882,84.61,26.44615321681865,Sea,36,3632,2112,25.0,0.0834942460060119,0.0357695259153842,0.1235101446790105,0.5205489246068594,0.2374145989757425,0.0421646166371868,0.0080157189319531,0.1772868761958795,0.0679565478574289,0.9985238316412702,2,8
+81e87893-da5e-4db2-afd1-b1bb11a03de7.mp4,11.973058700561523,2.250288963317871,0.1879460394871643,94.15666666666664,12.184221110468258,Sea,36,1848,1080,29.97,0.158597245812416,0.0801888853311538,0.0707714670215206,0.4440622167310621,0.4276124882238716,0.0134389530222863,0.0096513582393527,0.2976868553257442,0.0195476591309924,0.9545209309874344,2,6
+8b6d7852-7f21-47df-aa03-fc8c0f29e6d3.mp4,36.639710426330566,6.357483863830566,0.1735134855012899,98.35666666666668,11.7227002191702,Buildings,36,4216,2472,25.0,0.038616944104433,0.0222245398908853,0.1535103188816618,0.5920864945591565,0.2681580551402431,0.0082668454687439,0.0051134812335173,0.1357015141373388,0.0153606061513236,0.9985361279804812,1,7
+8f0464f5-2e81-4d50-b4bb-0667fadd55b6.mp4,34.017616271972656,16.64235496520996,0.4892275470495476,97.63333333333333,14.750361283262205,Street,36,1944,1000,30.0,0.7986264824867249,0.3549840152263641,0.1570230198475594,0.5378053457597031,0.2279299167540815,0.1251349451303155,0.0310485574106375,0.3349941700960219,0.180920524691358,0.986462531267651,1,6
+93495912-fd6c-435a-9fcb-c9cc978c122e.mp4,14.999189376831056,2.030162811279297,0.1353515020228525,90.58,15.28308285240923,Sea,36,2008,1248,29.545,0.1255028247833252,0.0577357523143291,0.1450512624336307,0.5325459562996547,0.2646494876660611,0.0453523778816358,0.0071958565774063,0.0897749812714952,0.0797762475738073,0.993942635378546,2,6
+9a049c4c-bb40-4692-8b95-cb2ca94d339f.mp4,7.705256462097168,0.7953510284423828,0.1032218761769688,89.89333333333333,32.48977789954205,Sea,36,2072,1168,29.97,0.0590476691722869,0.0255420710891485,0.0779400273458398,0.4569901856213298,0.4663660800924096,0.0096129795402055,0.0046418259541193,0.0497310850478658,0.0130963813005765,0.9963151955987876,2,8
+9d860f37-78b5-4e91-bbff-91bbfaaaa32a.mp4,24.54138946533203,3.542244911193848,0.1443375859462944,86.88999999999999,18.815549968769943,Mountain,36,2176,1128,23.976,0.3589254915714264,0.1361661404371261,0.1674924357608167,0.2623429547776905,0.4926483928925658,0.1339137300531915,0.0214552866915861,0.4039163537755528,0.2070070090868794,0.991671204099078,1,6
+a3fa72da-8a4e-466c-9a11-fc2a67863b9e.mp4,66.18983554840088,15.258377075195312,0.2305244747743438,98.00666666666666,11.54028731617105,Sea,36,4064,2328,29.97,0.0872727632522583,0.0455792434513568,0.0999884181943172,0.4212085293801522,0.3973935582882845,0.0268627222177124,0.0114057408645749,0.0736418196597848,0.0521458532043997,0.9822594713112536,2,6
+a508a47e-295b-4be0-ab3f-4b6478dacc65.mp4,150.44969272613525,62.874778747558594,0.4179123108081719,92.61,15.8732601360474,Sea,36,4360,2352,59.94,0.3012926876544952,0.1273589581251144,0.1922401876107427,0.5702624508009116,0.1724064290599012,0.085398268634671,0.0167182801912228,0.3027350657388337,0.1516859553454409,0.9744751753912574,2,6
+a5f32e7e-a5f3-4a7e-b7fd-dc0fb551e243.mp4,27.75857830047608,8.89590835571289,0.3204742065468217,93.04333333333334,18.556904219657586,Sea,36,1896,1120,29.97,0.4847494661808014,0.2182989865541458,0.1002119651271572,0.4154083440689919,0.3129233998451701,0.1315088469459513,0.0165209782620271,0.2850421313039984,0.1916254614978902,0.9980037344579182,2,6
+a75909eb-460b-4eb8-ab69-1f81413fde39.mp4,15.16309642791748,1.656632423400879,0.1092542299177611,91.09333333333332,17.147321929463487,Glacier,36,3504,2216,24.0,0.0099504310637712,0.0039873127825558,0.1837182655713437,0.320486532314655,0.7251103568436426,0.0009946943908697,0.0028258475164572,0.0432883306133887,0.0012447738943013,0.974405000500192,1,8
+a8fb16e1-2992-4ab7-95b7-47d48938f465.mp4,56.77720260620117,6.564875602722168,0.1156252034510265,87.28666666666668,25.996976327787028,Sea,36,4416,2512,25.0,0.0753649845719337,0.0320221297442913,0.1090954151336163,0.5430451944241572,0.1567155809969492,0.0323188429836302,0.0074781634223957,0.2131279520139081,0.0550013467962475,0.9987616523664528,2,8
+af18139c-acaf-4c43-977a-9a86fb3f3602.mp4,15.229940414428713,1.547590255737305,0.1016149908420608,94.05666666666666,14.702759137373825,Glacier,36,3920,2208,24.0,0.0150572964921593,0.006208827253431,0.1435621928273399,0.3124642683160221,0.8005967936691585,0.0014279398353544,0.003335137773926,0.0207769520851819,0.002143411712511,0.988551496232551,1,7
+b2b4e988-b71d-4d6f-a5dd-8db222348faa.mp4,8.236392974853516,1.106584548950195,0.1343530538584914,91.45666666666666,18.26996100063993,Mountain,36,1992,1232,25.0,0.0576150827109813,0.0262715872377157,0.0962681090485671,0.5841186732542597,0.1946375993959711,0.0105294011544011,0.0063949679024517,0.1362384060049722,0.0184834304751473,0.989757914392482,1,7
+b872dec9-a527-443e-807b-8a650fb44aa5.mp4,31.921814918518063,4.167214393615723,0.1305444068344088,90.35,20.685591731501987,Glacier,36,3672,2200,29.97,0.0734859108924865,0.0299688708037138,0.122406591632788,0.3481631003097746,0.4225727329685422,0.0204849970291146,0.0085126602401336,0.083881626724764,0.0360843731431966,0.9853751111654804,1,8
+bb85c24e-dfb2-4e74-a538-7b88444ba7a2.mp4,7.403351783752441,1.078202247619629,0.1456370410475259,86.96666666666668,31.55410760665986,Sea,36,2064,1136,29.97,0.0316026173532009,0.0123316012322902,0.3639183350001875,0.4339056100931475,0.6477346277180488,0.0062771249590566,0.0054633522716661,0.8203375209265932,0.0106365238426684,0.999820633741268,2,8
+bd22f174-e591-4d7a-a5fa-40447e18191e.mp4,14.803239822387695,2.936840057373047,0.1983917096939491,88.06666666666666,19.394910594585504,Mountain,36,1840,1008,59.94,0.172185018658638,0.0587177462875843,0.0989175467097531,0.413866736610103,0.3300058145238772,0.0461997857717966,0.0112428820381561,0.0506351363008971,0.0771057086783988,0.9926592185787358,2,6
+c6b21693-9149-46a7-8062-b4e36d861374.mp4,6.766033172607422,0.8436651229858398,0.1246912483966904,91.64333333333332,34.748478048384115,Mountain,36,1800,1040,25.0,0.1755229383707046,0.0655823424458503,0.1886238112680818,0.3749341251885369,0.472089366515837,0.0616330128205128,0.01280546374619,0.3262396723646723,0.0449030448717948,0.9997276437070556,2,7
+d31d550a-bebb-4124-bd43-8b60d0e18de8.mp4,17.65333652496338,1.5875320434570312,0.0899281584085886,92.79,18.366078180220185,Street,36,2256,1208,23.976,0.321790337562561,0.1782573610544204,0.1331180156782398,0.3457849007320899,0.3365648953207698,0.0981379798584691,0.0206291632105906,0.4263416271350961,0.1503226495350147,0.9993916711217388,1,6
+d863f7e4-dceb-4f47-8a78-dd6d1e4e880d.mp4,29.070735931396484,6.318779945373535,0.2173587885867462,85.97333333333334,20.767000095983462,Sea,36,2200,1240,59.94,0.1871851682662964,0.0643177106976509,0.1103539881428786,0.3952507633258582,0.3379617215801276,0.0673505620723362,0.0123686343431472,0.2884670087976539,0.10835392228739,0.9977341311597951,2,6
+dd477309-fa8a-4317-94ff-d8b54bc3cad1.mp4,21.595118522644043,2.3091840744018555,0.1069308358729547,93.02666666666666,12.38130718901219,Buildings,36,3944,2168,25.0,0.0399475842714309,0.0225663352757692,0.0982543567243773,0.4887902318051936,0.4495643316600509,0.0099232115546307,0.0066649932414293,0.1681051635567065,0.0187829684775042,0.964893394653431,2,7
+e0ece203-f76b-40b9-8285-cb9fd999c5c4.mp4,48.40852928161621,4.847820281982422,0.1001439282276118,95.54333333333334,15.267127113506389,Buildings,36,3912,2192,24.0,0.1240128055214881,0.0678207352757453,0.1008983220628024,0.3571532536652205,0.3761971421338625,0.0539492387886296,0.012217029929161,0.2409559114385085,0.0994769276267669,0.9933512871772088,1,6
+e199cb9b-752f-4aa1-a4b9-1885fa53a026.mp4,67.37089347839355,9.13538932800293,0.1355984588646241,93.14,18.97621105248905,Buildings,36,3704,2192,24.0,0.3928792476654053,0.1705749481916427,0.1482475339820311,0.3366086798822518,0.1580182770650997,0.0791778993446947,0.0160163554052511,0.3772218204295481,0.1360922079700777,0.9976828925927232,1,6
+e7f5193f-e47b-4376-977d-feb98314b110.mp4,18.898674964904785,2.464480400085449,0.1304049307510732,98.17,13.702267426394744,Street,36,1976,1112,29.97,0.2872275412082672,0.1347596794366836,0.1224473220403082,0.450834061852685,0.4047301679970621,0.0687426273556053,0.0160518120974302,0.2834111253507316,0.1179757358081146,0.989530204248128,2,6
+f11482e6-3485-46a8-9ade-92b46a803067.mp4,17.065518379211426,3.2750844955444336,0.1919123945003639,88.09666666666665,23.87321348719044,Sea,36,2016,1184,30.0,0.131056860089302,0.0564496926963329,0.2015653390023331,0.5128782488502158,0.2638884277747635,0.0529823908730158,0.0086417753870288,0.5257810824217074,0.0851019127386314,0.999383320097934,2,7
+f4f67a32-a8f5-43ac-93fb-6a41a45696de.mp4,48.70376110076904,11.58397102355957,0.2378455125794517,94.2,27.01278655262587,Street,36,3920,2072,24.0,0.5899763107299805,0.3269930779933929,0.1248712283772103,0.4635716519555055,0.3184764832573956,0.1427197012975074,0.030318242808183,0.2410834121293304,0.107225469821133,0.9999854710223858,2,6
+fcd1e637-3ac0-49af-920e-6bc5ae2e32cf.mp4,46.41104698181152,11.405869483947754,0.245757642322047,90.84,23.09361398873996,Sea,36,3696,2256,25.0,0.1243470683693885,0.0575859062373638,0.4032672850400358,0.0772454033864781,0.3632161264328427,0.0128380995236048,0.0054249467017749,0.6764255555811407,0.0217236959258235,0.9999686643274333,2,8
+fd4e4b88-600d-4a77-acdc-a1315ce301cc.mp4,20.68675708770752,1.9913969039916992,0.09626433449905136,92.33999999999999,14.531413968873949,Glacier,36,4568,2672,24.0,0.0160443242639303,0.0065641249530017,0.1358391283293425,0.3137757971488773,0.7292011663634032,0.0011647567387117,0.0032998408811787,0.1209636331540072,0.0016134270425873,0.9884601788362084,1,7

iqf_scores_1.csv

@@ -0,0 +1,75 @@
+file_name,ori_luma_qp,ori_chroma,ori_preset,brightness,contrast,colorfulness,sharpness,quality_factor,mos_zscore,luma_qp,chroma,preset,final_scores
+04d651c3-3b08-4de9-befe-af12b3b3555b.mp4,32,0,4,1.8469307366129406e-16,0.9999998410542806,1.0,0.9999999602635702,0.298225900199812,0.0,35,5,10,90.31333333333333
+07484eba-7a60-4754-ba0b-f9c0744af11b.mp4,31,-1,4,0.6979172627131144,0.6313334306081136,0.6084306836128235,0.6348755955696106,0.6509576241175333,0.7038862506548563,38,0,10,84.82666666666667
+0cb873d6-4c3a-4ced-84e9-87939b08565d.mp4,35,1,4,2.1057123452742498e-07,0.9972970485687256,0.9999999602635702,0.9853918751080832,0.3318715903168057,6.486347245594561e-25,36,6,10,92.60666666666667
+0d0496e7-fe16-443b-9c16-369aa386bb4e.mp4,31,-1,4,0.5955032904942831,0.7397701740264893,0.5834726889928182,0.7210836410522461,0.65736456712087,0.4505663216114044,37,0,10,86.69333333333333
+0e4ce3ab-c7c1-4dd6-9d9d-983eabf8acf3.mp4,31,-1,4,0.6425169706344604,0.6254289746284485,0.5407780408859253,0.6723130941390991,0.7194178899129232,0.6874635815620422,37,-1,10,81.39333333333333
+10e3a5e7-dda1-496d-84bb-f826e6567d82.mp4,31,-1,4,0.666383703549703,0.644948422908783,0.5396574338277181,0.6548968553543091,0.6909757057825724,0.6799997289975485,37,-1,10,80.31333333333335
+12cb34d6-c1d8-4b85-8f0e-60afaf26ffc9.mp4,31,-1,4,0.559302568435669,0.6554734110832214,0.517133355140686,0.6597744027773539,0.6716094811757406,0.6479589343070984,37,-1,10,99.25333333333333
+12dd2d2b-24f3-4c31-b873-fa4e53803778.mp4,33,2,4,0.0304905549855902,0.8879064122835795,0.9823326071103414,0.992975890636444,0.0004040396706827,2.798745185113234e-08,35,7,10,90.84666666666668
+221cab7a-eb1a-4b14-9568-9ac4a4ec9330.mp4,31,-1,4,0.6206316550572714,0.6937900980313619,0.5681640307108561,0.6865283250808716,0.6309727231661478,0.5269437432289124,37,0,10,88.66666666666667
+249c9213-36ad-4280-a900-306b96685c0e.mp4,31,-1,4,0.6744417746861776,0.6287276744842529,0.5382514794667562,0.6795710523923238,0.7059144775072733,0.6740560928980509,37,-1,10,80.68666666666667
+2884fdc7-6b49-4008-ae33-54956784cf22.mp4,31,-1,4,0.5739724636077881,0.6645207007726034,0.5748539765675863,0.6702662507692972,0.6798134446144104,0.6453063488006592,37,0,10,99.71333333333332
+2efd6ba4-b102-4009-b197-da0cdaa634dc.mp4,33,0,4,0.2123574561207135,0.923816998799642,0.5404039584100246,0.557942457186679,0.5570492148494531,0.1948199073473612,42,0,10,94.18333333333334
+31f7bc2c-838f-43c2-9cf8-745cc9ce27ab.mp4,32,0,4,0.2436689063906669,0.865463117758433,0.5987633650268739,0.663530599674465,0.0083957752296021,0.0033863165364441,39,1,11,87.52999999999999
+329f1c4c-f5df-453d-9cfc-6f2cbef5142b.mp4,35,1,4,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,41,2,10,84.48
+34e7d8b9-5fd5-44d6-ba9c-194d4e2078ae.mp4,33,0,4,0.6085565884908041,0.7023536364237467,0.5811308026313782,0.6709411342938741,0.6804569562276205,0.6665542125701904,39,1,10,88.88666666666666
+39c98272-d26f-4139-afbf-d870b7553fab.mp4,31,-1,4,0.6213184396425883,0.6266296108563741,0.5339837074279785,0.6631546020507812,0.7125220696131388,0.6837653716405233,37,-1,10,78.45333333333333
+40949702-a809-4464-9d14-481e76abd967.mp4,33,0,4,3.0931066325599755e-11,0.6665612919865964,1.0,0.5694492856661543,0.013828640182813,4.3167463616559045e-17,43,5,11,88.24666666666667
+424df265-1080-4edf-8cfc-b05f62acfffc.mp4,31,-1,4,0.572777271270752,0.8049134612083435,0.5622189939022064,0.7238964438438416,0.6895942687988281,0.4115677277247111,36,0,10,87.91000000000001
+4df1a23d-73f2-4cab-b43c-5538b566a458.mp4,35,1,4,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,41,2,10,84.48
+59bb4aa2-724b-490a-944c-eaae28496192.mp4,31,-1,4,9.296274529428212e-07,0.3862022735666339,0.0247434326447546,1.0,1.0,0.0171932382619767,35,-6,10,94.98666666666668
+5e800829-24b2-4ca7-bac4-89a02199fbec.mp4,35,1,4,0.6375203331311544,0.6609386603037516,0.5363780458768209,0.6825437943140665,0.7010063727696737,0.6790463924407959,41,1,10,82.86
+5fe0ff99-37a3-4760-81a4-f441876cb867.mp4,35,1,4,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,41,2,10,84.48
+6084559b-4f79-480c-ae41-bdb3d0a6987c.mp4,33,2,4,0.5323069393634796,0.7520566980044047,0.5722926259040833,0.693462073802948,0.5514254768689474,0.2662951275706291,39,3,10,91.99666666666667
+61a7d453-d120-440f-abfe-fa05714179b4.mp4,35,1,4,0.5853416124979655,0.6666666666666666,1.0,0.3333347989194711,2.981454431780764e-25,0.0,50,6,11,79.58666666666667
+64e41231-4092-46c3-906d-5170de857162.mp4,30,0,4,0.745102326075236,0.670194149017334,0.5261250138282776,0.7535956104596456,0.707586407661438,0.3179372052351634,35,0,10,84.63666666666666
+691de276-7b47-4015-bc54-da4343889084.mp4,32,0,4,0.6291013558705648,0.647834857304891,0.6641747156778971,0.6670735081036886,0.7004674077033997,0.6992351412773132,38,2,10,88.96666666666665
+733704b4-12f7-4977-b920-6896bc9ca77c.mp4,31,-1,4,0.6398445963859558,0.6260692278544108,0.5751756628354391,0.6669502059618632,0.7081162532170614,0.6691677371660868,37,0,10,79.04333333333334
+81e87893-da5e-4db2-afd1-b1bb11a03de7.mp4,33,2,4,7.679543605343628e-09,1.0,1.0,0.3358941231754215,4.8890841564280026e-21,4.577665144872662e-36,47,7,11,78.89666666666666
+890c5911-8ee1-4faa-a801-c605f0dde8e0.mp4,35,1,4,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,41,2,10,84.48
+8b6d7852-7f21-47df-aa03-fc8c0f29e6d3.mp4,35,1,4,0.6386719544728597,0.6828855474789938,0.5790578722953796,0.6756150126457214,0.7062546610832214,0.6745621760686239,41,2,10,96.22000000000001
+8f0464f5-2e81-4d50-b4bb-0667fadd55b6.mp4,33,0,4,0.6737418174743652,0.6781927148501078,0.5551733573277792,0.6866800983746847,0.6682468851407369,0.6677144169807434,39,1,10,93.66000000000001
+93495912-fd6c-435a-9fcb-c9cc978c122e.mp4,31,-1,4,0.3303557277324671,0.572416496075069,0.8744631012280782,0.5750492256289969,0.245182732741038,0.1620057622591654,41,3,10,82.59333333333333
+9a049c4c-bb40-4692-8b95-cb2ca94d339f.mp4,31,-1,4,0.5415121912956238,0.6919364531834921,0.5953385432561239,0.7154134511947632,0.6035712758700053,0.5871815880139669,36,0,10,86.02666666666669
+9d860f37-78b5-4e91-bbff-91bbfaaaa32a.mp4,30,0,4,0.5807816584904989,0.6518141428629557,0.5270594159762064,0.6739723483721415,0.6623684565226237,0.5438634157180786,36,0,10,82.79
+a3fa72da-8a4e-466c-9a11-fc2a67863b9e.mp4,31,-1,4,0.2128963904734471,0.8745509584744772,0.8768628239631653,0.579653590063875,0.24392955436218,0.2292507886886597,39,3,10,95.11666666666667
+a508a47e-295b-4be0-ab3f-4b6478dacc65.mp4,31,-1,4,0.626129150390625,0.6703311999638876,0.562980075677236,0.6703017155329386,0.6834884285926819,0.6630960901578268,37,0,10,88.67
+a5f32e7e-a5f3-4a7e-b7fd-dc0fb551e243.mp4,31,-1,4,0.6408935189247131,0.7019673387209574,0.5994003017743429,0.701171875,0.6946845253308614,0.6745195984840393,36,0,10,90.31333333333333
+a75909eb-460b-4eb8-ab69-1f81413fde39.mp4,35,1,4,0.0452174662328464,0.6664746296834588,0.9997160037358602,0.662308836724454,0.2454252270120681,4.135975021220975e-11,43,6,10,85.72666666666667
+a8fb16e1-2992-4ab7-95b7-47d48938f465.mp4,31,-1,4,0.6491552790006002,0.6554122765858968,0.5638013680775961,0.663050651550293,0.7081366777420044,0.6996987660725912,37,0,10,82.66666666666667
+acfbb4ee-70e5-45bf-8aa8-349e388499ed.mp4,35,1,4,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,41,2,10,84.48
+af18139c-acaf-4c43-977a-9a86fb3f3602.mp4,33,2,4,0.2569143105560701,0.3665943775946895,0.7403472264607748,0.6492060224215189,0.3337878490177342,0.0003729414893314,41,4,10,90.76999999999998
+b2b4e988-b71d-4d6f-a5dd-8db222348faa.mp4,33,2,4,0.6797566215197245,0.6921680370966593,0.5756566723187765,0.6673476894696554,0.7057122588157654,0.6777393817901611,39,3,10,86.19
+b872dec9-a527-443e-807b-8a650fb44aa5.mp4,33,2,4,0.5625234958715737,0.8364881674448649,0.8529369036356608,0.3062493354858209,0.2298784634719292,0.2218764863639043,47,6,10,76.47
+bb85c24e-dfb2-4e74-a538-7b88444ba7a2.mp4,31,-1,4,0.5719117522239685,0.5746606588363647,0.7491706609725952,0.6051486531893412,0.6949742039044698,0.6399241884549459,38,1,10,79.57333333333332
+bd22f174-e591-4d7a-a5fa-40447e18191e.mp4,31,-1,4,0.3112848651896153,0.9546863834063212,0.6849623595674833,0.8972047170003256,0.5202026833430864,0.2215489234929057,35,1,10,84.64999999999999
+bdc6f64e-fe6c-4f98-b37d-a8405f0674a6.mp4,35,1,4,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,41,2,10,84.48
+c6b21693-9149-46a7-8062-b4e36d861374.mp4,30,0,4,0.6675481796264648,0.6689058740933737,0.6905355652173361,0.6873549222946167,0.6984812021255493,0.6681686639785767,36,2,10,89.67333333333333
+ce34e0c1-7378-4fc8-96c7-44ddcbbf1487.mp4,31,-1,4,0.626129150390625,0.6703311999638876,0.562980075677236,0.6703017155329386,0.6834884285926819,0.6630960901578268,37,0,10,88.67
+d31d550a-bebb-4124-bd43-8b60d0e18de8.mp4,33,0,4,0.5594322880109152,0.7071808179219564,0.5779878795146942,0.7282688617706299,0.6871213515599569,0.5582586626211802,38,1,10,89.88333333333333
+d863f7e4-dceb-4f47-8a78-dd6d1e4e880d.mp4,33,2,4,0.7645663022994995,0.7623209357261658,0.3754141006926754,0.7709534366925558,0.8046964406967163,0.4424456845930156,37,1,10,80.22333333333334
+dd477309-fa8a-4317-94ff-d8b54bc3cad1.mp4,35,1,4,0.5718956192334493,0.6503244837125143,0.5420317649841309,0.6384625236193339,0.6779917677243551,0.6346049110094706,42,1,10,87.84666666666665
+e0ece203-f76b-40b9-8285-cb9fd999c5c4.mp4,35,1,4,0.7104902664820353,0.6507590810457865,0.6978453199068705,0.6581440766652426,0.7403779625892639,0.2868792239266137,42,3,10,88.86666666666666
+e199cb9b-752f-4aa1-a4b9-1885fa53a026.mp4,35,1,4,0.2177942705724667,0.7863604227701823,0.6638821821833668,0.7953539888064066,0.3359929546713829,0.0008118189095209,40,3,10,86.86666666666666
+e4bb727c-b404-4141-bfbe-af71df54c3ff.mp4,35,1,4,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,41,2,10,84.48
+e7f5193f-e47b-4376-977d-feb98314b110.mp4,33,0,4,0.6336689988772074,0.6886950929959615,0.5957454244295756,0.7071948448816935,0.67882106701533,0.6200438141822815,38,1,10,93.98
+f11482e6-3485-46a8-9ade-92b46a803067.mp4,31,-1,4,0.5987781286239624,0.6132558385531107,0.6389955282211304,0.6446781953175863,0.7036546866099039,0.6583541433016459,38,0,10,83.53666666666668
+f4f67a32-a8f5-43ac-93fb-6a41a45696de.mp4,33,0,4,0.6998077034950256,0.6582560737927755,0.5905927220980326,0.6627445220947266,0.6663028597831726,0.6565006971359253,39,1,10,90.92
+fcd1e637-3ac0-49af-920e-6bc5ae2e32cf.mp4,31,-1,4,0.0272201643213868,0.3309482576635976,0.4792167643706004,0.998989482720693,0.6663707869944121,0.0050284543152277,35,-1,10,89.79333333333334
+fd4e4b88-600d-4a77-acdc-a1315ce301cc.mp4,33,2,4,0.4362088193496068,0.4098552847281098,0.7522272070248922,0.8208715716997782,0.3990619123778742,0.4480555057525927,37,5,10,91.00666666666666
+test1.mp4,32,0,4,0.5417211453119913,0.6767938733100891,0.557605524857839,0.6215428908665975,0.6766568620999655,0.5881443421045939,39,1,10,85.44333333333333
+test10.mp4,32,0,4,0.3333333706116344,0.6667284226520375,1.0,1.0,2.8805363963881653e-13,0.0,35,5,10,82.65666666666665
+test11.mp4,31,-1,4,0.4099834094134469,0.4834768225749333,0.3692534565925598,0.7831077774365743,0.783106525739034,0.629439910252889,35,-2,10,92.98
+test12_gray.mp4,33,0,4,0.018794454264411,0.9975093007087708,0.5747074456497406,0.9784387747446696,0.2222395691399773,0.0231209589789311,35,1,10,89.79
+test13_gray.mp4,35,1,4,0.5948363542556763,0.7572359442710876,0.5567836960156759,0.7168492476145426,0.7041877706845602,0.4451386034488678,40,2,10,97.55333333333333
+test14.mp4,32,0,4,2.398985454732383e-10,0.999976634979248,0.3325004479909856,0.9213998317718506,0.0472111580893397,2.4258483184696295e-17,35,-2,10,90.44999999999999
+test15.mp4,30,-2,4,0.6469272573788961,0.646748940149943,0.5141305724779764,0.6336438258488973,0.6843962669372559,0.6492714285850525,37,-2,10,85.60000000000001
+test2.mp4,32,0,4,0.591302216053009,0.660931130250295,0.5407073299090067,0.6467535098393759,0.7081582148869833,0.6751541495323181,39,0,10,84.26
+test3.mp4,33,0,4,0.6335959037144979,0.6653205553690592,0.5678872664769491,0.6906165877978007,0.6796593268712362,0.6661312778790792,39,1,10,91.08999999999999
+test4.mp4,31,-1,4,0.6273186802864075,0.6763830780982971,0.577736496925354,0.6883265972137451,0.6920067270596822,0.6691595713297526,37,0,10,80.92333333333333
+test5.mp4,32,0,4,0.3322414370577034,0.836751659711202,0.6209217806657156,0.9802228212356568,0.283252388325516,0.1214854717254638,35,1,10,87.76666666666667
+test6.mp4,32,0,4,7.503743552443134e-10,0.6666666666703399,0.9999998807907104,0.0003142244143721,0.3394560635861126,1.5046710818080233e-23,50,5,11,79.53
+test7.mp4,31,-1,4,0.5248274604479471,0.5492491523424784,0.7139172554016113,0.6525176564852396,0.7086620926856995,0.6403847138086954,38,1,10,79.80333333333334
+test8.mp4,33,2,4,0.0,0.6666666666666666,0.6666666667085034,0.6666666666666666,1.1066234416402631e-20,0.0,41,4,11,88.39999999999999
+test9.mp4,31,-1,4,0.5562724669774374,0.5891389648119608,0.6328761577606201,0.6466207702954611,0.7093602021535238,0.6497571667035421,38,0,10,76.86

iqf_scores_2.csv

@@ -0,0 +1,31 @@
+file_name,input_size,output_size,final_compression,final_score,ori_luma_qp,ori_chroma,ori_preset,brightness,contrast,colorfulness,sharpness,quality_factor,mos_zscore,luma_qp,chroma,preset
+04d651c3-3b08-4de9-befe-af12b3b3555b.mp4,11.63755702972412,2.6749343872070312,77.01463992507333,91.75666666666666,28.1,0.0,4,1.8469307366129406e-16,0.9999998410542806,1.0,0.9999999602635702,0.298225900199812,0.0,37,0,6
+07484eba-7a60-4754-ba0b-f9c0744af11b.mp4,50.56832885742188,7.134676933288574,85.89101697743483,87.09666666666665,26.691666666666663,-1.0,4,0.6979172627131144,0.6313334306081136,0.6084306836128235,0.6348755955696106,0.6509576241175333,0.7038862506548563,34,0,11
+0cb873d6-4c3a-4ced-84e9-87939b08565d.mp4,19.441584587097168,1.293718338012695,93.34561268801464,92.84,26.13,1.0,4,2.1057123452742498e-07,0.9972970485687256,0.9999999602635702,0.9853918751080832,0.3318715903168057,6.486347245594561e-25,35,0,11
+0d0496e7-fe16-443b-9c16-369aa386bb4e.mp4,91.49424362182616,33.905229568481445,62.94277298075475,87.64666666666666,28.391666666666666,-1.0,4,0.5955032904942831,0.7397701740264893,0.5834726889928182,0.7210836410522461,0.65736456712087,0.4505663216114044,36,0,10
+0e4ce3ab-c7c1-4dd6-9d9d-983eabf8acf3.mp4,14.362677574157717,2.823794364929199,80.33935977223385,87.38,25.425,-1.0,4,0.6425169706344604,0.6254289746284485,0.5407780408859253,0.6723130941390991,0.7194178899129232,0.6874635815620422,33,0,8
+10e3a5e7-dda1-496d-84bb-f826e6567d82.mp4,12.642633438110352,2.3760366439819336,81.2061572803374,87.05,25.875,-1.0,4,0.666383703549703,0.644948422908783,0.5396574338277181,0.6548968553543091,0.6909757057825724,0.6799997289975485,33,0,7
+12cb34d6-c1d8-4b85-8f0e-60afaf26ffc9.mp4,97.8766794204712,30.80884456634521,68.52279342866483,99.04,31.183333333333337,-1.0,4,0.559302568435669,0.6554734110832214,0.517133355140686,0.6597744027773539,0.6716094811757406,0.6479589343070984,38,0,10
+12dd2d2b-24f3-4c31-b873-fa4e53803778.mp4,13.259980201721191,1.3995704650878906,89.44515418728739,91.7,24.0,2.0,4,0.0304905549855902,0.8879064122835795,0.9823326071103414,0.992975890636444,0.0004040396706827,2.798745185113234e-08,33,0,10
+221cab7a-eb1a-4b14-9568-9ac4a4ec9330.mp4,30.4854040145874,8.113468170166016,73.38572857265173,91.52333333333333,28.975,-1.0,4,0.6206316550572714,0.6937900980313619,0.5681640307108561,0.6865283250808716,0.6309727231661478,0.5269437432289124,36,0,6
+249c9213-36ad-4280-a900-306b96685c0e.mp4,56.18430137634277,6.987162590026856,87.56385250174365,84.53999999999999,25.06,-1.0,4,0.6744417746861776,0.6287276744842529,0.5382514794667562,0.6795710523923238,0.7059144775072733,0.6740560928980509,32,0,12
+2884fdc7-6b49-4008-ae33-54956784cf22.mp4,115.50566577911376,39.44039535522461,65.85414655706319,99.71333333333332,29.975,-1.0,4,0.5739724636077881,0.6645207007726034,0.5748539765675863,0.6702662507692972,0.6798134446144104,0.6453063488006592,37,0,11
+2efd6ba4-b102-4009-b197-da0cdaa634dc.mp4,24.736478805541992,3.4170312881469727,86.18626638411682,97.38,26.04,0.0,4,0.2123574561207135,0.923816998799642,0.5404039584100246,0.557942457186679,0.5570492148494531,0.1948199073473612,32,0,11
+31f7bc2c-838f-43c2-9cf8-745cc9ce27ab.mp4,22.826221466064453,2.654613494873047,88.37033322041654,90.9,23.43,0.0,4,0.2436689063906669,0.865463117758433,0.5987633650268739,0.663530599674465,0.0083957752296021,0.0033863165364441,31,0,11
+329f1c4c-f5df-453d-9cfc-6f2cbef5142b.mp4,9.611075401306152,1.5621337890625,83.74652446436738,88.86,26.85483870967742,-1.0,4,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,34,0,11
+34e7d8b9-5fd5-44d6-ba9c-194d4e2078ae.mp4,8.409784317016602,1.250507354736328,85.13032787052558,93.57666666666668,26.86,0.0,4,0.6085565884908041,0.7023536364237467,0.5811308026313782,0.6709411342938741,0.6804569562276205,0.6665542125701904,34,0,6
+39c98272-d26f-4139-afbf-d870b7553fab.mp4,11.697440147399902,2.55403995513916,78.16582155620715,86.31666666666666,25.95833333333333,-1.0,4,0.6213184396425883,0.6266296108563741,0.5339837074279785,0.6631546020507812,0.7125220696131388,0.6837653716405233,33,0,7
+40949702-a809-4464-9d14-481e76abd967.mp4,11.222305297851562,3.6306753158569336,67.64768717749995,94.60333333333334,28.79,0.0,4,3.0931066325599755e-11,0.6665612919865964,1.0,0.5694492856661543,0.013828640182813,4.3167463616559045e-17,36,0,6
+424df265-1080-4edf-8cfc-b05f62acfffc.mp4,93.02153778076172,36.84726619720459,60.38845725809408,87.91000000000001,28.941666666666663,-1.0,4,0.572777271270752,0.8049134612083435,0.5622189939022064,0.7238964438438416,0.6895942687988281,0.4115677277247111,36,0,10
+4df1a23d-73f2-4cab-b43c-5538b566a458.mp4,9.611075401306152,1.5621337890625,83.74652446436738,88.86,26.85483870967742,-1.0,4,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,34,0,11
+59bb4aa2-724b-490a-944c-eaae28496192.mp4,82.74820232391357,51.761945724487305,37.44644080379192,96.74,29.125,-1.0,4,9.296274529428212e-07,0.3862022735666339,0.0247434326447546,1.0,1.0,0.0171932382619767,33,0,10
+5e800829-24b2-4ca7-bac4-89a02199fbec.mp4,9.155067443847656,1.032573699951172,88.72128789564432,89.29,28.866666666666667,1.0,4,0.6375203331311544,0.6609386603037516,0.5363780458768209,0.6825437943140665,0.7010063727696737,0.6790463924407959,36,0,6
+5fe0ff99-37a3-4760-81a4-f441876cb867.mp4,9.611075401306152,1.5621337890625,83.74652446436738,88.86,26.85483870967742,-1.0,4,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,34,0,11
+6084559b-4f79-480c-ae41-bdb3d0a6987c.mp4,8.81439208984375,0.6471805572509766,92.65768358550012,94.24,20.84375,2.0,4,0.5323069393634796,0.7520566980044047,0.5722926259040833,0.693462073802948,0.5514254768689474,0.2662951275706291,28,0,12
+61a7d453-d120-440f-abfe-fa05714179b4.mp4,20.49268341064453,2.6226015090942383,87.20225430442176,91.52333333333333,28.0625,1.0,4,0.5853416124979655,0.6666666666666666,1.0,0.3333347989194711,2.981454431780764e-25,0.0,35,0,9
+64e41231-4092-46c3-906d-5170de857162.mp4,28.37565803527832,5.465407371520996,80.73909910837637,88.54666666666667,26.05208333333333,0.0,4,0.745102326075236,0.670194149017334,0.5261250138282776,0.7535956104596456,0.707586407661438,0.3179372052351634,33,0,7
+691de276-7b47-4015-bc54-da4343889084.mp4,21.35616779327393,3.5211429595947266,83.51229024945336,92.0,24.45,0.0,4,0.6291013558705648,0.647834857304891,0.6641747156778971,0.6670735081036886,0.7004674077033997,0.6992351412773132,32,0,11
+733704b4-12f7-4977-b920-6896bc9ca77c.mp4,42.62840366363525,5.25462818145752,87.67341084850415,83.07333333333332,25.05,-1.0,4,0.6398445963859558,0.6260692278544108,0.5751756628354391,0.6669502059618632,0.7081162532170614,0.6691677371660868,32,0,10
+81e87893-da5e-4db2-afd1-b1bb11a03de7.mp4,11.973058700561523,2.3520984649658203,80.35507447353024,93.7,28.125,2.0,4,7.679543605343628e-09,1.0,1.0,0.3358941231754215,4.8890841564280026e-21,4.577665144872662e-36,35,0,6
+890c5911-8ee1-4faa-a801-c605f0dde8e0.mp4,9.611075401306152,1.5621337890625,83.74652446436738,88.86,26.85483870967742,-1.0,4,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,34,0,11
+8b6d7852-7f21-47df-aa03-fc8c0f29e6d3.mp4,,,,,28.83,1.0,4,0.6386719544728597,0.6828855474789938,0.5790578722953796,0.6756150126457214,0.7062546610832214,0.6745621760686239,36,0,11

iqf_scores_3.csv

@@ -0,0 +1,8 @@
+file_name,input_size,output_size,final_compression,final_score,ori_luma_qp,ori_chroma,ori_preset,brightness,contrast,colorfulness,sharpness,quality_factor,mos_zscore,luma_qp,chroma,preset
+04d651c3-3b08-4de9-befe-af12b3b3555b.mp4,11.63755702972412,3.1724796295166016,72.73929896615246,93.11666666666667,28.1,0.0,4,1.8469307366129406e-16,0.9999998410542806,1.0,0.9999999602635702,0.298225900199812,0.0,35,0,6
+07484eba-7a60-4754-ba0b-f9c0744af11b.mp4,50.56832885742188,9.012784957885742,82.17701640230703,88.19333333333333,26.691666666666663,-1.0,4,0.6979172627131144,0.6313334306081136,0.6084306836128235,0.6348755955696106,0.6509576241175333,0.7038862506548563,32,0,12
+0cb873d6-4c3a-4ced-84e9-87939b08565d.mp4,19.441584587097168,1.5586957931518557,91.98267103090808,93.29666666666668,26.13,1.0,4,2.1057123452742498e-07,0.9972970485687256,0.9999999602635702,0.9853918751080832,0.3318715903168057,6.486347245594561e-25,33,0,11
+0d0496e7-fe16-443b-9c16-369aa386bb4e.mp4,91.49424362182616,40.06210517883301,56.21352383170465,89.47666666666667,28.391666666666666,-1.0,4,0.5955032904942831,0.7397701740264893,0.5834726889928182,0.7210836410522461,0.65736456712087,0.4505663216114044,34,0,11
+0e4ce3ab-c7c1-4dd6-9d9d-983eabf8acf3.mp4,14.362677574157717,3.4272356033325195,76.13790614154684,88.80666666666666,25.425,-1.0,4,0.6425169706344604,0.6254289746284485,0.5407780408859253,0.6723130941390991,0.7194178899129232,0.6874635815620422,31,0,8
+10e3a5e7-dda1-496d-84bb-f826e6567d82.mp4,12.642633438110352,2.90421199798584,77.02842519161165,88.29,25.875,-1.0,4,0.666383703549703,0.644948422908783,0.5396574338277181,0.6548968553543091,0.6909757057825724,0.6799997289975485,31,0,8
+12cb34d6-c1d8-4b85-8f0e-60afaf26ffc9.mp4,,,,,31.183333333333337,-1.0,4,0.559302568435669,0.6554734110832214,0.517133355140686,0.6597744027773539,0.6716094811757406,0.6479589343070984,36,0,10

iqf_scores_4.csv

@@ -0,0 +1,14 @@
+file_name,input_size,output_size,final_compression,final_score,ori_luma_qp,psnr_values,scene_type,luma_qp,brightness,contrast,colorfulness,sharpness,quality_factor,mos_zscore,chroma,preset
+07484eba-7a60-4754-ba0b-f9c0744af11b.mp4,50.56832885742188,34.3788480758667,0.6798494008532168,95.12666666666668,23.691666666666663,34.82451435257544,Sea,22,0.6979172627131144,0.6313334306081136,0.6084306836128235,0.6348755955696106,0.6509576241175333,0.7038862506548563,-1.0,6
+0d0496e7-fe16-443b-9c16-369aa386bb4e.mp4,91.49424362182616,100.9215087890625,1.1030367025733565,96.34999999999998,25.391666666666666,27.89417999534232,Sea,22,0.5955032904942831,0.7397701740264893,0.5834726889928182,0.7210836410522461,0.65736456712087,0.4505663216114044,-1.0,6
+0e4ce3ab-c7c1-4dd6-9d9d-983eabf8acf3.mp4,14.362677574157717,8.536499977111816,0.5943529632992148,95.10666666666668,22.425,30.44581862011659,Sea,22,0.6425169706344604,0.6254289746284485,0.5407780408859253,0.6723130941390991,0.7194178899129232,0.6874635815620422,-1.0,6
+10e3a5e7-dda1-496d-84bb-f826e6567d82.mp4,12.642633438110352,7.81199836730957,0.6179091093285072,94.66,22.875,29.992381826532565,Sea,22,0.666383703549703,0.644948422908783,0.5396574338277181,0.6548968553543091,0.6909757057825724,0.6799997289975485,-1.0,6
+12cb34d6-c1d8-4b85-8f0e-60afaf26ffc9.mp4,97.8766794204712,47.07356548309326,0.4809477166758856,99.79666666666668,28.183333333333334,16.3645023883341,Sea,32,0.559302568435669,0.6554734110832214,0.517133355140686,0.6597744027773539,0.6716094811757406,0.6479589343070984,-1.0,6
+12dd2d2b-24f3-4c31-b873-fa4e53803778.mp4,13.259980201721191,3.863698959350586,0.2913804470725427,96.45333333333332,19.0,31.048039674445505,Sea,22,0.0304905549855902,0.8879064122835795,0.9823326071103414,0.992975890636444,0.0004040396706827,2.798745185113234e-08,2.0,6
+221cab7a-eb1a-4b14-9568-9ac4a4ec9330.mp4,30.4854040145874,13.693915367126465,0.4491957974568376,95.35666666666668,25.975,24.29359649078312,Sea,32,0.6206316550572714,0.6937900980313619,0.5681640307108561,0.6865283250808716,0.6309727231661478,0.5269437432289124,-1.0,6
+249c9213-36ad-4280-a900-306b96685c0e.mp4,56.18430137634277,27.01200771331787,0.4807750038997846,92.53333333333336,22.06,35.30867793968724,Sea,22,0.6744417746861776,0.6287276744842529,0.5382514794667562,0.6795710523923238,0.7059144775072733,0.6740560928980509,-1.0,6
+2884fdc7-6b49-4008-ae33-54956784cf22.mp4,115.50566577911376,56.05314254760742,0.4852847881488354,99.82666666666668,26.975,19.456423450946858,Sea,32,0.5739724636077881,0.6645207007726034,0.5748539765675863,0.6702662507692972,0.6798134446144104,0.6453063488006592,-1.0,6
+39c98272-d26f-4139-afbf-d870b7553fab.mp4,11.697440147399902,7.938425064086914,0.678646350317207,94.16666666666669,22.95833333333333,30.240432260663724,Sea,22,0.6213184396425883,0.6266296108563741,0.5339837074279785,0.6631546020507812,0.7125220696131388,0.6837653716405233,-1.0,6
+424df265-1080-4edf-8cfc-b05f62acfffc.mp4,93.02153778076172,111.02602577209473,1.1935518205876898,96.40333333333336,25.941666666666663,26.716159386938628,Sea,22,0.572777271270752,0.8049134612083435,0.5622189939022064,0.7238964438438416,0.6895942687988281,0.4115677277247111,-1.0,6
+494e83e7-548e-408f-af3d-d702cc6ae594.mp4,6.668767929077148,3.722039222717285,0.5581299667796891,97.79,22.02083333333333,27.043169740053514,Sea,22,0.6418240666389465,0.6350036462148031,0.5903654098510742,0.6643276611963908,0.6858240564664205,0.6821937759717306,-1.0,6
+59bb4aa2-724b-490a-944c-eaae28496192.mp4,,,,,26.125,18.335617949324277,Sea,32,9.296274529428211e-07,0.3862022735666339,0.024743432644754648,1.0,1.0,0.017193238261976756,-1.0,6

iqf_scores_custom.csv

@@ -0,0 +1,48 @@
+file_name,input_size,output_size,final_compression,final_score,ori_luma_qp,ori_chroma,ori_preset,psnr_values,scene_type,brightness,contrast,colorfulness,sharpness,quality_factor,mos_zscore,luma_qp,chroma,preset
+04d651c3-3b08-4de9-befe-af12b3b3555b.mp4,11.63755702972412,2.9998998641967773,74.22225423656728,89.54666666666667,24.1,0.0,4,24.34790082106915,Glacier,1.8469307366129406e-16,0.9999998410542806,1.0,0.9999999602635702,0.298225900199812,0.0,36,0.0,12
+07484eba-7a60-4754-ba0b-f9c0744af11b.mp4,50.56832885742188,5.350363731384277,89.41953619533344,85.96666666666668,23.691666666666663,-1.0,4,34.82451435257544,Sea,0.6979172627131144,0.6313334306081136,0.6084306836128235,0.6348755955696106,0.6509576241175333,0.7038862506548563,36,-1.0,12
+0cb873d6-4c3a-4ced-84e9-87939b08565d.mp4,19.441584587097168,0.6575107574462891,96.61801868823665,90.50666666666666,19.13,1.0,4,32.55061039813054,Buildings,2.1057123452742498e-07,0.9972970485687256,0.9999999602635702,0.9853918751080832,0.3318715903168057,6.486347245594561e-25,43,1.0,12
+0d0496e7-fe16-443b-9c16-369aa386bb4e.mp4,91.49424362182616,33.905229568481445,62.94277298075475,87.64666666666666,25.391666666666666,-1.0,4,27.89417999534232,Sea,0.5955032904942831,0.7397701740264893,0.5834726889928182,0.7210836410522461,0.65736456712087,0.4505663216114044,36,-1.0,12
+0e4ce3ab-c7c1-4dd6-9d9d-983eabf8acf3.mp4,14.362677574157717,3.847278594970703,73.21336098296196,88.19333333333333,22.425,-1.0,4,30.44581862011659,Sea,0.6425169706344604,0.6254289746284485,0.5407780408859253,0.6723130941390991,0.7194178899129232,0.6874635815620422,29,-1.0,12
+10e3a5e7-dda1-496d-84bb-f826e6567d82.mp4,12.642633438110352,3.197593688964844,74.70785098201205,86.99000000000001,22.875,-1.0,4,29.992381826532565,Sea,0.666383703549703,0.644948422908783,0.5396574338277181,0.6548968553543091,0.6909757057825724,0.6799997289975485,29,-1.0,12
+12cb34d6-c1d8-4b85-8f0e-60afaf26ffc9.mp4,97.8766794204712,13.43449592590332,86.27405832988092,87.71333333333332,28.183333333333334,-1.0,4,16.3645023883341,Sea,0.559302568435669,0.6554734110832214,0.517133355140686,0.6597744027773539,0.6716094811757406,0.6479589343070984,50,-1.0,12
+12dd2d2b-24f3-4c31-b873-fa4e53803778.mp4,13.259980201721191,0.6298971176147461,95.24963757085412,86.85333333333334,19.0,2.0,4,31.048039674445505,,0.0304905549855902,0.8879064122835795,0.9823326071103414,0.992975890636444,0.0004040396706827,2.798745185113234e-08,43,2.0,12
+221cab7a-eb1a-4b14-9568-9ac4a4ec9330.mp4,30.4854040145874,8.677053451538086,71.53702326731154,89.46666666666665,25.975,-1.0,4,24.29359649078312,Sea,0.6206316550572714,0.6937900980313619,0.5681640307108561,0.6865283250808716,0.6309727231661478,0.5269437432289124,36,-1.0,12
+249c9213-36ad-4280-a900-306b96685c0e.mp4,56.18430137634277,10.10262393951416,82.01877803580197,86.36,22.06,-1.0,4,35.30867793968724,Sea,0.6744417746861776,0.6287276744842529,0.5382514794667562,0.6795710523923238,0.7059144775072733,0.6740560928980509,29,-1.0,12
+2884fdc7-6b49-4008-ae33-54956784cf22.mp4,115.50566577911376,16.16676139831543,86.0034905740193,89.88666666666667,26.975,-1.0,4,19.456423450946858,Sea,0.5739724636077881,0.6645207007726034,0.5748539765675863,0.6702662507692972,0.6798134446144104,0.6453063488006592,50,-1.0,12
+2efd6ba4-b102-4009-b197-da0cdaa634dc.mp4,24.736478805541992,0.8398094177246094,96.60497589682628,90.75333333333332,21.04,0.0,4,17.135833803028024,Street,0.2123574561207135,0.923816998799642,0.5404039584100246,0.557942457186679,0.5570492148494531,0.1948199073473612,50,0.0,12
+31f7bc2c-838f-43c2-9cf8-745cc9ce27ab.mp4,22.826221466064453,1.5528364181518557,93.1971376845684,88.98333333333333,19.43,0.0,4,35.789955905092,Glacier,0.2436689063906669,0.865463117758433,0.5987633650268739,0.663530599674465,0.0083957752296021,0.0033863165364441,36,0.0,12
+329f1c4c-f5df-453d-9cfc-6f2cbef5142b.mp4,9.611075401306152,1.3005437850952148,86.46828028299029,87.64,19.85483870967742,-1.0,4,29.396985786067585,Buildings,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,36,-1.0,12
+34e7d8b9-5fd5-44d6-ba9c-194d4e2078ae.mp4,8.409784317016602,1.3808231353759766,83.58075447212148,91.11333333333334,21.86,0.0,4,27.697119754095937,Street,0.6085565884908041,0.7023536364237467,0.5811308026313782,0.6709411342938741,0.6804569562276205,0.6665542125701904,34,0.0,12
+39c98272-d26f-4139-afbf-d870b7553fab.mp4,11.697440147399902,3.302997589111328,71.7630733947759,85.51999999999998,22.95833333333333,-1.0,4,30.240432260663724,Sea,0.6213184396425883,0.6266296108563741,0.5339837074279785,0.6631546020507812,0.7125220696131388,0.6837653716405233,29,-1.0,12
+40949702-a809-4464-9d14-481e76abd967.mp4,11.222305297851562,3.0290184020996094,73.00894672078209,90.15666666666664,23.79,0.0,4,23.28805529599666,Street,3.0931066325599755e-11,0.6665612919865964,1.0,0.5694492856661543,0.013828640182813,4.3167463616559045e-17,41,0.0,12
+424df265-1080-4edf-8cfc-b05f62acfffc.mp4,93.02153778076172,36.84726619720459,60.38845725809408,87.91000000000001,25.941666666666663,-1.0,4,26.716159386938628,Sea,0.572777271270752,0.8049134612083435,0.5622189939022064,0.7238964438438416,0.6895942687988281,0.4115677277247111,36,-1.0,12
+4df1a23d-73f2-4cab-b43c-5538b566a458.mp4,9.611075401306152,1.3005437850952148,86.46828028299029,87.64,19.85483870967742,-1.0,4,29.396985786067585,Buildings,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,36,-1.0,12
+59bb4aa2-724b-490a-944c-eaae28496192.mp4,82.74820232391357,40.78819561004639,50.7080583450223,93.95,26.125,-1.0,4,18.33561794932428,Sea,9.296274529428212e-07,0.3862022735666339,0.0247434326447546,1.0,1.0,0.0171932382619767,36,-1.0,12
+5e800829-24b2-4ca7-bac4-89a02199fbec.mp4,9.155067443847656,2.107905387878418,76.97553403284907,89.20666666666666,21.866666666666667,1.0,4,36.65562661105682,Buildings,0.6375203331311544,0.6609386603037516,0.5363780458768209,0.6825437943140665,0.7010063727696737,0.6790463924407959,29,1.0,12
+5fe0ff99-37a3-4760-81a4-f441876cb867.mp4,9.611075401306152,1.3005437850952148,86.46828028299029,87.64,19.85483870967742,-1.0,4,29.396985786067585,Buildings,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,36,-1.0,12
+6084559b-4f79-480c-ae41-bdb3d0a6987c.mp4,8.81439208984375,0.2493619918823242,97.17096778381747,92.81,15.84375,2.0,4,44.19402395567592,,0.5323069393634796,0.7520566980044047,0.5722926259040833,0.693462073802948,0.5514254768689474,0.2662951275706291,36,2.0,12
+61a7d453-d120-440f-abfe-fa05714179b4.mp4,20.49268341064453,4.774928092956543,76.69935167945698,95.10333333333334,21.0625,1.0,4,23.28430139070841,Buildings,0.5853416124979655,0.6666666666666666,1.0,0.3333347989194711,2.981454431780764e-25,0.0,29,1.0,12
+64e41231-4092-46c3-906d-5170de857162.mp4,28.37565803527832,3.930176734924317,86.1494780842154,84.14333333333333,24.05208333333333,0.0,4,25.41429757462589,Mountain,0.745102326075236,0.670194149017334,0.5261250138282776,0.7535956104596456,0.707586407661438,0.3179372052351634,36,0.0,12
+691de276-7b47-4015-bc54-da4343889084.mp4,21.35616779327393,2.450800895690918,88.52415414874764,90.08333333333331,20.45,0.0,4,28.257029596777684,Glacier,0.6291013558705648,0.647834857304891,0.6641747156778971,0.6670735081036886,0.7004674077033997,0.6992351412773132,36,0.0,12
+733704b4-12f7-4977-b920-6896bc9ca77c.mp4,42.62840366363525,7.459269523620605,82.50164471914336,84.60666666666667,22.05,-1.0,4,34.503775113036255,Sea,0.6398445963859558,0.6260692278544108,0.5751756628354391,0.6669502059618632,0.7081162532170614,0.6691677371660868,29,-1.0,12
+81e87893-da5e-4db2-afd1-b1bb11a03de7.mp4,11.973058700561523,2.4130001068115234,79.846418804425,89.86666666666666,23.125,2.0,4,29.955702790992284,,7.679543605343628e-09,1.0,1.0,0.3358941231754215,4.8890841564280026e-21,4.577665144872662e-36,36,2.0,12
+890c5911-8ee1-4faa-a801-c605f0dde8e0.mp4,9.611075401306152,1.3005437850952148,86.46828028299029,87.64,19.85483870967742,-1.0,4,29.396985786067585,Buildings,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,36,-1.0,12
+8b6d7852-7f21-47df-aa03-fc8c0f29e6d3.mp4,36.639710426330566,2.526042938232422,93.1057235200824,89.26333333333334,21.83,1.0,4,19.31974385124029,Buildings,0.6386719544728597,0.6828855474789938,0.5790578722953796,0.6756150126457214,0.7062546610832214,0.6745621760686239,50,1.0,12
+8f0464f5-2e81-4d50-b4bb-0667fadd55b6.mp4,34.017616271972656,5.3361406326293945,84.31359625563806,74.34666666666668,27.291666666666668,0.0,4,17.875918400820858,Street,0.6737418174743652,0.6781927148501078,0.5551733573277792,0.6866800983746847,0.6682468851407369,0.6677144169807434,50,0.0,12
+93495912-fd6c-435a-9fcb-c9cc978c122e.mp4,14.999189376831056,1.5714950561523438,89.52280008825143,85.81,23.04201680672269,-1.0,4,29.72427086056156,Sea,0.3303557277324671,0.572416496075069,0.8744631012280782,0.5750492256289969,0.245182732741038,0.1620057622591654,36,-1.0,12
+9a049c4c-bb40-4692-8b95-cb2ca94d339f.mp4,7.705256462097168,0.5107479095458984,93.37143530447932,86.02666666666669,19.433333333333334,-1.0,4,47.35919096909639,Sea,0.5415121912956238,0.6919364531834921,0.5953385432561239,0.7154134511947632,0.6035712758700053,0.5871815880139669,36,-1.0,12
+9d860f37-78b5-4e91-bbff-91bbfaaaa32a.mp4,24.54138946533203,3.238698005676269,86.8031188280869,82.79,24.05208333333333,0.0,4,25.67234493498757,Mountain,0.5807816584904989,0.6518141428629557,0.5270594159762064,0.6739723483721415,0.6623684565226237,0.5438634157180786,36,0.0,12
+a3fa72da-8a4e-466c-9a11-fc2a67863b9e.mp4,66.18983554840088,5.890133857727051,91.10115048794776,83.83333333333333,24.291666666666668,-1.0,4,16.2941854660188,Sea,0.2128963904734471,0.8745509584744772,0.8768628239631653,0.579653590063875,0.24392955436218,0.2292507886886597,50,-1.0,12
+a508a47e-295b-4be0-ab3f-4b6478dacc65.mp4,150.44969272613525,66.06287097930908,56.08972688328196,89.68666666666667,28.57017543859649,-1.0,4,20.067948955885825,Sea,0.626129150390625,0.6703311999638876,0.562980075677236,0.6703017155329386,0.6834884285926819,0.6630960901578268,36,-1.0,12
+a5f32e7e-a5f3-4a7e-b7fd-dc0fb551e243.mp4,27.75857830047608,8.555665016174316,69.17830256448119,90.31333333333332,25.991666666666667,-1.0,4,20.73713088892713,Sea,0.6408935189247131,0.7019673387209574,0.5994003017743429,0.701171875,0.6946845253308614,0.6745195984840393,36,-1.0,12
+a75909eb-460b-4eb8-ab69-1f81413fde39.mp4,15.16309642791748,0.7881450653076172,94.80221556952888,85.72666666666667,19.17708333333333,1.0,4,30.9834009328239,Buildings,0.0452174662328464,0.6664746296834588,0.9997160037358602,0.662308836724454,0.2454252270120681,4.1359750212209746e-11,43,1.0,12
+a8fb16e1-2992-4ab7-95b7-47d48938f465.mp4,56.77720260620117,10.663334846496582,81.21898516125214,87.81666666666666,22.03,-1.0,4,32.6959957036605,Sea,0.6491552790006002,0.6554122765858968,0.5638013680775961,0.663050651550293,0.7081366777420044,0.6996987660725912,29,-1.0,12
+acfbb4ee-70e5-45bf-8aa8-349e388499ed.mp4,9.611075401306152,1.3005437850952148,86.46828028299029,87.64,19.85483870967742,-1.0,4,29.396985786067585,Buildings,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,36,-1.0,12
+af18139c-acaf-4c43-977a-9a86fb3f3602.mp4,15.229940414428713,1.370335578918457,91.00235758230404,92.81666666666666,18.510416666666668,2.0,4,32.8864798429277,,0.2569143105560701,0.3665943775946895,0.7403472264607748,0.6492060224215189,0.3337878490177342,0.0003729414893314,36,2.0,12
+b2b4e988-b71d-4d6f-a5dd-8db222348faa.mp4,8.236392974853516,1.0207548141479492,87.60677377506865,88.11666666666666,20.3,2.0,4,30.94902322197443,,0.6797566215197245,0.6921680370966593,0.5756566723187765,0.6673476894696554,0.7057122588157654,0.6777393817901611,36,2.0,12
+b872dec9-a527-443e-807b-8a650fb44aa5.mp4,31.921814918518063,6.28378963470459,80.31506150028042,89.21666666666665,21.316666666666663,2.0,4,31.778037288875964,,0.5625234958715737,0.8364881674448649,0.8529369036356608,0.3062493354858209,0.2298784634719292,0.2218764863639043,29,2.0,12
+bb85c24e-dfb2-4e74-a538-7b88444ba7a2.mp4,7.403351783752441,1.4399042129516602,80.55064442416871,86.10000000000001,21.10833333333333,-1.0,4,43.96922372729665,Sea,0.5719117522239685,0.5746606588363647,0.7491706609725952,0.6051486531893412,0.6949742039044698,0.6399241884549459,29,-1.0,12
+bd22f174-e591-4d7a-a5fa-40447e18191e.mp4,14.803239822387695,2.4618701934814453,83.36938249316049,84.21,25.00438596491228,-1.0,4,30.95666927265913,Sea,0.3112848651896153,0.9546863834063212,0.6849623595674833,0.8972047170003256,0.5202026833430864,0.2215489234929057,36,-1.0,12
+bdc6f64e-fe6c-4f98-b37d-a8405f0674a6.mp4,9.611075401306152,1.3005437850952148,86.46828028299029,87.64,19.85483870967742,-1.0,4,29.396985786067585,Buildings,0.583096981048584,0.6963175336519877,0.5527470707893372,0.6834075252215067,0.6812475522359213,0.5811437368392944,36,-1.0,12
+c6b21693-9149-46a7-8062-b4e36d861374.mp4,6.766033172607422,0.555415153503418,91.79112576994093,89.67333333333333,19.1,0.0,4,49.603593158290806,Mountain,0.6675481796264648,0.6689058740933737,0.6905355652173361,0.6873549222946167,0.6984812021255493,0.6681686639785767,36,0.0,12

iqf_scores_video1.csv

@@ -0,0 +1,29 @@
+file_name,input_size,output_size,final_compression,final_score,psnr_values,scene_type,luma_qp,quality_noise_level,quality_sharpness,quality_contrast,quality_brightness,quality_color_saturation,quality_motion_blur,quality_compression_artifacts,quality_text_content,quality_edge_density,quality_temporal_consistency,chroma,preset
+026fe674-d8c4-40a4-96c5-0cb6f1fb7c06.mp4,22.074841499328613,2.785863876342773,0.1262008552327546,93.08666666666666,26.13181026051079,Sea,33,0.0281049907207489,0.0167996753007173,0.1342756832257432,0.3967183437811308,0.3348408286037159,0.0102033827781422,0.0042888157380123,0.2226463602789319,0.0173612439864421,0.9997948641607676,2,8
+1fda2da4-b877-415b-a0b2-9643e8c19343.mp4,42.13912010192871,4.191298484802246,0.0994633602852663,88.55666666666667,19.74997773179496,Mountain,36,0.1175154820084571,0.0461746454238891,0.1698552824803696,0.4773372729081188,0.1762627786880638,0.0413492260696467,0.0111680872117479,0.7232348793690635,0.0703951503710317,0.9971271971765552,1,7
+223c0d7d-c60b-4ce0-b867-a6292c9aa465.mp4,45.65006923675537,4.773685455322266,0.1045712642967627,90.91,18.361035670056648,Mountain,35,0.1735588163137436,0.0710327699780464,0.1924423491662839,0.3859789412249714,0.1846702573626785,0.0851046132594358,0.015286094819506,0.9235667442983528,0.1461225657623207,0.991769307651044,1,6
+2b4b64a6-a07f-4bce-93eb-0b3ce53e0575.mp4,45.77764892578125,4.4001970291137695,0.0961210794431089,89.87333333333333,20.31808044588177,Mountain,35,0.1654309034347534,0.0693681240081787,0.1945907355813904,0.4009358367907413,0.1967351534458278,0.0817902631896655,0.0148024419322609,0.9143815857079082,0.1401244914633221,0.9930504353683388,1,6
+2b8983b8-2396-4020-a6db-35b19bb2d287.mp4,47.75133895874024,4.317131996154785,0.0904086061311291,88.83666666666666,20.24408139521997,Mountain,38,0.1422079205513,0.0581630282104015,0.2012230718832824,0.3787347649628497,0.2031581901056525,0.073356599381059,0.0149929175774256,0.7752869102153293,0.1257005266287348,0.9969557560560646,1,7
+43a9cd6b-81bc-438d-819c-6352d7193145.mp4,43.062859535217285,4.463125228881836,0.1036421008045654,88.68333333333334,19.1756830753702,Mountain,35,0.1361274570226669,0.0552828311920166,0.1703905049275502,0.4539282307889309,0.1831038004086405,0.0580689047895802,0.0123649441326657,0.731457977111989,0.1049097084179139,0.9815015737117856,1,7
+494e83e7-548e-408f-af3d-d702cc6ae594.mp4,6.668767929077148,1.1391572952270508,0.1708197537149402,92.08666666666666,15.28414787432056,Sea,36,0.0644450113177299,0.0318450145423412,0.1218587687048134,0.5155074374479302,0.3446948237605802,0.0206735079199236,0.0081399170060952,0.3944745150014188,0.0389192013002089,0.9925388100348878,2,7
+5533624b-8b2f-476e-93c3-26ecc8abbbfc.mp4,48.74678897857666,4.002272605895996,0.0821033075153919,88.94,20.368462730755084,Mountain,37,0.1413482576608657,0.0594401359558105,0.1886964347338915,0.4077637824619008,0.2283467568483899,0.0767561909194802,0.0143880064909656,0.6034597344262048,0.1327680358778163,0.9937148534950766,1,7
+58628666-a50b-4b53-86f3-9bce954fd87a.mp4,17.49576473236084,4.228129386901856,0.2416658803762573,98.91666666666669,21.25486157432972,Sea,33,0.0431025587022304,0.0199701022356748,0.3801464858933288,0.1332456478568448,0.611579316008798,0.0024631645124081,0.0025733727961778,0.6121459220339367,0.0034776776627143,0.9973595402976382,2,8
+5cbb381b-c803-4c00-9f7c-eb34a93f0f11.mp4,43.69903087615967,4.624711036682129,0.1058309748284412,89.24666666666667,17.629037236788477,Mountain,35,0.1505059599876403,0.0603656210005283,0.1814356638339386,0.4207115634726497,0.1782449488412061,0.0653040586070096,0.0135400975123047,0.8411135233554857,0.119503881935261,0.9788613655686916,1,7
+6f22e710-af89-4704-8e14-022222e9748b.mp4,26.640109062194824,2.7298479080200195,0.1024713488089268,92.90000000000002,25.658407466420066,Sea,38,0.0485589206218719,0.0231323186308145,0.1153739397145537,0.463199056968312,0.3847542499002731,0.0137213119667827,0.0031315109226852,0.1833413000403856,0.0216421512948659,0.9949059255782428,2,8
+708b5e08-9d59-4b41-9dba-f7735682a9b4.mp4,27.11849975585937,3.5335893630981445,0.1303018011656289,88.83666666666666,19.987420021489257,Glacier,39,0.0166761334985494,0.0071951509453356,0.2228156889157377,0.3924565241366342,0.7564402887392186,0.0021965440270935,0.0035960952906558,0.5808692813811348,0.0034892198617952,0.9858591746085408,2,8
+70b2de9e-3c32-4b01-8505-8a78d5bccd59.mp4,37.72974681854248,6.375006675720215,0.1689650001199368,90.67,26.28220540391436,Sea,33,0.0360238887369632,0.0152332307770848,0.1206950385830347,0.511027495028049,0.2998014956295594,0.0078212501433094,0.0043184760337074,0.282369536052244,0.0135870261694049,0.9988060480115136,2,8
+7fb26377-5336-45c3-8648-14c7df0d1822.mp4,8.315752983093262,1.3558111190795898,0.1630412930538084,94.14333333333332,18.98384660344204,Glacier,35,0.0722586363554,0.0439577437937259,0.1263059475750047,0.5686536038260235,0.377071315116488,0.0240558069117096,0.009015806329747,0.5724709479049758,0.0389493897306397,0.9592674120012764,2,7
+814a4743-06ee-4a4b-9e77-e11bee77ceeb.mp4,5.243513107299805,0.6225442886352539,0.1187265628779631,93.65333333333332,22.36412702479837,Glacier,34,0.0474878959357738,0.0205531790852546,0.1985460133073029,0.2297653506247488,0.7212429583505275,0.010479251782424,0.0074468950430552,0.7969974880122681,0.0183791027225598,0.9985523841836662,1,8
+8fb42072-b53c-4ee3-b54d-4c2e1cf6d1ea.mp4,27.705836296081543,9.31836223602295,0.33633210477537,92.65666666666668,15.691813835264224,Street,33,0.4326435327529907,0.1827086210250854,0.1589946302332441,0.4811455634902676,0.2646468814980862,0.1195052192903368,0.0232531875371933,0.484191548456252,0.1929814757768828,0.9696954825913656,1,6
+918a9d77-727b-4255-bf27-d67c73ab109e.mp4,53.68707656860352,12.61237907409668,0.2349239310503353,95.35,13.299115682322263,Buildings,33,0.1324290484189987,0.0732438713312149,0.1579082716568159,0.2904904572709194,0.4459472019345969,0.0440004614111756,0.0098852856705586,0.3789205217776646,0.077397912777377,0.977604551435959,1,6
+b7340fda-e72e-4b12-9029-316dbd0c9ce8.mp4,16.855341911315918,1.5283565521240234,0.0906749065172005,93.06333333333332,30.707378416224845,Buildings,39,0.075921282172203,0.034921821206808,0.1509332493571397,0.3837449406136722,0.3531127043688376,0.0164538663940422,0.0059778722934424,0.0796282384863345,0.018695976111073,0.961157444517792,2,8
+be4a76cd-c69a-433b-b55c-9dfd478c9594.mp4,91.5072259902954,20.27893829345703,0.2216102397815848,94.58333333333331,13.14202322363013,Buildings,33,0.2657359540462494,0.1347031891345977,0.1066279604487404,0.4325665933039882,0.5377423675610595,0.0564917502088554,0.0161084520320097,0.1908051378446115,0.097688081811672,0.9839293682385236,1,6
+c7d92eab-29ca-490c-ab85-e18229efdf96.mp4,97.28178691864014,33.901222229003906,0.3484847811991425,94.10333333333334,13.507726959867174,Sea,33,0.192488357424736,0.1012503281235694,0.0961965353301766,0.4876347176471124,0.2784021018853362,0.0490402666342134,0.0148710856835047,0.1341335683256892,0.0872538335327444,0.98749093327581,2,6
+d4346f5c-0084-437f-a2ab-3eaedfc55c11.mp4,21.600625038146973,2.7130613327026367,0.1256010568171677,86.63333333333333,29.301524936051145,Mountain,35,0.0324001275002956,0.0119790434837341,0.0899387215730463,0.4335584335421187,0.3625504576623417,0.0055937685794973,0.0050580248547097,0.1096177840090553,0.0100087439759552,0.9993855382951184,2,8
+d69e637f-ced7-4a94-b11f-7e3a7fc584c5.mp4,42.82363224029541,7.869690895080566,0.1837698131471316,88.47000000000001,21.705490783403683,Sea,38,0.0484559424221515,0.0249015484005212,0.1273258361643435,0.435330105384125,0.4183141918787222,0.0173588259087107,0.0059984366719921,0.2724476860040493,0.0288331306644454,0.99976134757579,2,8
+da4c28f0-dce4-49b6-b992-df633c640d41.mp4,127.13426303863524,33.8479118347168,0.2662375273645205,98.95,14.78405775820291,Forest,33,0.6543295979499817,0.2910408973693847,0.1373758221723152,0.5046602271961581,0.3814980234424291,0.1978286082474226,0.0325104215492804,0.4851184786004373,0.2947656396438612,0.9992652571806604,2,6
+dcc6663d-5979-4b94-8780-8f08f1459367.mp4,54.03766345977783,16.396857261657715,0.3034338683770529,94.12333333333332,23.759774352151624,Street,33,0.370427519083023,0.2039624601602554,0.133535066310104,0.339642842742698,0.3444164673070249,0.1023351721047729,0.0232562640060981,0.3504134883616999,0.1369291179189364,0.9939171225978608,1,6
+e2dd775b-6dbe-49fd-876e-3e9b4a2e80cd.mp4,52.91536045074463,9.409367561340332,0.1778192094164961,93.73666666666666,13.593667907575028,Buildings,36,0.1354481726884842,0.0743122622370719,0.1634576248055144,0.3116403942588515,0.4550657866970771,0.0439209715183308,0.0097172350312272,0.1103883875206228,0.0768300366208766,0.9770803141912644,1,6
+ea63ccc6-22fa-4b9b-91eb-67da4241ed6d.mp4,51.6378231048584,11.61158561706543,0.2248659009789462,94.10333333333334,10.662733148504527,Buildings,35,0.0870254561305046,0.0478470772504806,0.1353242805091566,0.4523556977557734,0.3012495941855623,0.0307206434675966,0.008035152995338,0.143403323368975,0.0540664242644898,0.9066783540598498,2,6
+f0bab96c-7918-40b7-8e75-470ee67f2ce4.mp4,50.66206169128418,19.06877613067627,0.3763916329910599,93.69666666666669,22.65985438616542,Sea,31,0.138214036822319,0.0643599405884742,0.4485925112259545,0.0523797637873839,0.3629621079527614,0.0136145792224255,0.0061063171985248,0.8541742905320562,0.0238152737416137,0.9990574532561204,2,8
+f67fdc5d-c16c-434f-88b6-2885b6e16244.mp4,4.923687934875488,0.8116235733032227,0.16484057967084526,95.21,12.12852561266281,Street,37,0.037277165800333,0.0159068945795297,0.1130266998501148,0.5849823456829463,0.2362355845124187,0.0032554956997445,0.005870988437285,0.3444003885611866,0.0038838354199269,0.9677222326473224,1,7

neurons/miner.py

@@ -0,0 +1,299 @@
+import time
+import uuid
+import traceback
+import os
+from typing import Tuple
+from loguru import logger
+import bittensor as bt
+from vidaio_subnet_core.base.miner import BaseMiner
+from vidaio_subnet_core.protocol import VideoUpscalingProtocol, LengthCheckProtocol, ContentLength, VideoCompressionProtocol, TaskWarrantProtocol, TaskType
+from services.miner_utilities.miner_utils import video_upscaler, video_compressor
+
+from vidaio_subnet_core.utilities.version import check_version
+
+MAX_CONTENT_LEN = ContentLength.FIVE
+warrant_task = TaskType.COMPRESSION
+
+VALIDATOR_HOTKEYS = [
+    "5FR392L6eKrTGwUjQurpxw89YUe7LzKANktDwRKLYYSgwxhb",
+    "5E2LP6EnZ54m3wS8s1yPvD5c3xo71kQroBw7aUVK32TKeZ5u",
+    "5CyiseaJEUjRpE1nLLYZBNk3Akty4yugUZSyBg8H4BfRsn85",
+    "5EUqqYFhNeYbZCm6UTQ3SULNDibNs2ZVjukV8pqeYZA6ms85"
+]
+
+class Miner(BaseMiner):
+    def __init__(self, config: dict | None = None) -> None:
+        """
+        Initializes the Miner instance.
+        """
+        super().__init__()
+
+    async def forward_upscaling_requests(self, synapse: VideoUpscalingProtocol) -> VideoUpscalingProtocol:
+        """
+        Processes a video upscaling request by downloading, upscaling,
+        uploading, and returning a sharing link.
+        """
+
+        should_blacklist, reason = self.blacklist_all_requests(synapse)
+        if should_blacklist:
+            logger.warning(f"Upscaling Request blacklisted: {reason}")
+            return synapse
+        
+        start_time = time.time()
+
+        task_type: str = synapse.miner_payload.task_type      
+        payload_url: str = synapse.miner_payload.reference_video_url
+        validator_uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+
+        logger.info(f"✅✅✅ Receiving {task_type} Request from validator: {synapse.dendrite.hotkey} with uid: {validator_uid}: round_id : {synapse.round_id}")
+        
+        check_version(synapse.version)
+
+        try:
+            processed_video_url = await video_upscaler(payload_url, task_type)
+            
+            if processed_video_url is None:
+                logger.info(f"💔 Failed to upscaling video 💔")
+                return synapse
+            
+            synapse.miner_response.optimized_video_url = processed_video_url
+
+            processed_time = time.time() - start_time
+
+            logger.info(f"💜 Returning Response, Processed in {processed_time:.2f} seconds 💜")
+            
+            return synapse
+            
+        except Exception as e:
+            logger.error(f"Failed to process upscaling request: {e}")
+            traceback.print_exc()
+            return synapse
+
+    async def forward_compression_requests(self, synapse: VideoCompressionProtocol) -> VideoCompressionProtocol:
+        """
+        Processes a video compression request by downloading, compressing,
+        uploading, and returning a sharing link.
+        """
+        should_blacklist, reason = self.blacklist_all_requests(synapse)
+        if should_blacklist:
+            logger.warning(f"Compression Request blacklisted: {reason}")
+            return synapse
+        
+        start_time = time.time()
+        
+        payload_url: str = synapse.miner_payload.reference_video_url
+        vmaf_threshold: float = synapse.miner_payload.vmaf_threshold
+        validator_uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+        
+        logger.info(f"🛜🛜🛜 Receiving CompressionRequest from validator: {synapse.dendrite.hotkey} with uid: {validator_uid} 🛜🛜🛜")
+        logger.info(f"Compression Parameters - VMAF Threshold: {vmaf_threshold}, Payload URL: {payload_url}")
+
+        check_version(synapse.version)
+        
+        try:
+            processed_video_url = await video_compressor(payload_url, vmaf_threshold)
+            
+            if processed_video_url is None:
+                logger.info(f"💔 Failed to compress video 💔")
+                return synapse
+            
+            synapse.miner_response.optimized_video_url = processed_video_url
+            
+            processed_time = time.time() - start_time
+
+            logger.info(f"💜 Returning Response, Processed in {processed_time:.2f} seconds 💜\n"
+                        f"✅ Video compressed successfully. Optimized video URL: {processed_video_url}")
+            
+            return synapse
+
+        except Exception as e:
+            logger.error(f"Failed to process compression request: {e}")
+            traceback.print_exc()
+            return synapse
+
+    async def forward_length_check_requests(self, synapse: LengthCheckProtocol) -> LengthCheckProtocol:
+
+        validator_uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+        logger.info(f"⭐️⭐️⭐️ Receiving LengthCheckRequest from validator: {synapse.dendrite.hotkey} with uid: {validator_uid} ⭐️⭐️⭐️")
+
+        check_version(synapse.version)
+
+        synapse.max_content_length = MAX_CONTENT_LEN
+
+        return synapse
+
+    async def forward_task_warrant_requests(self, synapse: TaskWarrantProtocol) -> TaskWarrantProtocol:
+        """
+        Processes a task warrant request by verifying the task type and returning a warrant.
+        """
+
+        validator_uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+        logger.info(f"🌕🌕🌕 Receiving TaskWarrantRequest from validator: {synapse.dendrite.hotkey} with uid: {validator_uid} 🌕🌕🌕")
+
+        check_version(synapse.version)
+
+        synapse.warrant_task = warrant_task
+
+        return synapse
+
+    async def blacklist_upscaling_requests(self, synapse: VideoUpscalingProtocol) -> Tuple[bool, str]:
+        """
+        Determines whether a request should be blacklisted based on the hotkey status.
+        """
+        if not synapse.dendrite or not synapse.dendrite.hotkey:
+            logger.warning("Received a request without a dendrite or hotkey.")
+            return True, "Missing dendrite or hotkey"
+
+        uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+
+        if not self.metagraph.validator_permit[uid]:
+            logger.warning(f"Blacklisting non-validator hotkey {synapse.dendrite.hotkey}")
+            return True, "Non-validator hotkey"
+
+        logger.trace(f"Hotkey {synapse.dendrite.hotkey} recognized and allowed.")
+        return False, "Hotkey recognized!"
+
+    async def priority_upscaling_requests(self, synapse: VideoUpscalingProtocol) -> float:
+        """
+        Assigns a priority to requests based on the stake of the requesting entity.
+        Higher stakes result in higher priority.
+        """
+        if not synapse.dendrite or not synapse.dendrite.hotkey:
+            logger.warning("Received a request without a dendrite or hotkey.")
+            return 0.0
+
+        caller_uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+        priority: float = float(self.metagraph.S[caller_uid])
+        
+        logger.trace(f"Prioritizing {synapse.dendrite.hotkey} with value: {priority}")
+        return priority
+
+    async def blacklist_length_check_requests(self, synapse: LengthCheckProtocol) -> Tuple[bool, str]:
+        """
+        Determines whether a request should be blacklisted based on the hotkey status.
+        """
+        if not synapse.dendrite or not synapse.dendrite.hotkey:
+            logger.warning("Received a request without a dendrite or hotkey.")
+            return True, "Missing dendrite or hotkey"
+
+        uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+
+        if not self.metagraph.validator_permit[uid]:
+            logger.warning(f"Blacklisting non-validator hotkey {synapse.dendrite.hotkey}")
+            return True, "Non-validator hotkey"
+
+        logger.trace(f"Hotkey {synapse.dendrite.hotkey} recognized and allowed.")
+        return False, "Hotkey recognized!"
+
+    async def priority_length_check_requests(self, synapse: LengthCheckProtocol) -> float:
+        """
+        Assigns a priority to requests based on the stake of the requesting entity.
+        Higher stakes result in higher priority.
+        """
+        if not synapse.dendrite or not synapse.dendrite.hotkey:
+            logger.warning("Received a request without a dendrite or hotkey.")
+            return 0.0
+
+        caller_uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+        priority: float = float(self.metagraph.S[caller_uid])
+        
+        logger.trace(f"Prioritizing {synapse.dendrite.hotkey} with value: {priority}")
+        return priority
+
+    async def blacklist_compression_requests(self, synapse: VideoCompressionProtocol) -> Tuple[bool, str]:
+        """
+        Determines whether a request should be blacklisted based on the hotkey status.
+        """
+        if not synapse.dendrite or not synapse.dendrite.hotkey:
+            logger.warning("Received a request without a dendrite or hotkey.")
+            return True, "Missing dendrite or hotkey"
+
+        uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+
+        if not self.metagraph.validator_permit[uid]:
+            logger.warning(f"Blacklisting non-validator hotkey {synapse.dendrite.hotkey}")
+            return True, "Non-validator hotkey"
+
+        logger.trace(f"Hotkey {synapse.dendrite.hotkey} recognized and allowed.")
+        return False, "Hotkey recognized!"
+
+    async def priority_compression_requests(self, synapse: VideoCompressionProtocol) -> float:
+        """
+        Assigns a priority to requests based on the stake of the requesting entity.
+        Higher stakes result in higher priority.
+        """
+        if not synapse.dendrite or not synapse.dendrite.hotkey:
+            logger.warning("Received a request without a dendrite or hotkey.")
+            return 0.0
+
+        caller_uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+        priority: float = float(self.metagraph.S[caller_uid])
+        
+        logger.trace(f"Prioritizing {synapse.dendrite.hotkey} with value: {priority}")
+        return priority
+
+    async def blacklist_task_warrant_requests(self, synapse: TaskWarrantProtocol) -> Tuple[bool, str]:
+        """
+        Determines whether a request should be blacklisted based on the hotkey status.
+        """
+        if not synapse.dendrite or not synapse.dendrite.hotkey:
+            logger.warning("Received a request without a dendrite or hotkey.")
+            return True, "Missing dendrite or hotkey"   
+
+        uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+
+        if not self.metagraph.validator_permit[uid]:
+            logger.warning(f"Blacklisting non-validator hotkey {synapse.dendrite.hotkey}")
+            return True, "Non-validator hotkey"
+
+        logger.trace(f"Hotkey {synapse.dendrite.hotkey} recognized and allowed.")
+        return False, "Hotkey recognized!"
+
+    async def priority_task_warrant_requests(self, synapse: TaskWarrantProtocol) -> float:
+        """
+        Assigns a priority to requests based on the stake of the requesting entity.
+        Higher stakes result in higher priority.
+        """
+        if not synapse.dendrite or not synapse.dendrite.hotkey:
+            logger.warning("Received a request without a dendrite or hotkey.")
+            return 0.0
+
+        caller_uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+        priority: float = float(self.metagraph.S[caller_uid])
+
+        logger.trace(f"Prioritizing {synapse.dendrite.hotkey} with value: {priority}")
+        return priority
+
+    def blacklist_all_requests(self, synapse) -> Tuple[bool, str]:
+        """
+        Determines whether a request should be blacklisted based on the hotkey status.
+        """
+        if not synapse.dendrite or not synapse.dendrite.hotkey:
+            logger.warning("Received a request without a dendrite or hotkey.")
+            return True, "Missing dendrite or hotkey"   
+
+        uid: int = self.metagraph.hotkeys.index(synapse.dendrite.hotkey)
+
+        if not self.metagraph.validator_permit[uid]:
+            logger.warning(f"Blacklisting non-validator hotkey {synapse.dendrite.hotkey}")
+            return True, "Non-validator hotkey"
+
+        hotkey: str = synapse.dendrite.hotkey
+        if hotkey not in VALIDATOR_HOTKEYS:
+            logger.warning(f"Validator hotkey {hotkey} is not recognized.")
+            return True, "Validator hotkey not recognized."
+        
+        if hotkey != VALIDATOR_HOTKEYS[0]:
+            logger.warning(f"Validator hotkey {hotkey} is not authorized to make requests at this time because of staking amount.",
+                           f" Only {VALIDATOR_HOTKEYS[0]} is authorized.",
+                           f" Request denied.")
+            return True, "Validator hotkey not authorized."
+        
+        logger.trace(f"Hotkey {synapse.dendrite.hotkey} recognized and allowed.")
+        return False, "Hotkey recognized!"
+    
+if __name__ == "__main__":
+    with Miner() as miner:
+        while True:
+            logger.info(f"Miner running... {time.time()}")
+            time.sleep(50)

neurons/validator.py

@@ -0,0 +1,1227 @@
+import os
+import time
+import uuid
+import httpx
+import random
+import asyncio
+import traceback
+import pandas as pd
+import bittensor as bt
+from loguru import logger
+from datetime import datetime, timezone
+from concurrent.futures import ThreadPoolExecutor
+from vidaio_subnet_core.utilities.version import get_version
+from vidaio_subnet_core import validating, CONFIG, base, protocol
+from vidaio_subnet_core.utilities.wandb_manager import WandbManager
+from services.video_scheduler.video_utils import get_trim_video_path
+from vidaio_subnet_core.utilities.uids import get_organic_forward_uids
+from vidaio_subnet_core.protocol import LengthCheckProtocol, TaskWarrantProtocol, TaskType
+from vidaio_subnet_core.validating.managing.sql_schemas import MinerMetadata, MinerPerformanceHistory, Base
+from sqlalchemy import desc, asc, func, select, delete
+from sqlalchemy.ext.asyncio import AsyncSession
+from datetime import datetime, timedelta
+from services.dashboard.server import send_upscaling_data_to_dashboard, send_compression_data_to_dashboard
+from services.video_scheduler.redis_utils import (
+    get_redis_connection, 
+    get_organic_upscaling_queue_size, 
+    get_organic_compression_queue_size, 
+    set_scheduler_ready
+)
+from typing import List, Tuple, Any
+
+VMAF_QUALITY_THRESHOLDS = [
+    85, #Low
+    90, #Medium
+    95, #High
+]
+
+SLEEP_TIME_LOW = 60 * 3 # 3 minutes
+SLEEP_TIME_HIGH = 60 * 4 # 4 minutes
+
+class Validator(base.BaseValidator):
+    def __init__(self):
+        super().__init__()
+        self.miner_manager = validating.managing.MinerManager(
+            uid=self.uid, config=self.config, wallet=self.wallet, metagraph=self.metagraph
+        )
+        logger.info("💧 Initialized miner manager 💧")
+        
+        self.challenge_synthesizer = validating.synthesizing.Synthesizer()
+        logger.info("💧 Initialized challenge synthesizer 💧")
+        
+        self.dendrite = bt.dendrite(wallet=self.wallet)
+        logger.info("💧 Initialized dendrite 💧")
+        
+        self.score_client = httpx.AsyncClient(
+            base_url=f"http://{CONFIG.score.host}:{CONFIG.score.port}"
+        )
+        logger.info(
+            f"💧 Initialized score client with base URL: http://{CONFIG.score.host}:{CONFIG.score.port} 💧"
+        )
+        
+        self.set_weights_executor = ThreadPoolExecutor(max_workers=1)
+        logger.info("💙 Initialized setting weights executor 💙")
+
+        self.redis_conn = get_redis_connection()
+        logger.info("💙 Initialized Redis connection 💙")
+        
+        self.wandb_manager = WandbManager(validator=self)
+        logger.info("🔑 Initialized Wandb Manager 🔑")
+
+        self.organic_gateway_base_url = f"http://localhost:{CONFIG.organic_gateway.port}"
+
+        self.push_result_endpoint = f"http://{CONFIG.video_scheduler.host}:{CONFIG.video_scheduler.port}/api/push_result"
+        
+        self.scheduler_ready_endpoint = f"http://{CONFIG.video_scheduler.host}:{CONFIG.video_scheduler.port}/api/scheduler_ready"
+
+    async def check_scheduler_ready(self) -> bool:
+        """
+        Check if the video scheduler is ready to process synthetic requests.
+        
+        Returns:
+            bool: True if scheduler is ready, False otherwise
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(self.scheduler_ready_endpoint, timeout=10)
+                response.raise_for_status()
+                data = response.json()
+                return data.get("ready", False)
+        except httpx.HTTPStatusError as e:
+            logger.error(f"HTTP error checking scheduler readiness: {e.response.status_code}")
+            return False
+        except httpx.RequestError as e:
+            logger.error(f"Request error checking scheduler readiness: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Unexpected error checking scheduler readiness: {e}")
+            return False
+
+    async def wait_for_scheduler_ready(self) -> None:
+        """
+        Wait for the scheduler to be ready before proceeding with synthetic requests.
+        """
+        logger.info("🔄 Checking if video scheduler is ready...")
+        
+        while not await self.check_scheduler_ready():
+            logger.info("⏳ Waiting for scheduler server to be ready (all synthetic queues need to be populated)...")
+            await asyncio.sleep(10)
+        
+        logger.info("✅ Scheduler is ready! Proceeding with synthetic requests.")
+
+    async def refresh_miner_manager(self, miner_uids: list[int]):
+        if not miner_uids:
+            return
+
+        miner_hotkeys = [self.metagraph.hotkeys[uid] for uid in miner_uids]
+
+        # Single query to fetch all miners
+        stmt = select(MinerMetadata).where(MinerMetadata.uid.in_(miner_uids))
+        result = self.miner_manager.session.execute(stmt)
+        miners = {miner.uid: miner for miner in result.scalars().all()}
+
+        delete_uids = []
+
+        for uid, latest_hotkey in zip(miner_uids, miner_hotkeys):
+            miner = miners.get(uid)
+            if miner is None:
+                continue
+
+            if miner.hotkey != latest_hotkey:
+                delete_uids.append(uid)
+                logger.info(
+                    f"UID {uid} hotkey changed from {miner.hotkey} → {latest_hotkey}"
+                )
+                miner.hotkey = latest_hotkey  # update record in-memory
+
+        if delete_uids:
+            delete_stmt = delete(MinerPerformanceHistory).where(
+                MinerPerformanceHistory.uid.in_(delete_uids)
+            )
+            self.miner_manager.session.execute(delete_stmt)
+
+        self.miner_manager.session.commit()
+
+    async def start_synthetic_epoch(self):
+        # Wait for scheduler to be ready first
+        await self.wait_for_scheduler_ready()
+        
+        logger.info("✅✅✅✅✅ Starting synthetic forward ✅✅✅✅✅")
+        epoch_start_time = time.time()
+
+        miner_uids = self.filter_miners()
+        logger.debug(f"Initialized {len(miner_uids)} subnet neurons of total {len(self.metagraph.S)} neurons")
+
+        uids = self.miner_manager.consume(miner_uids)
+
+        logger.info(f"Filtered UIDs after consumption: {uids}")
+
+        random_uids = uids.copy()
+        random.shuffle(random_uids)
+        logger.info(f"Randomized UIDs: {random_uids}")
+
+        axons = [self.metagraph.axons[uid] for uid in random_uids]
+
+        logger.info(f"Sending TaskWarrantProtocol requests to {len(axons)} miners")
+
+        version = get_version()
+        task_warrant_synapse = TaskWarrantProtocol(version=version)
+        
+        task_warrant_responses = await self.dendrite.forward(
+            axons=axons, synapse=task_warrant_synapse, timeout=10
+        )
+        logger.info(f"💊 Received {len(task_warrant_responses)} responses from miners for TaskWarrantProtocol requests💊")
+
+        upscaling_miners = []
+        compression_miners = []
+        unknown_task_miners = []
+        
+        for i, response in enumerate(task_warrant_responses):
+            uid = random_uids[i]
+            axon = axons[i]
+
+            if response.warrant_task == TaskType.UPSCALING:
+                upscaling_miners.append((axon, uid))
+            elif response.warrant_task == TaskType.COMPRESSION:
+                compression_miners.append((axon, uid))
+            else:
+                unknown_task_miners.append(uid)
+        
+        if unknown_task_miners:
+            logger.info(f"🔍 Checking database for {len(unknown_task_miners)} unknown task warrant miners")
+            db_task_types = self.miner_manager.get_miner_processing_task_types(unknown_task_miners)
+            
+            resolved_from_db = []
+            defaulted_to_upscaling = []
+            
+            for i, uid in enumerate(unknown_task_miners):
+                axon = axons[random_uids.index(uid)]
+                
+                if uid in db_task_types:
+                    db_task_type = db_task_types[uid]
+                    if db_task_type == "upscaling":
+                        upscaling_miners.append((axon, uid))
+                        resolved_from_db.append(f"{uid}(upscaling)")
+                    elif db_task_type == "compression":
+                        compression_miners.append((axon, uid))
+                        resolved_from_db.append(f"{uid}(compression)")
+                    else:
+                        upscaling_miners.append((axon, uid))
+                        defaulted_to_upscaling.append(f"{uid}(unknown_db_value:{db_task_type})")
+                else:
+                    upscaling_miners.append((axon, uid))
+                    defaulted_to_upscaling.append(f"{uid}(no_db_record)")
+            
+        upscaling_uids = [uid for _, uid in upscaling_miners]
+        compression_uids = [uid for _, uid in compression_miners]
+        all_uids = upscaling_uids + compression_uids
+        
+        await self.refresh_miner_manager(all_uids)
+        
+        logger.info(f"🛜 Grouped miners: {len(upscaling_miners)} upscaling, {len(compression_miners)} compression 🛜")
+        if upscaling_uids:
+            logger.info(f"📈 Upscaling UIDs: {upscaling_uids}")
+        if compression_uids:
+            logger.info(f"📉 Compression UIDs: {compression_uids}")
+        if unknown_task_miners:
+            logger.info(f"❓ Unknown task UIDs processed: {unknown_task_miners}")
+
+        if upscaling_miners:
+            logger.info(f"Sending LengthCheckProtocol requests to {len(upscaling_miners)} upscaling miners")
+            
+            upscaling_start_time = time.time()
+            upscaling_axons = [miner[0] for miner in upscaling_miners]
+            length_check_synapse = LengthCheckProtocol(version=version)
+            
+            length_check_responses = await self.dendrite.forward(
+                axons=upscaling_axons, synapse=length_check_synapse, timeout=10
+            )
+            logger.info(f"💊 Received {len(length_check_responses)} responses from upscaling miners for LengthCheckProtocol requests💊")
+
+            upscaling_content_lengths = []
+            for response in length_check_responses:
+                avail_max_len = response.max_content_length.value
+                if avail_max_len == 10:
+                    upscaling_content_lengths.append(avail_max_len)
+                else:
+                    upscaling_content_lengths.append(5)
+
+            logger.info(f"Upscaling content lengths: {upscaling_content_lengths}")
+
+            upscaling_miners_with_lengths = []
+            for i, (axon, uid) in enumerate(upscaling_miners):
+                content_length = upscaling_content_lengths[i] if i < len(upscaling_content_lengths) else 5
+                upscaling_miners_with_lengths.append((axon, uid, content_length))
+
+            await self.process_upscaling_miners(upscaling_miners_with_lengths, version)
+
+            upscaling_processed_time = time.time() - upscaling_start_time
+
+            logger.info(f"Upscaling tasks processed in {upscaling_processed_time:.2f} seconds")
+
+            await asyncio.sleep(2)
+
+        if compression_miners:
+            logger.info(f"Processing {len(compression_miners)} compression miners")
+
+            compression_start_time = time.time()
+            await self.process_compression_miners(compression_miners, version)
+
+            compression_processed_time = time.time() - compression_start_time
+
+            logger.info(f"Compression tasks processed in {compression_processed_time:.2f} seconds")
+
+            await asyncio.sleep(2)
+
+        epoch_processed_time = time.time() - epoch_start_time
+        logger.info(f"Completed one epoch within {epoch_processed_time:.2f} seconds")
+
+        if epoch_processed_time < 60: # if epoch completed within 60 seconds in case of no miners requiring synth checking, sleep for 10 minutes
+            await asyncio.sleep(60 * 10)
+        else:
+            await asyncio.sleep(2)
+
+    #   --------------------------------------------------------------------------- #
+    #  Helper – turn the raw list of (axon, uid) into a dict {uid: (axon, uid)}
+    # --------------------------------------------------------------------------- #
+    def _miner_lookup(self, miners: List[Tuple[Any, int]]) -> dict[int, Tuple[Any, int]]:
+        """{uid: (axon, uid)} – fast lookup while preserving the original tuple."""
+        return {uid: (axon, uid) for axon, uid in miners}
+
+
+    async def create_miner_batches(
+        self,
+        miners: List[Tuple[Any, int]],
+        batch_size: int,
+        task_type: str = "upscaling",
+    ) -> List[List[Tuple[Any, int]]]:
+        """
+        Build batches of miners for *task_type* (upscaling / compression).
+
+        Rules
+        -----
+        1. Miners with **fewest** performance-history rows go first.
+        2. Miners whose **most recent entry** is older than 2 h are eligible, subject to 70% probability of selection in batching.
+        3. Miners that already have >= CONFIG.score.max_performance_records rows
+        **and** whose latest entry is < 2 h are **skipped**.
+        """
+        session = self.miner_manager.session
+        hours_threshold = datetime.utcnow() - timedelta(hours=CONFIG.score.synthetics_hours_threshold)
+        max_records = CONFIG.score.max_performance_records
+
+        info_new_uids = []
+
+        # ------------------------------------------------------------------- #
+        # 1. One-shot aggregated stats per UID (count + latest timestamp)
+        # ------------------------------------------------------------------- #
+        uid_stats_subq = (
+            session.query(
+                MinerPerformanceHistory.uid,
+                func.count(MinerPerformanceHistory.id).label("record_count"),
+                func.max(MinerPerformanceHistory.timestamp).label("latest_timestamp"),
+            )
+            .filter(
+                MinerPerformanceHistory.processed_task_type == task_type,
+                MinerPerformanceHistory.uid.in_([uid for _axon, uid in miners]),
+            )
+            .group_by(MinerPerformanceHistory.uid)
+            .subquery()
+        )
+
+        uid_stats = session.query(
+            uid_stats_subq.c.uid,
+            uid_stats_subq.c.record_count,
+            uid_stats_subq.c.latest_timestamp,
+        ).all()
+
+        # uid → (record_count, latest_timestamp)
+        uid_info: dict[int, Tuple[int, datetime | None]] = {
+            row.uid: (row.record_count or 0, row.latest_timestamp) for row in uid_stats
+        }
+
+        # ------------------------------------------------------------------- #
+        # 2. Miners that have *zero* rows are the highest priority
+        # ------------------------------------------------------------------- #
+        all_uids = {uid for _axon, uid in miners}
+        for uid in all_uids - uid_info.keys():
+            uid_info[uid] = (0, None)
+
+        # ------------------------------------------------------------------- #
+        # 3. Build a fast lookup {uid: original_tuple}
+        # ------------------------------------------------------------------- #
+        miner_by_uid = self._miner_lookup(miners)
+
+        # ------------------------------------------------------------------- #
+        # 4. Filter + priority key
+        # ------------------------------------------------------------------- #
+        eligible: List[Tuple[Tuple[int, datetime], Tuple[Any, int]]] = []
+
+        for uid in all_uids:
+            miner_tuple = miner_by_uid[uid]
+            rec_cnt, latest_ts = uid_info[uid]
+
+            # ---- Rule 3: skip capped miners with recent performance record ----
+            if rec_cnt >= max_records and latest_ts and latest_ts >= hours_threshold:
+                logger.info(
+                    f"Skipping miner uid={uid}: {rec_cnt} records, last update {latest_ts}"
+                )
+                continue
+
+            # ---- Rule 2: include if never seen, below capacity or stale ----
+            if rec_cnt < max_records or not latest_ts \
+                or (latest_ts < hours_threshold and random.random() < CONFIG.score.synthetics_select_probability):
+                priority = (
+                    rec_cnt,                                   # fewer records first
+                    latest_ts if latest_ts else datetime.min,  # oldest first
+                )
+                if rec_cnt == 0:
+                    info_new_uids.append(uid) 
+                eligible.append((priority, miner_tuple))
+
+        # ------------------------------------------------------------------- #
+        # 5. Sort & batch
+        # ------------------------------------------------------------------- #
+        eligible.sort(key=lambda x: x[0])                     # by priority tuple
+        sorted_miners = [miner for _prio, miner in eligible]
+
+        batches = [
+            sorted_miners[i : i + batch_size]
+            for i in range(0, len(sorted_miners), batch_size)
+        ]
+
+        logger.info(
+            f"Created {len(batches)} {task_type} batches (size≤{batch_size}). "
+            f"Selected {len(sorted_miners)}/{len(miners)} miners."
+            f" New UIDs with no history: {info_new_uids}"
+        )
+        if eligible:
+            top_uid = eligible[0][1][1]   # (axon, uid) → uid
+            logger.info(
+                f"Top-priority miner uid={top_uid} – records={uid_info[top_uid][0]}"
+            )
+
+        return batches
+
+    async def call_miner(self, axon, synapse, uid, timeout=60):
+        start = time.perf_counter()
+
+        try:
+            raw = await self.dendrite.forward(
+                axons=[axon],
+                synapse=synapse,
+                timeout=timeout,
+            )
+            duration = (time.perf_counter() - start) * 1000  # ms
+
+            try:
+                result = raw[0]
+            except Exception as e:
+                logger.error(
+                    f"UID {uid} → invalid response structure after {duration:.2f} ms | {e}",
+                    exc_info=True
+                )
+                return {
+                    "uid": uid,
+                    "result": None,
+                    "error": e,
+                    "latency_ms": duration,
+                }
+
+            logger.info(f"UID {uid} → success | {duration:.2f} ms")
+
+            return {
+                "uid": uid,
+                "result": result,
+                "error": None,
+                "latency_ms": duration,
+            }
+
+        except Exception as e:
+            duration = (time.perf_counter() - start) * 1000  # ms
+
+            logger.error(
+                f"UID {uid} → failure after {duration:.2f} ms | {type(e).__name__}: {e}",
+                exc_info=True
+            )
+
+            return {
+                "uid": uid,
+                "result": None,  # EXACT same shape as original gather usage
+                "error": e,
+                "latency_ms": duration,
+            }
+    
+    async def process_upscaling_miners(self, upscaling_miners_with_lengths, version):
+        """Process upscaling miners in batches similar to the original implementation."""
+        batch_size = CONFIG.bandwidth.requests_per_synthetic_interval
+
+        upscaling_miners = [(axon, uid) for axon, uid, _ in upscaling_miners_with_lengths]
+        upscaling_content_lengths = {uid: length for _, uid, length in upscaling_miners_with_lengths}
+
+        miner_batches = await self.create_miner_batches(upscaling_miners, batch_size, task_type="upscaling")
+
+        logger.info(f"Created {len(miner_batches)} upscaling batches of size {batch_size}")
+
+        for batch_idx, batch in enumerate(miner_batches):
+            batch_start_time = time.time()
+            logger.info(f"🧩 Processing upscaling batch {batch_idx + 1}/{len(miner_batches)} 🧩")
+            
+            uids = []
+            axons = []
+            content_lengths = []
+            for miner in batch:
+                content_lengths.append(upscaling_content_lengths[miner[1]])
+                uids.append(miner[1])
+                axons.append(miner[0])
+            
+            round_id = str(uuid.uuid4())
+            payload_urls, video_ids, uploaded_object_names, synapses, task_types = await self.challenge_synthesizer.build_synthetic_protocol(content_lengths, version, round_id)
+            logger.info(f"Built compression challenge protocol: payload URLs: {payload_urls}\nvideo IDs: {video_ids}")
+            logger.debug(f"Built upscaling challenge protocol")
+
+            timestamp = datetime.now(timezone.utc).isoformat()
+
+            forward_tasks = [
+                self.call_miner(axon, synapse, uid, timeout=60)
+                for uid, axon, synapse in zip(uids, axons, synapses)
+            ]
+            raw_responses = await asyncio.gather(*forward_tasks)
+            responses = [response['result'] for response in raw_responses]
+
+            logger.info(f"🎲 Received {len(responses)} upscaling responses from miners 🎲")
+
+            reference_video_paths = []
+            for video_id in video_ids:
+                reference_video_path = get_trim_video_path(video_id)
+                if not os.path.exists(reference_video_path):
+                    logger.warning(f"⚠️ Reference video file missing for video_id {video_id}: {reference_video_path}")
+                reference_video_paths.append(reference_video_path)
+            
+            asyncio.create_task(self.score_upscalings(uids, responses, payload_urls, reference_video_paths, timestamp, video_ids, uploaded_object_names, content_lengths, task_types, round_id))
+
+            batch_processed_time = time.time() - batch_start_time
+            
+            sleep_time = random.uniform(SLEEP_TIME_LOW, SLEEP_TIME_HIGH) - batch_processed_time
+            logger.info(f"Completed upscaling batch within {batch_processed_time:.2f} seconds")
+            logger.info(f"Sleeping for 3-4 minutes before next upscaling batch")
+            
+            await asyncio.sleep(sleep_time)
+
+    async def process_compression_miners(self, compression_miners, version):
+        """Process compression miners in batches similar to upscaling but with compression protocols."""
+        batch_size = CONFIG.bandwidth.requests_per_synthetic_interval
+
+        miner_batches = await self.create_miner_batches(compression_miners, batch_size, task_type="compression")
+        
+        logger.info(f"Created {len(miner_batches)} compression batches of size {batch_size}")
+
+        for batch_idx, batch in enumerate(miner_batches):
+            batch_start_time = time.time()
+            logger.info(f"🧩 Processing compression batch {batch_idx + 1}/{len(miner_batches)} 🧩")
+            
+            uids = []
+            axons = []
+            for miner in batch:
+                uids.append(miner[1])
+                axons.append(miner[0])
+            
+            vmaf_threshold = random.choice(VMAF_QUALITY_THRESHOLDS)
+            
+            round_id = str(uuid.uuid4())
+
+            num_miners = len(uids)
+
+            payload_urls, video_ids, uploaded_object_names, synapses = await self.challenge_synthesizer.build_compression_protocol(vmaf_threshold, num_miners, version, round_id)
+            logger.info(f"Built compression challenge protocol: payload URLs: {payload_urls}\nvideo IDs: {video_ids}")
+            logger.debug(f"Built compression challenge protocol")
+
+            timestamp = datetime.now(timezone.utc).isoformat()
+
+            logger.debug(f"Processing compression UIDs in batch: {uids}")
+            
+            forward_tasks = [
+                self.call_miner(axon, synapse, uid, timeout=60)
+                for uid, axon, synapse in zip(uids, axons, synapses)
+            ]
+            raw_responses = await asyncio.gather(*forward_tasks)
+            responses = [response['result'] for response in raw_responses]
+
+            logger.info(f"🎲 Received {len(responses)} compression responses from miners 🎲")
+
+            reference_video_paths = []
+            for video_id in video_ids:
+                reference_video_path = get_trim_video_path(video_id)
+                if not os.path.exists(reference_video_path):
+                    logger.warning(f"⚠️ Reference video file missing for video_id {video_id}: {reference_video_path}")
+                reference_video_paths.append(reference_video_path)
+            
+            asyncio.create_task(self.score_compressions(uids, responses, payload_urls, reference_video_paths, timestamp, video_ids, uploaded_object_names, vmaf_threshold, round_id))
+
+            batch_processed_time = time.time() - batch_start_time
+            sleep_time = random.uniform(SLEEP_TIME_LOW, SLEEP_TIME_HIGH) - batch_processed_time
+
+            logger.info(f"Completed compression batch within {batch_processed_time:.2f} seconds")
+            logger.info(f"Sleeping for 3-4 minutes before next compression batch")
+            
+            await asyncio.sleep(sleep_time)
+
+
+    async def start_organic_loop(self):
+        """Start organic processing loop for both upscaling and compression tasks asynchronously."""
+        try:
+            # Create tasks for both upscaling and compression processing
+            upscaling_task = asyncio.create_task(self._process_organic_upscaling_loop())
+            compression_task = asyncio.create_task(self._process_organic_compression_loop())
+            
+            # Wait for both tasks to complete (they run indefinitely)
+            await asyncio.gather(upscaling_task, compression_task)
+        except Exception as e:
+            logger.error(f"Error during organic processing loop: {e}")
+
+    async def _process_organic_upscaling_loop(self):
+        """Process organic upscaling tasks in a loop."""
+        while True:
+            try:
+                await self.should_process_organic_upscaling()
+                await asyncio.sleep(5)
+            except Exception as e:
+                logger.error(f"Error during organic upscaling processing: {e}")
+                await asyncio.sleep(5)
+
+    async def _process_organic_compression_loop(self):
+        """Process organic compression tasks in a loop."""
+        while True:
+            try:
+                await self.should_process_organic_compression()
+                await asyncio.sleep(5)
+            except Exception as e:
+                logger.error(f"Error during organic compression processing: {e}")
+                await asyncio.sleep(5)
+
+    async def score_upscalings(
+        self, 
+        uids: list[int], 
+        responses: list[protocol.Synapse], 
+        payload_urls: list[str], 
+        reference_video_paths: list[str], 
+        timestamp: str, 
+        video_ids: list[str], 
+        uploaded_object_names: list[str], 
+        content_lengths: list[int], 
+        task_types: list[str],
+        round_id: str
+    ):
+        distorted_urls = []
+        for uid, response in zip(uids, responses):
+            distorted_urls.append(response.miner_response.optimized_video_url)
+
+        logger.info(f"responses: {responses}")
+
+        score_response = await self.score_client.post(
+            "/score_upscaling_synthetics",
+            json = {
+                "uids": uids,
+                "payload_urls": payload_urls,
+                "distorted_urls": distorted_urls,
+                "reference_paths": reference_video_paths,
+                "video_ids": video_ids,
+                "uploaded_object_names": uploaded_object_names,
+                "content_lengths": content_lengths,
+                "task_types": task_types
+            },
+            timeout=240
+        )
+
+        response_data = score_response.json()
+
+        quality_scores = response_data.get("quality_scores", [])
+        length_scores = response_data.get("length_scores", [])
+        final_scores = response_data.get("final_scores", [])
+        vmaf_scores = response_data.get("vmaf_scores", [])
+        pieapp_scores = response_data.get("pieapp_scores", [])
+        reasons = response_data.get("reasons", [])
+        
+        logger.info(f"Updating miner manager with {len(quality_scores)} miner scores after synthetic requests processing")
+
+        miner_hotkeys = [self.metagraph.hotkeys[uid] for uid in uids]
+        
+        accumulate_scores, applied_multipliers = self.miner_manager.step_synthetics_upscaling(
+            round_id, uids, miner_hotkeys, vmaf_scores, pieapp_scores, quality_scores, length_scores, final_scores, content_lengths
+        )
+
+        max_length = max(
+            len(uids),
+            len(quality_scores),
+            len(length_scores),
+            len(final_scores),
+            len(vmaf_scores),
+            len(pieapp_scores),
+            len(reasons),
+            len(content_lengths),
+            len(applied_multipliers),
+            len(accumulate_scores),
+        )
+
+        vmaf_scores.extend([0.0] * (max_length - len(vmaf_scores)))
+        pieapp_scores.extend([0.0] * (max_length - len(pieapp_scores)))
+        quality_scores.extend([0.0] * (max_length - len(quality_scores)))
+        length_scores.extend([0.0] * (max_length - len(length_scores)))
+        final_scores.extend([0.0] * (max_length - len(final_scores)))
+        reasons.extend(["No reason provided"] * (max_length - len(reasons)))
+        content_lengths.extend([0.0] * (max_length - len(content_lengths)))
+        applied_multipliers.extend([0.0] * (max_length - len(applied_multipliers)))
+
+        logger.info(f"Synthetic scoring results for {len(uids)} miners")
+        logger.info(f"Uids: {uids}")
+
+        for uid, vmaf_score, pieapp_score, quality_score, length_score, final_score, reason, content_length, applied_multiplier in zip(
+            uids, vmaf_scores, pieapp_scores, quality_scores, length_scores, final_scores, reasons, content_lengths, applied_multipliers
+        ):
+            logger.info(
+                f"{uid} ** VMAF: {vmaf_score:.2f} ** PieAPP: {pieapp_score:.2f} ** Quality: {quality_score:.4f} "
+                f"** Length: {length_score:.4f} ** Content Length: {content_length} ** Applied_multiplier {applied_multiplier} ** Final: {final_score:.4f} || {reason}"
+            )
+
+        miner_data = {
+            "validator_uid": self.my_subnet_uid,
+            "validator_hotkey": self.wallet.hotkey.ss58_address,
+            "request_type": "Synthetic",
+            "processing_task_type": "upscaling",
+            "miner_uids": uids,
+            "miner_hotkeys": miner_hotkeys,
+            "vmaf_scores": vmaf_scores,
+            "pieapp_scores": pieapp_scores,
+            "quality_scores": quality_scores,
+            "length_scores": length_scores,
+            "final_scores": final_scores,
+            "accumulate_scores": accumulate_scores,
+            "applied_multipliers": applied_multipliers,
+            "status": reasons,
+            "task_urls": payload_urls,
+            "processed_urls": distorted_urls,
+            "timestamp": timestamp
+        }
+        
+        success = send_upscaling_data_to_dashboard(miner_data)
+        if success:
+            logger.info("Data successfully sent to dashboard")
+        else:
+            logger.info("Failed to send data to dashboard")
+
+    async def score_compressions(
+        self, 
+        uids: list[int], 
+        responses: list[protocol.Synapse], 
+        payload_urls: list[str], 
+        reference_video_paths: list[str], 
+        timestamp: str, 
+        video_ids: list[str], 
+        uploaded_object_names: list[str], 
+        vmaf_threshold: float, 
+        round_id: str
+    ):
+        distorted_urls = []
+        for uid, response in zip(uids, responses):
+            distorted_urls.append(response.miner_response.optimized_video_url)
+
+        score_response = await self.score_client.post(
+            "/score_compression_synthetics",
+            json = {
+                "uids": uids,
+                "distorted_urls": distorted_urls,
+                "reference_paths": reference_video_paths,
+                "video_ids": video_ids,
+                "uploaded_object_names": uploaded_object_names,
+                "vmaf_threshold": vmaf_threshold
+            },
+            timeout=240
+        )
+
+        response_data = score_response.json()
+
+        compression_rates = response_data.get("compression_rates", [])
+        final_scores = response_data.get("final_scores", [])
+        vmaf_scores = response_data.get("vmaf_scores", [])
+        reasons = response_data.get("reasons", [])
+        
+        logger.info(f"Updating miner manager with {len(compression_rates)} compression miner scores after synthetic requests processing")
+
+        miner_hotkeys = [self.metagraph.hotkeys[uid] for uid in uids]
+        
+        if not compression_rates:
+            compression_rates = [0.5] * len(uids)
+        
+        accumulate_scores, applied_multipliers = self.miner_manager.step_synthetics_compression(
+            round_id, uids, miner_hotkeys, vmaf_scores,
+            final_scores, [10] * len(uids), vmaf_threshold, compression_rates
+        )
+
+        max_length = max(
+            len(uids),
+            len(final_scores),
+            len(vmaf_scores),
+            len(reasons),
+            len(applied_multipliers),
+            len(accumulate_scores),
+        )
+
+        vmaf_scores.extend([0.0] * (max_length - len(vmaf_scores)))
+        final_scores.extend([0.0] * (max_length - len(final_scores)))
+        reasons.extend(["No reason provided"] * (max_length - len(reasons)))
+        compression_rates.extend([0.5] * (max_length - len(compression_rates)))
+        applied_multipliers.extend([0.0] * (max_length - len(applied_multipliers)))
+
+        vmaf_thresholds = [vmaf_threshold] * len(uids)
+
+        logger.info(f"Synthetic compression scoring results for {len(uids)} miners")
+        logger.info(f"Uids: {uids}")
+
+        for uid, vmaf_score, final_score, reason, compression_rate, applied_multiplier in zip(
+            uids, vmaf_scores, final_scores, reasons, compression_rates, applied_multipliers
+        ):
+            logger.info(
+                f"{uid} ** VMAF: {vmaf_score:.2f} "
+                f"** VMAF Threshold: {vmaf_threshold} ** Compression Rate: {compression_rate:.4f} ** Final: {final_score:.4f} || {reason}"
+            )
+
+        miner_data = {
+            "validator_uid": self.my_subnet_uid,
+            "validator_hotkey": self.wallet.hotkey.ss58_address,
+            "request_type": "Synthetic",
+            "processing_task_type": "compression",
+            "miner_uids": uids,
+            "miner_hotkeys": miner_hotkeys,
+            "vmaf_scores": vmaf_scores,
+            "vmaf_thresholds": vmaf_thresholds,
+            "compression_rates": compression_rates,
+            "final_scores": final_scores,
+            "accumulate_scores": accumulate_scores,
+            "applied_multipliers": applied_multipliers,
+            "status": reasons,
+            "task_urls": payload_urls,
+            "processed_urls": distorted_urls,
+            "timestamp": timestamp
+        }
+        
+        success = send_compression_data_to_dashboard(miner_data)
+        if success:
+            logger.info("Compression data successfully sent to dashboard")
+        else:
+            logger.info("Failed to send compression data to dashboard")
+
+    async def score_organics_upscaling(self, uids: list[int], responses: list[protocol.Synapse], reference_urls: list[str], task_types: list[str], timestamp: str):
+        """Score organic upscaling tasks."""
+        distorted_urls = [response.miner_response.optimized_video_url for response in responses]
+
+        combined = list(zip(uids, distorted_urls, reference_urls, task_types))
+        random.shuffle(combined)
+        uids, distorted_urls, reference_urls, task_types = map(list, zip(*combined))
+
+        num_pairs_to_validate = min(1, len(combined))
+        selected_indices = random.sample(range(len(combined)), num_pairs_to_validate)
+        
+        selected_uids = [uids[i] for i in selected_indices]
+        selected_distorted_urls = [distorted_urls[i] for i in selected_indices]
+        selected_reference_urls = [reference_urls[i] for i in selected_indices]
+        selected_task_types = [task_types[i] for i in selected_indices]
+
+        logger.info(f"Randomly selected {len(selected_uids)} pairs out of {len(uids)} total pairs for validation")
+
+        score_response = await self.score_client.post(
+            "/score_organics_upscaling",
+            json={
+                "uids": selected_uids,
+                "distorted_urls": selected_distorted_urls,
+                "reference_urls": selected_reference_urls,
+                "task_types": selected_task_types
+            },
+            timeout=38
+        )
+
+        response_data = score_response.json()
+        scores = response_data.get("final_scores", [])
+        vmaf_scores = response_data.get("vmaf_scores", [])
+        pieapp_scores = response_data.get("pieapp_scores", [])
+        quality_scores = response_data.get("quality_scores", [])
+        length_scores = response_data.get("length_scores", [])
+        reasons = response_data.get("reasons", [])
+
+        max_length = max(len(uids), len(scores), len(vmaf_scores), len(pieapp_scores), len(reasons))
+        scores.extend([0.0] * (max_length - len(scores)))
+        vmaf_scores.extend([0.0] * (max_length - len(vmaf_scores)))
+        pieapp_scores.extend([0.0] * (max_length - len(pieapp_scores)))
+        quality_scores.extend([0.0] * (max_length - len(quality_scores)))
+        length_scores.extend([0.0] * (max_length - len(length_scores)))
+        reasons.extend(["no reason provided"] * (max_length - len(reasons)))
+
+        logger.info(f"organic upscaling scoring results for {len(selected_uids)} miners")
+        logger.info(f"uids: {selected_uids}")
+        for uid, vmaf_score, score, reason in zip(selected_uids, vmaf_scores, scores, reasons):
+            logger.info(f"{uid} ** {vmaf_score:.2f} ** {score:.4f} || {reason}")
+
+        round_id = f"organic_upscaling_{int(time.time())}"
+        
+        logger.info(f"updating miner manager with {len(scores)} miner scores after organic upscaling requests processing…")
+        accumulate_scores, applied_multipliers = self.miner_manager.step_organic_upscaling(scores, selected_uids, round_id)
+
+        miner_hotkeys = [self.metagraph.hotkeys[uid] for uid in selected_uids]
+
+        miner_data = {
+            "validator_uid": self.my_subnet_uid,
+            "validator_hotkey": self.wallet.hotkey.ss58_address,
+            "request_type": "Organic",
+            "processing_task_type": "upscaling",
+            "miner_uids": selected_uids,
+            "miner_hotkeys": miner_hotkeys,
+            "vmaf_scores": vmaf_scores,
+            "pieapp_scores": pieapp_scores,
+            "quality_scores": quality_scores,
+            "length_scores": length_scores,
+            "final_scores": scores,
+            "accumulate_scores": accumulate_scores,
+            "applied_multipliers": applied_multipliers,
+            "status": reasons,
+            "task_urls": selected_reference_urls,
+            "processed_urls": selected_distorted_urls,
+            "timestamp": timestamp
+        }
+        
+        success = send_upscaling_data_to_dashboard(miner_data)
+        if success:
+            logger.info("Data successfully sent to dashboard")
+        else:
+            logger.info("Failed to send data to dashboard")
+
+    async def score_organics_compression(self, uids: list[int], responses: list[protocol.Synapse], reference_urls: list[str], vmaf_thresholds: list[float], timestamp: str):
+        """Score organic compression tasks."""
+        distorted_urls = [response.miner_response.optimized_video_url for response in responses]
+
+        combined = list(zip(uids, distorted_urls, reference_urls, vmaf_thresholds))
+        random.shuffle(combined)
+        uids, distorted_urls, reference_urls, vmaf_thresholds = map(list, zip(*combined))
+
+        num_pairs_to_validate = min(5, len(combined))
+        selected_indices = random.sample(range(len(combined)), num_pairs_to_validate)
+        
+        selected_uids = [uids[i] for i in selected_indices]
+        selected_distorted_urls = [distorted_urls[i] for i in selected_indices]
+        selected_reference_urls = [reference_urls[i] for i in selected_indices]
+        selected_vmaf_thresholds = [vmaf_thresholds[i] for i in selected_indices]
+
+        logger.info(f"Randomly selected {len(selected_uids)} pairs out of {len(uids)} total pairs for compression validation")
+
+        score_response = await self.score_client.post(
+            "/score_organics_compression",
+            json={
+                "uids": selected_uids,
+                "distorted_urls": selected_distorted_urls,
+                "reference_urls": selected_reference_urls,
+                "vmaf_thresholds": selected_vmaf_thresholds
+            },
+            timeout=115
+        )
+
+        response_data = score_response.json()
+        scores = response_data.get("final_scores", [])
+        vmaf_scores = response_data.get("vmaf_scores", [])
+        compression_rates = response_data.get("compression_rates", [])
+        reasons = response_data.get("reasons", [])
+
+        max_length = max(len(selected_uids), len(scores), len(vmaf_scores), len(compression_rates), len(reasons))
+        scores.extend([0.0] * (max_length - len(scores)))
+        vmaf_scores.extend([0.0] * (max_length - len(vmaf_scores)))
+        compression_rates.extend([0.5] * (max_length - len(compression_rates)))
+        reasons.extend(["no reason provided"] * (max_length - len(reasons)))
+
+        round_id = f"organic_compression_{int(time.time())}"
+        
+        logger.info(f"updating miner manager with {len(scores)} miner scores after organic compression requests processing…")
+        accumulate_scores, applied_multipliers = self.miner_manager.step_organic_compression(scores, selected_uids, vmaf_scores, compression_rates, selected_vmaf_thresholds, round_id)
+
+        logger.info(f"organic compression scoring results for {len(selected_uids)} miners")
+        logger.info(f"uids: {selected_uids}")
+        for uid, vmaf_score, final_score, reason, compression_rate, applied_multiplier, vmaf_threshold in zip(
+            selected_uids, vmaf_scores, scores, reasons, compression_rates, applied_multipliers, selected_vmaf_thresholds
+        ):
+            logger.info(
+                f"{uid} ** VMAF: {vmaf_score:.2f} "
+                f"** VMAF Threshold: {vmaf_threshold} ** Compression Rate: {compression_rate:.4f} ** Final: {final_score:.4f} || {reason}"
+            )
+
+        miner_hotkeys = [self.metagraph.hotkeys[uid] for uid in selected_uids]
+
+        miner_data = {
+            "validator_uid": self.my_subnet_uid,
+            "validator_hotkey": self.wallet.hotkey.ss58_address,
+            "request_type": "Organic",
+            "processing_task_type": "compression",
+            "miner_uids": selected_uids,
+            "miner_hotkeys": miner_hotkeys,
+            "vmaf_scores": vmaf_scores,
+            "vmaf_thresholds": selected_vmaf_thresholds,
+            "compression_rates": compression_rates,
+            "final_scores": scores,
+            "accumulate_scores": accumulate_scores,
+            "applied_multipliers": applied_multipliers,
+            "status": reasons,
+            "task_urls": selected_reference_urls,
+            "processed_urls": selected_distorted_urls,
+            "timestamp": timestamp
+        }
+        
+        success = send_compression_data_to_dashboard(miner_data)
+        if success:
+            logger.info("Compression data successfully sent to dashboard")
+        else:
+            logger.info("Failed to send compression data to dashboard")
+
+    def filter_miners(self):
+        min_stake = CONFIG.bandwidth.min_stake
+        stake_array = self.metagraph.S
+        miner_uids = [i for i, stake in enumerate(stake_array) if stake < min_stake]
+
+        return miner_uids
+
+    async def should_process_organic_upscaling(self):
+        """Check if organic upscaling tasks should be processed."""
+        num_organic_upscaling_chunks = get_organic_upscaling_queue_size(self.redis_conn)
+
+        if num_organic_upscaling_chunks > 0:
+            logger.info(f"🔷 | UPSCALING | The organic_upscaling_queue_size: {num_organic_upscaling_chunks}, processing organic upscaling requests. 🔷")
+            await self.process_organic_upscaling_chunks(num_organic_upscaling_chunks)
+            return True
+        else:
+            return False
+
+    async def should_process_organic_compression(self):
+        """Check if organic compression tasks should be processed."""
+        num_organic_compression_chunks = get_organic_compression_queue_size(self.redis_conn)
+
+        if num_organic_compression_chunks > 0:
+            logger.info(f"🔷 | COMPRESSION | The organic_compression_queue_size: {num_organic_compression_chunks}, processing organic compression requests. 🔷")
+            await self.process_organic_compression_chunks(num_organic_compression_chunks)
+            return True
+        else:
+            return False
+
+    async def process_organic_upscaling_chunks(self, num_organic_chunks):
+        """Process organic upscaling chunks."""
+        organic_start_time = time.time() 
+
+        needed = min(CONFIG.bandwidth.requests_per_organic_interval, num_organic_chunks)
+        
+        logger.info(f"☘️ | UPSCALING | Start processing organic upscaling query. need {needed} miners ☘️")
+
+        forward_uids = get_organic_forward_uids(self, needed, "upscaling", CONFIG.bandwidth.min_stake)
+
+        if len(forward_uids) < needed:
+            logger.info(f"There are just {len(forward_uids)} miners available for organic upscaling, handling {len(forward_uids)} chunks")
+            needed = len(forward_uids)
+
+        axon_list = [self.metagraph.axons[uid] for uid in forward_uids]
+
+        task_ids, original_urls, task_types, synapses = await self.challenge_synthesizer.build_organic_upscaling_protocol(needed)
+
+        if len(task_ids) != needed or len(synapses) != needed:
+            logger.error(
+                f"Mismatch in organic upscaling synapses after building organic protocol: {len(task_ids)} != {needed} or {len(synapses)} != {needed}"
+            )
+            return
+
+        logger.info("Updating task status to 'processing' for upscaling")
+        for task_id, original_url in zip(task_ids, original_urls):
+            await self.update_task_status(task_id, original_url, "processing")
+
+        timestamp = datetime.now(timezone.utc).isoformat()
+
+        logger.info("🌜 | UPSCALING | Performing forward operations asynchronously for upscaling 🌜")
+        forward_tasks = [
+            self.call_miner(axon, synapse, uid, timeout=100)
+            for uid, axon, synapse in zip(forward_uids, axon_list, synapses)
+        ]
+        raw_responses = await asyncio.gather(*forward_tasks)
+        responses = [response['result'] for response in raw_responses]
+
+        processed_urls = [response.miner_response.optimized_video_url for response in responses]
+
+        logger.info(f"Processing organic upscaling chunks with uids: {forward_uids.tolist()}")
+        logger.info("Updating task status to 'completed' and pushing results for upscaling")
+        for task_id, original_url, processed_url in zip(task_ids, original_urls, processed_urls):
+            await self.update_task_status(task_id, original_url, "completed")
+            await self.push_result(task_id, original_url, processed_url)
+
+        asyncio.create_task(self.score_organics_upscaling(forward_uids.tolist(), responses, original_urls, task_types, timestamp))
+
+        end_time = time.time()
+        total_time = end_time - organic_start_time
+        logger.info(f"🍏 Organic upscaling chunk processing complete in {total_time:.2f} seconds 🍏")
+
+    async def process_organic_compression_chunks(self, num_organic_chunks):
+        """Process organic compression chunks."""
+        organic_start_time = time.time() 
+
+        needed = min(CONFIG.bandwidth.requests_per_organic_interval, num_organic_chunks)
+        
+        logger.info(f"☘️ | COMPRESSION | Start processing organic compression query. need {needed} miners ☘️")
+
+        forward_uids = get_organic_forward_uids(self, needed, "compression", CONFIG.bandwidth.min_stake)
+
+        if len(forward_uids) < needed:
+            logger.info(f"There are just {len(forward_uids)} miners available for organic compression, handling {len(forward_uids)} chunks")
+            needed = len(forward_uids)
+
+        axon_list = [self.metagraph.axons[uid] for uid in forward_uids]
+
+        task_ids, original_urls, vmaf_thresholds, synapses = await self.challenge_synthesizer.build_organic_compression_protocol(needed)
+
+        if len(task_ids) != needed or len(synapses) != needed:
+            logger.error(
+                f"Mismatch in organic compression synapses after building organic protocol: {len(task_ids)} != {needed} or {len(synapses)} != {needed}"
+            )
+            return
+
+        logger.info(f"Processing organic compression chunks with uids: {forward_uids.tolist()}")
+        logger.info("Updating task status to 'processing' for compression")
+        for task_id, original_url in zip(task_ids, original_urls):
+            await self.update_task_status(task_id, original_url, "processing")
+
+        timestamp = datetime.now(timezone.utc).isoformat()
+
+        logger.info("🌜 | COMPRESSION | Performing forward operations asynchronously for compression 🌜")
+
+        forward_tasks = [
+            self.call_miner(axon, synapse, uid, timeout=120)
+            for uid, axon, synapse in zip(forward_uids, axon_list, synapses)
+        ]
+        raw_responses = await asyncio.gather(*forward_tasks)
+        responses = [response['result'] for response in raw_responses]
+
+        processed_urls = [response.miner_response.optimized_video_url for response in responses]
+
+        logger.info("Updating task status to 'completed' and pushing results for compression")
+        for task_id, original_url, processed_url in zip(task_ids, original_urls, processed_urls):
+            await self.update_task_status(task_id, original_url, "completed")
+            await self.push_result(task_id, original_url, processed_url)
+
+        asyncio.create_task(self.score_organics_compression(forward_uids.tolist(), responses, original_urls, vmaf_thresholds, timestamp))
+
+        end_time = time.time()
+        total_time = end_time - organic_start_time
+        logger.info(f"🍏 Organic compression chunk processing complete in {total_time:.2f} seconds 🍏")
+
+
+    async def update_task_status(self, task_id, original_url, status):
+        status_update_endpoint = f"{self.organic_gateway_base_url}/admin/task/{task_id}/status"
+        status_update_payload = {
+            "status": status,
+            "original_video_url": original_url
+        }
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(status_update_endpoint, json=status_update_payload)
+                response.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            logger.error(f"Error updating status for task {task_id}: {e.response.status_code} - {e.response.text}")
+        except httpx.RequestError as e:
+            logger.error(f"Request error updating status for task {task_id}: {e}")
+
+    async def push_result(self, task_id, original_url, processed_url):
+        result_payload = {
+            "processed_video_url": processed_url,
+            "original_video_url": original_url,
+            "score": 0,
+            "task_id": task_id,
+        }
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(self.push_result_endpoint, json=result_payload)
+                response.raise_for_status()
+                logger.info(f"Successfully pushed result for task {task_id}")
+        except httpx.RequestError as e:
+            logger.error(f"Error pushing result for task {task_id}: {e}")
+
+    def set_weights(self):
+        self.current_block = self.subtensor.get_current_block()
+        self.last_update = self.metagraph.last_update[self.uid]
+        uids, weights = self.miner_manager.weights
+        (
+            processed_weight_uids,
+            processed_weights,
+        ) = bt.utils.weight_utils.process_weights_for_netuid(
+            uids = uids,
+            weights=weights,
+            netuid=self.config.netuid,
+            subtensor=self.subtensor,
+            metagraph=self.metagraph,
+        )
+        (
+            uint_uids,
+            uint_weights,
+        ) = bt.utils.weight_utils.convert_weights_and_uids_for_emit(
+            uids=processed_weight_uids, weights=processed_weights
+        )
+        if self.current_block > self.last_update + CONFIG.SUBNET_TEMPO:
+            weight_info = list(zip(uint_uids, uint_weights))
+            weight_info_df = pd.DataFrame(weight_info, columns=["uid", "weight"])
+            logger.info(f"Weight info:\n{weight_info_df.to_markdown()}")
+            logger.info("Trying to set weights.")
+            try:
+                future = self.set_weights_executor.submit(
+                    self.subtensor.set_weights,
+                    netuid=self.config.netuid,
+                    wallet=self.wallet,
+                    uids=uint_uids,
+                    weights=uint_weights,
+                )
+                success, msg = future.result(timeout=120)
+                if not success:
+                    logger.error(f"😠 Failed to set weights: {msg}")
+                else: 
+                    logger.debug("😎 Set weights successfully ")
+            except Exception as e:
+                logger.error(f"Failed to set weights: {e}")
+                traceback.print_exc()
+
+        else:
+            logger.info(
+                f"Not setting weights because current block {self.current_block} is not greater than last update {self.last_update} + tempo {CONFIG.SUBNET_TEMPO}"
+            )
+
+
+class WeightSynthesizer:
+    def __init__(self, validator: Validator):
+        self.validator = validator
+
+    async def run(self):
+        while True:
+            try:
+                logger.info("Running weight_manager...")
+                self.validator.set_weights()  
+            except Exception as e:
+                logger.error(f"Error in WeightSynthesizer: {e}", exc_info=True)
+            await asyncio.sleep(1200)  
+
+
+if __name__ == "__main__":
+    validator = Validator()
+    weight_synthesizer = WeightSynthesizer(validator)
+    time.sleep(1300) # wait till the video scheduler is ready
+
+    set_scheduler_ready(validator.redis_conn, False)
+    logger.info("Set scheduler readiness flag to False")
+
+    async def main():
+        validator_synthetic_task = asyncio.create_task(validator.run_synthetic())
+        validator_organic_task = asyncio.create_task(validator.run_organic())
+        weight_setter = asyncio.create_task(weight_synthesizer.run())
+
+        await asyncio.gather(validator_synthetic_task, validator_organic_task, weight_setter)
+
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        logger.info("Program terminated by user.")
+    except Exception as e:
+        logger.error(f"Unhandled exception: {e}", exc_info=True)
+
+

pretrained/AIM_Training_2branche_KAN-Head.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:70c243d7324c76df43df8ab6a44eb535ee9f4f3acb928e5dfe9deb2bb3b7b0ab
+size 85484315

pretrained/AIM_Training_2branche_MLP-Head.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68116e2d548b6bec6d80982ce3bbd7fb1136b20e2db728669b3b307fb3e7a094
+size 81899582

pretrained/single_branch_pretrained/Authentic.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fe09b8a81d2527165188cefd63e3f699a8df16aa4b0b631525734756696f2e6c
+size 22135322

pretrained/single_branch_pretrained/Synthetic.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9e7122c4e079f81227ff692f4680be2fdd99431ba90cdcf4a0656cfe93adc63
+size 22135322

run.sh

@@ -0,0 +1,261 @@
+#!/bin/bash
+
+script="neurons/validator.py"
+autoRunLoc=$(readlink -f "$0")
+proc_name="video-validator"
+args=()
+version_location="./vidaio_subnet_core/__init__.py"
+version="__version__"
+old_args=$@
+subnet=85
+restart_video_scheduler=true
+
+if ! command -v pm2 &> /dev/null
+then
+    echo "pm2 could not be found. To install see: https://pm2.keymetrics.io/docs/usage/quick-start/"
+    exit 1
+fi
+
+version_less_than_or_equal() {
+    [ "$1" = "$(echo -e "$1\n$2" | sort -V | head -n1)" ]
+}
+
+version_less_than() {
+    [ "$1" = "$2" ] && return 1 || version_less_than_or_equal $1 $2
+}
+
+read_version_value() {
+    while IFS= read -r line; do
+        if [[ "$line" == *"$version"* ]]; then
+            local value=$(echo "$line" | awk -F '=' '{print $2}' | tr -d ' ')
+            strip_quotes "$value"
+            return 0
+        fi
+    done < "$version_location"
+    echo ""
+}
+
+check_package_installed() {
+    local package_name="$1"
+    if ! command -v "$package_name" &> /dev/null; then
+        echo "Error: '$package_name' is not installed."
+        echo "Installing '$package_name'..."
+        sudo apt-get install -y "$package_name"
+    fi
+}
+
+strip_quotes() {
+    local input="$1"
+    local stripped="${input#\"}"
+    stripped="${stripped%\"}"
+    echo "$stripped"
+}
+
+check_variable_value_on_github() {
+    local repo="vidaio-subnet/vidaio-subnet"
+    local branch="$1"
+    local file_path="vidaio_subnet_core/__init__.py"
+    local variable="$2"
+
+
+    local content
+    content=$(curl -s "https://api.github.com/repos/$repo/contents/$file_path?ref=$branch" | jq -r '.content' | base64 --decode)
+
+    if [[ $? -ne 0 || -z "$content" ]]; then
+        echo "Error: Could not retrieve file content from GitHub."
+        return 1
+    fi
+
+    local value
+    value=$(echo "$content" | grep "$variable" | awk -F '=' '{print $2}' | tr -d ' ')
+
+    # Replace the strip_quotes call with direct quote removal
+    echo "$value" | tr -d '"' | tr -d "'"
+}
+
+ensure_process() {
+    local name="$1"
+    local cmd="$2"
+    local restart_flag="$3"   # "true" or "false"
+
+    if pm2 describe "$name" &>/dev/null; then
+        echo "Process '$name' already running."
+        if [[ "$restart_flag" == "true" ]]; then
+            echo "Reloading $name..."
+            pm2 reload "$name"
+        fi
+    else
+        echo "Starting $name..."
+        pm2 start bash --name "$name" -- -c "$cmd"
+    fi
+}
+
+ensure_config_process() {
+    local config="$1"
+    local name="$2"
+    local restart_flag="$3"   # "true" or "false"
+
+    if pm2 describe "$name" &>/dev/null; then
+        echo "Process '$name' already running (from $config)."
+        if [[ "$restart_flag" == "true" ]]; then
+            echo "Reloading $name from config..."
+            pm2 startOrReload "$config"
+        fi
+    else
+        echo "Starting $name from config..."
+        pm2 startOrReload "$config"
+    fi
+}
+
+while [[ $# -gt 0 ]]; do
+  arg="$1"
+  if [[ "$arg" == -* ]]; then
+    if [[ $# -gt 1 && "$2" != -* ]]; then
+        if [[ "$arg" == "--script" ]]; then
+            script="$2"
+            shift 2
+        elif [[ "$arg" == "--subnet" ]]; then
+            subnet="$2"
+            args+=("'--netuid'")
+            args+=("'$2'")
+            shift 2
+        elif [[ "$arg" == "--netuid" ]]; then
+            subnet="$2"
+            args+=("'$arg'")
+            args+=("'$2'")
+            shift 2
+        else
+            args+=("'$arg'")
+            args+=("'$2'")
+            shift 2
+        fi
+    else
+        if [[ "$arg" == "--no-video-scheduler" ]]; then
+            restart_video_scheduler=false
+            shift
+        else
+            args+=("'$arg'")
+            shift
+        fi
+    fi
+  else
+    args+=("'$arg'")
+    shift
+  fi
+done
+
+branch=$(git branch --show-current)
+echo "Watching branch: $branch"
+echo "Reapplying git stash"
+git stash pop
+echo "PM2 process name: $proc_name"
+if [[ -n "$subnet" ]]; then
+    echo "Subnet: $subnet"
+fi
+echo "Restart video scheduler: $restart_video_scheduler"
+
+current_version=$(read_version_value)
+
+if pm2 status | grep -q $proc_name; then
+    echo "The script is already running with pm2. Stopping and restarting..."
+    pm2 delete $proc_name
+fi
+
+echo "Running $script with the following PM2 config:"
+
+# Ensure netuid is always included in args
+netuid_found=false
+for arg in "${args[@]}"; do
+    if [[ "$arg" == "'--netuid'" ]]; then
+        netuid_found=true
+        break
+    fi
+done
+
+if [[ "$netuid_found" == "false" ]]; then
+    args+=("'--netuid'")
+    args+=("'$subnet'")
+fi
+
+joined_args=$(printf "%s," "${args[@]}")
+joined_args=${joined_args%,}
+
+echo "module.exports = {
+  apps : [{
+    name   : '$proc_name',
+    script : '$script',
+    interpreter: 'python3',
+    min_uptime: '5m',
+    max_restarts: '5',
+    args: [$joined_args],
+    cwd: '$(pwd)',
+    env: {
+      PYTHONPATH: '.'
+    }
+  }]
+}" > app.config.js
+
+cat app.config.js
+ensure_config_process "app.config.js" "$proc_name" "true"
+
+
+check_package_installed "jq"
+
+# 🚀 START THE ADDITIONAL PM2 PROCESSES
+ensure_process "scoring_endpoint" "bash -c 'PYTHONPATH=. python services/scoring/server.py'" "true"
+ensure_process "video_scheduler_worker" "bash -c 'PYTHONPATH=. python services/video_scheduler/worker.py'" "$restart_video_scheduler"
+ensure_process "video_scheduler_endpoint" "bash -c 'PYTHONPATH=. python services/video_scheduler/server.py'" "$restart_video_scheduler"
+ensure_process "organic-gateway" "bash -c 'PYTHONPATH=. python services/organic_gateway/server.py'" "true"
+
+# Auto-update loop
+last_restart_time=$(date +%s)
+restart_interval=$((30 * 3600))  # 30 hours in seconds
+
+while true; do
+    current_time=$(date +%s)
+    time_since_last_restart=$((current_time - last_restart_time))
+
+    if [ -d "./.git" ]; then
+        latest_version=$(check_variable_value_on_github "$branch" "$version")
+
+        if version_less_than $current_version $latest_version; then
+            echo "Latest version: $latest_version"
+            echo "Current version: $current_version"
+
+            git stash
+            if git pull origin "$branch"; then
+                echo "New version detected. Updating..."
+                pip install -e .
+
+                current_version=$(read_version_value)
+                last_restart_time=$current_time
+
+                echo "Restarting script..."
+                exec ./$(basename "$0") $old_args
+            else
+                echo "** Will not update **"
+                echo "You have uncommitted changes. Please stash them using 'git stash'."
+            fi
+        else
+            echo "** No update needed **"
+            echo "$current_version is up-to-date with $latest_version."
+
+            if [ $time_since_last_restart -ge $restart_interval ]; then
+                echo "30 hours passed. Performing periodic PM2 restart..."
+                pm2 restart scoring_endpoint
+                if [[ "$restart_video_scheduler" == "true" ]]; then
+                    pm2 restart video_scheduler_worker
+                    pm2 restart video_scheduler_endpoint
+                fi
+                pm2 restart video-validator
+
+                last_restart_time=$current_time
+                echo "Periodic restart completed."
+            fi
+        fi
+    else
+        echo "The installation does not appear to be from Git. Please install from source at https://github.com/vidaio-subnet/vidaio-subnet."
+    fi
+
+    sleep 1800  # Sleep 30 minutes before checking again
+done

scripts/capture_video_frames.py

@@ -0,0 +1,83 @@
+import cv2
+import os
+import argparse
+import numpy as np
+from pathlib import Path
+
+def capture_frames(video_path, output_dir, num_frames=3):
+    """
+    Captures the first num_frames frames from a video file and resizes them to 128x128 pixels.
+
+    Args:
+        video_path (str): Path to the video file
+        output_dir (str): Directory to save the captured frames
+        num_frames (int): Number of frames to capture from the start
+
+    Returns:
+        list: Paths to the saved frames
+    """
+    # Check if video exists
+    if not os.path.isfile(video_path):
+        raise FileNotFoundError(f"Video file not found: {video_path}")
+
+    # Create output directory if it doesn't exist
+    os.makedirs(output_dir, exist_ok=True)
+
+    # Get video filename without extension
+    video_name = Path(video_path).stem
+
+    # Open the video file
+    cap = cv2.VideoCapture(video_path)
+
+    if not cap.isOpened():
+        raise Exception(f"Error opening video file: {video_path}")
+
+    # Get video properties
+    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    fps = cap.get(cv2.CAP_PROP_FPS)
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+
+    print(f"Video Info:")
+    print(f" Resolution: {width}x{height}")
+    print(f" FPS: {fps:.2f}")
+    print(f" Total Frames: {total_frames}")
+
+    # Adjust num_frames if video is shorter
+    if total_frames < num_frames:
+        print(f"Warning: Video has only {total_frames} frames, adjusting to capture {total_frames} frames.")
+        num_frames = total_frames
+
+    saved_frames = []
+    for i in range(num_frames):
+        ret, frame = cap.read()
+        if not ret:
+            print(f"Error reading frame {i}")
+            break
+
+        resized_frame = cv2.resize(frame, (10, 10), interpolation=cv2.INTER_AREA)
+
+        # Save resized frame
+        frame_path = os.path.join(output_dir, f"{video_name}_frame_{i:03d}.png")
+        cv2.imwrite(frame_path, resized_frame)
+        saved_frames.append(frame_path)
+        print(f"Saved frame {i+1}/{num_frames}: {frame_path}")
+
+    cap.release()
+    return saved_frames
+
+def main():
+    parser = argparse.ArgumentParser(description="Capture and resize frames from a video to 128x128 pixels")
+    parser.add_argument("--video", required=True, help="Path to the video file")
+    parser.add_argument("--output", default="frames", help="Directory to save the frames")
+    parser.add_argument("--frames", type=int, default=3, help="Number of frames to capture from the start")
+    args = parser.parse_args()
+
+    try:
+        saved_frames = capture_frames(args.video, args.output, args.frames)
+        print(f"Successfully captured {len(saved_frames)} frames from the video")
+    except Exception as e:
+        print(f"Error: {e}")
+
+if __name__ == "__main__":
+    main()

scripts/check_queues.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""
+Quick script to check video scheduler queue sizes
+"""
+
+import sys
+import os
+
+# Add the services directory to Python path
+# sys.path.append(os.path.join(os.path.dirname(__file__), 'services', 'video_scheduler'))
+
+from services.video_scheduler.redis_utils import (
+    get_redis_connection,
+    get_5s_queue_size,
+    get_10s_queue_size,
+    get_organic_upscaling_queue_size,
+    get_organic_compression_queue_size,
+    get_pexels_queue_size,
+    get_youtube_queue_size,
+    is_scheduler_ready
+)
+
+def main():
+    """Check and display all queue sizes"""
+    try:
+        redis_conn = get_redis_connection()
+        
+        print("=" * 50)
+        print("📊 VIDEO SCHEDULER QUEUE STATUS")
+        print("=" * 50)
+        
+        # Scheduler readiness status
+        ready = is_scheduler_ready(redis_conn)
+        status_icon = "🟢" if ready else "🔴"
+        print(f"{status_icon} Scheduler Ready: {'YES' if ready else 'NO'}")
+        print()
+        
+        # Synthetic queues
+        print("🎬 SYNTHETIC QUEUES:")
+        print(f"   5s chunks:  {get_5s_queue_size(redis_conn):>4}")
+        print(f"   10s chunks: {get_10s_queue_size(redis_conn):>4}")
+        print(f"   Compressed chunks: {get_organic_compression_queue_size(redis_conn):>4}")
+        print(f"   Upscaling chunks: {get_organic_upscaling_queue_size(redis_conn):>4}")
+        print()
+        
+        # Source queues
+        print("🎥 SOURCE QUEUES:")
+        print(f"   Pexels IDs:  {get_pexels_queue_size(redis_conn):>4}")
+        print(f"   YouTube IDs: {get_youtube_queue_size(redis_conn):>4}")
+        print()
+        
+        
+        # Total counts
+        total_synthetic = get_5s_queue_size(redis_conn) + get_10s_queue_size(redis_conn) + get_organic_compression_queue_size(redis_conn) + get_organic_upscaling_queue_size(redis_conn)
+        total_source = get_pexels_queue_size(redis_conn) + get_youtube_queue_size(redis_conn)
+        
+        print("📈 TOTALS:")
+        print(f"   Total Synthetic: {total_synthetic:>4}")
+        print(f"   Total Source:    {total_source:>4}")
+        print("=" * 50)
+        
+    except Exception as e:
+        print(f"❌ Error checking queues: {str(e)}")
+        print("💡 Make sure Redis is running and accessible")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main() 

scripts/clip_video.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+"""
+Video Clipping Script
+
+This script clips a video file to exactly 19 seconds starting from the beginning.
+Uses ffmpeg for efficient video processing.
+"""
+
+import os
+import sys
+import subprocess
+from pathlib import Path
+from typing import Optional, Tuple
+import argparse
+
+def _validate_video_file(file_path: str) -> bool:
+    """
+    Validate that the input file exists and is a readable video file.
+    
+    Args:
+        file_path: Path to the video file
+        
+    Returns:
+        True if file is valid, False otherwise
+    """
+    if not os.path.exists(file_path):
+        print(f"Error: File '{file_path}' does not exist.")
+        return False
+    
+    if not os.path.isfile(file_path):
+        print(f"Error: '{file_path}' is not a file.")
+        return False
+    
+    if not os.access(file_path, os.R_OK):
+        print(f"Error: File '{file_path}' is not readable.")
+        return False
+    
+    return True
+
+def _get_video_duration(file_path: str) -> Optional[float]:
+    """
+    Get the duration of a video file using ffprobe.
+    
+    Args:
+        file_path: Path to the video file
+        
+    Returns:
+        Duration in seconds, or None if ffprobe fails
+    """
+    try:
+        cmd = [
+            'ffprobe', 
+            '-v', 'quiet', 
+            '-show_entries', 'format=duration', 
+            '-of', 'csv=p=0', 
+            file_path
+        ]
+        
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        duration = float(result.stdout.strip())
+        return duration
+    except (subprocess.CalledProcessError, ValueError, FileNotFoundError) as e:
+        print(f"Error getting video duration: {e}")
+        return None
+
+def _generate_output_filename(input_path: str) -> str:
+    """
+    Generate output filename by adding '_19s' suffix before the extension.
+    
+    Args:
+        input_path: Path to the input video file
+        
+    Returns:
+        Output filename with '_19s' suffix
+    """
+    input_path_obj = Path(input_path)
+    stem = input_path_obj.stem
+    suffix = input_path_obj.suffix
+    
+    # Create output filename
+    output_filename = f"{stem}_19s{suffix}"
+    
+    # If output would overwrite input, add timestamp
+    if output_filename == input_path_obj.name:
+        from datetime import datetime
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_filename = f"{stem}_19s_{timestamp}{suffix}"
+    
+    return output_filename
+
+def _clip_video(input_path: str, output_path: str, duration: int = 19) -> bool:
+    """
+    Clip the video to the specified duration using ffmpeg.
+    
+    Args:
+        input_path: Path to the input video file
+        output_path: Path for the output video file
+        duration: Duration to clip to in seconds (default: 19)
+        
+    Returns:
+        True if clipping was successful, False otherwise
+    """
+    try:
+        cmd = [
+            'ffmpeg',
+            '-i', input_path,
+            '-t', str(duration),
+            '-c', 'copy',  # Copy streams without re-encoding for speed
+            '-avoid_negative_ts', 'make_zero',
+            '-y',  # Overwrite output file if it exists
+            output_path
+        ]
+        
+        print(f"Cliping video to {duration} seconds...")
+        print(f"Input: {input_path}")
+        print(f"Output: {output_path}")
+        
+        # Run ffmpeg command
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        
+        print("Video clipping completed successfully!")
+        return True
+        
+    except subprocess.CalledProcessError as e:
+        print(f"Error during video clipping: {e}")
+        if e.stderr:
+            print(f"FFmpeg error: {e.stderr}")
+        return False
+    except Exception as e:
+        print(f"Unexpected error: {e}")
+        return False
+
+def clip_video_to_19s(video_path: str) -> bool:
+    """
+    Main function to clip a video file to 19 seconds.
+    
+    Args:
+        video_path: Path to the input video file
+        
+    Returns:
+        True if clipping was successful, False otherwise
+    """
+    # Validate input file
+    if not _validate_video_file(video_path):
+        return False
+    
+    # Get original video duration
+    original_duration = _get_video_duration(video_path)
+    if original_duration is None:
+        return False
+    
+    print(f"Original video duration: {original_duration:.2f} seconds")
+    
+    # Check if video is already shorter than 19 seconds
+    if original_duration <= 19:
+        print(f"Video is already {original_duration:.2f} seconds long (≤ 19s). No clipping needed.")
+        return True
+    
+    # Generate output filename
+    output_filename = _generate_output_filename(video_path)
+    output_path = os.path.join(os.path.dirname(video_path), output_filename)
+    
+    # Perform video clipping
+    success = _clip_video(video_path, output_path, 19)
+    
+    if success:
+        # Verify output file exists and get its duration
+        if os.path.exists(output_path):
+            output_duration = _get_video_duration(output_path)
+            if output_duration:
+                print(f"Output video duration: {output_duration:.2f} seconds")
+                print(f"Output saved to: {output_path}")
+            else:
+                print("Warning: Could not verify output video duration")
+        else:
+            print("Warning: Output file was not created")
+    
+    return success
+
+def main():
+    """Main entry point for command line usage."""
+    parser = argparse.ArgumentParser(
+        description="Clip a video file to 19 seconds",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  python clip_video.py video.mp4
+  python clip_video.py /path/to/video.mov
+  python clip_video.py "video with spaces.avi"
+        """
+    )
+    
+    parser.add_argument(
+        'video_path',
+        help='Path to the input video file'
+    )
+    #python clip_video.py --video_path /workspace/vidaio-subnet/2025-03-18 12-27-33.mov
+    args = parser.parse_args()
+    
+    # Perform video clipping
+    success = clip_video_to_19s(args.video_path)
+    
+    # Exit with appropriate code
+    sys.exit(0 if success else 1)
+
+if __name__ == "__main__":
+    main() 

scripts/compress_miner_king1_0.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+python neurons/miner.py \
+    --wallet.name king85 \
+    --wallet.hotkey bothot00 \
+    --subtensor.network finney \
+    --netuid 85 \
+    --axon.port 8091 \
+    --logging.debug
+

scripts/compress_miner_king85_1.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+python neurons/miner.py \
+    --wallet.name king85 \
+    --wallet.hotkey bothot01 \
+    --subtensor.network finney \
+    --netuid 85 \
+    --axon.port 8092 \
+    --logging.debug
+

scripts/compress_miner_king85_2.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+python neurons/miner.py \
+    --wallet.name king85 \
+    --wallet.hotkey bothot02 \
+    --subtensor.network finney \
+    --netuid 85 \
+    --axon.port 8093 \
+    --logging.debug
+

scripts/compress_miner_king85_3.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+python neurons/miner.py \
+    --wallet.name king85 \
+    --wallet.hotkey bothot03 \
+    --subtensor.network finney \
+    --netuid 85 \
+    --axon.port 8094 \
+    --logging.debug
+

scripts/compress_server.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+python services/custom_compress/server.py

scripts/get_video_lengths.py

@@ -0,0 +1,212 @@
+#!/usr/bin/env python3
+"""
+Video Length Scanner Script
+
+This script scans the /videos directory and prints a list of all video files
+along with their durations in a readable format.
+"""
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+def get_video_duration(file_path: str) -> Optional[float]:
+    """
+    Get the duration of a video file using ffprobe.
+    
+    Args:
+        file_path: Path to the video file
+        
+    Returns:
+        Duration in seconds, or None if ffprobe fails
+    """
+    try:
+        # Use ffprobe to get video duration
+        cmd = [
+            'ffprobe', 
+            '-v', 'quiet', 
+            '-show_entries', 'format=duration', 
+            '-of', 'csv=p=0', 
+            file_path
+        ]
+        
+        result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+        duration = float(result.stdout.strip())
+        return duration
+    except (subprocess.CalledProcessError, ValueError, FileNotFoundError):
+        return None
+
+def format_duration(seconds: float) -> str:
+    """
+    Format duration in seconds to a human-readable string.
+    
+    Args:
+        seconds: Duration in seconds
+        
+    Returns:
+        Formatted duration string (e.g., "1:23.45")
+    """
+    if seconds < 0:
+        return "Invalid"
+    
+    minutes = int(seconds // 60)
+    remaining_seconds = seconds % 60
+    
+    if minutes == 0:
+        return f"{remaining_seconds:.2f}s"
+    else:
+        return f"{minutes}:{remaining_seconds:05.2f}"
+
+def categorize_duration(seconds: float) -> str:
+    """
+    Categorize duration into chunks (e.g., 10s, 20s, 30s).
+    Videos within ±0.5 seconds of a whole number are grouped together.
+    
+    Args:
+        seconds: Duration in seconds
+        
+    Returns:
+        Category string (e.g., "10s", "20s", "1m", "2m")
+    """
+    if seconds < 0:
+        return "Invalid"
+    
+    # Round to nearest second for categorization
+    rounded_seconds = round(seconds)
+    
+    if rounded_seconds < 60:
+        return f"{rounded_seconds}s"
+    else:
+        minutes = rounded_seconds // 60
+        remaining_seconds = rounded_seconds % 60
+        if remaining_seconds == 0:
+            return f"{minutes}m"
+        else:
+            return f"{minutes}m{remaining_seconds}s"
+
+def scan_videos_directory(videos_dir: str = "videos") -> List[Tuple[str, float]]:
+    """
+    Scan the videos directory and return a list of video files with their durations.
+    
+    Args:
+        videos_dir: Path to the videos directory
+        
+    Returns:
+        List of tuples containing (filename, duration_in_seconds)
+    """
+    video_files = []
+    
+    if not os.path.exists(videos_dir):
+        print(f"Error: Directory '{videos_dir}' does not exist.")
+        return []
+    
+    # Supported video extensions
+    video_extensions = {'.mp4', '.avi', '.mov', '.mkv', '.wmv', '.flv', '.webm', '.m4v'}
+    
+    for filename in os.listdir(videos_dir):
+        file_path = os.path.join(videos_dir, filename)
+        
+        # Check if it's a file and has a video extension
+        if os.path.isfile(file_path) and Path(filename).suffix.lower() in video_extensions:
+            duration = get_video_duration(file_path)
+            if duration is not None:
+                video_files.append((filename, duration))
+            else:
+                print(f"Warning: Could not get duration for {filename}")
+    
+    return sorted(video_files, key=lambda x: x[1])  # Sort by duration
+
+def main():
+    """Main function to run the video length scanner."""
+    print("Video Length Scanner")
+    print("=" * 50)
+    
+    # Check if ffprobe is available
+    try:
+        subprocess.run(['ffprobe', '-version'], capture_output=True, check=True)
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        print("Error: ffprobe is not installed or not in PATH.")
+        print("Please install FFmpeg to use this script.")
+        print("On Ubuntu/Debian: sudo apt install ffmpeg")
+        print("On CentOS/RHEL: sudo yum install ffmpeg")
+        print("On macOS: brew install ffmpeg")
+        sys.exit(1)
+    
+    # Scan for videos
+    print("Scanning videos directory for video files...")
+    video_files = scan_videos_directory()
+    
+    if not video_files:
+        print("No video files found in /videos directory.")
+        return
+    
+    # Print results
+    print(f"\nFound {len(video_files)} video files:\n")
+    print(f"{'Filename':<50} {'Duration':<15} {'Size':<10}")
+    print("-" * 75)
+    
+    total_duration = 0
+    
+    for filename, duration in video_files:
+        # Get file size
+        file_path = os.path.join("videos", filename)
+        file_size = os.path.getsize(file_path)
+        size_mb = file_size / (1024 * 1024)
+        
+        formatted_duration = format_duration(duration)
+        print(f"{filename:<50} {formatted_duration:<15} {size_mb:.1f}MB")
+        total_duration += duration
+    
+    print("-" * 75)
+    print(f"{'Total':<50} {format_duration(total_duration):<15} {len(video_files)} files")
+    
+    # Summary statistics
+    if video_files:
+        avg_duration = total_duration / len(video_files)
+        min_duration = min(video_files, key=lambda x: x[1])[1]
+        max_duration = max(video_files, key=lambda x: x[1])[1]
+        
+        print(f"\nSummary Statistics:")
+        print(f"Average duration: {format_duration(avg_duration)}")
+        print(f"Shortest video: {format_duration(min_duration)}")
+        print(f"Longest video: {format_duration(max_duration)}")
+        
+        # Duration category summary
+        print(f"\nDuration Categories:")
+        print("=" * 40)
+        
+        # Group videos by duration category
+        duration_categories = {}
+        for filename, duration in video_files:
+            category = categorize_duration(duration)
+            if category not in duration_categories:
+                duration_categories[category] = []
+            duration_categories[category].append((filename, duration))
+        
+        # Sort categories by duration (convert to seconds for sorting)
+        def category_sort_key(cat):
+            if 'm' in cat:
+                if 's' in cat:
+                    # Format like "1m30s"
+                    parts = cat.replace('m', ' ').replace('s', '').split()
+                    return int(parts[0]) * 60 + int(parts[1])
+                else:
+                    # Format like "2m"
+                    return int(cat.replace('m', '')) * 60
+            else:
+                # Format like "30s"
+                return int(cat.replace('s', ''))
+        
+        sorted_categories = sorted(duration_categories.items(), key=lambda x: category_sort_key(x[0]))
+        
+        for category, videos in sorted_categories:
+            total_category_duration = sum(duration for _, duration in videos)
+            print(f"{category:<10} | {len(videos):>3} videos | Total: {format_duration(total_category_duration):<10} | Avg: {format_duration(total_category_duration/len(videos))}")
+        
+        print("=" * 40)
+        print(f"Total categories: {len(duration_categories)}")
+
+if __name__ == "__main__":
+    main() 

scripts/video_info_cap.py

@@ -0,0 +1,68 @@
+import subprocess
+import json
+import sys
+
+def get_video_info(file_path):
+    """
+    Get detailed video information using FFprobe.
+    :param file_path: Path to the video file
+    """
+    try:
+        # Run FFprobe to get video details in JSON format
+        command = [
+            "ffprobe",
+            "-v", "error",  # Suppress unnecessary logs
+            "-show_format",  # Show container format
+            "-show_streams",  # Show codec and stream details
+            "-count_frames",  # Count the number of frames
+            "-print_format", "json",  # Output as JSON
+            file_path
+        ]
+        
+        result = subprocess.run(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        
+        # Parse the JSON output
+        video_info = json.loads(result.stdout)
+        
+        # Print details
+        print("\n=== Video File Information ===")
+        print(f"File Path: {file_path}")
+        print("=" * 40)
+        
+        # Format information
+        if "format" in video_info:
+            format_info = video_info["format"]
+            print(f"File Format: {format_info.get('format_name', 'N/A')}")
+            print(f"File Size: {int(format_info.get('size', 0)) / (1024 ** 2):.2f} MB")
+            print(f"Duration: {float(format_info.get('duration', 0)):.2f} seconds")
+            print(f"Bitrate: {int(format_info.get('bit_rate', 0)) / 1000:.2f} kbps")
+            print(f"Compressed: {'Yes' if 'bit_rate' in format_info else 'No'}")
+        
+        print("\n=== Stream Information ===")
+        for stream in video_info.get("streams", []):
+            codec_type = stream.get("codec_type", "unknown").capitalize()
+            print(f"\nStream Type: {codec_type}")
+            print(f"Codec: {stream.get('codec_name', 'N/A')}")
+            print(f"Codec Long Name: {stream.get('codec_long_name', 'N/A')}")
+            if codec_type == "Video":
+                print(f"Resolution: {stream.get('width', 'N/A')}x{stream.get('height', 'N/A')}")
+                print(f"Frame Rate: {eval(stream.get('r_frame_rate', '0')):.2f} fps")
+                print(f"Number of Frames: {stream.get('nb_frames', 'N/A')}")
+                print(f"Pixel Format: {stream.get('pix_fmt', 'N/A')}")
+            elif codec_type == "Audio":
+                print(f"Sample Rate: {stream.get('sample_rate', 'N/A')} Hz")
+                print(f"Channels: {stream.get('channels', 'N/A')}")
+                print(f"Channel Layout: {stream.get('channel_layout', 'N/A')}")
+            print(f"Bitrate: {int(stream.get('bit_rate', 0)) / 1000:.2f} kbps")
+        
+        print("\nDetailed Info Extraction Complete.")
+    
+    except Exception as e:
+        print(f"Error: {e}")
+        sys.exit(1)
+
+# Example usage
+if __name__ == "__main__":
+    # Input video file path
+    video_path = input("Enter the path to the video file: ").strip()
+    get_video_info(video_path)

services/compress/encoder.py

@@ -0,0 +1,893 @@
+import os
+import sys
+import time
+import torch
+import pickle 
+import traceback
+import subprocess
+from sklearn.exceptions import NotFittedError
+from sklearn.preprocessing import StandardScaler
+from sklearn.utils.validation import check_is_fitted
+from utils.processing_utils import (
+    encode_scene_with_size_check,
+    classify_scene_from_path 
+)
+from utils.encode_video import encode_video
+from utils.classify_scene import load_scene_classifier_model, CombinedModel
+
+def get_cq_from_lookup_table(scene_type, config, target_vmaf=None, target_quality_level=None):
+    """
+    Look up the recommended CQ (Constant Quality) value for a scene type and target quality.
+      
+    CQ values control encoding quality:
+    - Lower CQ = Higher quality, bigger file size (CQ 15-20)
+    - Higher CQ = Lower quality, smaller file size (CQ 30-35)
+    
+    The lookup table now supports two selection modes:
+    - By explicit quality level via config['video_processing']['basic_cq_lookup_by_quality']
+    - By VMAF-derived tiers via config['video_processing']['basic_cq_lookup_tiered']
+    - High quality tier (VMAF 95+): Lower CQ values for better quality
+    - Medium quality tier (VMAF ~90): Balanced CQ values
+    - Low quality tier (VMAF ~85): Higher CQ values for smaller files
+    
+    Args:
+        scene_type (str): Scene classification from AI model
+        config (dict): Configuration containing CQ lookup tables
+    target_vmaf (float, optional): Target VMAF score for quality tier (fallback)
+    target_quality_level (str, optional): 'High'|'Medium'|'Low' to select from by-quality table
+        
+    Returns:
+        int: Recommended CQ value for encoding this scene type at target quality
+    """
+    vp = config.get('video_processing', {})
+
+    if target_quality_level:
+        norm = {'high': 'High', 'medium': 'Medium', 'low': 'Low'}
+        q_key = norm.get(str(target_quality_level).lower(), target_quality_level)
+        by_quality = vp.get('basic_cq_lookup_by_quality', {})
+        if isinstance(by_quality, dict):
+            table = by_quality.get(q_key) or by_quality.get(q_key.lower()) or {}
+            if isinstance(table, dict):
+                return table.get(scene_type, table.get('default', 25))
+
+    # Determine quality tier based on target VMAF (fallback)
+    if target_vmaf is None:
+        quality_tier = 'medium'  # Default to medium if no target specified
+    elif target_vmaf >= 93:
+        quality_tier = 'high'
+    elif target_vmaf >= 88:
+        quality_tier = 'medium'
+    else:
+        quality_tier = 'low'
+    
+    default_cq_map = {
+        # High quality tier (lower CQ = higher quality)
+        'high': {
+            'animation': 25,      # Cartoons compress well naturally
+            'low-action': 23,     # Text/faces need moderate CQ for clarity
+            'medium-action': 21,  # Balanced CQ for general content
+            'high-action': 19,    # Gaming/sports need lower CQ for quality
+            'default': 22         # Safe middle-ground when unsure
+        },
+        # Medium quality tier (balanced CQ)
+        'medium': {
+            'animation': 28,      # Cartoons compress well, can use higher CQ
+            'low-action': 26,     # Text/faces need moderate CQ for clarity
+            'medium-action': 24,  # Balanced CQ for general content
+            'high-action': 22,    # Gaming/sports need lower CQ for quality
+            'default': 25         # Safe middle-ground when unsure
+        },
+        # Low quality tier (higher CQ = smaller files)
+        'low': {
+            'animation': 31,      # Cartoons compress well, can use higher CQ
+            'low-action': 29,     # Text/faces need moderate CQ for clarity
+            'medium-action': 27,  # Balanced CQ for general content
+            'high-action': 25,    # Gaming/sports need lower CQ for quality
+            'default': 28         # Safe middle-ground when unsure
+        }
+    }
+    
+    # Get the lookup table from config, or use our defaults
+    tier_cq_maps = vp.get('basic_cq_lookup_tiered', default_cq_map)
+    
+    # Use the appropriate tier based on target quality
+    cq_lookup_table = tier_cq_maps.get(quality_tier, tier_cq_maps.get('medium', default_cq_map['medium']))
+    
+    # Return the CQ for this scene type within the selected quality tier, with fallback to default
+    return cq_lookup_table.get(scene_type, cq_lookup_table.get('default', 25))
+
+def get_scalers_from_pipeline(pipeline_path='services/compress/models/preprocessing_pipeline.pkl', 
+                             verbose=True, logging_enabled=True):
+    """
+    Load preprocessing pipeline and extract individual components with verbosity control.
+    
+    This function loads a complete scikit-learn preprocessing pipeline and extracts
+    the individual components needed for VMAF prediction:
+    - Feature scaler for normalizing video metrics
+    - VMAF scaler for converting quality scores to model range
+    - CQ (Constant Quality) parameter bounds for optimization
+    
+    The function also sets verbosity levels for all pipeline components to control
+    the amount of output during batch processing operations.
+    
+    Pipeline Structure Expected:
+        - feature_scaler: StandardScaler or similar for video features
+        - vmaf_scaler: Custom scaler for VMAF quality scores  
+        - cq_scaler: Custom scaler containing CQ parameter bounds
+        
+    Args:
+        pipeline_path (str): Path to the saved preprocessing pipeline pickle file
+        verbose (bool): Whether individual pipeline steps should produce verbose output
+        logging_enabled (bool): Master logging control (overrides verbose if False)
+        
+    Returns:
+        tuple: (pipeline_obj, feature_scaler_step, vmaf_scaler, cq_min, cq_max)
+            - pipeline_obj: Complete fitted preprocessing pipeline
+            - feature_scaler_step: Feature scaling component
+            - vmaf_scaler: VMAF scaling component  
+            - cq_min: Minimum CQ value for optimization bounds
+            - cq_max: Maximum CQ value for optimization bounds
+            Returns (None, None, None, None, None) if loading fails
+    """
+    
+    try:
+        from utils import ColumnDropper, VMAFScaler, TargetExtractor, CQScaler, ResolutionTransformer, FeatureScaler, FrameRateTransformer
+        
+        if logging_enabled:
+            print(f"✅ Preprocessing classes are available through utils module")
+            
+    except ImportError as e:
+        if logging_enabled:
+            print(f"❌ ERROR: Could not access preprocessing classes: {e}")
+            print(f"   💡 Check that utils/__init__.py properly imports data_preprocessing classes")
+        return None, None, None, None, None
+    
+    actual_verbose = verbose and logging_enabled
+    
+    pipeline_obj = None
+    feature_scaler_step = None
+    vmaf_scaler = None
+    cq_min_original, cq_max_original = None, None
+    
+    # =================================================================
+    # PIPELINE FILE LOADING AND VALIDATION
+    # =================================================================
+    if not os.path.exists(pipeline_path):
+        if actual_verbose:
+            print(f"❌ ERROR: Pipeline file not found at '{pipeline_path}'")
+            print(f"   💡 Suggestion: Ensure preprocessing pipeline exists in /models/ directory")
+        return None, None, None, None, None
+    
+    try:
+        # Load the pickled preprocessing pipeline
+        if actual_verbose:
+            print(f"📖 Loading preprocessing pipeline from: {pipeline_path}")
+            
+        # Load the pickled preprocessing pipeline with custom unpickler to handle module namespace issues
+        class CustomUnpickler(pickle.Unpickler):
+            def find_class(self, module, name):
+                if module == '__main__':
+                    if actual_verbose:
+                        print(f"   🔧 Handling __main__ context for class: {name}")
+                    # Try to get the class from utils module
+                    try:
+                        from utils import ColumnDropper, VMAFScaler, TargetExtractor, CQScaler, ResolutionTransformer, FeatureScaler, FrameRateTransformer
+                        class_map = {
+                            'ColumnDropper': ColumnDropper,
+                            'VMAFScaler': VMAFScaler,
+                            'TargetExtractor': TargetExtractor,
+                            'CQScaler': CQScaler,
+                            'ResolutionTransformer': ResolutionTransformer,
+                            'FeatureScaler': FeatureScaler,
+                            'FrameRateTransformer': FrameRateTransformer
+                        }
+                        if name in class_map:
+                            if actual_verbose:
+                                print(f"   ✅ Found {name} in utils module")
+                            return class_map[name]
+                        else:
+                            if actual_verbose:
+                                print(f"   ❌ Class {name} not found in utils module")
+                    except ImportError as e:
+                        if actual_verbose:
+                            print(f"   ❌ Failed to import from utils: {e}")
+                
+                # Handle utils.data_preprocessing module context
+                elif module == 'utils.data_preprocessing':
+                    if actual_verbose:
+                        print(f"   🔧 Handling utils.data_preprocessing context for class: {name}")
+                    try:
+                        from utils import ColumnDropper, VMAFScaler, TargetExtractor, CQScaler, ResolutionTransformer, FeatureScaler, FrameRateTransformer
+                        class_map = {
+                            'ColumnDropper': ColumnDropper,
+                            'VMAFScaler': VMAFScaler,
+                            'TargetExtractor': TargetExtractor,
+                            'CQScaler': CQScaler,
+                            'ResolutionTransformer': ResolutionTransformer,
+                            'FeatureScaler': FeatureScaler,
+                            'FrameRateTransformer': FrameRateTransformer
+                        }
+                        if name in class_map:
+                            if actual_verbose:
+                                print(f"   ✅ Found {name} in utils module")
+                            return class_map[name]
+                        else:
+                            if actual_verbose:
+                                print(f"   ❌ Class {name} not found in utils module")
+                    except ImportError as e:
+                        if actual_verbose:
+                            print(f"   ❌ Failed to import from utils: {e}")
+                
+                # For other modules, use the default behavior
+                if actual_verbose:
+                    print(f"   🔧 Using default unpickler for {module}.{name}")
+                return super().find_class(module, name)
+        
+        # Try to load with custom unpickler
+        try:
+            with open(pipeline_path, 'rb') as f:
+                unpickler = CustomUnpickler(f)
+                pipeline_obj = unpickler.load()
+            if actual_verbose:
+                print(f"   ✅ Pipeline loaded with custom unpickler")
+        except Exception as e:
+            if actual_verbose:
+                print(f"   ❌ Custom unpickler failed: {e}")
+                print(f"   🔧 Attempting to load with standard pickle...")
+            
+            # Fallback to standard pickle loading
+            with open(pipeline_path, 'rb') as f:
+                pipeline_obj = pickle.load(f)
+            
+            if actual_verbose:
+                print(f"   ✅ Pipeline loaded with standard pickle")
+            
+        if actual_verbose:
+            print(f"✅ Pipeline loaded successfully")
+        
+        def set_pipeline_verbosity(pipeline, verbose_flag):
+            """
+            Recursively set verbose parameter for all pipeline components.
+            
+            Handles nested pipelines, feature unions, column transformers,
+            and custom transformer classes.
+            """
+            if hasattr(pipeline, 'steps'):
+                # Handle sklearn Pipeline objects
+                for step_name, step_obj in pipeline.steps:
+                    set_step_verbosity(step_obj, verbose_flag, step_name)
+            elif hasattr(pipeline, 'named_steps'):
+                # Handle pipelines with named step access
+                for step_name, step_obj in pipeline.named_steps.items():
+                    set_step_verbosity(step_obj, verbose_flag, step_name)
+            else:
+                # Handle single transformer objects
+                set_step_verbosity(pipeline, verbose_flag, "pipeline")
+        
+        def set_step_verbosity(step_obj, verbose_flag, step_name="unknown"):
+            """
+            Set verbosity for a single pipeline step.
+            
+            Handles various transformer types and their verbosity parameters.
+            """
+            try:
+                # ==========================================================
+                # STANDARD VERBOSITY PARAMETERS
+                # ==========================================================
+                # Common verbose parameters found in sklearn and custom transformers
+                verbose_attrs = ['verbose', 'verbose_', 'logging_enabled']
+                
+                for attr in verbose_attrs:
+                    if hasattr(step_obj, attr):
+                        setattr(step_obj, attr, verbose_flag)
+                        if actual_verbose and verbose_flag:
+                            print(f"   🔧 Set {attr}={verbose_flag} for step '{step_name}'")
+                
+                # ==========================================================
+                # NESTED PIPELINE HANDLING
+                # ==========================================================
+                # Handle Pipeline objects nested within other pipelines
+                if hasattr(step_obj, 'steps') or hasattr(step_obj, 'named_steps'):
+                    set_pipeline_verbosity(step_obj, verbose_flag)
+                
+                # Handle wrapped transformers
+                if hasattr(step_obj, 'transformer') and step_obj.transformer is not None:
+                    set_step_verbosity(step_obj.transformer, verbose_flag, f"{step_name}.transformer")
+                
+                # ==========================================================
+                # COMPOSITE TRANSFORMER HANDLING
+                # ==========================================================
+                # Handle FeatureUnion and ColumnTransformer which contain lists of transformers
+                if hasattr(step_obj, 'transformer_list'):
+                    for name, transformer in step_obj.transformer_list:
+                        set_step_verbosity(transformer, verbose_flag, f"{step_name}.{name}")
+                
+                # ==========================================================
+                # CUSTOM TRANSFORMER SPECIFIC PARAMETERS
+                # ==========================================================
+                # Handle verbosity parameters specific to our custom transformers
+                custom_transformer_attrs = ['debug', 'show_warnings', 'print_info']
+                for attr in custom_transformer_attrs:
+                    if hasattr(step_obj, attr):
+                        setattr(step_obj, attr, verbose_flag)
+                        if actual_verbose and verbose_flag:
+                            print(f"   🎛️ Set custom {attr}={verbose_flag} for step '{step_name}'")
+                            
+            except Exception as e:
+                if actual_verbose:
+                    print(f"  ⚠️ Warning: Could not set verbosity for step '{step_name}': {e}")
+        
+        # Apply verbosity settings to the entire pipeline
+        if actual_verbose:
+            print(f"🔧 Setting verbosity to {actual_verbose} for all pipeline components...")
+        
+        set_pipeline_verbosity(pipeline_obj, actual_verbose)
+        
+        # =================================================================
+        # PIPELINE FITNESS VALIDATION
+        # =================================================================
+        # Check if the loaded pipeline has been fitted (trained)
+        # Unfitted pipelines cannot be used for transformation
+        try:
+            check_is_fitted(pipeline_obj)
+            if actual_verbose:
+                print("✅ Loaded pipeline is fitted and ready for use")
+        except NotFittedError:
+            if actual_verbose:
+                print("⚠️ WARNING: Loaded pipeline is NOT fitted!")
+                print("   🔧 Attempting to extract components anyway for fallback creation...")
+        except Exception as e:
+            if actual_verbose:
+                print(f"⚠️ Warning: Could not verify pipeline fitness: {e}")
+
+        # =================================================================
+        # FEATURE SCALER EXTRACTION
+        # =================================================================
+        # Extract the feature scaling component used for normalizing video metrics
+        feature_scaler_step = None
+        scaler_step_name = 'feature_scaler'
+        
+        # Try to find by name in named_steps
+        if hasattr(pipeline_obj, 'named_steps') and scaler_step_name in pipeline_obj.named_steps:
+            feature_scaler_step = pipeline_obj.named_steps[scaler_step_name]
+            if actual_verbose:
+                print(f"✅ Found feature scaler step: '{scaler_step_name}'")
+        
+        # Fallback: search through all steps by name or type
+        elif hasattr(pipeline_obj, 'steps'):
+            for name, step in pipeline_obj.steps:
+                if scaler_step_name in name or isinstance(step, (StandardScaler)):
+                    feature_scaler_step = step
+                    if actual_verbose:
+                        print(f"✅ Found feature scaler step: '{name}'")
+                    break
+
+        # Create default if not found
+        if feature_scaler_step is None:
+            if actual_verbose:
+                print("⚠️ Warning: Could not find feature scaler step. Creating default StandardScaler...")
+            feature_scaler_step = StandardScaler()
+
+        # =================================================================
+        # VMAF SCALER EXTRACTION
+        # =================================================================
+        # Extract the VMAF scaling component for quality score normalization
+        vmaf_scaler = None
+        vmaf_scaler_step_name = 'vmaf_scaler'
+        
+        if hasattr(pipeline_obj, 'named_steps') and vmaf_scaler_step_name in pipeline_obj.named_steps:
+            vmaf_scaler = pipeline_obj.named_steps[vmaf_scaler_step_name]
+            if actual_verbose:
+                print(f"✅ Found VMAF scaler step: '{vmaf_scaler_step_name}'")
+
+        # Create default VMAF scaler if not found
+        if vmaf_scaler is None:
+            if actual_verbose:
+                print("⚠️ Warning: Could not find VMAF scaler. Creating default...")
+                
+            class DefaultVMAFScaler:
+                """Default VMAF scaler with typical VMAF range."""
+                def __init__(self): 
+                    self.min_val, self.max_val = 20.0, 100.0  # Typical VMAF range
+                    
+            vmaf_scaler = DefaultVMAFScaler()
+            if actual_verbose:
+                print(f"   📊 Using default VMAF range: {vmaf_scaler.min_val}-{vmaf_scaler.max_val}")
+
+        # =================================================================
+        # CQ PARAMETER BOUNDS EXTRACTION
+        # =================================================================
+        # Extract CQ (Constant Quality) parameter bounds for optimization
+        default_cq_min, default_cq_max = 10, 51  # Conservative CQ range
+        cq_min, cq_max = default_cq_min, default_cq_max
+        cq_scaler_step_name = 'cq_scaler'
+
+        # Try to find CQ scaler component
+        if hasattr(pipeline_obj, 'named_steps') and cq_scaler_step_name in pipeline_obj.named_steps:
+            cq_scaler = pipeline_obj.named_steps[cq_scaler_step_name]
+            
+            # Check for CQ bounds in various attribute naming conventions
+            if hasattr(cq_scaler, 'min_cq') and hasattr(cq_scaler, 'max_cq'):
+                cq_min, cq_max = cq_scaler.min_cq, cq_scaler.max_cq
+                if actual_verbose:
+                    print(f"✅ Found CQ range in step '{cq_scaler_step_name}': {cq_min}-{cq_max}")
+            elif hasattr(cq_scaler, 'min_val') and hasattr(cq_scaler, 'max_val'):
+                cq_min, cq_max = cq_scaler.min_val, cq_scaler.max_val
+                if actual_verbose:
+                    print(f"✅ Found CQ range in scaler attributes: {cq_min}-{cq_max}")
+
+        if actual_verbose:
+            print(f"📊 Using CQ optimization range: {cq_min}-{cq_max}")
+            print(f"   💡 This range will constrain the binary search for optimal quality parameters")
+
+        return pipeline_obj, feature_scaler_step, vmaf_scaler, int(cq_min), int(cq_max)
+
+    except Exception as e:
+        if actual_verbose:
+            print(f"❌ ERROR: Failed to load or extract from pipeline '{pipeline_path}': {e}")
+            print("🔍 Detailed error information:")
+            traceback.print_exc()
+        return None, None, None, None, None
+
+def load_encoding_resources(config, logging_enabled=True):
+    """
+    
+    1. Scene classifier AI model - to identify content type (animation, gaming, etc.)
+    2. Preprocessing pipeline - to prepare video frames for the AI model
+    3. GPU/CPU device selection - for running the AI inference
+    
+    
+    Args:
+        config (dict): Configuration containing model file paths
+        logging_enabled (bool): Whether to print loading status messages
+        
+    Returns:
+        tuple: (scene_model, preprocessing_pipeline, device) ready for encoding
+    """
+    # Get model file paths from config
+    model_paths = config.get('model_paths', {})
+    scene_model_path = model_paths.get('scene_classifier_model', "services/compress/models/scene_classifier_model.pth")
+    preprocessing_pipeline_path = model_paths.get('preprocessing_pipeline', "services/compress/models/preprocessing_pipeline.pkl")
+    
+    # Choose GPU if available, otherwise use CPU
+    device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+    # Load scene classifier AI model
+    model_state_dict, available_metrics, class_mapping = load_scene_classifier_model(scene_model_path, device, logging_enabled)
+    print(f"   ✅ Scene classifier model loaded from {scene_model_path} on {device}")
+    scene_classifier_model = CombinedModel(num_classes=len(class_mapping), metrics_dim=len(available_metrics))
+    scene_classifier_model.load_state_dict(model_state_dict)
+    scene_classifier_model.to(device)
+    scene_classifier_model.eval()
+    
+    pipeline_obj, feature_scaler_step, vmaf_scaler, cq_min, cq_max = get_scalers_from_pipeline(preprocessing_pipeline_path, verbose=logging_enabled, logging_enabled=logging_enabled)
+    print(f"   ✅ Preprocessing pipeline loaded from {preprocessing_pipeline_path}")
+    
+    return {
+        "scene_classifier_model": scene_classifier_model, 
+        "available_metrics": available_metrics,           
+        "device": device,                                 
+        "class_mapping": class_mapping,                   
+        "pipeline_obj": pipeline_obj,                     
+        "feature_scaler_step": feature_scaler_step,       
+        "vmaf_scaler": vmaf_scaler,                       
+        "cq_min": cq_min,                                 
+        "cq_max": cq_max                                  
+    }
+
+def ai_encoding(scene_metadata, config, resources, target_vmaf=None, target_quality_level=None, logging_enabled=True):
+    """
+    
+    1. Use AI to classify the scene content (animation, gaming, text, etc.)
+    2. Look up a pre-determined CQ value from a table based on scene type AND quality tier
+    3. Encode the scene once with that CQ value
+    
+    - High quality tier (VMAF ~95): Lower CQ values for better quality
+    - Medium quality tier (VMAF ~90): Balanced CQ values
+    - Low quality tier (VMAF ~85): Higher CQ values for smaller files
+    
+    - Runs multiple encoding attempts with different CQ values
+    - Uses AI to predict VMAF quality for each attempt
+    - Uses binary search to find the optimal CQ
+    
+    Args:
+        scene_metadata (dict): Contains scene file path, duration, etc.
+        config (dict): Configuration settings for encoding
+        resources (dict): Pre-loaded AI models and preprocessing tools
+        target_vmaf (float): Target quality used to select appropriate quality tier
+        target_quality_level (str): Desired quality level ('High', 'Medium', 'Low') used for CQ lookup
+        logging_enabled (bool): Whether to print progress messages
+        
+    Returns:
+        tuple: (success_status, scene_data_dict)
+            - success_status: True if encoding succeeded, False otherwise
+            - scene_data_dict: Contains encoding results, file sizes, CQ used, etc.
+    """
+    logging_enabled=True
+    
+    if not scene_metadata:
+        return None, {
+            'scene_number': 0,
+            'encoding_success': False,
+            'error_reason': 'Scene metadata is None or empty',
+            'processing_time_seconds': 0.0,
+            'encoded_path': None,
+            'path': None
+        }
+    
+    def safe_float(value, default=0.0):
+        """Convert value to float, return default if invalid"""
+        if value is None: return default
+        try:
+            result = float(value)
+            return result if not (result != result) else default
+        except (TypeError, ValueError):
+            return default
+    
+    def safe_positive_float(value, default=1.0):
+        """Convert to float and ensure it's positive"""
+        result = safe_float(value, default)
+        return max(result, 0.1)
+    
+    scene_path = scene_metadata.get('path')
+    scene_number = int(safe_float(scene_metadata.get('scene_number', 1), 1))
+    start_time = safe_float(scene_metadata.get('start_time'), 0.0)
+    end_time = safe_float(scene_metadata.get('end_time'), 0.0)
+    scene_duration = safe_positive_float(scene_metadata.get('duration'), 1.0)
+    
+    if end_time <= start_time or scene_duration <= 0:
+        if end_time > start_time:
+            scene_duration = end_time - start_time
+        else:
+            try:
+                cmd = ['ffprobe', '-v', 'quiet', '-show_entries', 'format=duration', '-of', 'csv=p=0', scene_path]
+                result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, timeout=10)
+                if result.returncode == 0 and result.stdout.strip():
+                    scene_duration = safe_positive_float(result.stdout.strip(), 1.0)
+                    end_time = start_time + scene_duration
+                else:
+                    scene_duration = 1.0
+            except Exception:
+                scene_duration = 1.0
+
+    is_very_short_scene = scene_duration < 1.0
+    if is_very_short_scene and logging_enabled:
+        print(f"   ⚠️ Very short scene detected ({scene_duration:.1f}s) - using special handling")
+
+    original_video_metadata = scene_metadata.get('original_video_metadata', {})
+    
+    if logging_enabled:
+        print(f"\n🎬 Processing Scene {scene_number}")
+        print(f"   📁 File: {os.path.basename(scene_path) if scene_path else 'None'}")
+        print(f"   ⏱️ Timing: {start_time:.1f}s - {end_time:.1f}s (duration: {scene_duration:.1f}s)")
+
+    if not scene_path or not os.path.exists(scene_path) or os.path.getsize(scene_path) == 0:
+        return None, {
+            'scene_number': scene_number,
+            'encoding_success': False,
+            'error_reason': 'Scene file is missing, empty, or inaccessible',
+            'processing_time_seconds': 0.0,
+            'encoded_path': None,
+            'path': scene_path
+        }
+
+    processing_start_time = time.time()
+    
+    # Get temporary directory for intermediate files
+    temp_dir = config.get('directories', {}).get('temp_dir', './videos/temp_scenes')
+    
+    if not target_quality_level:
+        target_quality_level = original_video_metadata.get('target_quality') or config.get('video_processing', {}).get('target_quality')
+    target_vmaf = safe_float(target_vmaf or original_video_metadata.get('target_vmaf') or 
+                           config.get('video_processing', {}).get('target_vmaf', 0.0), 0.0)
+
+    original_codec = original_video_metadata.get('original_codec', 'unknown')
+    target_codec_from_part1 = original_video_metadata.get('target_codec', 'auto')
+    current_codec = original_video_metadata.get('codec', original_codec)
+    config_codec = config.get('video_processing', {}).get('codec', 'auto')
+    
+    if target_codec_from_part1 and target_codec_from_part1 != 'auto':
+        codec = target_codec_from_part1
+    elif config_codec != 'auto':
+        codec = config_codec
+    else:
+        codec_upgrade_map = {'h264': 'av1_nvenc', 'hevc': 'av1_nvenc', 'vp9': 'av1_nvenc', 'av1': 'av1_nvenc'}
+        codec = codec_upgrade_map.get(current_codec.lower(), 'av1_nvenc')
+
+    if logging_enabled:
+        print(f"   🎥 Selected Codec: {codec}")
+
+    # STEP 1: BASIC ANALYSIS - Classify scene and extract video features in one call
+    if logging_enabled:
+        print(f"   🤖 Running scene classification and feature extraction...")
+    
+    scene_type = 'default'
+    confidence_score = 0.0
+    video_features = {}
+    detailed_results = {}
+    try:
+        classification_result = classify_scene_from_path(
+            scene_path=scene_path,
+            temp_dir=temp_dir,
+            scene_classifier_model=resources['scene_classifier_model'],
+            available_metrics=resources['available_metrics'],
+            device=resources['device'],
+            metrics_scaler=resources['feature_scaler_step'],
+            class_mapping=resources['class_mapping'],
+            logging_enabled=logging_enabled,
+        )
+        
+        # Handle the tuple return from classify_scene_from_path (now returns 3 items)
+        if isinstance(classification_result, tuple) and len(classification_result) == 3:
+            scene_type, detailed_results, video_features = classification_result
+            confidence_score = detailed_results.get('confidence_score', 0.0)
+        elif isinstance(classification_result, tuple) and len(classification_result) == 2:
+            # Fallback for older return format
+            scene_type, detailed_results = classification_result
+            confidence_score = detailed_results.get('confidence_score', 0.0)
+            video_features = {}
+        elif isinstance(classification_result, dict):
+            # Fallback if it returns a dict instead of tuple
+            scene_type = classification_result.get('scene_type', 'default')
+            confidence_score = classification_result.get('confidence_score', 0.0)
+            video_features = {}
+        else:
+            # Unknown return type, use defaults
+            scene_type = 'default'
+            confidence_score = 0.0
+            video_features = {}
+
+        if logging_enabled:
+            print(f"   🎭 Scene classified as: '{scene_type}' (Confidence: {confidence_score:.2f})")
+            if video_features:
+                print(f"   📊 Video features extracted: {len(video_features)} metrics")
+
+    except Exception as e:
+        if logging_enabled:
+            print(f"   ❌ Scene classification failed: {e}")
+            traceback.print_exc()
+    
+    # Map the scene type to lookup table key
+    original_scene_type = scene_type
+    mapped_scene_type = map_scene_type_to_lookup_key(scene_type)
+    
+    if logging_enabled and original_scene_type != mapped_scene_type:
+        print(f"   🔄 Mapped scene type '{original_scene_type}' -> '{mapped_scene_type}' for CQ lookup")
+    
+    # Get quality tier information for logging
+    print(f"   🎯 Target quality level: {target_quality_level}")
+    # If only quality level provided, derive indicative VMAF for logging purposes
+    if target_quality_level and not target_vmaf:
+        target_vmaf = get_target_vmaf_from_quality(target_quality_level)
+        if logging_enabled:
+            print(f"   ℹ️ Indicative VMAF from quality level '{target_quality_level}': {target_vmaf}")
+    
+    # Get CQ from lookup table using mapped scene type and target quality/VMAF
+    base_cq = get_cq_from_lookup_table(
+        mapped_scene_type,
+        config,
+        target_vmaf=target_vmaf,
+        target_quality_level=target_quality_level,
+    )
+    
+    # Log quality tier and CQ selection
+    if logging_enabled:
+        # Determine label for logging
+        if target_quality_level:
+            tier_label = str(target_quality_level).upper()
+        else:
+            if target_vmaf >= 93:
+                tier_label = "HIGH"
+            elif target_vmaf >= 88:
+                tier_label = "MEDIUM"
+            else:
+                tier_label = "LOW"
+
+        print(f"   🎯 Using quality tier: {tier_label} (Indicative VMAF: {target_vmaf if target_vmaf else 'n/a'})")
+        print(f"   🎚️ Base CQ from lookup table for '{mapped_scene_type}' at {tier_label} quality: {base_cq}")
+    
+    # Apply conservative adjustment from config
+    conservative_cq_adjustment = safe_float(config.get('video_processing', {}).get('conservative_cq_adjustment', 2), 2)
+    final_cq = min(base_cq + conservative_cq_adjustment, 51.0)
+    if logging_enabled:
+        print(f"   🔧 Applied conservative adjustment: +{conservative_cq_adjustment} -> Final CQ: {final_cq}")
+
+    # Create a placeholder scene_data object
+    scene_data = {
+        'path': scene_path,
+        'scene_number': scene_number,
+        'start_time': start_time,
+        'end_time': end_time,
+        'duration': scene_duration,
+        'original_video_metadata': original_video_metadata,
+        'scene_type': original_scene_type,  # Keep original scene type from classifier
+        'mapped_scene_type': mapped_scene_type,  # Add mapped scene type for CQ lookup
+        'confidence_score': confidence_score,
+    'optimal_cq': base_cq,
+        'adjusted_cq': final_cq,
+        'final_adjusted_cq': final_cq,
+        'codec_selection_process': {'final_selected_codec': codec},
+    'model_training_data': {}, # Placeholder
+        'target_quality_level': target_quality_level,
+    'base_cq_for_quality': base_cq,
+    }
+
+    if scene_duration < 1.0:
+        output_scene_path = os.path.join(
+            temp_dir,
+            f"encoded_scene_{scene_number:03d}_{start_time:.1f}s-{end_time:.1f}s_{codec.lower()}.mp4"
+        )
+    else:
+        output_scene_path = os.path.join(
+            temp_dir,
+            f"encoded_scene_{scene_number:03d}_{start_time:.0f}s-{end_time:.0f}s_{codec.lower()}.mp4"
+        )
+    os.makedirs(temp_dir, exist_ok=True)
+
+    size_increase_protection = config.get('video_processing', {}).get('size_increase_protection', True)
+    max_encoding_retries = int(safe_float(config.get('video_processing', {}).get('max_encoding_retries', 2), 2))
+    
+    encoding_start_time = time.time()
+    encoded_path = None
+    encoding_time = 0
+
+    if size_increase_protection:
+        if logging_enabled:
+            print(f"   🛡️ Size increase protection enabled")
+        try:
+            encoded_path, encoding_time = encode_scene_with_size_check(
+                scene_path=scene_path,
+                output_path=output_scene_path,
+                codec=codec,
+                adjusted_cq=final_cq,
+                content_type=scene_type,
+                contrast_value=0.5, 
+                max_retries=max_encoding_retries,
+                logging_enabled=logging_enabled
+            )
+        except Exception as e:
+            if logging_enabled:
+                print(f"   ❌ Size-protected encoding failed: {e}")
+    else:
+        if logging_enabled:
+            print(f"   ⚡ Standard encoding (size protection disabled)")
+        try:
+            _, encoding_time = encode_video(
+                input_path=scene_path,
+                output_path=output_scene_path,
+                codec=codec,
+                rate=final_cq,
+                scene_type=scene_type,
+                contrast_value=0.5, # Default contrast
+                logging_enabled=logging_enabled
+            )
+            encoded_path = output_scene_path
+        except Exception as e:
+            if logging_enabled:
+                print(f"   ❌ Standard encoding failed: {e}")
+
+    # Final update of scene_data
+    encoding_success = bool(encoded_path and os.path.exists(encoded_path) and os.path.getsize(encoded_path) > 0)
+    scene_data['encoding_success'] = encoding_success
+    scene_data['encoded_path'] = encoded_path if encoding_success else None
+    scene_data['encoding_time'] = safe_float(encoding_time, 0)
+    scene_data['processing_time_seconds'] = time.time() - processing_start_time
+    
+    # Add file size information and codec details
+    if encoding_success:
+        # Calculate file sizes in MB
+        input_file_size = os.path.getsize(scene_path) if os.path.exists(scene_path) else 0
+        output_file_size = os.path.getsize(encoded_path) if os.path.exists(encoded_path) else 0
+        
+        scene_data['input_size_mb'] = input_file_size / (1024 * 1024)
+        scene_data['encoded_file_size_mb'] = output_file_size / (1024 * 1024)
+        
+        # Calculate compression ratio
+        if input_file_size > 0:
+            compression_ratio = ((output_file_size - input_file_size) / input_file_size) * 100
+            scene_data['compression_ratio'] = compression_ratio
+        else:
+            scene_data['compression_ratio'] = 0
+        
+        # Store codec information for filename generation
+        scene_data['codec_used'] = codec
+    else:
+        scene_data['input_size_mb'] = 0
+        scene_data['encoded_file_size_mb'] = 0
+        scene_data['compression_ratio'] = 0
+        scene_data['codec_used'] = 'unknown'
+
+
+    scene_data['model_training_data'] = {
+        'raw_video_features': video_features,
+        'processed_video_features': {},  
+        'vmaf_model_features': {},       
+        'scene_classifier_features': video_features,
+        'scene_classifier_probabilities': detailed_results,
+        'processing_timings': {
+            'total_processing_time': time.time() - processing_start_time,
+            'encoding_time': safe_float(encoding_time, 0) if 'encoding_time' in locals() else 0
+        }
+    }
+
+    if encoding_success:
+        if logging_enabled:
+            print(f"   ✅ Scene {scene_number} encoded successfully.")
+        return encoded_path, scene_data
+    else:
+        if logging_enabled:
+            print(f"   ❌ Encoding failed for scene {scene_number}.")
+        scene_data['error_reason'] = 'Encoding process failed or produced an empty file'
+        return None, scene_data
+
+def map_scene_type_to_lookup_key(scene_type):
+    """
+    Convert AI scene classifier output to CQ lookup table keys.
+    
+    The AI scene classifier returns descriptive names like:
+    - 'Screen Content / Text' 
+    - 'Animation / Cartoon / Rendered Graphics'
+    - 'Faces / People'
+    - 'Gaming Content'
+    - 'other'
+    - 'unclear'
+    
+    But our CQ lookup table uses simpler keys:
+    - 'animation' (for cartoons/rendered content)
+    - 'low-action' (for text/faces - less motion)
+    - 'medium-action' (for general content)
+    - 'high-action' (for gaming/sports - lots of motion)
+    - 'default' (fallback for unclear content)
+    
+    Args:
+        scene_type (str): Output from AI scene classifier
+        
+    Returns:
+        str: Corresponding lookup table key
+    """
+    scene_lower = scene_type.lower() if scene_type else 'default'
+    
+    scene_mapping = {
+        'screen content / text': 'low-action',        # Text doesn't need high quality
+        'animation / cartoon / rendered graphics': 'animation',  # Cartoons compress well
+        'faces / people': 'low-action',               # Faces need clarity but less motion
+        'gaming content': 'high-action',              # Games have lots of motion/detail
+        'other': 'medium-action',                     # General content gets medium quality
+        'unclear': 'default',                        # When unsure, use safe default
+        'default': 'default'
+    }
+    
+    if scene_lower in scene_mapping:
+        return scene_mapping[scene_lower]
+    
+    for key, value in scene_mapping.items():
+        if key in scene_lower or scene_lower in key:
+            return value
+    
+    return 'default'
+
+def get_target_vmaf_from_quality(quality_level):
+    """
+    Map quality level to target VMAF score for Basic AI encoding.
+    
+
+    Quality Level Mappings:
+    - High: 95 VMAF (Maximum quality preservation)
+    - Medium: 90 VMAF (Balanced quality and file size)
+    - Low: 85 VMAF (Aggressive compression for smaller files)
+    
+    Args:
+        quality_level (str): Target quality level ('High', 'Medium', 'Low')
+    
+    Returns:
+        float: Target VMAF score for the specified quality level
+    """
+    quality_vmaf_map = {
+        'High': 95.0,
+        'Medium': 90.0,
+        'Low': 85.0
+    }
+    
+    return quality_vmaf_map.get(quality_level, 90.0)
+
+

services/compress/models/preprocessing_pipeline.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:341e6c97c4092410edfd7ec9ba64f4d8916e397768138a345530ee2bcca95333
+size 3594

services/compress/models/scene_classifier_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c31861eae4d5e39dd4e54994e44bc34a099342f237ee96548d6d663f3f10e3df
+size 11130108

services/compress/scene_detector.py

@@ -0,0 +1,614 @@
+import os
+import json
+import subprocess
+from utils.fast_scene_detect import adaptive_scene_detection_check
+from utils.split_video_into_scenes import split_video_into_scenes
+from utils.video_utils import get_keyframes
+
+def scene_detection(video_metadata):
+    """
+    Part 2: Scene detection based on video length using metadata from part 1.
+    
+    Args:
+        video_metadata (dict): Metadata from part1_pre_processing containing:
+                              - 'path': video file path
+                              - 'codec': current video codec
+                              - 'original_codec': original codec (if reencoded)
+                              - 'target_codec': target codec for encoding (NEW)
+                              - 'duration': video duration in seconds
+                              - 'was_reencoded': boolean
+                              - 'target_vmaf': target VMAF score
+                              - 'target_quality': target quality level
+                              - 'processing_info': processing details
+        
+    Returns:
+        list: List of scene metadata dictionaries, each containing:
+              - 'path': scene file path
+              - 'scene_number': scene index (1-based)
+              - 'start_time': scene start time in seconds
+              - 'end_time': scene end time in seconds
+              - 'duration': scene duration in seconds
+              - 'original_video_metadata': complete metadata from part 1
+    """
+    # Load configuration
+    try:
+        with open('services/compress/config.json', 'r') as f:
+            config = json.load(f)
+        print("✅ Configuration loaded successfully")
+    except FileNotFoundError:
+        print("⚠️ Config file not found, using default configuration")
+        config = {
+            'directories': {
+                'temp_dir': './videos/temp_scenes',
+                'output_dir': './output'
+            },
+            'video_processing': {
+                'SHORT_VIDEO_THRESHOLD': 20,
+                'target_vmaf': 93.0
+            },
+            'scene_detection': {
+                'enable_time_based_fallback': True,
+                'time_based_scene_duration': 60
+            }
+        }
+    
+    # Extract metadata
+    video_path = video_metadata['path']
+    duration = video_metadata['duration']
+    codec = video_metadata['codec']
+    original_codec = video_metadata.get('original_codec', codec)
+    target_codec = video_metadata.get('target_codec', 'auto') 
+    print("***********target_codec", target_codec) # ✅ NEW: Extract target codec
+    was_reencoded = video_metadata.get('was_reencoded', False)
+    target_vmaf = video_metadata.get('target_vmaf', 93.0)
+    target_quality = video_metadata.get('target_quality', 'Medium')
+
+    print(f"🎬 Processing video: {os.path.basename(video_path)}")
+    print(f"   ⏱️ Duration: {duration:.1f}s, Codec: {codec}, Reencoded: {was_reencoded}")
+    print(f"   🎯 Target: {target_quality} (VMAF: {target_vmaf})")
+    print(f"   🎥 Codec flow: {original_codec} → {codec} → {target_codec}")  # ✅ NEW: Show codec flow
+    
+    # Get processing configuration
+    video_processing_config = config.get('video_processing', {})
+    short_video_threshold = video_processing_config.get('SHORT_VIDEO_THRESHOLD', 20)
+    # Get directories from config only
+    temp_dir = config.get('directories', {}).get('temp_dir', './videos/temp_scenes')
+    
+    if duration <= short_video_threshold:
+        print(f"📏 Video is shorter than {short_video_threshold}s. Treating as a single scene.")
+        return [{
+            'path': video_metadata['path'],
+            'scene_number': 1,
+            'start_time': 0.0,
+            'end_time': duration,
+            'duration': duration,
+            'original_video_metadata': video_metadata  # ✅ Pass complete metadata including target_codec
+        }]
+    scene_config = config.get('scene_detection', {})
+    detection_mode = scene_config.get('mode', 'adaptive').lower()
+    
+    print(f"   🔍 Scene detection mode: {detection_mode}")
+    
+    if detection_mode == 'force_time_based':
+        # Force time-based splitting regardless of content
+        force_duration = scene_config.get('force_time_based_duration', 10)
+        print(f"   ⏰ Forcing time-based splitting with {force_duration}s segments")
+        return force_time_based_splitting(video_path, temp_dir, force_duration, duration, video_metadata)
+    
+    elif detection_mode == 'adaptive':
+        # Original adaptive scene detection logic
+        print(f"   🔍 Running adaptive scene detection...")
+        has_multiple_scenes, estimated_scenes, _ = adaptive_scene_detection_check(
+            video_path, duration, logging_enabled=True
+        )
+
+        if has_multiple_scenes:
+            print(f"   ✅ Multiple scenes detected ({estimated_scenes} estimated). Proceeding with full scene splitting.")
+            scene_files, _ = split_video_into_scenes(video_path, temp_dir)
+            
+            if scene_files and len(scene_files) > 1:
+                print(f"   📄 Created {len(scene_files)} scene files")
+                return create_scene_metadata_from_files(scene_files, video_metadata, config)
+            else:
+                print(f"   ⚠️ Scene splitting failed or found only 1 scene. Falling back to time-based splitting.")
+                return time_based_splitting(video_path, temp_dir, config, duration, video_metadata)
+        else:
+            print(f"   📏 Single scene detected.")
+            enable_fallback = scene_config.get('enable_time_based_fallback', False)
+            
+            if enable_fallback:
+                print(f"   🔄 Time-based fallback enabled. Attempting time-based scene splitting...")
+                return time_based_splitting(video_path, temp_dir, config, duration, video_metadata)
+            else:
+                print(f"   ✅ Using single scene (time-based fallback disabled)")
+                return [{
+                    'path': video_path,
+                    'scene_number': 1,
+                    'start_time': 0.0,
+                    'end_time': duration,
+                    'duration': duration,
+                    'original_video_metadata': video_metadata  # ✅ Pass complete metadata including target_codec
+                }]
+    
+    else:
+        print(f"   ❌ Unknown scene detection mode: {detection_mode}. Falling back to adaptive.")
+        # Fallback to adaptive mode
+        print(f"   🔍 Running adaptive scene detection...")
+        has_multiple_scenes, estimated_scenes, _ = adaptive_scene_detection_check(
+            video_path, duration, logging_enabled=True
+        )
+
+        if has_multiple_scenes:
+            print(f"   ✅ Multiple scenes detected ({estimated_scenes} estimated). Proceeding with full scene splitting.")
+            scene_files, _ = split_video_into_scenes(video_path, temp_dir)
+            
+            if scene_files and len(scene_files) > 1:
+                print(f"   📄 Created {len(scene_files)} scene files")
+                return create_scene_metadata_from_files(scene_files, video_metadata, config)
+            else:
+                print(f"   ⚠️ Scene splitting failed or found only 1 scene. Falling back to time-based splitting.")
+                return time_based_splitting(video_path, temp_dir, config, duration, video_metadata)
+        else:
+            print(f"   📏 Single scene detected. Using single scene.")
+            return [{
+                'path': video_path,
+                'scene_number': 1,
+                'start_time': 0.0,
+                'end_time': duration,
+                'duration': duration,
+                'original_video_metadata': video_metadata  # ✅ Pass complete metadata including target_codec
+            }]
+
+def force_time_based_splitting(video_path, temp_dir, segment_duration, total_duration, original_metadata, logging_enabled=True):
+    """
+    Force time-based splitting with keyframe-aligned boundaries to prevent stuttering.
+    
+    Args:
+        video_path (str): Path to the video file
+        temp_dir (str): Temporary directory for scene files
+        segment_duration (float): Target duration for each segment in seconds
+        total_duration (float): Total video duration in seconds
+        original_metadata (dict): Complete metadata from Part 1
+        logging_enabled (bool): Enable detailed logging
+    
+    Returns:
+        list: List of scene metadata dictionaries
+    """
+    if logging_enabled:
+        print(f"\n--- Force time-based splitting: {segment_duration}s segments ---")
+        print(f"   🎥 Source codec: {original_metadata.get('codec', 'unknown')}")
+        print(f"   ⏱️ Total duration: {total_duration:.1f}s")
+        print(f"   ✂️ Segment duration: {segment_duration}s")
+    
+    # Get keyframes for precise cutting
+    try:
+        keyframes = get_keyframes(video_path)
+        if logging_enabled:
+            print(f"   🔑 Found {len(keyframes)} keyframes for alignment")
+    except Exception as e:
+        # Try alternative import path
+        try:
+            keyframes = get_keyframes(video_path)
+            if logging_enabled:
+                print(f"   🔑 Found {len(keyframes)} keyframes for alignment")
+        except Exception as e2:
+            keyframes = []
+            if logging_enabled:
+                print(f"   ⚠️ Could not get keyframes: {e}")
+                print(f"   📐 Using time-based boundaries (may cause stuttering)")
+    
+    # Calculate scene boundaries, preferring keyframe alignment
+    scene_boundaries = []
+    current_start = 0
+    
+    while current_start < total_duration:
+        target_end = min(current_start + segment_duration, total_duration)
+        
+        # If we have keyframes, find the closest keyframe to target_end
+        if keyframes and target_end < total_duration:
+            # Find keyframe closest to target_end
+            closest_keyframe = min(keyframes, key=lambda kf: abs(kf - target_end))
+            
+            # Only use keyframe if it's reasonably close (within 2 seconds)
+            if abs(closest_keyframe - target_end) <= 2.0 and closest_keyframe > current_start:
+                scene_end = closest_keyframe
+            else:
+                scene_end = target_end
+        else:
+            scene_end = target_end
+        
+        # Handle very short final segments (< 2 seconds) by merging with previous scene
+        remaining_duration = total_duration - scene_end
+        if remaining_duration > 0 and remaining_duration < 2.0 and scene_boundaries:
+            # Extend current scene to end of video instead of creating tiny final scene
+            scene_end = total_duration
+            if logging_enabled:
+                print(f"   🔧 Merging final {remaining_duration:.1f}s with current scene to avoid stuttering")
+        
+        scene_boundaries.append((current_start, scene_end))
+        current_start = scene_end
+    
+    if logging_enabled:
+        print(f"   📊 Will create {len(scene_boundaries)} segments:")
+        for i, (start, end) in enumerate(scene_boundaries):
+            print(f"      Segment {i+1}: {start:.1f}s - {end:.1f}s (duration: {end-start:.1f}s)")
+    
+    # If only one scene, return original video
+    if len(scene_boundaries) <= 1:
+        if logging_enabled:
+            print(f"   📏 Video shorter than segment duration, using as single scene")
+        return [{
+            'path': video_path,
+            'scene_number': 1,
+            'start_time': 0.0,
+            'end_time': total_duration,
+            'duration': total_duration,
+            'original_video_metadata': original_metadata
+        }]
+    
+    # Create output directory
+    os.makedirs(temp_dir, exist_ok=True)
+    
+    # Choose scene file extension based on source codec
+    source_codec = original_metadata.get('codec', 'h264').lower()
+    if source_codec in ['ffv1', 'prores', 'dnxhd']:
+        scene_extension = '.mkv'  # Use MKV for lossless codecs
+    elif source_codec in ['av1', 'vp9']:
+        scene_extension = '.webm'  # Use WebM for modern codecs
+    else:
+        scene_extension = '.mp4'  # Default to MP4 for compatibility
+    
+    if logging_enabled:
+        print(f"   📦 Using {scene_extension} container for {source_codec} codec")
+    
+    # Split video and create metadata
+    scene_metadata_list = []
+    
+    for i, (start_time_sec, end_time_sec) in enumerate(scene_boundaries):
+        scene_number = i + 1
+        scene_filename = f"scene_{scene_number:03d}_time_{start_time_sec:.0f}s{scene_extension}"
+        scene_path = os.path.join(temp_dir, scene_filename)
+        
+        duration_scene = end_time_sec - start_time_sec
+        
+        # FFmpeg command with precise cutting to prevent frame alignment issues
+        # Use input seeking for efficiency and output seeking for precision
+        cmd = [
+            'ffmpeg', '-y',
+            '-ss', str(start_time_sec),     # Input seeking for efficiency
+            '-i', video_path,
+            '-t', str(duration_scene),      # Precise duration
+            '-avoid_negative_ts', 'make_zero',
+            '-fflags', '+genpts',           # Generate presentation timestamps
+            '-map', '0:v:0',                # Map video stream explicitly
+            '-map', '0:a?',                 # Map audio if exists (optional)
+        ]
+        
+        # Add codec-specific format options before encoding
+        format_options = []
+        if source_codec == 'ffv1':
+            format_options.extend(['-f', 'matroska'])
+        elif source_codec in ['av1', 'vp9']:
+            format_options.extend(['-f', 'webm'])
+        
+        # Always use fast re-encoding to ensure clean cuts and prevent stuttering
+        # Stream copy can cause artifacts at scene boundaries even with keyframe alignment
+        cmd.extend([
+            '-c:v', 'libx264',
+            '-preset', 'ultrafast',
+            '-crf', '18',
+            '-c:a', 'copy'
+        ])
+        cmd.extend(format_options)  # Add format options
+        cmd.append(scene_path)      # Add output file path
+        
+        if logging_enabled:
+            print(f"   ✂️ Creating segment {scene_number}: {scene_filename}")
+        
+        try:
+            # Execute FFmpeg command
+            result = subprocess.run(cmd, capture_output=True, text=True, timeout=300)
+            
+            if result.returncode == 0:
+                # Verify file exists and has content
+                if os.path.exists(scene_path) and os.path.getsize(scene_path) > 0:
+                    file_size_mb = os.path.getsize(scene_path) / (1024 * 1024)
+                    
+                    scene_metadata = {
+                        'path': scene_path,
+                        'scene_number': scene_number,
+                        'start_time': start_time_sec,
+                        'end_time': end_time_sec,
+                        'duration': duration_scene,
+                        'scene_codec': source_codec,
+                        'scene_container': scene_extension[1:],  # Remove the dot
+                        'file_size_mb': file_size_mb,
+                        'scene_detection_method': 'force_time_based',
+                        'original_video_metadata': original_metadata
+                    }
+                    scene_metadata_list.append(scene_metadata)
+                    
+                    if logging_enabled:
+                        print(f"      ✅ Created: {scene_filename} ({file_size_mb:.1f} MB)")
+                else:
+                    if logging_enabled:
+                        print(f"      ❌ Failed: {scene_filename} (file not created or empty)")
+            else:
+                if logging_enabled:
+                    print(f"      ❌ FFmpeg failed for {scene_filename}: {result.stderr}")
+                
+        except subprocess.TimeoutExpired:
+            if logging_enabled:
+                print(f"      ❌ Timeout creating {scene_filename}")
+        except Exception as e:
+            if logging_enabled:
+                print(f"      ❌ Error creating {scene_filename}: {e}")
+    
+    if not scene_metadata_list:
+        if logging_enabled:
+            print(f"   ❌ All segment creation failed, using original video as single scene")
+        return [{
+            'path': video_path,
+            'scene_number': 1,
+            'start_time': 0.0,
+            'end_time': total_duration,
+            'duration': total_duration,
+            'original_video_metadata': original_metadata
+        }]
+    
+    if logging_enabled:
+        print(f"   ✅ Successfully created {len(scene_metadata_list)} time-based segments")
+    
+    return scene_metadata_list
+
+def time_based_splitting(video_path, temp_dir, config, duration, original_metadata, logging_enabled=True):
+    """
+    Split video into scenes and return metadata for each scene.
+    
+    Args:
+        video_path (str): Path to the video file
+        temp_dir (str): Temporary directory for scene files
+        config (dict): Configuration dictionary
+        duration (float): Video duration in seconds
+        original_metadata (dict): Complete metadata from Part 1 including codec info
+        logging_enabled (bool): Enable detailed logging
+    
+    Returns:
+        list: List of scene metadata dictionaries
+    """
+    if logging_enabled:
+        print(f"\n--- Running time-based scene splitting with metadata ---")
+        # ✅ NEW: Log codec information for scene splitting
+        print(f"   🎥 Source codec: {original_metadata.get('codec', 'unknown')}")
+        print(f"   🎯 Target codec: {original_metadata.get('target_codec', 'auto')}")
+    
+    try:
+        total_duration = duration
+        if logging_enabled:
+            print(f"Using provided duration: {total_duration:.1f}s")
+        
+        if not total_duration:
+            return [{
+                'path': video_path,
+                'scene_number': 1,
+                'start_time': 0.0,
+                'end_time': duration,
+                'duration': duration,
+                'original_video_metadata': original_metadata
+            }]
+        
+        # Get scene duration from config
+        scene_config = config.get('scene_detection', {})
+        scene_duration = scene_config.get('time_based_scene_duration', None)
+        
+        # Auto-calculate scene duration if not specified
+        if scene_duration is None:
+            if total_duration <= 120:
+                scene_duration = 60
+            elif total_duration <= 600:
+                scene_duration = 120
+            elif total_duration <= 1800:
+                scene_duration = 300
+            else:
+                scene_duration = 600
+            
+            if logging_enabled:
+                print(f"Auto-calculated scene duration: {scene_duration}s for {total_duration:.1f}s video")
+        
+        # Calculate scene boundaries
+        scene_boundaries = []
+        current_start = 0
+        
+        while current_start < total_duration:
+            scene_end = min(current_start + scene_duration, total_duration)
+            scene_boundaries.append((current_start, scene_end))
+            current_start = scene_end
+        
+        if logging_enabled:
+            print(f"Calculated {len(scene_boundaries)} time-based scenes:")
+            for i, (start, end) in enumerate(scene_boundaries):
+                print(f"  Scene {i+1}: {start:.1f}s - {end:.1f}s (duration: {end-start:.1f}s)")
+        
+        # If only one scene, return original video
+        if len(scene_boundaries) <= 1:
+            return [{
+                'path': video_path,
+                'scene_number': 1,
+                'start_time': 0.0,
+                'end_time': total_duration,
+                'duration': total_duration,
+                'original_video_metadata': original_metadata
+            }]
+        
+        # Create output directory
+        os.makedirs(temp_dir, exist_ok=True)
+        
+        # ✅ IMPROVED: Choose scene file extension based on source codec
+        source_codec = original_metadata.get('codec', 'h264').lower()
+        if source_codec in ['ffv1', 'prores', 'dnxhd']:
+            scene_extension = '.mkv'  # Use MKV for lossless codecs
+        elif source_codec in ['av1', 'vp9']:
+            scene_extension = '.webm'  # Use WebM for modern codecs
+        else:
+            scene_extension = '.mp4'  # Default to MP4 for compatibility
+        
+        if logging_enabled:
+            print(f"   📦 Using {scene_extension} container for {source_codec} codec")
+        
+        # Split video and create metadata
+        scene_metadata_list = []
+        
+        for i, (start_time_sec, end_time_sec) in enumerate(scene_boundaries):
+            scene_number = i + 1
+            scene_filename = f"scene_{scene_number:03d}{scene_extension}"
+            scene_path = os.path.join(temp_dir, scene_filename)
+            
+            duration_scene = end_time_sec - start_time_sec
+            
+            # ✅ IMPROVED: FFmpeg command with codec-aware copy settings
+            cmd = [
+                'ffmpeg', '-y',
+                '-ss', str(start_time_sec),
+                '-i', video_path,
+                '-t', str(duration_scene),
+                '-c', 'copy',  # Stream copy for speed
+                '-map', '0',   # Copy all streams
+                '-avoid_negative_ts', 'make_zero',
+                scene_path
+            ]
+            
+            # ✅ NEW: Add codec-specific options if needed
+            if source_codec == 'ffv1':
+                # For FFV1, ensure proper MKV muxing
+                cmd.extend(['-f', 'matroska'])
+            elif source_codec in ['av1', 'vp9']:
+                # For modern codecs, ensure proper WebM muxing
+                cmd.extend(['-f', 'webm'])
+            
+            if logging_enabled:
+                print(f"Extracting scene {scene_number}/{len(scene_boundaries)}: {start_time_sec:.1f}s-{end_time_sec:.1f}s")
+            
+            try:
+                result = subprocess.run(
+                    cmd, 
+                    stdout=subprocess.PIPE, 
+                    stderr=subprocess.PIPE, 
+                    text=True, 
+                    check=True
+                )
+                
+                if os.path.exists(scene_path) and os.path.getsize(scene_path) > 0:
+                    # Create scene metadata
+                    scene_metadata = {
+                        'path': scene_path,
+                        'scene_number': scene_number,
+                        'start_time': start_time_sec,
+                        'end_time': end_time_sec,
+                        'duration': duration_scene,
+                        'original_video_metadata': original_metadata,  # ✅ Complete metadata including codec info
+                        'file_size_mb': os.path.getsize(scene_path) / (1024 * 1024),
+                        'scene_codec': source_codec,  # ✅ NEW: Track scene codec
+                        'scene_container': scene_extension[1:]  # ✅ NEW: Track container format
+                    }
+                    scene_metadata_list.append(scene_metadata)
+                    
+                    if logging_enabled:
+                        print(f"  ✅ Created: {scene_filename} ({scene_metadata['file_size_mb']:.1f} MB)")
+                else:
+                    if logging_enabled:
+                        print(f"  ❌ Failed: {scene_filename}")
+                        
+            except subprocess.CalledProcessError as e:
+                if logging_enabled:
+                    print(f"  ❌ FFmpeg error for scene {scene_number}: {e.stderr}")
+                continue
+            except Exception as e:
+                if logging_enabled:
+                    print(f"  ❌ Unexpected error for scene {scene_number}: {e}")
+                continue
+        
+        if logging_enabled:
+            print(f"Time-based splitting completed: {len(scene_metadata_list)} scenes created")
+            if scene_metadata_list:
+                total_size = sum(scene['file_size_mb'] for scene in scene_metadata_list)
+                print(f"   📊 Total scenes size: {total_size:.1f} MB")
+        
+        return scene_metadata_list if scene_metadata_list else [{
+            'path': video_path,
+            'scene_number': 1,
+            'start_time': 0.0,
+            'end_time': total_duration,
+            'duration': total_duration,
+            'original_video_metadata': original_metadata
+        }]
+        
+    except Exception as e:
+        if logging_enabled:
+            print(f"Time-based splitting failed: {e}")
+        return [{
+            'path': video_path,
+            'scene_number': 1,
+            'start_time': 0.0,
+            'end_time': duration,
+            'duration': duration,
+            'original_video_metadata': original_metadata
+        }]
+
+def create_scene_metadata_from_files(scene_files, original_metadata, config):
+    """
+    Create metadata for scenes created by PySceneDetect.
+    Note: PySceneDetect doesn't give us exact timing, so we estimate.
+    
+    Args:
+        scene_files (list): List of scene file paths
+        original_metadata (dict): Complete metadata from Part 1 including codec info
+        config (dict): Configuration dictionary
+    
+    Returns:
+        list: List of scene metadata dictionaries
+    """
+    scene_metadata_list = []
+    total_duration = original_metadata['duration']
+    source_codec = original_metadata.get('codec', 'unknown')
+    
+    if not scene_files:
+        return [{
+            'path': original_metadata['path'],
+            'scene_number': 1,
+            'start_time': 0.0,
+            'end_time': total_duration,
+            'duration': total_duration,
+            'original_video_metadata': original_metadata
+        }]
+    
+    # Estimate timing based on file count (not perfect, but reasonable)
+    estimated_scene_duration = total_duration / len(scene_files)
+    
+    print(f"   🎥 Creating metadata for {len(scene_files)} scenes from {source_codec} source")
+    
+    for i, scene_file in enumerate(scene_files):
+        scene_number = i + 1
+        start_time = i * estimated_scene_duration
+        end_time = min((i + 1) * estimated_scene_duration, total_duration)
+        
+        # Adjust last scene to cover remaining time
+        if i == len(scene_files) - 1:
+            end_time = total_duration
+        
+        # ✅ NEW: Extract scene file extension for container tracking
+        scene_extension = os.path.splitext(scene_file)[1][1:] if os.path.splitext(scene_file)[1] else 'unknown'
+        
+        scene_metadata = {
+            'path': scene_file,
+            'scene_number': scene_number,
+            'start_time': start_time,
+            'end_time': end_time,
+            'duration': end_time - start_time,
+            'original_video_metadata': original_metadata,  # ✅ Complete metadata including codec info
+            'file_size_mb': os.path.getsize(scene_file) / (1024 * 1024) if os.path.exists(scene_file) else 0,
+            'scene_codec': source_codec,  # ✅ NEW: Track scene codec
+            'scene_container': scene_extension  # ✅ NEW: Track container format
+        }
+        scene_metadata_list.append(scene_metadata)
+    
+    return scene_metadata_list

services/compress/server.py

@@ -0,0 +1,798 @@
+"""
+Video Compression Service API Server
+
+This module provides a FastAPI server for video compression services.
+It handles video upload, compression, and storage operations.
+"""
+
+import json
+import os
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Optional
+
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from loguru import logger
+
+from video_preprocessor import pre_processing
+from scene_detector import scene_detection
+from encoder import ai_encoding, load_encoding_resources
+from vmaf_calculator import scene_vmaf_calculation
+from validator_merger import validation_and_merging
+from vidaio_subnet_core.utilities import storage_client, download_video
+from vidaio_subnet_core import CONFIG
+
+
+# ============================================================================
+# FastAPI Application Setup
+# ============================================================================
+
+app = FastAPI(title="Video Compression Service", version="1.0.0")
+
+
+# ============================================================================
+# Data Models
+# ============================================================================
+
+class CompressPayload(BaseModel):
+    """Payload for video compression requests."""
+    payload_url: str
+    vmaf_threshold: float
+    target_quality: str = 'Medium'  # High, Medium, Low
+    max_duration: int = 3600  # Maximum allowed video duration in seconds
+    output_dir: str = './output'  # Output directory for final files
+
+
+class TestCompressPayload(BaseModel):
+    """Payload for test compression requests."""
+    video_path: str
+
+
+# ============================================================================
+# API Endpoints
+# ============================================================================
+
+@app.post("/compress-video")
+async def compress_video(video: CompressPayload):
+    """
+    Compress a video from a URL payload.
+    
+    Args:
+        video: Compression request payload
+        
+    Returns:
+        dict: Compression results with uploaded video URL
+    """
+    print(f"video url: {video.payload_url}")
+    print(f"vmaf threshold: {video.vmaf_threshold}")
+    
+    # Download video from URL
+    input_path = await download_video(video.payload_url)
+    input_file = Path(input_path)
+    vmaf_threshold = video.vmaf_threshold
+
+    # Map VMAF threshold to target quality
+    if vmaf_threshold == 85:
+        target_quality = 'Low'
+    elif vmaf_threshold == 90:
+        target_quality = 'Medium'
+    elif vmaf_threshold == 95:
+        target_quality = 'High'
+    else:
+        raise HTTPException(status_code=400, detail="Invalid VMAF threshold.")
+
+    # Validate input file
+    if not input_file.is_file():
+        raise HTTPException(status_code=400, detail="Input video file does not exist.")
+
+    # Create output directory
+    output_dir = Path(video.output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Perform video compression
+    try:
+        compressed_video_path = video_compressor(
+            input_file=str(input_file),
+            target_quality=target_quality,
+            max_duration=video.max_duration,
+            output_dir=str(output_dir)
+        )
+        print(f"compressed_video_path: {compressed_video_path}")
+
+        if compressed_video_path and Path(compressed_video_path).exists():
+            # Upload compressed video to storage
+            try:
+                compressed_video_name = os.path.basename(compressed_video_path)
+                object_name: str = compressed_video_name
+                
+                # Upload file
+                await storage_client.upload_file(object_name, compressed_video_path)
+                print(f"object_name: {object_name}")
+                print("Video uploaded successfully.")
+                
+                # Clean up local file
+                if os.path.exists(compressed_video_path):
+                    os.remove(compressed_video_path)
+                    print(f"{compressed_video_path} has been deleted.")
+                else:
+                    print(f"{compressed_video_path} does not exist.")
+                
+                # Get sharing link
+                sharing_link: Optional[str] = await storage_client.get_presigned_url(object_name)
+                print(f"sharing_link: {sharing_link}")
+                
+                if not sharing_link:
+                    print("Upload failed")
+                    return {"uploaded_video_url": None}
+                
+                return {
+                    "uploaded_video_url": sharing_link,
+                    "status": "success",
+                    "compressed_video_path": str(compressed_video_path)
+                }
+            except Exception as upload_error:
+                raise HTTPException(
+                    status_code=500, 
+                    detail=f"Failed to upload compressed video: {str(upload_error)}"
+                )
+        else:
+            raise HTTPException(status_code=500, detail="Video compression failed")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Video compression error: {str(e)}")
+
+
+@app.post("/test-compress")
+async def test_compress_video(test_payload: TestCompressPayload):
+    """
+    Test endpoint for video compression using local video path.
+    
+    Args:
+        test_payload: Test compression request payload
+        
+    Returns:
+        dict: Test compression results
+    """
+    video_path = Path(test_payload.video_path)
+    
+    # Validate input file
+    if not video_path.is_file():
+        raise HTTPException(
+            status_code=400, 
+            detail=f"Video file does not exist: {video_path}"
+        )
+    
+    try:
+        # Perform test compression
+        compressed_video_path = test_video_compression(str(video_path))
+        
+        if compressed_video_path and Path(compressed_video_path).exists():
+            return {
+                "status": "success",
+                "message": "Video compression test completed successfully",
+                "input_path": str(video_path),
+                "output_path": compressed_video_path,
+                "output_size_mb": round(
+                    Path(compressed_video_path).stat().st_size / (1024 * 1024), 2
+                )
+            }
+        else:
+            raise HTTPException(status_code=500, detail="Video compression test failed")
+            
+    except Exception as e:
+        raise HTTPException(
+            status_code=500, 
+            detail=f"Video compression test error: {str(e)}"
+        )
+
+
+# ============================================================================
+# Core Video Compression Functions
+# ============================================================================
+
+def video_compressor(
+    input_file: str, 
+    target_quality: str = 'Medium', 
+    max_duration: int = 3600, 
+    output_dir: str = './output'
+) -> Optional[str]:
+    """
+    Main video compression pipeline orchestrator.
+    
+    Args:
+        input_file: Path to input video file
+        target_quality: Target quality level ('High', 'Medium', 'Low')
+        max_duration: Maximum allowed video duration in seconds
+        output_dir: Output directory for final files
+        
+    Returns:
+        str: Path to compressed video file, or None if failed
+    """
+    # Record pipeline start time
+    pipeline_start_time = time.time()
+    
+    # Get current directory and setup paths
+    current_dir = os.path.dirname(os.path.abspath(__file__))
+    output_dir_path = Path(output_dir)
+    output_dir_path.mkdir(parents=True, exist_ok=True)
+    
+    # Load configuration
+    config = _load_configuration(current_dir)
+    config['directories']['output_dir'] = str(output_dir_path)
+    if 'video_processing' not in config:
+        config['video_processing'] = {}
+    config['video_processing']['target_quality'] = target_quality
+
+    # Create temp directory
+    temp_dir = Path(config['directories']['temp_dir'])
+    temp_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Display pipeline information
+    _display_pipeline_info(input_file, target_quality, max_duration, output_dir)
+
+    # PART 1: Pre-processing
+    part1_result = _execute_preprocessing(input_file, target_quality, max_duration, output_dir_path)
+    if not part1_result:
+        print("❌ Part 1 failed. Pipeline terminated.")
+        return False
+    
+    part1_time = time.time() - pipeline_start_time
+    _display_preprocessing_results(part1_result, part1_time)
+
+    # PART 2: Scene Detection
+    part2_start_time = time.time()
+    scenes_metadata = scene_detection(part1_result)
+    if not scenes_metadata:
+        print("❌ Part 2 failed. Pipeline terminated.")
+        return False
+    
+    part2_time = time.time() - part2_start_time
+    _display_scene_detection_results(scenes_metadata, part2_time)
+
+    # PART 3: AI Encoding
+    part3_result = _execute_ai_encoding(scenes_metadata, config, target_quality)
+    if not part3_result:
+        print("❌ Part 3 failed completely. Pipeline terminated.")
+        return False
+    
+    part3_time = part3_result['processing_time']
+    encoded_scenes_data = part3_result['encoded_scenes_data']
+    successful_encodings = part3_result['successful_encodings']
+
+    # PART 4: Validation and Merging
+    part4_result = _execute_validation_and_merging(
+        part1_result, encoded_scenes_data, config
+    )
+    if not part4_result:
+        print("❌ Part 4 failed. Could not create final video.")
+        return False
+    
+    part4_time = part4_result['processing_time']
+    final_video_path = part4_result['final_video_path']
+    final_vmaf = part4_result['final_vmaf']
+    comprehensive_report = part4_result['comprehensive_report']
+    
+    _display_validation_results(part4_result)
+
+    # Pipeline completion summary
+    total_pipeline_time = time.time() - pipeline_start_time
+    _display_pipeline_summary(
+        input_file, final_video_path, part1_result, scenes_metadata,
+        successful_encodings, output_dir, pipeline_start_time,
+        part1_time, part2_time, part3_time, part4_time, total_pipeline_time,
+        final_vmaf, comprehensive_report
+    )
+    
+    return final_video_path
+
+
+def test_video_compression(video_path: str) -> Optional[str]:
+    """
+    Test function for video compression using default parameters.
+    
+    Args:
+        video_path: Path to input video file
+        
+    Returns:
+        str: Path to compressed video file, or None if failed
+    """
+    print(f"\n🧪 === Testing Video Compression ===")
+    print(f"   📁 Input: {video_path}")
+    print(f"   🎯 Using default test parameters")
+    
+    # Default test parameters
+    test_params = {
+        'target_quality': 'Medium',
+        'max_duration': 3600,
+        'output_dir': './test_output'
+    }
+    
+    try:
+        # Validate input file
+        input_path = Path(video_path)
+        if not input_path.is_file():
+            print(f"❌ Input file does not exist: {video_path}")
+            return None
+        # Create test output directory
+        test_output_dir = Path(test_params['output_dir'])
+        test_output_dir.mkdir(parents=True, exist_ok=True)
+        
+        # Perform compression
+        result = video_compressor(
+            input_file=str(input_path),
+            target_quality=test_params['target_quality'],
+            max_duration=test_params['max_duration'],
+            output_dir=str(test_output_dir)
+        )
+        
+        if result and Path(result).exists():
+            print(f"\n✅ Test completed successfully!")
+            print(f"   📁 Compressed video: {result}")
+            return result
+        else:
+            print(f"\n❌ Test failed - no output file generated")
+            return None
+            
+    except Exception as e:
+        print(f"\n❌ Test failed with exception: {e}")
+        return None
+
+
+# ============================================================================
+# Helper Functions
+# ============================================================================
+
+def _load_configuration(current_dir: str) -> dict:
+    """Load configuration from config.json or use defaults."""
+    try:
+        config_path = os.path.join(current_dir, 'config.json')
+        with open(config_path, 'r') as f:
+            config = json.load(f)
+        print("✅ Configuration loaded successfully")
+        return config
+    except FileNotFoundError:
+        print("⚠️ Config file not found, using default configuration")
+        return _get_default_config()
+
+
+def _get_default_config() -> dict:
+    """Get default configuration when config.json is not available."""
+    return {
+        'directories': {
+            'temp_dir': './videos/temp_scenes',
+            'output_dir': './output'
+        },
+        'video_processing': {
+            'SHORT_VIDEO_THRESHOLD': 20,
+            'target_vmaf': 93.0,
+            'codec': 'auto',
+            'size_increase_protection': True,
+            'conservative_cq_adjustment': 2,
+            'max_output_size_ratio': 1.15,
+            'max_encoding_retries': 2,
+            'basic_cq_lookup_by_quality': {
+                'High': {
+                    'animation': 22,
+                    'low-action': 20,
+                    'medium-action': 18,
+                    'high-action': 16,
+                    'default': 19
+                },
+                'Medium': {
+                    'animation': 25,
+                    'low-action': 23,
+                    'medium-action': 21,
+                    'high-action': 19,
+                    'default': 22
+                },
+                'Low': {
+                    'animation': 28,
+                    'low-action': 26,
+                    'medium-action': 24,
+                    'high-action': 22,
+                    'default': 25
+                }
+            },
+        },
+        'scene_detection': {
+            'enable_time_based_fallback': True,
+            'time_based_scene_duration': 90
+        },
+        'vmaf_calculation': {
+            'calculate_full_video_vmaf': True,
+            'vmaf_use_sampling': True,
+            'vmaf_num_clips': 3,
+            'vmaf_clip_duration': 2
+        },
+        'output_settings': {
+            'save_individual_scene_reports': True,
+            'save_comprehensive_report': True
+        },
+        'model_paths': {
+            'scene_classifier_model': 'services/compress/models/scene_classifier_model.pth'
+        }
+    }
+
+
+def _display_pipeline_info(input_file: str, target_quality: str, max_duration: int, output_dir: str):
+    """Display pipeline initialization information."""
+    print(f"\n🎬 === AI Video Compression Pipeline ===")
+    print(f"   📁 Input: {Path(input_file).name}")
+    print(f"   🎯 Target Quality: {target_quality}")
+    print(f"   ⏱️ Max Duration: {max_duration}s")
+    print(f"   📁 Output Dir: {output_dir}")
+    print(f"   🕐 Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+
+
+def _execute_preprocessing(input_file: str, target_quality: str, max_duration: int, output_dir_path: Path) -> Optional[dict]:
+    """Execute Part 1: Pre-processing."""
+    print(f"\n🔧 === Part 1: Pre-processing ===")
+    part1_start_time = time.time()
+    
+    part1_result = pre_processing(
+        video_path=input_file,
+        target_quality=target_quality,
+        max_duration=max_duration,
+        output_dir=output_dir_path,
+        codec='libsvtav1'
+    )
+    
+    print("part1_result", part1_result)
+    return part1_result
+
+
+def _display_preprocessing_results(part1_result: dict, part1_time: float):
+    """Display Part 1 results."""
+    print(f"\n✅ Part 1 completed in {part1_time:.1f}s:")
+    print(f"   📁 Video: {os.path.basename(part1_result['path'])}")
+    print(f"   🎥 Codec: {part1_result['codec']} (original: {part1_result['original_codec']})")
+    print(f"   ⏱️ Duration: {part1_result['duration']:.1f}s")
+    print(f"   🔄 Reencoded: {part1_result['was_reencoded']}")
+    print(f"   🎯 Target VMAF: {part1_result['target_vmaf']} ({part1_result['target_quality']})")
+    
+    if part1_result['was_reencoded']:
+        print(f"   🔄 Lossless conversion: {part1_result['processing_info']['original_format']} → {part1_result['processing_info']['standardized_format']}")
+        print(f"   ⏱️ Encoding time: {part1_result['encoding_time']:.1f}s")
+
+
+def _display_scene_detection_results(scenes_metadata: list, part2_time: float):
+    """Display Part 2 results."""
+    print(f"\n✅ Part 2 completed in {part2_time:.1f}s: {len(scenes_metadata)} scenes detected")
+    
+    # Display scene information
+    total_scene_size = 0
+    for scene in scenes_metadata:
+        scene_size = scene.get('file_size_mb', 0)
+        total_scene_size += scene_size
+        print(f"   Scene {scene['scene_number']}: {scene['start_time']:.1f}s - {scene['end_time']:.1f}s "
+              f"(duration: {scene['duration']:.1f}s)")
+        if scene_size > 0:
+            print(f"      📁 File: {os.path.basename(scene['path'])} ({scene_size:.1f} MB)")
+        else:
+            print(f"      📁 File: {os.path.basename(scene['path'])}")
+    
+    if total_scene_size > 0:
+        print(f"   📊 Total scene files: {total_scene_size:.1f} MB")
+
+
+def _execute_ai_encoding(scenes_metadata: list, config: dict, target_quality: str) -> Optional[dict]:
+    """Execute Part 3: AI Encoding."""
+    print(f"\n🧠 === Part 3: AI Encoding ===")
+    part3_start_time = time.time()
+    
+    print(f"   🔧 Loading AI models and resources...")
+    print(f"   📋 Using quality-based CQ lookup tables for {target_quality} quality")
+    print(f"   🎯 Target Quality Level: {target_quality}")
+    
+    # Display CQ ranges for selected quality level
+    quality_info = {
+        'High': {'vmaf': 95, 'cq_range': '16-22'},
+        'Medium': {'vmaf': 93, 'cq_range': '19-25'},
+        'Low': {'vmaf': 90, 'cq_range': '22-28'}
+    }
+    
+    if target_quality in quality_info:
+        info = quality_info[target_quality]
+        print(f"   🎚️ CQ Range for {target_quality}: {info['cq_range']} (Target VMAF: {info['vmaf']})")
+    
+    print(f"   🔧 Loading AI models and resources...")
+    
+    try:
+        resources = load_encoding_resources(config, logging_enabled=True)
+        print(f"   ✅ AI resources loaded successfully")
+        print(f"   🧠 Mode: Scene classification + CQ lookup table")
+    except Exception as e:
+        print(f"   ❌ Failed to load GGG AI resources: {e}")
+        return None
+    
+    # Process each scene individually
+    encoded_scenes_data = []
+    successful_encodings = 0
+    failed_encodings = 0
+    total_input_size = 0
+    total_output_size = 0
+    
+    print(f"\n   📊 Processing {len(scenes_metadata)} scenes with AI approach...")
+    
+    for i, scene_metadata in enumerate(scenes_metadata):
+        scene_result = _process_single_scene(
+            scene_metadata, i, len(scenes_metadata), config, resources, target_quality
+        )
+        
+        if scene_result['success']:
+            successful_encodings += 1
+            total_input_size += scene_result['input_size_mb']
+            total_output_size += scene_result['output_size_mb']
+        else:
+            failed_encodings += 1
+        
+        encoded_scenes_data.append(scene_result['scene_data'])
+    
+    part3_time = time.time() - part3_start_time
+    
+    # Display Part 3 summary
+    _display_ai_encoding_summary(
+        successful_encodings, failed_encodings, len(scenes_metadata),
+        part3_time, target_quality, total_input_size, total_output_size
+    )
+    
+    if successful_encodings == 0:
+        print("❌ Part 3 failed completely. No scenes were encoded. Pipeline terminated.")
+        return None
+    
+    return {
+        'encoded_scenes_data': encoded_scenes_data,
+        'successful_encodings': successful_encodings,
+        'failed_encodings': failed_encodings,
+        'processing_time': part3_time,
+        'total_input_size': total_input_size,
+        'total_output_size': total_output_size
+    }
+
+
+def _process_single_scene(scene_metadata: dict, scene_index: int, total_scenes: int, 
+                         config: dict, resources: dict, target_quality: str) -> dict:
+    """Process a single scene for AI encoding."""
+    scene_number = scene_metadata['scene_number']
+    scene_path = scene_metadata['path']
+    scene_duration = scene_metadata['duration']
+    
+    print(f"\n   🎬 Scene {scene_number}/{total_scenes}: {os.path.basename(scene_path)}")
+    print(f"      ⏱️ Duration: {scene_duration:.1f}s")
+    
+    indicative_vmaf = scene_metadata['original_video_metadata'].get('target_vmaf')
+    print(f"      🎯 Target Quality: {target_quality}" + (f" (VMAF≈{indicative_vmaf})" if indicative_vmaf else ""))
+    print(f"      🧠 Method: scene classification + CQ lookup")
+    
+    scene_start_time = time.time()
+    
+    try:
+        encoded_path, scene_data = ai_encoding(
+            scene_metadata=scene_metadata,
+            config=config,
+            resources=resources,
+            target_vmaf=None,
+            target_quality_level=target_quality,
+            logging_enabled=True
+        )
+        
+        scene_processing_time = time.time() - scene_start_time
+        
+        if encoded_path and scene_data.get('encoding_success', False):
+            size_mb = scene_data.get('encoded_file_size_mb', 0)
+            input_size_mb = scene_data.get('input_size_mb', 0)
+            compression = scene_data.get('compression_ratio', 0)
+            
+            print(f"      ✅ Scene {scene_number} encoded successfully")
+            print(f"         📁 Output: {os.path.basename(encoded_path)}")
+            print(f"         📊 Size: {input_size_mb:.1f} MB → {size_mb:.1f} MB ({compression:+.1f}% compression)")
+            print(f"         🎭 Scene type: {scene_data.get('scene_type', 'unknown')}")
+            print(f"         🎯 Quality: {scene_data.get('target_quality_level', target_quality)}")
+            print(f"         🎚️ CQ used: {scene_data.get('base_cq_for_quality', 'N/A')} → {scene_data.get('final_adjusted_cq', 'unknown')} (after adjustment)")
+            print(f"         📋 Method: Quality-based lookup table CQ selection")
+            print(f"         ⏱️ Processing: {scene_processing_time:.1f}s")
+            
+            # Update scene metadata
+            scene_metadata['encoded_path'] = encoded_path
+            scene_metadata['encoding_data'] = scene_data
+            
+            return {
+                'success': True,
+                'scene_data': scene_data,
+                'input_size_mb': input_size_mb,
+                'output_size_mb': size_mb
+            }
+        else:
+            error_reason = scene_data.get('error_reason', 'Unknown error')
+            print(f"      ❌ Scene {scene_number} encoding failed: {error_reason}")
+            print(f"         ⏱️ Processing: {scene_processing_time:.1f}s")
+            
+            scene_metadata['encoded_path'] = None
+            scene_metadata['encoding_data'] = scene_data
+            
+            return {
+                'success': False,
+                'scene_data': scene_data,
+                'input_size_mb': 0,
+                'output_size_mb': 0
+            }
+            
+    except Exception as e:
+        scene_processing_time = time.time() - scene_start_time
+        print(f"      ❌ Scene {scene_number} processing failed with exception: {e}")
+        print(f"         ⏱️ Processing: {scene_processing_time:.1f}s")
+        
+        error_scene_data = {
+            'scene_number': scene_number,
+            'encoding_success': False,
+            'error_reason': f'Exception: {str(e)}',
+            'processing_time_seconds': scene_processing_time,
+            'encoded_path': None,
+            'original_video_metadata': scene_metadata['original_video_metadata']
+        }
+        
+        scene_metadata['encoded_path'] = None
+        scene_metadata['encoding_data'] = error_scene_data
+        
+        return {
+            'success': False,
+            'scene_data': error_scene_data,
+            'input_size_mb': 0,
+            'output_size_mb': 0
+        }
+
+
+def _display_ai_encoding_summary(successful_encodings: int, failed_encodings: int, total_scenes: int,
+                                part3_time: float, target_quality: str, total_input_size: float, total_output_size: float):
+    """Display Part 3 summary."""
+    print(f"\n   📊 Part 3 Processing Summary:")
+    print(f"      ✅ Successful encodings: {successful_encodings}")
+    print(f"      ❌ Failed encodings: {failed_encodings}")
+    print(f"      📈 Success rate: {successful_encodings/total_scenes*100:.1f}%")
+    print(f"      ⏱️ Total processing time: {part3_time:.1f}s")
+    print(f"      🎯 Quality Level: {target_quality}")
+    print(f"      🧠 AI Method: Scene classification + quality-based CQ lookup")
+    
+    if total_input_size > 0 and total_output_size > 0:
+        overall_compression = (1 - total_output_size / total_input_size) * 100
+        print(f"      🗜️ Overall compression: {overall_compression:+.1f}%")
+        print(f"      📊 Total size: {total_input_size:.1f} MB → {total_output_size:.1f} MB")
+    
+    print(f"✅ Part 3 completed with {successful_encodings} successful encodings")
+
+
+def _execute_validation_and_merging(part1_result: dict, encoded_scenes_data: list, config: dict) -> Optional[dict]:
+    """Execute Part 4: Validation and Merging."""
+    part4_start_time = time.time()
+    
+    try:
+        final_video_path, final_vmaf, comprehensive_report = validation_and_merging(
+            original_video_path=part1_result['path'],
+            encoded_scenes_data=encoded_scenes_data,
+            config=config,
+            logging_enabled=True
+        )
+        
+        part4_time = time.time() - part4_start_time
+        
+        if final_video_path and os.path.exists(final_video_path):
+            return {
+                'final_video_path': final_video_path,
+                'final_vmaf': final_vmaf,
+                'comprehensive_report': comprehensive_report,
+                'processing_time': part4_time
+            }
+        else:
+            print("❌ Part 4 failed. Could not create final video.")
+            return None
+            
+    except Exception as e:
+        print(f"❌ Part 4 failed with exception: {e}")
+        return None
+
+
+def _display_validation_results(part4_result: dict):
+    """Display Part 4 results."""
+    final_video_path = part4_result['final_video_path']
+    final_vmaf = part4_result['final_vmaf']
+    comprehensive_report = part4_result['comprehensive_report']
+    part4_time = part4_result['processing_time']
+    
+    print(f"✅ Part 4 completed successfully in {part4_time:.1f}s!")
+    print(f"   📁 Final video: {os.path.basename(final_video_path)}")
+    
+    if final_vmaf:
+        print(f"   🎯 Final VMAF: {final_vmaf:.2f}")
+    
+    if comprehensive_report:
+        compression_info = comprehensive_report.get('compression_metrics', {})
+        final_compression = compression_info.get('overall_compression_ratio_percent', 0)
+        final_size = compression_info.get('final_file_size_mb', 0)
+        
+        print(f"   🗜️ Overall compression: {final_compression:+.1f}%")
+        print(f"   📊 Final file size: {final_size:.1f} MB")
+
+
+def _display_pipeline_summary(input_file: str, final_video_path: str, part1_result: dict,
+                            scenes_metadata: list, successful_encodings: int, output_dir: str,
+                            pipeline_start_time: float, part1_time: float, part2_time: float,
+                            part3_time: float, part4_time: float, total_pipeline_time: float,
+                            final_vmaf: Optional[float], comprehensive_report: Optional[dict]):
+    """Display complete pipeline summary."""
+    print(f"\n🎉 === Pipeline Completed Successfully ===")
+    print(f"   📁 Input video: {os.path.basename(input_file)}")
+    print(f"   📁 Final video: {os.path.basename(final_video_path)}")
+    print(f"   🎯 Target quality: {part1_result['target_quality']} (VMAF: {part1_result['target_vmaf']})")
+    print(f"   📊 Scenes processed: {len(scenes_metadata)} total, {successful_encodings} successful")
+    print(f"   📁 Output directory: {output_dir}")
+    print(f"   🕐 Completed: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+    
+    # Performance breakdown
+    print(f"\n   ⏱️ Performance Breakdown:")
+    print(f"      Part 1 (Pre-processing): {part1_time:.1f}s")
+    print(f"      Part 2 (Scene Detection): {part2_time:.1f}s")
+    print(f"      Part 3 (AI Encoding): {part3_time:.1f}s")
+    print(f"      Part 4 (Validation & Merging): {part4_time:.1f}s")  
+    print(f"      Total Pipeline Time: {total_pipeline_time:.1f}s")
+    
+    # Final file size comparison
+    input_file_path = Path(input_file)
+    final_video_path_obj = Path(final_video_path)
+    if input_file_path.exists() and final_video_path_obj.exists():
+        input_size = input_file_path.stat().st_size / (1024 * 1024)
+        output_size = final_video_path_obj.stat().st_size / (1024 * 1024)
+        final_compression = (1 - output_size / input_size) * 100
+        
+        print(f"\n   📊 Final Size Comparison:")
+        print(f"      Input: {input_size:.1f} MB")
+        print(f"      Output: {output_size:.1f} MB")
+        print(f"      Compression: {final_compression:+.1f}%")
+        
+        if final_compression > 0:
+            print(f"      💾 Space saved: {input_size - output_size:.1f} MB")
+    
+    # Quality achievement summary
+    if final_vmaf and comprehensive_report:
+        quality_info = comprehensive_report.get('quality_metrics', {})
+        scenes_meeting_target = quality_info.get('scenes_meeting_target', 0)
+        avg_scene_vmaf = quality_info.get('average_scene_vmaf', 0)
+        
+        print(f"\n   🎯 Quality Achievement:")
+        print(f"      Final VMAF: {final_vmaf:.2f}")
+        print(f"      Average Scene VMAF: {avg_scene_vmaf:.2f}")
+        print(f"      Scenes meeting target: {scenes_meeting_target}/{len(scenes_metadata)}")
+        
+        if 'prediction_accuracy_stats' in comprehensive_report.get('scene_analysis', {}):
+            pred_stats = comprehensive_report['scene_analysis']['prediction_accuracy_stats']
+            avg_error = pred_stats.get('average_prediction_error')
+            if avg_error:
+                print(f"      AI prediction accuracy: ±{avg_error:.1f} VMAF points")
+    
+    # Report file locations
+    if comprehensive_report:
+        print(f"\n   📄 Reports Generated:")
+        print(f"      📁 Output directory: {output_dir}")
+        print(f"      📊 Comprehensive report: comprehensive_processing_report_*.json")
+        print(f"      📄 Individual scene reports: scene_reports/scene_*_report.json")
+    
+    print(f"\n   🎉 Pipeline completed successfully!")
+    print(f"   🚀 Ready for playback: {final_video_path}")
+
+
+# ============================================================================
+# Main Execution
+# ============================================================================
+
+if __name__ == "__main__":
+    # import uvicorn
+
+    # logger.info("Starting video compressor server")
+    # logger.info(f"Video compressor server running on http://{CONFIG.video_compressor.host}:{CONFIG.video_compressor.port}")
+
+    # uvicorn.run(app, host=CONFIG.video_compressor.host, port=CONFIG.video_compressor.port)
+
+    result = test_video_compression('/home/85/test_video/0cb873d6-4c3a-4ced-84e9-87939b08565d.mp4')
+    print(result)
+
+    #python services/compress/server.py

services/compress/utils/__init__.py

@@ -0,0 +1,34 @@
+from .video_utils import (
+    get_video_duration, 
+)
+
+from .processing_utils import (
+    analyze_input_compression,
+    encode_scene_with_size_check,
+    should_skip_encoding
+)
+from .fast_scene_detect import adaptive_scene_detection_check, fast_scene_detection_check, motion_based_scene_check
+
+# Import preprocessing classes to make them available for pickle loading
+from .data_preprocessing import (
+    ColumnDropper, VMAFScaler, TargetExtractor, CQScaler,
+    ResolutionTransformer, FeatureScaler, FrameRateTransformer
+)
+
+__all__ = [
+    'monitor_memory_usage', 'ProgressTracker',
+    'calculate_perceptual_contrast', 'get_video_duration', 
+    'calculate_contrast_adjusted_cq', 'sort_scene_files_by_number',
+    'process_scene_analysis_and_cq', 
+    'calculate_vmaf_for_scenes_df',
+    'analyze_input_compression',
+    'calculate_bitrate_aware_cq',
+    'encode_scene_with_size_check',
+    'should_skip_encoding',
+    'create_summary_and_save', 'cleanup_temporary_items',
+    'adaptive_scene_detection_check', 'fast_scene_detection_check', 'motion_based_scene_check',
+    'VideoProcessingLogger',
+    # Add preprocessing classes to make them available
+    'ColumnDropper', 'VMAFScaler', 'TargetExtractor', 'CQScaler',
+    'ResolutionTransformer', 'FeatureScaler', 'FrameRateTransformer'
+]

services/compress/utils/analyze_video_fast.py

@@ -0,0 +1,568 @@
+import os
+import json
+import numpy as np
+import cv2
+import subprocess
+
+def analyze_video_fast(video_path, max_frames=150,logging_enabled=True,include_quality_metrics=False):
+    """
+    Enhanced video analysis with ONLY required features for efficient processing.
+    
+    Args:
+        video_path: Path to video file
+        max_frames: Maximum frames to analyze
+        logging_enabled: Whether to log progress
+    """
+    if not os.path.exists(video_path):
+        if logging_enabled:
+            print(f"❌ Video file not found: {video_path}")
+        return None
+    
+    features = {}
+    try:
+        # Step 1: Get basic video properties using ffprobe
+        basic_features = extract_basic_video_properties(video_path, logging_enabled)
+        if not basic_features:
+            return None
+        
+        features.update(basic_features)
+        
+        # Step 2: Extract comprehensive motion and complexity metrics using OpenCV
+        advanced_features = extract_comprehensive_video_metrics(video_path, max_frames, logging_enabled)
+        features.update(advanced_features)
+
+        # Step 3: Add quality metrics for preprocessing if requested
+        if include_quality_metrics:
+            if logging_enabled:
+                print("   🔍 Analyzing video quality for preprocessing recommendations...")
+            quality_metrics = analyze_video_quality_metrics(video_path, num_frames=20)
+            if quality_metrics:
+                # Add quality metrics with prefix to avoid conflicts
+                for key, value in quality_metrics.items():
+                    features[f'quality_{key}'] = value
+        
+        if logging_enabled:
+            print(f"✅ Video analysis completed:")
+        
+        return features
+        
+    except Exception as e:
+        if logging_enabled:
+            print(f"❌ Video analysis failed: {e}")
+        return None
+
+def extract_basic_video_properties(video_path, logging_enabled=True):
+    """Extract basic video properties using ffprobe."""
+    try:
+        ffprobe_cmd = [
+            'ffprobe', '-v', 'quiet', '-print_format', 'json',
+            '-show_format', '-show_streams', video_path
+        ]
+        
+        result = subprocess.run(ffprobe_cmd, capture_output=True, text=True, timeout=30)
+        
+        if result.returncode != 0:
+            if logging_enabled:
+                print(f"❌ ffprobe failed: {result.stderr}")
+            return None
+        
+        probe_data = json.loads(result.stdout)
+        
+        video_stream = None
+        for stream in probe_data.get('streams', []):
+            if stream.get('codec_type') == 'video':
+                video_stream = stream
+                break
+        
+        if not video_stream:
+            if logging_enabled:
+                print("❌ No video stream found")
+            return None
+        
+        features = {}
+        
+        features['metrics_resolution_width'] = int(video_stream.get('width', 0))
+        features['metrics_resolution_height'] = int(video_stream.get('height', 0))
+        
+        frame_rate_str = video_stream.get('r_frame_rate', '0/1')
+        if '/' in frame_rate_str:
+            num, den = frame_rate_str.split('/')
+            features['metrics_frame_rate'] = float(num) / float(den) if float(den) != 0 else 0
+        else:
+            features['metrics_frame_rate'] = float(frame_rate_str)
+        
+        features['metrics_bit_depth'] = int(video_stream.get('bits_per_raw_sample', 8))
+        
+        features['input_codec'] = video_stream.get('codec_name', 'unknown')
+        
+        format_info = probe_data.get('format', {})
+        bitrate_bps = 0
+        
+        if video_stream.get('bit_rate'):
+            bitrate_bps = int(video_stream['bit_rate'])
+        elif format_info.get('bit_rate'):
+            bitrate_bps = int(format_info['bit_rate'])
+        else:
+            file_size_bytes = int(format_info.get('size', 0))
+            duration_seconds = float(format_info.get('duration', 0))
+            if file_size_bytes > 0 and duration_seconds > 0:
+                bitrate_bps = int((file_size_bytes * 8) / duration_seconds)
+        
+        features['input_bitrate_kbps'] = bitrate_bps / 1000 if bitrate_bps > 0 else 0
+        
+        features['metrics_resolution'] = f"({features['metrics_resolution_width']}, {features['metrics_resolution_height']})"
+        
+        if (features['metrics_resolution_width'] > 0 and 
+            features['metrics_resolution_height'] > 0 and 
+            features['metrics_frame_rate'] > 0 and 
+            features['input_bitrate_kbps'] > 0):
+            
+            pixels_per_second = (features['metrics_resolution_width'] * 
+                               features['metrics_resolution_height'] * 
+                               features['metrics_frame_rate'])
+            features['bits_per_pixel'] = (features['input_bitrate_kbps'] * 1000) / pixels_per_second
+        else:
+            features['bits_per_pixel'] = 0
+        
+        return features
+        
+    except Exception as e:
+        if logging_enabled:
+            print(f"❌ Basic video property extraction failed: {e}")
+        return None
+
+def extract_comprehensive_video_metrics(video_path, max_frames=150, logging_enabled=True, use_middle_section=True):
+    """
+    Extract ALL required video metrics using OpenCV analysis.
+    
+    Args:
+        use_middle_section (bool): If True, sample from middle 60% of video
+    """
+    features = {
+        'metrics_avg_motion': 0,
+        'metrics_avg_edge_density': 0,
+        'metrics_avg_texture': 0,
+        'metrics_avg_color_complexity': 0,
+        'metrics_avg_motion_variance': 0,
+        'metrics_avg_grain_noise': 0
+    }
+    
+    try:
+        cap = cv2.VideoCapture(video_path)
+        if not cap.isOpened():
+            if logging_enabled:
+                print(f"❌ Cannot open video: {video_path}")
+            return features
+        
+        total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+        fps = cap.get(cv2.CAP_PROP_FPS)
+        
+        if use_middle_section and total_frames > max_frames * 2:
+            start_frame = int(total_frames * 0.2)  # Skip first 20%
+            end_frame = int(total_frames * 0.8)    # Skip last 20%
+            effective_total = end_frame - start_frame
+        else:
+            start_frame = min(int(fps * 1.0), total_frames // 10)  # Skip first second or 10%
+            end_frame = total_frames
+            effective_total = end_frame - start_frame
+        
+        if effective_total > max_frames:
+            frame_interval = effective_total // max_frames
+        else:
+            frame_interval = 1
+        
+        cap.set(cv2.CAP_PROP_POS_FRAMES, start_frame)
+
+        edge_density_values = []
+        texture_values = []
+        color_complexity_values = []
+        spatial_info_values = []
+        temporal_info_values = []
+        grain_noise_values = []
+        motion_values = []
+        
+        prev_frame = None
+        frame_count = 0
+        processed_frames = 0
+        current_frame_pos = start_frame
+        
+        if logging_enabled:
+            print(f"   📊 Analyzing {min(max_frames, effective_total)} frames from middle section...")
+            print(f"   📍 Sampling range: frame {start_frame} to {end_frame} ({effective_total} frames)")
+        
+        while processed_frames < max_frames:
+            ret, frame = cap.read()
+            if not ret:
+                break
+            
+            if frame_count % frame_interval != 0:
+                frame_count += 1
+                current_frame_pos += 1
+                continue
+            
+            gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            
+            edge_density = compute_edge_density(gray)
+            edge_density_values.append(edge_density)
+            
+            texture_complexity = compute_texture_complexity(gray)
+            texture_values.append(texture_complexity)
+            
+            color_complexity = compute_color_complexity(frame)
+            color_complexity_values.append(color_complexity)
+            
+            spatial_info = compute_spatial_information(gray)
+            spatial_info_values.append(spatial_info)
+            
+            grain_noise = compute_grain_noise_level(gray)
+            grain_noise_values.append(grain_noise)
+            
+            if prev_frame is not None:
+                motion = compute_motion_metric(prev_frame, gray)
+                motion_values.append(motion)
+                temporal_info = compute_temporal_information(prev_frame, gray)
+                temporal_info_values.append(temporal_info)
+            
+            prev_frame = gray.copy()
+            processed_frames += 1
+            frame_count += 1
+            current_frame_pos += 1
+        
+        cap.release()
+        
+        if edge_density_values:
+            features['metrics_avg_edge_density'] = np.mean(edge_density_values)
+        
+        if texture_values:
+            features['metrics_avg_texture'] = np.mean(texture_values)
+        
+        if color_complexity_values:
+            features['metrics_avg_color_complexity'] = np.mean(color_complexity_values)
+        
+        if spatial_info_values:
+            features['metrics_avg_spatial_information'] = np.mean(spatial_info_values)
+        
+        if grain_noise_values:
+            features['metrics_avg_grain_noise'] = np.mean(grain_noise_values)
+        
+        if motion_values:
+            features['metrics_avg_motion'] = np.mean(motion_values)
+            features['metrics_avg_motion_variance'] = np.var(motion_values)
+        
+        if temporal_info_values:
+            features['metrics_avg_temporal_information'] = np.mean(temporal_info_values)
+        
+
+        if logging_enabled:
+            print(f"   ✅ Processed {processed_frames} frames")
+        return features
+        
+    except Exception as e:
+        if logging_enabled:
+            print(f"⚠️ Comprehensive video analysis failed: {e}")
+        
+        return {
+            'metrics_avg_motion': 0.1,
+            'metrics_avg_edge_density': 0.05,      
+            'metrics_avg_texture': 4.0,            
+            'metrics_avg_color_complexity': 3.0,   
+            'metrics_avg_motion_variance': 1.0,    
+            'metrics_avg_grain_noise': 5.0         
+        }
+
+def compute_edge_density(gray_frame, threshold1=100, threshold2=200):
+    """Compute edge density using Canny edge detection."""
+    edges = cv2.Canny(gray_frame, threshold1, threshold2)
+    edge_pixels = np.count_nonzero(edges)
+    total_pixels = edges.size
+    return edge_pixels / total_pixels
+
+def compute_texture_complexity(gray_frame):
+    """Compute texture complexity using histogram entropy."""
+    hist = cv2.calcHist([gray_frame], [0], None, [256], [0, 256]).ravel()
+    hist_norm = hist / hist.sum()  # normalize histogram
+    entropy = -np.sum([p * np.log2(p) for p in hist_norm if p > 0])
+    return entropy
+
+def compute_color_complexity(frame):
+    """Compute color complexity as average entropy across color channels."""
+    channels = cv2.split(frame)
+    entropies = []
+    for channel in channels:
+        hist = cv2.calcHist([channel], [0], None, [256], [0, 256]).ravel()
+        hist_sum = np.sum(hist)
+        if hist_sum > 0:
+            hist_norm = hist / hist_sum
+            entropy = -np.sum([p * np.log2(p) for p in hist_norm if p > 0])
+        else:
+            entropy = 0
+        entropies.append(entropy)
+    return np.mean(entropies)
+
+def compute_spatial_information(gray_frame):
+    """Compute spatial information using Sobel gradients."""
+    sobelx = cv2.Sobel(gray_frame, cv2.CV_64F, 1, 0, ksize=3)
+    sobely = cv2.Sobel(gray_frame, cv2.CV_64F, 0, 1, ksize=3)
+    gradient_magnitude = np.sqrt(sobelx**2 + sobely**2)
+    return np.std(gradient_magnitude)
+
+def compute_temporal_information(prev_gray, curr_gray):
+    """Compute temporal information as standard deviation of frame difference."""
+    diff = cv2.absdiff(prev_gray, curr_gray)
+    return np.std(diff)
+
+def compute_motion_metric(prev_gray, curr_gray):
+    """Compute motion metric as normalized frame difference."""
+    diff = cv2.absdiff(prev_gray, curr_gray)
+    motion_value = np.mean(diff) / 255.0  # Normalize to 0-1
+    return motion_value
+
+def compute_grain_noise_level(gray_frame, kernel_size=3):
+    """Compute grain/noise level using high-pass filtering."""
+    blurred = cv2.GaussianBlur(gray_frame, (kernel_size, kernel_size), 0)
+    noise = gray_frame.astype(np.float32) - blurred.astype(np.float32)
+    return np.std(noise)
+
+def analyze_video_quality_metrics(video_path, num_frames=30):
+    """
+    Analyze video to determine which preprocessing filters would be beneficial.
+    Returns a dictionary of quality metrics and recommendations.
+    """
+    cap = cv2.VideoCapture(video_path)
+    
+    if not cap.isOpened():
+        return None
+    
+    metrics = {
+        'noise_level': 0,
+        'sharpness': 0,
+        'contrast': 0,
+        'brightness': 0,
+        'color_saturation': 0,
+        'motion_blur': 0,
+        'compression_artifacts': 0,
+        'text_content': 0,
+        'edge_density': 0,
+        'temporal_consistency': 0
+    }
+    
+    frames = []
+    frame_count = 0
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    step = max(1, total_frames // num_frames)
+    
+    while frame_count < num_frames:
+        cap.set(cv2.CAP_PROP_POS_FRAMES, frame_count * step)
+        ret, frame = cap.read()
+        if not ret:
+            break
+        frames.append(frame)
+        frame_count += 1
+    
+    cap.release()
+    
+    if not frames:
+        return None
+    
+    # Analyze each metric
+    metrics.update({
+        'noise_level': _analyze_noise_level(frames),
+        'sharpness': _analyze_sharpness(frames),
+        'contrast': _analyze_contrast(frames),
+        'brightness': _analyze_brightness(frames),
+        'color_saturation': _analyze_color_saturation(frames),
+        'motion_blur': _analyze_motion_blur(frames),
+        'compression_artifacts': _analyze_compression_artifacts(frames),
+        'text_content': _analyze_text_content(frames),
+        'edge_density': _analyze_edge_density(frames),
+        'temporal_consistency': _analyze_temporal_consistency(frames)
+    })
+    
+    return metrics
+
+def _analyze_noise_level(frames):
+    """Estimate noise level in video frames."""
+    noise_scores = []
+    
+    for frame in frames:
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        
+        laplacian = cv2.Laplacian(gray, cv2.CV_64F)
+        noise_var = laplacian.var()
+        
+        f_transform = np.fft.fft2(gray)
+        f_shift = np.fft.fftshift(f_transform)
+        magnitude = np.abs(f_shift)
+        
+        h, w = magnitude.shape
+        center_h, center_w = h // 2, w // 2
+        high_freq_mask = np.zeros_like(magnitude)
+        high_freq_mask[center_h-h//8:center_h+h//8, center_w-w//8:center_w+w//8] = 1
+        high_freq_energy = np.sum(magnitude * (1 - high_freq_mask)) / np.sum(magnitude)
+        
+        noise_scores.append(min(noise_var / 1000, high_freq_energy * 2))
+    
+    return np.mean(noise_scores)
+
+def _analyze_sharpness(frames):
+    """Analyze image sharpness using multiple methods."""
+    sharpness_scores = []
+    
+    for frame in frames:
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        
+        laplacian_var = cv2.Laplacian(gray, cv2.CV_64F).var()
+        
+        sobelx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+        sobely = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+        tenengrad = np.mean(sobelx**2 + sobely**2)
+        
+        combined_sharpness = (laplacian_var / 2000 + tenengrad / 50000) / 2
+        sharpness_scores.append(min(combined_sharpness, 1.0))
+    
+    return np.mean(sharpness_scores)
+
+def _analyze_contrast(frames):
+    """Analyze contrast using RMS contrast and histogram analysis."""
+    contrast_scores = []
+    
+    for frame in frames:
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        
+        rms_contrast = np.std(gray) / np.mean(gray) if np.mean(gray) > 0 else 0
+        
+        hist = cv2.calcHist([gray], [0], None, [256], [0, 256])
+        hist_norm = hist / hist.sum()
+        
+        pixels_in_range = []
+        for i in range(0, 256, 32):
+            pixels_in_range.append(np.sum(hist_norm[i:i+32]))
+        
+        hist_spread = np.std(pixels_in_range)
+        
+        combined_contrast = (rms_contrast / 100 + hist_spread * 3) / 2
+        contrast_scores.append(min(combined_contrast, 1.0))
+    
+    return np.mean(contrast_scores)
+
+def _analyze_brightness(frames):
+    """Analyze brightness distribution."""
+    brightness_scores = []
+    
+    for frame in frames:
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        mean_brightness = np.mean(gray) / 255.0
+        brightness_scores.append(mean_brightness)
+    
+    return np.mean(brightness_scores)
+
+def _analyze_color_saturation(frames):
+    """Analyze color saturation levels."""
+    saturation_scores = []
+    
+    for frame in frames:
+        hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
+        saturation = hsv[:, :, 1]
+        mean_saturation = np.mean(saturation) / 255.0
+        saturation_scores.append(mean_saturation)
+    
+    return np.mean(saturation_scores)
+
+def _analyze_motion_blur(frames):
+    """Detect motion blur using edge analysis."""
+    if len(frames) < 2:
+        return 0
+    
+    blur_scores = []
+    
+    for i in range(len(frames) - 1):
+        gray1 = cv2.cvtColor(frames[i], cv2.COLOR_BGR2GRAY)
+        gray2 = cv2.cvtColor(frames[i + 1], cv2.COLOR_BGR2GRAY)
+        
+        edges1 = cv2.Canny(gray1, 50, 150)
+        edges2 = cv2.Canny(gray2, 50, 150)
+        
+
+        edge_diff = np.sum(np.abs(edges1.astype(float) - edges2.astype(float)))
+        frame_size = gray1.shape[0] * gray1.shape[1]
+        blur_score = edge_diff / frame_size / 255.0
+        
+        blur_scores.append(blur_score)
+    
+    return np.mean(blur_scores)
+
+def _analyze_compression_artifacts(frames):
+    """Detect compression artifacts using blockiness detection."""
+    artifact_scores = []
+    
+    for frame in frames:
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        
+        block_diffs = []
+        h, w = gray.shape
+        
+        for y in range(0, h - 8, 8):
+            for x in range(0, w - 8, 8):
+                block = gray[y:y+8, x:x+8]
+                
+                if x + 8 < w:
+                    right_block = gray[y:y+8, x+8:x+16] if x+16 <= w else None
+                    if right_block is not None:
+                        edge_diff = np.mean(np.abs(block[:, -1].astype(float) - right_block[:, 0].astype(float)))
+                        block_diffs.append(edge_diff)
+        
+        if block_diffs:
+            artifact_score = np.mean(block_diffs) / 255.0
+            artifact_scores.append(artifact_score)
+    
+    return np.mean(artifact_scores) if artifact_scores else 0
+
+def _analyze_text_content(frames):
+    """Detect text/high-contrast content."""
+    text_scores = []
+    
+    for frame in frames:
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        
+        edges = cv2.Canny(gray, 100, 200)
+        edge_density = np.sum(edges > 0) / (edges.shape[0] * edges.shape[1])
+        
+        _, binary = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+        contrast_regions = np.sum(binary > 0) / (binary.shape[0] * binary.shape[1])
+        
+        text_score = (edge_density * 2 + abs(contrast_regions - 0.5) * 2)
+        text_scores.append(min(text_score, 1.0))
+    
+    return np.mean(text_scores)
+
+def _analyze_edge_density(frames):
+    """Analyze edge density for detail preservation."""
+    edge_scores = []
+    
+    for frame in frames:
+        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+        edges = cv2.Canny(gray, 50, 150)
+        edge_density = np.sum(edges > 0) / (edges.shape[0] * edges.shape[1])
+        edge_scores.append(edge_density)
+    
+    return np.mean(edge_scores)
+
+def _analyze_temporal_consistency(frames):
+    """Analyze temporal consistency between frames."""
+    if len(frames) < 3:
+        return 1.0
+    
+    consistency_scores = []
+    
+    for i in range(1, len(frames) - 1):
+        prev_gray = cv2.cvtColor(frames[i-1], cv2.COLOR_BGR2GRAY)
+        curr_gray = cv2.cvtColor(frames[i], cv2.COLOR_BGR2GRAY)
+        next_gray = cv2.cvtColor(frames[i+1], cv2.COLOR_BGR2GRAY)
+        
+        diff1 = np.mean(np.abs(curr_gray.astype(float) - prev_gray.astype(float)))
+        diff2 = np.mean(np.abs(next_gray.astype(float) - curr_gray.astype(float)))
+        
+        consistency = 1.0 - min(abs(diff1 - diff2) / 255.0, 1.0)
+        consistency_scores.append(consistency)
+    
+    return np.mean(consistency_scores)

services/compress/utils/calculate_vmaf_adv.py

@@ -0,0 +1,734 @@
+import os
+import time
+import json
+import tempfile
+import subprocess
+import concurrent.futures
+from ffmpeg_quality_metrics import FfmpegQualityMetrics
+    
+def _extract_clip_optimized(input_file, output_file, start_time, duration, logging_enabled=False):
+    """Extract clip with keyframe-aware seeking for better quality."""
+    try:
+        input_ext = os.path.splitext(input_file)[1].lower()
+        raw_formats = ['.y4m', '.yuv', '.raw', '.rgb']
+        is_raw_format = input_ext in raw_formats
+        
+        if is_raw_format:
+            cmd = [
+                'ffmpeg', '-y', '-ss', str(start_time), '-i', input_file,
+                '-t', str(duration),
+                '-c:v', 'libx264', '-preset', 'ultrafast', '-qp', '0',
+                '-pix_fmt', 'yuv420p', '-an', output_file
+            ]
+        else:
+            cmd = [
+                'ffmpeg', '-y', 
+                '-ss', str(max(0, start_time - 1)),  
+                '-i', input_file,
+                '-ss', '1',  
+                '-t', str(duration),
+                '-c:v', 'libx264', '-preset', 'ultrafast', '-crf', '10',  
+                '-pix_fmt', 'yuv420p', '-an', output_file
+            ]
+        
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60)
+        success = result.returncode == 0 and os.path.exists(output_file) and os.path.getsize(output_file) > 0
+        
+        if logging_enabled:
+            method = "lossless encoding" if is_raw_format else "keyframe-aligned encoding"
+            status = "✅" if success else "❌"
+            print(f"   {status} Clip extraction ({method}): {start_time}s")
+        
+        return success
+        
+    except Exception as e:
+        if logging_enabled:
+            print(f"   ❌ Clip extraction error: {e}")
+        return False
+
+def extract_vmaf_clips_with_keyframe_detection(input_file, encoded_file, num_clips=5, clip_duration=3, logging_enabled=True):
+    """Enhanced clip extraction with proper keyframe alignment."""
+    
+    try:
+        cmd = [
+            'ffprobe', '-v', 'quiet', '-show_entries', 'format=duration',
+            '-of', 'json', input_file
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+        data = json.loads(result.stdout)
+        duration = float(data['format']['duration'])
+        
+        if duration < clip_duration * num_clips:
+            if logging_enabled:
+                print(f"   ⚠️ Video too short ({duration:.1f}s) for {num_clips} clips")
+            return None
+            
+    except Exception as e:
+        if logging_enabled:
+            print(f"   ❌ Could not determine video duration: {e}")
+        return None
+    
+    try:
+        cmd = [
+            'ffprobe', '-v', 'quiet', '-select_streams', 'v:0',
+            '-show_frames', '-show_entries', 'frame=pts_time,key_frame',
+            '-of', 'csv=p=0', input_file
+        ]
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=30)
+        
+        keyframes = []
+        for line in result.stdout.strip().split('\n'):
+            if line:
+                parts = line.split(',')
+                if len(parts) >= 2 and parts[1] == '1':  # key_frame=1
+                    keyframes.append(float(parts[0]))
+        
+        if logging_enabled:
+            print(f"   🔑 Found {len(keyframes)} keyframes")
+            
+    except Exception as e:
+        if logging_enabled:
+            print(f"   ⚠️ Keyframe detection failed: {e}, using standard timing")
+        keyframes = []
+    
+    clip_positions = []
+    
+    target_positions = []
+    for i in range(num_clips):
+        position = 0.15 + (i * (0.85 - 0.15) / (num_clips - 1)) if num_clips > 1 else 0.5
+        target_positions.append(duration * position)
+    
+    for target_pos in target_positions:
+        if keyframes:
+            nearest_keyframe = min(keyframes, key=lambda x: abs(x - target_pos))
+            if nearest_keyframe + clip_duration <= duration:
+                clip_positions.append(nearest_keyframe)
+            else:
+                valid_keyframes = [kf for kf in keyframes if kf + clip_duration <= duration]
+                if valid_keyframes:
+                    clip_positions.append(max(valid_keyframes))
+                else:
+                    clip_positions.append(max(0, duration - clip_duration))
+        else:
+            clip_positions.append(max(0, min(target_pos, duration - clip_duration)))
+    
+    if logging_enabled:
+        print(f"   📍 Clip positions: {[f'{pos:.2f}s' for pos in clip_positions]}")
+    
+    vmaf_scores = []
+    
+    for i, start_time in enumerate(clip_positions):
+        if logging_enabled:
+            print(f"   🎬 Extracting clip {i+1} at {start_time:.2f}s...")
+        
+        temp_dir = tempfile.mkdtemp()
+        ref_clip = os.path.join(temp_dir, f"ref_clip_{i+1}.mp4")
+        enc_clip = os.path.join(temp_dir, f"enc_clip_{i+1}.mp4")
+        
+        try:
+            ref_cmd = [
+                'ffmpeg', '-y', '-ss', str(start_time), '-i', input_file,
+                '-t', str(clip_duration), '-c:v', 'libx264', '-preset', 'ultrafast',
+                '-crf', '10', '-force_key_frames', 'expr:gte(t,0)', 
+                '-pix_fmt', 'yuv420p', '-avoid_negative_ts', 'make_zero', ref_clip
+            ]
+            
+            enc_cmd = [
+                'ffmpeg', '-y', '-ss', str(start_time), '-i', encoded_file,
+                '-t', str(clip_duration), '-c:v', 'libx264', '-preset', 'ultrafast',
+                '-crf', '15', '-pix_fmt', 'yuv420p', '-avoid_negative_ts', 'make_zero', enc_clip
+            ]
+            
+            ref_result = subprocess.run(ref_cmd, capture_output=True, text=True, timeout=60)
+            enc_result = subprocess.run(enc_cmd, capture_output=True, text=True, timeout=60)
+            
+            if ref_result.returncode == 0 and enc_result.returncode == 0:
+                from ffmpeg_quality_metrics import FfmpegQualityMetrics
+                
+                ffqm = FfmpegQualityMetrics(ref_clip, enc_clip)
+                metrics = ffqm.calculate(["vmaf"])
+                
+                if 'vmaf' in metrics and metrics['vmaf']:
+                    clip_vmaf = sum([frame["vmaf"] for frame in metrics["vmaf"]]) / len(metrics["vmaf"])
+                    vmaf_scores.append(round(clip_vmaf, 2))
+                    
+                    if logging_enabled:
+                        print(f"   ✅ Clip {i+1} VMAF: {clip_vmaf:.2f}")
+                else:
+                    if logging_enabled:
+                        print(f"   ❌ Clip {i+1} VMAF calculation failed")
+            else:
+                if logging_enabled:
+                    print(f"   ❌ Clip {i+1} extraction failed")
+                    
+        except Exception as e:
+            if logging_enabled:
+                print(f"   ❌ Clip {i+1} processing failed: {e}")
+        finally:
+            # Cleanup
+            for temp_file in [ref_clip, enc_clip]:
+                if os.path.exists(temp_file):
+                    try:
+                        os.remove(temp_file)
+                    except:
+                        pass
+            try:
+                os.rmdir(temp_dir)
+            except:
+                pass
+    
+    if vmaf_scores:
+        if len(vmaf_scores) >= 3:
+            sorted_scores = sorted(vmaf_scores)
+            median_score = sorted_scores[len(sorted_scores)//2]
+            min_score = sorted_scores[0]
+            max_score = sorted_scores[-1]
+            
+            outliers = [s for s in vmaf_scores if abs(s - median_score) > 15]
+            
+            if outliers and logging_enabled:
+                print(f"   ⚠️ Detected outlier scores: {outliers}")
+                print(f"   📊 Score distribution: min={min_score:.1f}, median={median_score:.1f}, max={max_score:.1f}")
+                
+                filtered_scores = [s for s in vmaf_scores if abs(s - median_score) <= 15]
+                if len(filtered_scores) >= 2:
+                    final_vmaf = sum(filtered_scores) / len(filtered_scores)
+                    print(f"   🔧 Using filtered scores (removed {len(outliers)} outliers): {final_vmaf:.2f}")
+                    return final_vmaf
+        
+        final_vmaf = sum(vmaf_scores) / len(vmaf_scores)
+        if logging_enabled:
+            print(f"   📊 Individual scores: {[f'{s:.2f}' for s in vmaf_scores]}")
+            print(f"   📊 Average VMAF: {final_vmaf:.2f}")
+        return final_vmaf
+    else:
+        return None
+
+def calculate_vmaf_advanced(input_file, encoded_file, 
+                           use_sampling=True, num_clips=3, clip_duration=2,
+                           use_downscaling=False, scale_factor=0.5,
+                           use_parallel=False, # This parameter is for the caller of parallel, not used inside this single func
+                           use_vmafneg=False, 
+                           default_vmaf_model_path_config: str = None,
+                           vmafneg_model_path_config: str = None,
+                           use_frame_rate_scaling=False,    
+                           target_fps=15.0,                 
+                           frame_rate_scaling_method='uniform', 
+                           logger=None,logging_enabled=True):
+    """
+    Calculate VMAF with multiple sampling methods
+    
+    Args:
+        input_file: Path to the reference video file
+        encoded_file: Path to the encoded video file
+        use_sampling: Whether to use sampling for VMAF calculation
+        num_clips: Number of clips to sample for VMAF calculation
+        clip_duration: Duration of each clip in seconds
+        use_downscaling: Whether to downscale videos for faster VMAF calculation
+        scale_factor: Scale factor for downscaling (0.5 = 50% resolution)
+        use_vmafneg: Whether to use VMAFNEG model
+        default_vmaf_model_path_config: Full path to the default VMAF model.
+        vmafneg_model_path_config: Full path to the VMAFNEG model.
+        logger: Optional logger instance for logging messages
+    Returns:
+        VMAF score as a float, or None if calculation fails
+        
+    """  
+    def log_message(message, level="info"):
+        if logger:
+            if level == "error": logger.error(message)
+            elif level == "warning": logger.warning(message)
+            elif level == "debug" and hasattr(logger, 'debug'): logger.debug(message)
+            else: logger.info(message)
+        else:
+            print(message) # Fallback if no logger
+
+    if not os.path.exists(input_file):
+        log_message(f"Error: Input file '{input_file}' does not exist", "error")
+        return None
+        
+    if not os.path.exists(encoded_file):
+        log_message(f"Error: Encoded file '{encoded_file}' does not exist", "error")
+        return None
+    
+    if use_frame_rate_scaling:
+        log_message(f"Using frame rate scaling: {target_fps} FPS with {frame_rate_scaling_method} method")
+    
+    # Determine which VMAF model path to use directly from parameters
+    target_model_path = None
+    model_type_for_log = "libvmaf_default" # Default assumption
+
+    if use_vmafneg:
+        log_message(f"VMAFNEG flag is True. Using VMAFNEG model path: '{vmafneg_model_path_config}'", "debug")
+        target_model_path = vmafneg_model_path_config
+        model_type_for_log = "VMAFNEG"
+    else:
+        log_message(f"VMAFNEG flag is False. Using Default VMAF model path: '{default_vmaf_model_path_config}'", "debug")
+        target_model_path = default_vmaf_model_path_config
+        model_type_for_log = "Default VMAF"
+
+    vmaf_options_dict = None
+    
+    if target_model_path and os.path.exists(target_model_path):
+        log_message(f"Using VMAF model ({model_type_for_log}): {target_model_path}")
+        vmaf_options_dict = {"model_path": target_model_path}
+    elif target_model_path: # Path provided but not found
+        log_message(f"Warning: Specified {model_type_for_log} model file not found at '{target_model_path}'. "
+                    "ffmpeg-quality-metrics will use libvmaf's default model.", "warning")
+        model_type_for_log = "libvmaf_default (model file not found)" # Update log type
+    else: # No path provided for the selected option
+        log_message(f"Warning: No model path provided for {model_type_for_log} configuration. "
+                    "ffmpeg-quality-metrics will use libvmaf's default model.", "warning")
+        model_type_for_log = "libvmaf_default (no model path provided)" # Update log type
+    
+    log_message(f"Effective VMAF model for this calculation: {model_type_for_log}", "debug")
+
+    temp_dir = tempfile.mkdtemp()
+    temp_files = []
+
+    def extract_vmaf_score(metrics):
+        """Extract VMAF score from metrics dictionary"""
+        try:
+            if 'vmaf' in metrics and metrics['vmaf']:
+                # Calculate average of frame VMAF scores
+                vmaf_score = sum([frame["vmaf"] for frame in metrics["vmaf"]]) / len(metrics["vmaf"])
+                return round(vmaf_score, 2)
+            else:
+                print("No VMAF data found in metrics")
+                return None
+        except Exception as e:
+            print(f"Error extracting VMAF score: {e}")
+            return None
+    
+    try:
+        # ---------- Handle downscaling if enabled ----------
+        if use_downscaling:
+            if logging_enabled:
+                print(f"Downscaling videos to {int(scale_factor * 100)}% for faster VMAF calculation")
+            
+            # ✅ Check if input is raw/uncompressed format
+            input_ext = os.path.splitext(input_file)[1].lower()
+            encoded_ext = os.path.splitext(encoded_file)[1].lower()
+            
+            # Raw formats that cannot use stream copy
+            raw_formats = ['.y4m', '.yuv', '.raw', '.rgb']
+            
+            is_input_raw = input_ext in raw_formats
+            is_encoded_raw = encoded_ext in raw_formats
+            
+            scaled_ref = os.path.join(temp_dir, "ref_scaled.mp4")
+            scaled_enc = os.path.join(temp_dir, "enc_scaled.mp4")
+            temp_files.extend([scaled_ref, scaled_enc])
+            
+            # Get video dimensions
+            cmd = [
+                'ffprobe', '-v', 'error', '-select_streams', 'v:0',
+                '-show_entries', 'stream=width,height', '-of', 'json', input_file
+            ]
+            result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            data = json.loads(result.stdout)
+            
+            try:
+                width = int(int(data['streams'][0]['width']) * scale_factor)
+                height = int(int(data['streams'][0]['height']) * scale_factor)
+                
+                # Must be even numbers for YUV formats
+                width = width - (width % 2)
+                height = height - (height % 2)
+                
+                # ✅ Smart codec selection for reference video
+                if is_input_raw:
+                    # Raw format - must encode (use lossless to preserve quality)
+                    if logging_enabled:
+                        print(f"   📹 Raw format detected ({input_ext}) - using lossless encoding")
+                    ref_cmd = [
+                        'ffmpeg', '-y', '-i', input_file, 
+                        '-vf', f'scale={width}:{height}',
+                        '-c:v', 'libx264', '-preset', 'ultrafast', '-qp', '0',  # Lossless
+                        '-pix_fmt', 'yuv420p', scaled_ref
+                    ]
+                else:
+                    # Already encoded - try to use stream copy with scaling
+                    if logging_enabled:
+                        print(f"   📼 Encoded format detected ({input_ext}) - trying stream copy with scaling")
+                    ref_cmd = [
+                        'ffmpeg', '-y', '-i', input_file, 
+                        '-vf', f'scale={width}:{height}',
+                        '-c:v', 'libx264', '-preset', 'ultrafast', '-crf', '10',  # Very high quality fallback
+                        '-pix_fmt', 'yuv420p', scaled_ref
+                    ]
+                
+                if is_encoded_raw:
+                    # Raw format - must encode
+                    enc_cmd = [
+                        'ffmpeg', '-y', '-i', encoded_file, 
+                        '-vf', f'scale={width}:{height}',
+                        '-c:v', 'libx264', '-preset', 'ultrafast', '-crf', '15',  # High quality
+                        '-pix_fmt', 'yuv420p', scaled_enc
+                    ]
+                else:
+                    # Already encoded - use moderate quality
+                    enc_cmd = [
+                        'ffmpeg', '-y', '-i', encoded_file, 
+                        '-vf', f'scale={width}:{height}',
+                        '-c:v', 'libx264', '-preset', 'ultrafast', '-crf', '18',  # Standard quality
+                        '-pix_fmt', 'yuv420p', scaled_enc
+                    ]
+                
+                # Execute commands
+                ref_result = subprocess.run(ref_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                enc_result = subprocess.run(enc_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+                
+                if ref_result.returncode == 0 and enc_result.returncode == 0:
+                    # Replace original paths with scaled versions
+                    input_file = scaled_ref
+                    encoded_file = scaled_enc
+                    if logging_enabled:
+                        quality_note = "lossless reference" if is_input_raw else "high quality reference"
+                        print(f"   ✅ Videos downscaled to {width}x{height} ({quality_note})")
+                else:
+                    if logging_enabled:
+                        print(f"   ❌ Error downscaling videos, using original resolution")
+                        if ref_result.returncode != 0:
+                            print(f"   Reference error: {ref_result.stderr.decode()}")
+                        if enc_result.returncode != 0:
+                            print(f"   Encoded error: {enc_result.stderr.decode()}")
+                
+            except (KeyError, ValueError, subprocess.SubprocessError) as e:
+                if logging_enabled:
+                    print(f"   ❌ Error downscaling videos, using original resolution: {e}")
+                
+        
+        if use_frame_rate_scaling:
+            if logging_enabled:
+                print(f"Scaling frame rate to {target_fps} FPS for faster VMAF calculation")
+            
+            # Apply frame rate scaling to both input and encoded videos
+            fps_scaled_ref, fps_scaled_enc = apply_frame_rate_scaling(
+                input_file, encoded_file, target_fps, frame_rate_scaling_method, temp_dir, logging_enabled
+            )
+            
+            if fps_scaled_ref and fps_scaled_enc:
+                temp_files.extend([fps_scaled_ref, fps_scaled_enc])
+                # Update file paths to use frame rate scaled versions
+                input_file = fps_scaled_ref
+                encoded_file = fps_scaled_enc
+                if logging_enabled:
+                    print(f"Videos scaled to {target_fps} FPS for VMAF calculation")
+            else:
+                log_message(f"Frame rate scaling failed, using original frame rate", "warning")
+
+        # ---------- Handle clip sampling if enabled ----------
+        if use_sampling:
+            vmaf_score = extract_vmaf_clips_with_keyframe_detection(
+                input_file=input_file,
+                encoded_file=encoded_file,
+                num_clips=num_clips,
+                clip_duration=clip_duration,
+                logging_enabled=logging_enabled
+            )
+            
+            if vmaf_score is not None:
+                return vmaf_score
+            else:
+                if logging_enabled:
+                    print("Enhanced sampling failed, falling back to original method...")
+        
+            # Get video duration
+            cmd = [
+                'ffprobe', '-v', 'error', '-show_entries', 'format=duration',
+                '-of', 'json', encoded_file
+            ]
+            result = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+            data = json.loads(result.stdout)
+            
+            try:
+                duration = float(data['format']['duration'])
+                print(f"Video duration: {duration}s")
+            except (KeyError, ValueError) as e:
+                print(f"Could not determine video duration: {e}, falling back to full calculation")
+                # Calculate VMAF on full videos
+                ffqm = FfmpegQualityMetrics(input_file, encoded_file)
+                metrics = ffqm.calculate(["vmaf"], vmaf_options=vmaf_options_dict) # Pass model options
+                return extract_vmaf_score(metrics)
+            
+            # Skip sampling for short videos
+            if duration <= num_clips * clip_duration * 2:
+                log_message(f"Video too short ({duration}s), calculating full VMAF")
+                ffqm = FfmpegQualityMetrics(input_file, encoded_file)
+                metrics = ffqm.calculate(["vmaf"], vmaf_options=vmaf_options_dict) # Pass model options
+                return extract_vmaf_score(metrics)
+            
+            # Calculate strategic sample points (beginning, middle, end)
+            sample_points = []
+            
+            # Beginning segment (first 30%)
+            if num_clips >= 1:
+                begin_point = duration * 0.1  # 10% into the video
+                sample_points.append(begin_point)
+            
+            # Middle segment (middle 40%)
+            if num_clips >= 2:
+                middle_point = duration * 0.5  # 50% into the video
+                sample_points.append(middle_point)
+            
+            # End segment (last 30%)
+            if num_clips >= 3:
+                end_point = duration * 0.9  # 90% into the video
+                sample_points.append(end_point)
+            
+            # Add more evenly distributed points if requested
+            if num_clips > 3:
+                for i in range(4, num_clips + 1):
+                    pos = duration * (i - 0.5) / (num_clips + 1)
+                    sample_points.append(pos)
+            
+            print(f"Using {len(sample_points)} clips for VMAF calculation")
+            
+            # ---------- Define clip processing function for parallel/sequential use ----------
+            def process_clip(start_time):
+                """Process a single clip for VMAF calculation"""
+                # Adjust start time to ensure we don't go beyond video duration
+                start_time = max(0, min(start_time, duration - clip_duration))
+                
+                # Create temp files for this clip
+                ref_clip = os.path.join(temp_dir, f"ref_clip_{start_time:.2f}.mp4")
+                enc_clip = os.path.join(temp_dir, f"enc_clip_{start_time:.2f}.mp4")
+                
+                # ✅ Use optimized extraction
+                ref_success = _extract_clip_optimized(input_file, ref_clip, start_time, clip_duration, logging_enabled)
+                if not ref_success:
+                    print(f"Failed to extract reference clip at {start_time}s")
+                    return None
+                
+                enc_success = _extract_clip_optimized(encoded_file, enc_clip, start_time, clip_duration, logging_enabled)
+                if not enc_success:
+                    print(f"Failed to extract encoded clip at {start_time}s")
+                    return None
+                
+                temp_files.extend([ref_clip, enc_clip])
+                
+                # Calculate VMAF for this clip
+                try:
+                    ffqm = FfmpegQualityMetrics(ref_clip, enc_clip)
+                    metrics = ffqm.calculate(["vmaf"], vmaf_options=vmaf_options_dict) # Pass model options
+                    
+                    # Extract VMAF score using our helper function
+                    clip_vmaf = extract_vmaf_score(metrics)
+                    if clip_vmaf is not None:
+                        print(f"Clip at {start_time:.2f}s VMAF: {clip_vmaf}")
+                    return clip_vmaf
+                except Exception as e:
+                    print(f"Error calculating VMAF for clip at {start_time:.2f}s: {e}")
+                    return None
+            
+            # ---------- Process clips in parallel or sequentially ----------
+            vmaf_scores = []
+            
+            if use_parallel:
+                # Process clips in parallel
+                with concurrent.futures.ThreadPoolExecutor(max_workers=min(num_clips, os.cpu_count())) as executor:
+                    futures = [executor.submit(process_clip, start_time) for start_time in sample_points]
+                    
+                    for future in concurrent.futures.as_completed(futures):
+                        try:
+                            result = future.result()
+                            if result is not None:
+                                vmaf_scores.append(result)
+                        except Exception as e:
+                            print(f"Error processing clip: {e}")
+            else:
+                # Process clips sequentially
+                for start_time in sample_points:
+                    result = process_clip(start_time)
+                    if result is not None:
+                        vmaf_scores.append(result)
+            
+            # Average the scores
+            if vmaf_scores:
+                avg_vmaf = sum(vmaf_scores) / len(vmaf_scores)
+                return round(avg_vmaf, 2)
+            else:
+                print("No valid VMAF scores calculated from clips, trying direct calculation")
+                # Fall back to original calculation
+                try:
+                    ffqm = FfmpegQualityMetrics(input_file, encoded_file)
+                    metrics = ffqm.calculate(["vmaf"], vmaf_options=vmaf_options_dict) # Pass model options
+                    return extract_vmaf_score(metrics)
+                except Exception as e:
+                    print(f"Direct VMAF calculation failed: {e}")
+                    return None
+        else:
+            # No sampling, calculate VMAF on entire video
+            try:
+                print("Calculating full VMAF (no sampling)...")
+                ffqm = FfmpegQualityMetrics(input_file, encoded_file)
+                metrics = ffqm.calculate(["vmaf"], vmaf_options=vmaf_options_dict) # Pass model options
+                return extract_vmaf_score(metrics)
+            except Exception as e:
+                print(f"Full VMAF calculation failed: {e}")
+                return None
+            
+    except Exception as e:
+        log_message(f"Error in VMAF calculation: {e}", "error")
+        # Fall back to direct FFmpeg VMAF calculation
+        try:
+            log_message("Attempting direct FFmpeg VMAF calculation...")
+            libvmaf_options_list = ["log_fmt=json"]
+            if target_model_path and os.path.exists(target_model_path): # Check target_model_path directly
+                model_path_for_cli = target_model_path.replace("\\", "/") 
+                libvmaf_options_list.append(f"model_path='{model_path_for_cli}'")
+            libvmaf_filter_options = ":".join(libvmaf_options_list)
+            cmd = [
+                'ffmpeg', '-i', input_file, '-i', encoded_file,
+                '-filter_complex', f'[0:v]setpts=PTS-STARTPTS[reference];[1:v]setpts=PTS-STARTPTS[distorted];[reference][distorted]libvmaf={libvmaf_filter_options}',
+                '-f', 'null', '-'
+            ]
+            
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            
+            # Extract VMAF score from output
+            for line in result.stderr.splitlines():
+                if "VMAF score:" in line:
+                    score = float(line.split("VMAF score:")[1].strip())
+                    print(f"Direct FFmpeg VMAF score: {score}")
+                    return round(score, 2)
+            
+            print("Could not extract VMAF score from FFmpeg output")
+            return None
+        except Exception as e2:
+            print(f"Fatal error calculating VMAF: {e2}")
+            return None
+        
+    finally:
+        # Clean up temp files and directory
+        for file in temp_files:
+            try:
+                if os.path.exists(file):
+                    os.unlink(file)
+            except Exception as e:
+                print(f"Error cleaning up temp file {file}: {e}")
+        
+        try:
+            os.rmdir(temp_dir)
+        except Exception as e:
+            print(f"Error removing temp directory: {e}")
+
+def apply_frame_rate_scaling(input_file, encoded_file, target_fps, scaling_method, temp_dir, logging_enabled=True):
+    """Apply frame rate scaling while preserving reference quality."""
+    try:
+        import subprocess
+        import json
+        
+        # Get original video properties
+        def get_video_info(video_path):
+            cmd = [
+                'ffprobe', '-v', 'quiet', '-print_format', 'json',
+                '-show_streams', '-select_streams', 'v:0', video_path
+            ]
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            if result.returncode == 0:
+                data = json.loads(result.stdout)
+                stream = data['streams'][0]
+                fps_str = stream.get('r_frame_rate', '30/1')
+                if '/' in fps_str:
+                    num, den = fps_str.split('/')
+                    fps = float(num) / float(den) if float(den) != 0 else 30
+                else:
+                    fps = float(fps_str)
+                return fps
+            return None
+        
+        # Get original frame rates
+        ref_fps = get_video_info(input_file)
+        enc_fps = get_video_info(encoded_file)
+        
+        if not ref_fps or not enc_fps:
+            if logging_enabled:
+                print("Could not determine original frame rates")
+            return None, None
+        
+        # Check if scaling is beneficial
+        min_original_fps = min(ref_fps, enc_fps)
+        if target_fps >= min_original_fps:
+            if logging_enabled:
+                print(f"Target FPS ({target_fps}) >= original FPS ({min_original_fps}), skipping frame rate scaling")
+            return input_file, encoded_file  # Return original files
+        
+        # Create output paths
+        scaled_ref = os.path.join(temp_dir, "ref_fps_scaled.mp4")
+        scaled_enc = os.path.join(temp_dir, "enc_fps_scaled.mp4")
+        
+        # Build FFmpeg filter based on scaling method
+        if scaling_method == 'uniform':
+            filter_complex = f'fps={target_fps}'
+        elif scaling_method == 'smart':
+            interval = max(1, int(min_original_fps / target_fps))
+            filter_complex = f'select=not(mod(n\\,{interval})),setpts=N/FRAME_RATE/TB'
+        else:
+            filter_complex = f'fps={target_fps}'
+        
+        # ✅ Smart codec selection based on input format
+        input_ext = os.path.splitext(input_file)[1].lower()
+        encoded_ext = os.path.splitext(encoded_file)[1].lower()
+        
+        raw_formats = ['.y4m', '.yuv', '.raw', '.rgb']
+        is_input_raw = input_ext in raw_formats
+        is_encoded_raw = encoded_ext in raw_formats
+        
+        # Scale reference video with appropriate quality
+        if is_input_raw:
+            # Raw format - use lossless encoding
+            ref_cmd = [
+                'ffmpeg', '-y', '-i', input_file,
+                '-vf', filter_complex,
+                '-c:v', 'libx264', '-preset', 'ultrafast', '-qp', '0',  # Lossless
+                '-pix_fmt', 'yuv420p', scaled_ref
+            ]
+        else:
+            # Already encoded - use very high quality
+            ref_cmd = [
+                'ffmpeg', '-y', '-i', input_file,
+                '-vf', filter_complex,
+                '-c:v', 'libx264', '-preset', 'ultrafast', '-crf', '10',  # Very high quality
+                '-pix_fmt', 'yuv420p', scaled_ref
+            ]
+        
+        # Scale encoded video (can use standard quality)
+        enc_cmd = [
+            'ffmpeg', '-y', '-i', encoded_file,
+            '-vf', filter_complex,
+            '-c:v', 'libx264', '-preset', 'ultrafast', '-crf', '18',
+            '-pix_fmt', 'yuv420p', scaled_enc
+        ]
+        
+        # Execute commands
+        ref_result = subprocess.run(ref_cmd, capture_output=True, text=True)
+        if ref_result.returncode != 0:
+            if logging_enabled:
+                print(f"Reference frame rate scaling failed: {ref_result.stderr}")
+            return None, None
+        
+        enc_result = subprocess.run(enc_cmd, capture_output=True, text=True)
+        if enc_result.returncode != 0:
+            if logging_enabled:
+                print(f"Encoded frame rate scaling failed: {enc_result.stderr}")
+            return None, None
+        
+        # Verify scaled files exist and have content
+        if (os.path.exists(scaled_ref) and os.path.getsize(scaled_ref) > 0 and
+            os.path.exists(scaled_enc) and os.path.getsize(scaled_enc) > 0):
+            
+            if logging_enabled:
+                quality_note = "lossless" if is_input_raw else "high quality"
+                print(f"Frame rate scaling successful: {min_original_fps:.1f} → {target_fps} FPS ({quality_note} reference)")
+            return scaled_ref, scaled_enc
+        else:
+            if logging_enabled:
+                print("Frame rate scaling produced empty files")
+            return None, None
+            
+    except Exception as e:
+        if logging_enabled:
+            print(f"Frame rate scaling error: {e}")
+        return None, None