MP4封装mjpeg代码

MP4 (MPEG-4 Part 14) 是一种常见的多媒体文件格式，而 MJPEG (Motion JPEG) 则是一种连续帧的静止图像压缩编码技术，常用于实时视频流。要在MP4文件中封装MJPG数据，通常需要使用一些库如FFmpeg，它提供了一套强大的多媒体处理工具。

以下是使用FFmpeg将MJPG序列封装到MP4的基本步骤：

ffmpeg -i input_mjpeg.jpg -f mjpeg -vcodec libx264 -crf 23 -pix_fmt yuv420p output.mp4

解释一下命令参数：
- `-i input_mjpeg.jpg`：指定输入的MJPG图片文件名。
- `-f mjpeg`：设置输出的编码格式为 Motion JPEG。
- `-vcodec libx264`：使用H.264编码算法，这是MP4常用的视频编码标准。
- `-crf 23`：控制视频的质量和大小，数值越低质量越高，文件越大。
- `-pix_fmt yuv420p`：色彩空间格式，yuv420p适合大多数设备和网络传输。
- `output.mp4`：输出的MP4文件名。

相关问题

MP4封装mjpeg c++代码

在C++中，MP4是一种常见的多媒体文件格式，而MJPEG（Motion JPEG）是压缩视频的一种方法，常用于实时视频编码。将MJPEG数据封装到MP4文件中需要一些库的帮助，如FFmpeg，因为直接操作媒体文件可能会很复杂。以下是一个简化的FFmpeg封装示例，但这并不包括MJPEG编码过程，通常会先通过解码或者其他方式获得MJPEG数据。

#include <string>
#include <cstdlib>
#include <cstring>

int main() {
    const char* input_mjpeg_data = ... // MJPEG数据
    const size_t mjpeg_size = strlen(input_mjpeg_data);
    const char* output_mp4_file = ... // 输出MP4文件路径

    // 使用FFmpeg的avformat_write_header开始写入头部信息
    av_register_all();
    AVFormatContext* format_ctx = avformat_alloc_context3(NULL);
    if (!format_ctx) {
        // 处理错误...
        return -1;
    }
    format_ctx->oformat = av_guess_format("mp4", NULL, NULL); // 指定输出格式为MP4
    if (!format_ctx->oformat) {
        // 处理错误...
        avformat_free_context(format_ctx);
        return -1;
    }

    AVStream* stream = avformat_new_stream(format_ctx, NULL);
    if (!stream) {
        // 处理错误...
        avformat_free_context(format_ctx);
        return -1;
    }
    stream->codecpar->codec_id = AV_CODEC_ID_MJPEG; // 设置流的编码格式为MJPEG

    // 初始化并设置MJPEG参数
    AVCodecParameters* codec_params = stream->codecpar;
    codec_params->width = ...; // 视频宽度
    codec_params->height = ...; // 视频高度
    codec_params->time_base.num = 1; // 帧率
    codec_params->time_base.den = ...; // 帧率

    // 写入MJPEG数据到MP4文件
    FILE* file = fopen(output_mp4_file, "wb");
    if (!file) {
        // 处理错误...
        avformat_close_input(&format_ctx);
        return -1;
    }
    if (avio_open(&format_ctx->pb, file, AVIO_FLAG_WRITE | AVIO_FLAG_TRUNCATE) < 0) {
        // 处理错误...
        fclose(file);
        avformat_close_input(&format_ctx);
        return -1;
    }
    if (avformat_write_header(format_ctx, NULL) < 0) {
        // 处理错误...
        fclose(file);
        avformat_close_input(&format_ctx);
        return -1;
    }
    av_interleaved_write_frame(format_ctx, &input_mjpeg_data[0], mjpeg_size);

    // 结束写入并关闭文件
    avio_close(format_ctx->pb);
    fclose(file);
    avformat_write_trailer(format_ctx);
    avformat_free_context(format_ctx);

    return 0;
}

请注意，这个示例假设你已经包含了必要的FFmpeg库，并且对FFmpeg API有一定的了解。实际应用中可能需要根据具体需求调整编码参数和处理流程。

MP4可以封装MJPEG格式吗，帮忙给出参考代码

是的，MP4可以封装MJPEG格式。下面是一个使用FFmpeg库进行封装的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <errno.h>
#include <unistd.h>

#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libavutil/imgutils.h>
#include <libavutil/mathematics.h>
#include <libavutil/time.h>

#define STREAM_DURATION 10.0
#define STREAM_FRAME_RATE 25 /* 25 images/s */
#define STREAM_PIX_FMT AV_PIX_FMT_YUV420P /* default pix_fmt */

static AVFormatContext *format_ctx;
static AVCodecContext *codec_ctx;
static AVStream *stream;
static char *output_file = "output.mp4";
static int video_frame_count;

static int open_video(void)
{
    AVCodec *codec;
    int ret;

    codec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
    if (!codec) {
        fprintf(stderr, "Codec not found\n");
        exit(1);
    }

    codec_ctx = avcodec_alloc_context3(codec);
    if (!codec_ctx) {
        fprintf(stderr, "Could not allocate video codec context\n");
        exit(1);
    }

    codec_ctx->bit_rate = 400000;
    codec_ctx->width = 640;
    codec_ctx->height = 480;
    codec_ctx->time_base = (AVRational){1, STREAM_FRAME_RATE};
    codec_ctx->pix_fmt = STREAM_PIX_FMT;
    codec_ctx->codec_id = AV_CODEC_ID_MJPEG;
    codec_ctx->codec_type = AVMEDIA_TYPE_VIDEO;

    if (format_ctx->oformat->flags & AVFMT_GLOBALHEADER)
        codec_ctx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;

    ret = avcodec_open2(codec_ctx, codec, NULL);
    if (ret < 0) {
        fprintf(stderr, "Could not open codec: %s\n", av_err2str(ret));
        exit(1);
    }

    stream = avformat_new_stream(format_ctx, NULL);
    if (!stream) {
        fprintf(stderr, "Could not allocate video stream\n");
        exit(1);
    }

    ret = avcodec_parameters_from_context(stream->codecpar, codec_ctx);
    if (ret < 0) {
        fprintf(stderr, "Could not copy codec parameters: %s\n", av_err2str(ret));
        exit(1);
    }

    av_dump_format(format_ctx, 0, output_file, 1);

    return 0;
}

static void write_video_frame(AVFrame *frame)
{
    int ret;
    AVPacket pkt = { 0 };

    av_init_packet(&pkt);

    /* encode the image */
    ret = avcodec_send_frame(codec_ctx, frame);
    if (ret < 0) {
        fprintf(stderr, "Error sending a frame for encoding: %s\n", av_err2str(ret));
        exit(1);
    }

    while (ret >= 0) {
        ret = avcodec_receive_packet(codec_ctx, &pkt);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            return;
        else if (ret < 0) {
            fprintf(stderr, "Error during encoding: %s\n", av_err2str(ret));
            exit(1);
        }

        pkt.stream_index = stream->index;

        /* Write the compressed frame to the media file. */
        av_interleaved_write_frame(format_ctx, &pkt);

        av_packet_unref(&pkt);
    }
}

int main(int argc, char **argv)
{
    int ret;
    AVFrame *frame = NULL;
    int got_frame = 0;
    int64_t start_time;

    av_register_all();
    avformat_alloc_output_context2(&format_ctx, NULL, NULL, output_file);
    if (!format_ctx) {
        fprintf(stderr, "Could not create output context\n");
        exit(1);
    }

    open_video();

    ret = avio_open(&format_ctx->pb, output_file, AVIO_FLAG_WRITE);
    if (ret < 0) {
        fprintf(stderr, "Could not open output file '%s': %s\n", output_file, av_err2str(ret));
        exit(1);
    }

    start_time = av_gettime();

    avformat_write_header(format_ctx, NULL);

    for (;;) {
        AVPacket pkt = { 0 };
        av_init_packet(&pkt);

        /* Prepare a dummy image. */
        if (!frame) {
            if (!(frame = av_frame_alloc())) {
                fprintf(stderr, "Could not allocate video frame\n");
                exit(1);
            }
            frame->format = codec_ctx->pix_fmt;
            frame->width  = codec_ctx->width;
            frame->height = codec_ctx->height;

            /* Allocate the buffer for the frame data. */
            ret = av_image_alloc(frame->data, frame->linesize, codec_ctx->width, codec_ctx->height, codec_ctx->pix_fmt, 32);
            if (ret < 0) {
                fprintf(stderr, "Could not allocate raw picture buffer\n");
                exit(1);
            }
        }

        /* Prepare a dummy image. */
        /* Y */
        for (int y = 0; y < codec_ctx->height; y++) {
            for (int x = 0; x < codec_ctx->width; x++) {
                frame->data[0][y * frame->linesize[0] + x] = x + y + video_frame_count * 3;
            }
        }

        /* Cb and Cr */
        for (int y = 0; y < codec_ctx->height / 2; y++) {
            for (int x = 0; x < codec_ctx->width / 2; x++) {
                frame->data[1][y * frame->linesize[1] + x] = 128 + y + video_frame_count * 2;
                frame->data[2][y * frame->linesize[2] + x] = 64 + x + video_frame_count * 5;
            }
        }

        frame->pts = av_rescale_q(av_gettime() - start_time, (AVRational){1, 1000000}, codec_ctx->time_base);
        video_frame_count++;

        write_video_frame(frame);

        if (video_frame_count >= STREAM_DURATION * STREAM_FRAME_RATE)
            break;
    }

    av_write_trailer(format_ctx);

    avcodec_free_context(&codec_ctx);
    av_frame_free(&frame);
    avio_closep(&format_ctx->pb);
    avformat_free_context(format_ctx);

    return 0;
}

这个示例代码将生成一个10秒长的MJPEG格式视频，并将其封装为MP4格式。你可以根据自己的需求修改代码中的参数。