目前许多短视频平台都采用把用户上传视频统一转码为m3u8+ts文件格式

主要优势：
适应性流媒体传输：M3U8可以根据用户的网络速度自动调整视频质量，确保流畅播放。它通过提供不同质量级别的媒体文件链接，使播放器能够根据当前网络条件选择最合适的质量级别进行播放。

分段传输：将长视频分割成小片段，便于通过HTTP协议快速传输。这种方式使得视频可以边下载边播放，减少了等待时间。

跨平台兼容性：M3U8格式被广泛支持，可以在多种设备和浏览器上播放，包括移动设备、桌面计算机以及智能电视等。

直播和点播：M3U8既可以用于直播流媒体，也可以用于点播服务，使其成为在线视频平台的理想选择。

本次使用php对接阿里云提供的mps服务，对视频进行转码

安装以下SDK

composer install alibabacloud/sdk
composer install alibabacloud/mts-20140618

下面代码为提交转码任务

<?php
namespace app;

use AlibabaCloud\SDK\Mts\V20140618\Models\SubmitJobsRequest;
use AlibabaCloud\SDK\Mts\V20140618\Mts;
use Darabonba\OpenApi\Models\Config;

use AlibabaCloud\Tea\Tea;
use AlibabaCloud\Tea\Utils\Utils;

class LeCommon
{

    const accessKeyId = 'LT*******mHs';
    const accessKeySecret = 'rki********P3J';
    const regionId = 'cn-hangzhou'; //地域id

    const PipelineId = '457cf7********2d77'; //管道ID

    const ossLocation = 'oss-cn-hangzhou';

    const bucket  = 'sh*****-1'; //oss bucket名称

      //此处为阿里云内置模板，转换1920全高清为m3u8+ts格式
    const templateId = "S00000001-100040"; #转码模板ID，按需配置
    const oss_input_object  = "test_input.mp4"; //oss上面的路径
    const oss_output_object  = "output_test"; //输出后的oss路径

    public static function createClient(){
        $config = new Config([]);
        $config->accessKeyId = self::accessKeyId;
        $config->accessKeySecret = self::accessKeySecret;
        $config->regionId = self::regionId;
        $config->protocol = "HTTPS";
        $config->endpoint = 'mts.cn-hangzhou.aliyuncs.com';
        return new Mts($config);
    }

    public static function test(){

        $client = self::createClient();

        $request = new SubmitJobsRequest([
            "input" => json_encode(array(
                'Location' => self::ossLocation,
                'Bucket' => self::bucket,
                'Object' => urlencode(self::oss_input_object))
            ),
            "outputBucket" => self::bucket,
            "outputLocation" => self::ossLocation,
            "pipelineId" => self::PipelineId,
            "outputs" => self::outputs(),
        ]);

        $response = $client->submitJobs($request);
        //Console::log();

        var_dump($response);
        var_dump(Utils::toJSONString(Tea::merge($response->body)));
    }

    public static function outputs() {
        $output = array('OutputObject' => urlencode(self::oss_output_object));
        $output['TemplateId'] = self::templateId;
        $outputs = array($output);
        return json_encode($outputs);
    }

}

1.安装wkhtmltopdf
ubuntu 安装
sudo apt-get install wkhtmltopdf
centos 安装
sudo yum install wkhtmltopdf

2.php中使用thinkphp-template模板组件

$res = ThinkPHP::render('mobile',['html'=>$html]);

        $filename = runtime_path().'/html/'.time().mt_rand(1,999).'.html';
        file_put_contents($filename, $res);

        $tempHtmlFile = $filename;

        // 生成图像输出文件路径
        $outputImageFile = runtime_path().'/html/res.png';

        // 使用 wkhtmltoimage 命令行工具生成图像
        //quality 质量 1-100
        //width 宽度
        //-disable-smart-width 禁用宽度自动调整
        // --zoom 0.8 缩小分辨率
        $command = "wkhtmltoimage --width 700 --quality 75 --disable-smart-width $tempHtmlFile $outputImageFile";
        //exec($command);
        exec($command, $output, $status);
        if ($status == 0) {
            echo "生成成功！";
        } else {
            echo "生成失败！状态码: " . $status;
            print_r($output);  // 查看详细的错误输出
        }

        if (file_exists($tempHtmlFile)) {
            unlink($tempHtmlFile);  // 删除临时文件
            echo "临时文件已删除";
        } else {
            echo "临时文件不存在，无法删除";
        }

public class Demo1 {

    public static void main(String[] args) {
//        Java 特点

//        1. 平台独立性
//        解释：Java 是一次编写，处处运行。它通过 Java 虚拟机（JVM）来实现平台无关性，程序在任何平台上都可以运行，只要该平台上有 Java 环境。
//        原理：Java 源代码编译后会生成字节码文件（.class），然后 JVM 解释和执行这些字节码，不直接依赖于底层操作系统。
//        2. 面向对象
//        解释：Java 是一门面向对象的编程语言，几乎所有的内容都作为对象存在。面向对象有四个基本特性：
//        封装：数据和方法被封装在对象中，外界不能直接访问对象的属性，只能通过方法来操作对象的数据。
//        继承：Java 允许类之间的继承，子类可以继承父类的属性和方法，从而实现代码重用。
//        多态：多态允许通过父类引用指向子类对象，并在运行时决定调用哪个方法。这样可以使得代码更具扩展性。
//        抽象：抽象允许你只关心对象的行为而不关心其具体实现，通常通过抽象类或接口来实现。
//        3. 简洁和易学
//        解释：Java 的语法比较简洁，比 C++ 少了指针、手动内存管理等复杂特性，学习起来相对容易。
//        优点：对初学者来说，Java 提供了清晰且易于理解的结构和语法，快速上手。
//        4. 垃圾回收机制
//        解释：Java 有自动的垃圾回收机制，JVM 会自动管理内存，定期清理不再使用的对象，减少了内存泄漏的风险。
//        原理：通过垃圾回收（GC）机制，程序员不需要手动释放内存，只需关注逻辑和性能，JVM 会自动处理内存的分配和回收。
//        5. 多线程支持
//        解释：Java 提供了内建的多线程支持，可以轻松创建多线程应用。Java 提供了线程类和接口，使得线程的管理和同步变得容易。
//        原理：Java 通过 Thread 类和 Runnable 接口来创建和管理线程，使用 synchronized 关键字来保证线程之间的同步，避免数据竞争。
//        6. 丰富的标准库
//        解释：Java 提供了大量的标准类库，涵盖了输入输出、网络、数据库、GUI、并发等各种功能。
//        优点：你可以直接使用这些库来完成常见的开发任务，而不必自己从头编写。
//        7. 安全性
//        解释：Java 的安全性设计非常严密，能够有效避免很多常见的安全问题。通过 Java 安全管理器和字节码验证机制，Java 可以有效防止恶意代码的执行。
//        原理：Java 提供了一种安全的执行环境，可以限制应用程序对系统资源的访问，防止程序执行潜在的有害操作。
//        8. 跨平台性
//        解释：Java 程序通过 JVM 实现跨平台执行，Java 程序可以在不同操作系统上运行，如 Windows、Linux、macOS 等。
//        原理：只要目标操作系统上安装了相应的 JVM，就可以执行相同的字节码。
//        9. 高性能
//        解释：Java 是一种编译型语言，编译后的字节码执行速度较快，而且随着 JVM 和垃圾回收技术的优化，Java 性能也在不断提高。
//        优化：现代的 JIT（即时编译）技术可以将热点代码编译成本地机器码，从而提高执行效率。
//        10. 大规模应用支持
//        解释：Java 具有良好的扩展性，适合开发大规模的应用，广泛应用于企业级应用、Web 开发和大数据处理等领域。

    }
}

package main

import (
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "gorm.io/gorm/schema"
    "time"
)

// 定义模型
type Admin struct {
    ID uint `gorm:"primaryKey;not null"`
    Username string `gorm:"size:100;not null"`
    Password string `gorm:"size:200;not null"`
    Nickname string `gorm:"size:100"`
    CreatedAt time.Time `gorm:"type:datetime"`
    UpdatedAt time.Time `gorm:"type:datetime"`
}

var DB *gorm.DB

func main(){

    dsn := "test:test@tcp(127.0.0.1:3306)/gormdemo1?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
        NamingStrategy: schema.NamingStrategy{
            TablePrefix:   "la_", // 设置表前缀
            SingularTable: false,      // 禁用表名复数
        },
    })
    if err != nil {
        fmt.Println("数据库连接失败")
    }

    DB = db

    // 创建表
    DB.AutoMigrate(&Admin{})

    // 添加数据
    admin1 := Admin{
        Username:"admin",
        Password:"pwd",
        Nickname:"nickadm",
    }

    DB.Create(&admin1)

    if admin1.ID > 0 {
        fmt.Println("创建成功")
    }

    var searchadm1 Admin

    DB.Find(&searchadm1,3)

    fmt.Println(searchadm1)

    if searchadm1.ID > 0 {
        DB.Delete(searchadm1)
    }

    fmt.Println("执行完成")

}

package main

import (
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
    "gorm.io/gorm/schema"
    "time"
)

// 定义用户模型
type User struct {
    ID uint `gorm:"primaryKey;not null"`
    Name string `gorm:"size:100"`
    Mobile string `gorm:"uniqueIndex;size:20"`
    CreatedAt time.Time
    UpdatedAt time.Time
}

func main(){

    dsn := "root:123456@tcp(127.0.0.1:3306)/gormdemo1?charset=utf8mb4&parseTime=True&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
        NamingStrategy: schema.NamingStrategy{
            TablePrefix:   "tes_", // 设置表前缀
            SingularTable: false,      // 禁用表名复数
        },
    })
    if err != nil {
        fmt.Println("数据库连接失败: %v", err)
    }

    fmt.Println("数据库连接成功!")

    err = db.AutoMigrate(&User{})
    if err != nil {
        fmt.Println("创建User表失败: %v", err)
    }
    fmt.Println("创建User表成功")

    // 添加一条数据
    // user1 := User{
    //  Name:"user1",
    //  Mobile:"1000000000",
    // }

    // result := db.Create(&user1)

    // if result.Error != nil {
    //  fmt.Println("failed to create user: %v", result.Error)
    // }

    // fmt.Println(user1)

    // 查询数据
    var user User

    // 主键查询
    db.Find(&user,1)

    var user2 User

    // 条件查询
    db.Find(&user2,"mobile = ?","1000000000")

    fmt.Println(user)
    fmt.Println(user2)

    // 模拟动态条件
    var wheres = make(map[string]interface{})
    wheres["name"] = "test"
    wheres["mobile"] = "111"
    // wheres := map[string]interface{}{"name":"test","mobile":"1111",}

    var user3 User
    query := db.Model(&User{})
    for key,value := range wheres{

        if value != "" {
            query = query.Where(fmt.Sprintf("%s = ?", key), value)
        }
    }
    query.Find(&user3)

    var upduser User
    db.Find(&upduser,1)
    // 更新某个字段
    db.Model(&upduser).Update("mobile","123123")

    // 更新多个字段
    db.Model(&upduser).Updates(&User{Name:"aaaa",Mobile:"1000000000"})

    // 删除
    db.Delete(&upduser)

    // 查询多条数据
    var userlist []User
    db.Where("id > ?",0).Find(&userlist)
    fmt.Println(userlist)
    for k,v := range userlist {
        fmt.Println(k)
        fmt.Println(v.Name)
    }

    var orderlist []User
    // 分页及排序
    db.Order("id desc").Limit(10).Offset(0).Find(&orderlist)

    fmt.Println(orderlist)

    // 事务操作
    err = db.Transaction(func(tx *gorm.DB) error {
        if err := tx.Create(&User{Name: "User1",Mobile:"1700000111"}).Error; err != nil {
            return err
        }
        if err := tx.Create(&User{Name: "User2",Mobile:"160000"}).Error; err != nil {
            return err
        }
        return nil
    })

    if err != nil {
        fmt.Println("出现事务错误")
        fmt.Println(err)
    }

    pageFind(db)

    // 关闭连接
    mysqldb,err := db.DB()

    mysqldb.Close()

}

// 分页查询，处理总数量、总页数
func pageFind(db *gorm.DB){

    fmt.Println("进入分页方法查询")

    var totalCount int64

    query := db.Model(&User{}).Where("id > 0")

    // 查询总数量
    query.Count(&totalCount)

    // 查询当前页数据
    var list []User

    pageSize := 2
    currentPage := 0

    db.Limit(pageSize).Offset(currentPage).Find(&list)

    // 计算总页数
    totalPages := (totalCount + int64(pageSize) - 1) / int64(pageSize)

    fmt.Println("分页查询完毕")
    fmt.Println(list)
    fmt.Println("总数量",totalCount,"总页数",totalPages)
}