gstreamer的I420转jpeg格式数据产生耗时

已于 2023-10-20 16:13:10 修改
阅读量292 收藏 2
点赞数
文章标签： 前端 javascript 算法
于 2023-10-20 16:12:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_23350817/article/details/133948654
版权

1、将I430数据转化为jpg数据

JPegEncoder.h

#pragma once
#include <cstdint>
#include <vector>
#include <functional>
#include <gst/gst.h>
#include <gst/app/gstappsink.h>
#include "Resolution.h"
#include "VideoSettings.h"

namespace sinftech {
namespace tv {
class JpegEncoder {
public:
  using Handler = std::function<void(const uint8_t* data, size_t size, const Resolution& resolution)>;
  JpegEncoder(Handler&& handler);
  ~JpegEncoder();
  void encode(const uint8_t* data, size_t size, const Resolution& resolution);
  void start(const VideoSettings& settings);
  void stop();

private:
  static GstFlowReturn _onEncoded(GstAppSink *appsink, gpointer user_data);
  GstElement* _pipeline;
  GstElement* _source;
  GstElement* _queue0;
  GstElement* _convert;
  GstElement* _scale;
  GstElement* _rate;
  GstElement* _capsfilter;
  GstElement* _queue1;
  GstElement* _encode;
  GstElement* _queue2;
  GstElement* _sink;
  Handler _handler;
};
}//namespace tv
}//namespace sinftech

JPegEncoder.cpp

#include "JpegEncoder.h"
#include <gst/app/gstappsrc.h>
#include <gst/video/video.h>
#include "Check.h"
#include <windows.h>

namespace sinftech {
namespace tv {

GstFlowReturn JpegEncoder::_onEncoded(GstAppSink *appsink, gpointer user_data) {
  JpegEncoder* pThis = static_cast<JpegEncoder*>(user_data);
  GstSample* sample = gst_app_sink_pull_sample(appsink);
  if (sample != NULL) {
    GstCaps* caps = gst_sample_get_caps(sample);
    gint width, height;
    GstStructure* structure = gst_caps_get_structure(caps, 0);
    gst_structure_get_int(structure, "width", &width);
    gst_structure_get_int(structure, "height", &height);
    GstBuffer* buffer = gst_sample_get_buffer(sample);
    if (buffer != NULL) {
      GstMapInfo map;
      if (gst_buffer_map(buffer, &map, GST_MAP_READ)) {
        if (pThis->_handler) {
          pThis->_handler(map.data, map.size, {uint16_t(width), uint16_t(height)});
        }
        gst_buffer_unmap(buffer, &map);
      }
    }
    gst_sample_unref(sample);
  }
  return GST_FLOW_OK;
}

JpegEncoder::JpegEncoder(Handler&& handler)
  : _handler(std::move(handler)) {
  gst_init(nullptr, nullptr);
  _pipeline   = chk(gst_pipeline_new(nullptr));
  _source     = chk(gst_element_factory_make("appsrc",       nullptr));
  _queue0     = chk(gst_element_factory_make("queue",        nullptr));
  _convert    = chk(gst_element_factory_make("videoconvert", nullptr));
  _scale      = chk(gst_element_factory_make("videoscale",   nullptr));
  _rate       = chk(gst_element_factory_make("videorate",    nullptr));
  _capsfilter = chk(gst_element_factory_make("capsfilter",   nullptr));
  _queue1     = chk(gst_element_factory_make("queue",        nullptr));
  _encode     = chk(gst_element_factory_make("jpegenc",      nullptr));
  _queue2     = chk(gst_element_factory_make("queue",        nullptr));
  _sink       = chk(gst_element_factory_make("appsink",      nullptr));

  g_object_set(_source, "is-live", true, "do-timestamp", true, "format", GST_FORMAT_TIME, NULL);
  g_object_set(_queue0, "leaky", 2, NULL);
  g_object_set(_capsfilter, "caps-change-mode", 1, NULL);
  g_object_set(_queue1, "leaky", 2, NULL);
  g_object_set(_queue2, "leaky", 2, NULL);
  g_object_set(_sink, "sync", false, "enable-last-sample", false, "drop", true, "max-buffers", 200, "max-lateness", 1000000000ll, NULL);

  GstAppSinkCallbacks callbacks{nullptr, nullptr, &_onEncoded};
  gst_app_sink_set_callbacks(GST_APP_SINK(_sink), &callbacks, this, nullptr);

  gst_bin_add_many(GST_BIN(_pipeline), _source, _queue0, _convert, _scale, _rate, _capsfilter, _queue1, _encode, _queue2, _sink, NULL);
  gst_element_link_many(               _source, _queue0, _convert, _scale, _rate, _capsfilter, _queue1, _encode, _queue2, _sink, NULL);
}

JpegEncoder::~JpegEncoder() {
  gst_element_set_state(_pipeline, GST_STATE_NULL);
  gst_object_unref(_pipeline);
}

void JpegEncoder::start(const VideoSettings& settings) {
  stop();
  GstCaps* caps = gst_caps_new_simple(
    "video/x-raw",
    "format", G_TYPE_STRING, "I420",
    "width", G_TYPE_INT, settings.resolution.width,
    "height", G_TYPE_INT, settings.resolution.height,
    "framerate", GST_TYPE_FRACTION, settings.fps, 1,
    NULL);
  g_object_set(_capsfilter, "caps", caps, NULL);
  gst_caps_unref(caps);

  gst_element_set_state(_pipeline, GST_STATE_PLAYING);
}

void JpegEncoder::stop() {
  gst_element_set_state(_pipeline, GST_STATE_NULL);
}

void JpegEncoder::encode(const uint8_t* data, size_t size, const Resolution& resolution) {
  GstState state = GST_STATE_NULL;
  GstState pending = GST_STATE_NULL;
  gst_element_get_state(_pipeline, &state, &pending, 0);
  if (state == GST_STATE_PLAYING || pending == GST_STATE_PLAYING) {
    GstBuffer* buffer = gst_buffer_new_and_alloc(size);
    if (buffer != NULL) {
      GstMapInfo map;
      if (gst_buffer_map(buffer, &map, GST_MAP_WRITE)) {
        memcpy(map.data, data, size);
        gst_buffer_unmap(buffer, &map);
        GstVideoInfo videoInfo;
        gst_video_info_set_format(&videoInfo, GST_VIDEO_FORMAT_I420, resolution.width, resolution.height);
        GstCaps* caps = gst_video_info_to_caps(&videoInfo);
        GstSample* sample = gst_sample_new(buffer, caps, nullptr, nullptr);
        gst_caps_unref(caps);
        if (sample != NULL) {
          gst_app_src_push_sample(GST_APP_SRC(_source), sample);
          gst_sample_unref(sample);
        }
      }
      gst_buffer_unref(buffer);
    }
  }
}

}//namespace tv
}//namespace sinftech

测试发现插件rate产生耗时(gstreamer在同步时间产生耗时), 并且一个输入会产生多个输出。耗时解释如下：

gstreamer的videorate插件的耗时取决于多个因素，包括输入视频帧率、输出视频帧率以及系统硬件性能等。在实际使用中，可以通过测试和性能优化来评估具体情况。

一般来说，videorate插件的耗时较低，因为它只是简单地调整视频帧的时间戳而不涉及复杂的图像处理操作。但是，如果输入和输出之间的帧率差异很大或者需要进行额外的转码操作，则可能会增加一些延迟。

现修改如下：

#include "JpegEncoder.h"
#include <gst/app/gstappsrc.h>
#include <gst/video/video.h>
#include "Check.h"
#include <windows.h>

#include <string>
#include <chrono>
#include <ctime>

namespace sinftech {
namespace tv {

GstFlowReturn JpegEncoder::_onEncoded(GstAppSink *appsink, gpointer user_data) {
  JpegEncoder* pThis = static_cast<JpegEncoder*>(user_data);
  GstSample* sample = gst_app_sink_pull_sample(appsink);
  if (sample != NULL) {
    GstCaps* caps = gst_sample_get_caps(sample);
    gint width, height;
    GstStructure* structure = gst_caps_get_structure(caps, 0);
    gst_structure_get_int(structure, "width", &width);
    gst_structure_get_int(structure, "height", &height);
    GstBuffer* buffer = gst_sample_get_buffer(sample);
    if (buffer != NULL) {
      GstMapInfo map;
      if (gst_buffer_map(buffer, &map, GST_MAP_READ)) {
        if (pThis->_handler) {
          pThis->_handler(map.data, map.size, {uint16_t(width), uint16_t(height)});
          //pThis->SaveVideoDatToFile(map.data, map.size, 2);
        }
        gst_buffer_unmap(buffer, &map);
      }
    }
    gst_sample_unref(sample);
  }
  return GST_FLOW_OK;
}

JpegEncoder::JpegEncoder(Handler&& handler, bool bEncoderEnable)
  : _handler(std::move(handler)) {

    m_bEncoderEnable = bEncoderEnable;
  //gst_debug_set_active(TRUE);
  //gst_debug_set_default_threshold(GST_LEVEL_WARNING);
    if (m_bEncoderEnable)
    {
        gst_init(nullptr, nullptr);
        _pipeline = chk(gst_pipeline_new(nullptr));
        _source = chk(gst_element_factory_make("appsrc", nullptr));
        _queue0 = chk(gst_element_factory_make("queue", nullptr));
        _convert = chk(gst_element_factory_make("videoconvert", nullptr));
        _scale = chk(gst_element_factory_make("videoscale", nullptr));
        _capsfilter = chk(gst_element_factory_make("capsfilter", nullptr));
        _queue1 = chk(gst_element_factory_make("queue", nullptr));
        _encode = chk(gst_element_factory_make("jpegenc", nullptr));
        _queue2 = chk(gst_element_factory_make("queue", nullptr));
        _sink = chk(gst_element_factory_make("appsink", nullptr));

        g_object_set(_source, "is-live", true, "do-timestamp", true, "format", GST_FORMAT_TIME, NULL);
        g_object_set(_queue0, "leaky", 2, NULL);
        g_object_set(_capsfilter, "caps-change-mode", 1, NULL);
        g_object_set(_queue1, "leaky", 2, NULL);
        g_object_set(_queue2, "leaky", 2, NULL);
        //g_object_set(_sink, "sync", false, "enable-last-sample", false, "drop", true, "max-buffers", 200, "max-lateness", 1000000000ll, NULL);
        g_object_set(_sink, "sync", true, "enable-last-sample", true, "drop", true, "max-buffers", 1, "max-lateness", 1, NULL);

        GstAppSinkCallbacks callbacks{ nullptr, nullptr, &_onEncoded };
        gst_app_sink_set_callbacks(GST_APP_SINK(_sink), &callbacks, this, nullptr);

        gst_bin_add_many(GST_BIN(_pipeline), _source, _queue0, _convert, _scale, _capsfilter, _queue1, _encode, _queue2, _sink, NULL);
        gst_element_link_many(_source, _queue0, _convert, _scale, _capsfilter, _queue1, _encode, _queue2, _sink, NULL);
    }
}

JpegEncoder::~JpegEncoder() {
    if (m_bEncoderEnable)
    {
        gst_element_set_state(_pipeline, GST_STATE_NULL);
        gst_object_unref(_pipeline);
    }
}

void JpegEncoder::start(const VideoSettings& settings) 
{
    if (!m_bEncoderEnable)
        return;

	if (0 != settings.fps && settings != _settings)
	{
		_settings = settings;
		pause();
		GstCaps* caps = gst_caps_new_simple(
			"video/x-raw",
			"format", G_TYPE_STRING, "I420",
			"width", G_TYPE_INT, settings.resolution.width,
			"height", G_TYPE_INT, settings.resolution.height,
			"framerate", GST_TYPE_FRACTION, settings.fps, 1,
			NULL);
		g_object_set(_capsfilter, "caps", caps, NULL);
		gst_caps_unref(caps);

		gst_element_set_state(_pipeline, GST_STATE_PLAYING);
	}
	else
	{
		//do nothing
	}
}

void JpegEncoder::pause(void)
{
    if (!m_bEncoderEnable)
        return;

	gst_element_set_state(_pipeline, GST_STATE_NULL);
}

void JpegEncoder::stop() {
    if (!m_bEncoderEnable)
        return;

	pause();
	_settings.fps = 0;  //force reset setting
}

void JpegEncoder::encode(const uint8_t* data, size_t size, const Resolution& resolution) {

    if (!m_bEncoderEnable)
        return;

  //SaveVideoDatToFile(data, size, 1);

  GstState state = GST_STATE_NULL;
  GstState pending = GST_STATE_NULL;
  gst_element_get_state(_pipeline, &state, &pending, 0);
  if (state == GST_STATE_PLAYING || pending == GST_STATE_PLAYING) {
    GstBuffer* buffer = gst_buffer_new_and_alloc(size);
    if (buffer != NULL) {
      GstMapInfo map;
      if (gst_buffer_map(buffer, &map, GST_MAP_WRITE)) {
        memcpy(map.data, data, size);
        gst_buffer_unmap(buffer, &map);
        GstVideoInfo videoInfo;
        gst_video_info_set_format(&videoInfo, GST_VIDEO_FORMAT_I420, resolution.width, resolution.height);
        GstCaps* caps = gst_video_info_to_caps(&videoInfo);
        GstSample* sample = gst_sample_new(buffer, caps, nullptr, nullptr);
        gst_caps_unref(caps);
        if (sample != NULL) {
          gst_app_src_push_sample(GST_APP_SRC(_source), sample);
          gst_sample_unref(sample);
        }
      }
      gst_buffer_unref(buffer);
    }
  }
}

std::string JpegEncoder::GetCurFormatTime()
{
    auto now = std::chrono::system_clock::now();
    std::time_t time = std::chrono::system_clock::to_time_t(now);
    std::tm* tm = std::localtime(&time);

    auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
        now.time_since_epoch()).count() % 1000;

    return std::move(std::to_string(tm->tm_year + 1900)
        + "-" + std::to_string(tm->tm_mon + 1)
        + "-" + std::to_string(tm->tm_mday)
        + "_" + std::to_string(tm->tm_hour)
        + "-" + std::to_string(tm->tm_min)
        + "-" + std::to_string(tm->tm_sec)
        + "." + std::to_string(ms));
}

void JpegEncoder::SaveVideoDatToFile(const uint8_t* data, size_t size, int type)
{
    std::string fileName;
    if (type == 1)
    {
        fileName = "input_" + GetCurFormatTime() + ".yuv";
    }
    else if (type == 2)
    {
        fileName = "output_" + GetCurFormatTime() + ".jpg";
    }
    
    FILE* fp = fopen(fileName.c_str(), "wb+");
    fwrite(data, size, 1, fp);
    fclose(fp);
}

}//namespace tv
}//namespace sinftech

2、jpeg数据转化为I420

JPegDecoder.h

#pragma once
#include <cstdint>
#include <vector>
#include <thread>
#include <gst/gst.h>
#include <gst/app/gstappsink.h>
#include "Resolution.h"
#include "VideoSettings.h"

namespace sinftech {
namespace tv {
class JpegDecoder {
public:
  using Handler = std::function<void(const uint8_t* data, size_t size, const Resolution& resolution)>;
  JpegDecoder(Handler&& handler);
  ~JpegDecoder();
  void decode(const uint8_t* data, size_t size);

private:
  static GstFlowReturn _onDecoded(GstAppSink *appsink, gpointer user_data);
  GstElement* _pipeline;
  GstElement* _source;
  GstElement* _queue0;
  GstElement* _decode;
  GstElement* _queue1;
  GstElement* _sink;
  Handler _handler;
};
}//namespace tv
}//namespace sinftech

JPegDecoder.cpp

#include "JpegDecoder.h"
#include <gst/app/gstappsrc.h>
#include <gst/video/video.h>
#include "Check.h"
#include <util/Log.h>

namespace sinftech {
namespace tv {

GstFlowReturn JpegDecoder::_onDecoded(GstAppSink *appsink, gpointer user_data) {
  JpegDecoder* pThis = static_cast<JpegDecoder*>(user_data);
  GstSample* sample = gst_app_sink_pull_sample(appsink);
  if (sample != NULL) {
    GstCaps* caps = gst_sample_get_caps(sample);
    gint width, height;
    GstStructure* structure = gst_caps_get_structure(caps, 0);
    gst_structure_get_int(structure, "width", &width);
    gst_structure_get_int(structure, "height", &height);
    GstBuffer* buffer = gst_sample_get_buffer(sample);
    if (buffer != NULL) {
      GstMapInfo map;
      if (gst_buffer_map(buffer, &map, GST_MAP_READ)) {
        if (pThis->_handler) {
          try {
            pThis->_handler(map.data, map.size, {uint16_t(width), uint16_t(height)});
          } catch (const std::exception& e) {
            util::log(std::string("jpeg decoder exception: ") + e.what());
            throw;
          } catch (...) {
            util::log("jpeg decoder exception: unknown");
            throw;
          }
        }
        gst_buffer_unmap(buffer, &map);
      }
    }
    gst_sample_unref(sample);
  }
  return GST_FLOW_OK;
}

JpegDecoder::JpegDecoder(Handler&& handler)
  : _handler(std::move(handler)) {
  gst_init(nullptr, nullptr);
  _pipeline = chk(gst_pipeline_new(nullptr));
  _source   = chk(gst_element_factory_make("appsrc",  nullptr));
  _queue0   = chk(gst_element_factory_make("queue",   nullptr));
  _decode   = chk(gst_element_factory_make("jpegdec", nullptr));
  _queue1   = chk(gst_element_factory_make("queue",   nullptr));
  _sink     = chk(gst_element_factory_make("appsink", nullptr));

  g_object_set(_source, "is-live", true, "do-timestamp", true, "format", GST_FORMAT_TIME, NULL);
  g_object_set(_queue0, "leaky", 2, NULL);
  g_object_set(_queue1, "leaky", 2, NULL);
  GstCaps* caps = gst_caps_new_simple("video/x-raw", "format", G_TYPE_STRING, "I420", NULL);
  g_object_set(_sink, "caps", caps, "sync", false, "enable-last-sample", false, "drop", true, "max-buffers", 200, "max-lateness", 1000000000ll, NULL);
  gst_caps_unref(caps);

  GstAppSinkCallbacks callbacks{nullptr, nullptr, &_onDecoded};
  gst_app_sink_set_callbacks(GST_APP_SINK(_sink), &callbacks, this, nullptr);

  gst_bin_add_many(GST_BIN(_pipeline), _source, _queue0, _decode, _queue1, _sink, NULL);
  gst_element_link_many(               _source, _queue0, _decode, _queue1, _sink, NULL);

  gst_element_set_state(_pipeline, GST_STATE_PLAYING);
}

JpegDecoder::~JpegDecoder() {
  gst_element_set_state(_pipeline, GST_STATE_NULL);
  gst_object_unref(_pipeline);
}

void JpegDecoder::decode(const uint8_t* data, size_t size) {
  GstState state = GST_STATE_NULL;
  GstState pending = GST_STATE_NULL;
  gst_element_get_state(_pipeline, &state, &pending, 0);
  if (state == GST_STATE_PLAYING || pending == GST_STATE_PLAYING) {
    GstBuffer* buffer = gst_buffer_new_and_alloc(size);
    if (buffer != NULL) {
      GstMapInfo map;
      if (gst_buffer_map(buffer, &map, GST_MAP_WRITE)) {
        memcpy(map.data, data, size);
        gst_buffer_unmap(buffer, &map);
        GstCaps* caps = gst_caps_new_simple("image/jpeg", NULL);
        GstSample* sample = gst_sample_new(buffer, caps, nullptr, nullptr);
        gst_caps_unref(caps);
        if (sample != NULL) {
          gst_app_src_push_sample(GST_APP_SRC(_source), sample);
          gst_sample_unref(sample);
        }
      }
      gst_buffer_unref(buffer);
    }
  }
}

}//namespace tv
}//namespace sinftech
Hello，C++！
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
YUV颜色空间转换（YV12、NV12、NV21、I420、RGB等）
08-17
本程序实现了简单的YUV数据之间的转换和YUV与RGB的转换。 注：1、本程序只是简单YUV之间的颜色空间转换和YUV与RGB的转换。 2、本程序使用的vs2019创建的，需使用2019打开工程。 3、包含功能： 1）YV12_2_I420； ...
【GStreamer 】 TX1中CPU和GPU解码显示海康相机RTSP流
cau_weiyuhu的博客
02-18 2729
使用GStreamer 在TX1中CPU和GPU解码显示海康相机RTSP流，并且对比了CPU和GPU解码的差别。
GStreamer 截取RTSP 视频帧
热门推荐
qthello
02-14 1万+
需求：无人机配套的某些低成本摄像机没有拍照功能，只有RTSP视频流的推送，因此可以利用GStreamer框架将视频帧进行保存，来达到拍照的效果。 思路： 在需要拍照的航点，触发信号。在GstVideoReciver.cpp 绑定此信号并进行视频帧的保存。 视频帧保存代码（某大神写的，非原创）： void GstVideoReceiver::takeMyScreenshot(const QString &imageFile) { // gpointer widget
opencv gstreamer
power的专栏
12-03 2839
https://www.ardusub.com/developers/opencv.html Top side computer To capture video stream with the python script and QGC at same time, it's necessary to modifygstreamer options, changing! udpsink h...
Deepstream 之 appsink元素保存图片
m_wordPlan的博客
11-16 3725
目录 1. appsink元素介绍 2. appsink 元素结合cv::Mat保存图片 2.1 开发环境 2.2 软件代码与说明 1. appsink元素介绍 appsink 元素作为gstreamer的sink节点，它可以实现pipeline中的流媒体数据与其他应用程序的交换，比如实现gstreamer与CUDA交互，gstreamer与OpenCV交互，等等。 主要作用是借助gstreamer pipeline的 media streaming, 我们通过appsink用一个buffer
nvjpeg与opencv 图片解码和预处理耗时对比
tbl1234567的博客
05-18 6855
nvjpeg与opencv 解码和预处理耗时对比 1. opencv c++与python jpeg decode对比 环境 CPU: AMD Ryzen 5 5600X 6-Core Processor 3.70 GHz 内存：32.0 GB C++ vs2017 MSVC编译器工具集 python 3.6.8 测试图片有两类： 数据集1 血片细胞图片尺寸：2448*2048. 数据集2 网上随机下载的自然风光，人物，汽车等20张图片，尺寸在471 *600 至 20
GStreamer第一阶段的简单总结
瞧，那小子真帅
04-27 913
1)了解pipeline的使用，简单说就是通道的概念, 因为涉及到数据的复用和拓展， 里面有一个filter(tee插件), 通过tee和后续拓展的绑定关系复用数据，很像许多Soc编解码芯片中的vpss通道的概念。数据复用为视频编码通道， 数据jpeg通道以及对数据处理的通道。2)重点是去了解Pad Templates 中的Availability,这个关系到link的方式，另外关注Element Properties的属性设置。
【GStreamer】利用GStreamer实现mp4格式视频播放
06-10
Linux平台C语言利用GStreamer实现mp4格式视频播放代码，包括管道配置，连接，以及动态连接element的pad。难点：demux控件通过回调方式进行音视频的分流，连接解码器、sink输出。
gstreamer 拉流rtsp使用appsink获取帧数据（预览+截图）
11-11
在本文中，我们将深入探讨如何使用GStreamer框架从RTSP流中拉取视频，并通过`appsink`组件来获取帧数据，以便进行预览和截图。GStreamer是一个强大的开源多媒体处理框架，广泛应用于Linux系统中，它允许开发者构建...
qt+gstreamer中如何使用probe（探针）获取帧数据
11-15
对于视频，这通常涉及解码像素格式，例如NV12、I420等。 2. **转换图像格式**: 为了方便后续处理，通常需要将GstBuffer转换为更易于操作的格式，如OpenCV的`cv::Mat`或Qt的`QImage`。 ```cpp QImage ...
linux C语言实现yuyv拍照保存并转为jpeg格式
10-16
5. **保存JPEG图片**：JPEG编码完成后，使用文件I/O操作将JPEG数据写入文件。可以使用标准的文件操作函数如`fopen`、`fwrite`和`fclose`来完成这个任务。 6. **优化和性能**：为了提高效率，可以考虑使用多线程技术...
Gstreamer基础教程14：好用的元素
R_X
06-07 1439
文章目录1. Goal2. Elements2.1 Bins1. playbin2. uridecodebin3. decodebin2.2 File input/output1. filesrc2. filesink2.3 Network1. souphttpsrc2.4 Test media generation1. videotestsrc2. audiotestsrc2.5 Video adapters1. videoconvert2. videorate3. videoscale2.6 Audio
Gstreamer 实现预览与动态录像
最新发布
qq_44334499的博客
10-08 769
Gstreamer 预览与动态录像
gstreamer 常用element
fanzirong_的博客
01-07 1578
一、bin，这些bin在内部包含了element，但是在外部还是把它看做一个element。 1、playbin：它会处理播放器从source经过解复用、解码到显示的过程，同时它也非常灵活，有很多的设置项。 2、uridecodebin：从一个uri获取数据，然后解码成原始数据。 二、文件输入和输出 1、filesrc：读取一个本地文件然后用caps输出媒体数据 2、filesink：这...
GStreamer显示图片
简单即美
03-21 3850
<br />曾使用gst-launch-0.10和playbin2显示常见格式的图片，命令如下：<br /> <br />gst-launch-0.10 playbin2 uri=file:///home/user/Pictures/filename.jpg<br />gst-l
Kurento 源码解析系列（2）- PlayerEndpoint的初始化过程
ywcai
07-18 856
Kurento 源码解析系列（2）- PlayerEndpoint的初始化 一个将源项目各个子项目整合并编译以后的工程地址 https://github.com/ywcai/JKms.git PlayerEndpoint.cpp 初始化过程代码分析 回顾 PlayerEndpointImpl.cpp初始化的过程，会先初始化他的父类MediaElementImpl.cpp以及UriEndpointImpl.cpp.其中MediaELement.CPP会作最重要的c层gstreamer插件的初始化工作:
gstreamer 插件 编码 解码 混合器 分离器 命令大全
believe的专栏
02-11 4981
Video Test Source To generate a test video stream use videotestsrc[2]: gst-launch videotestsrc ! ximagesink Use the pattern property to select a specific pattern: gst-launch videotestsrc pat
【GStreamer 】5-2 gstreamer实现RTSP相机保存JPG照片
cau_weiyuhu的博客
12-21 1925
gstreamer实现RTSP相机保存JPG照片
Gstreamer-音频数据播放之AAC
JIJSIDUH的博客
07-27 303
需要在当前设备端播放，AAC编码格式的音频数据。
gstreamer 插件耗时
04-29
GStreamer的插件是一个非常重要的组件，它可以将多个不同来源的多媒体流混合在一起。插件功能非常强大，但是在使用过程中可能会比较耗时。主要有以下几个原因： 第一，插件本身可能会比较占用CPU和内存资源。这是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值