[参考译文] AM5728：双摄像头编码

AM5728 EVM 板只有一个摄像头接口。 您将如何馈送第二个摄像头输入？ 您如何尝试创建用例-通过 gstreamer 流水线或在 V4L2和 DCE 接口层工作？

谢谢、我使用 gstreamer 方法推送 NV12数据、现在我使用两个线程创建两个流水线、但只有一个工作。 在每个线程中，我读取不同的文件。  我将 H264数据写入两个文件。 如果我只使用一个线程 、我会获得正确的数据。 如果我使用两个线程，则只有一个线程可以获得正确的数据。 谢谢

////////// 这是我的 buscall.h ///////////////////////

#ifndef BUSCALL_H
#define BUSCALL_H

#include
#include

gboolean bus_call (GstBus *总线、GstMessage * msg、gpointer 数据)；
gboolean bus_callTwo (GstBus *总线、GstMessage * msg、gpointer 数据)；

unsigned int MyGetTickCount()；
#endif // BUSCALL_H

////// 这是我的 buscall.cpp ////////////////////

#include "buscall.h"
#include
#include
#include

gboolean bus_call (GstBus *总线、GstMessage * msg、gpointer 数据)
｛
   GMainLoop * loop =(GMainLoop *)数据；
   开关(GST_MESSAGE_TYPE (消息))
   ｛

   案例 GST_MESSAGE_EOS：
       fprintf (stderr、"流结束\n")；
       G_MAIN_LOOP_QUIT (LOOP)；
       中断；

   案例 GST_MESSAGE_ERROR：
   ｛
       gchar *调试；
       GError *错误；
       GST_MESSAGE_PART_ERROR (msg、&error、&DEBUG)；
       G_FREE (调试)；
       G_printerr ("错误：%s\n"、错误->消息)；
       G_ERROR_FREE (错误)；
       G_MAIN_LOOP_QUIT (LOOP)；
       中断；
   ｝
   默认值：
       中断；
   ｝

   返回 true；
｝



gboolean bus_callTwo (GstBus *总线、GstMessage *消息、gpointer 数据)
｛
   GMainLoop * loop =(GMainLoop *)数据；
   开关(GST_MESSAGE_TYPE (消息))
   ｛

   案例 GST_MESSAGE_EOS：
       fprintf (stderr、"流结束\n")；
       G_MAIN_LOOP_QUIT (LOOP)；
       中断；

   案例 GST_MESSAGE_ERROR：
   ｛
       gchar *调试；
       GError *错误；
       GST_MESSAGE_PART_ERROR (msg、&error、&DEBUG)；
       G_FREE (调试)；
       G_printerr ("错误：%s\n"、错误->消息)；
       G_ERROR_FREE (错误)；
       G_MAIN_LOOP_QUIT (LOOP)；
       中断；
   ｝
   默认值：
       中断；
   ｝

   返回 true；
｝

////////////////////////////////////////////////// 这是我的 encode.h //////////////////////////////////////////////////////

#ifndef encode_H
#define encode_H
#include
#include
#include
#include
#include

int init_encodeTwo ()；
int startEncodeTwo (char *nv12buf，int NV12Len，char *encoddebugf，int* encodeLen)；
void PushBufferEncodeTwo (char *nv12buf，int len)；
char* pullH264EncodeTwo (int* outlen)；


int init_encode()；
int startEncode (char *nv12buf，int NV12Len，char *encodebedef，int* encodeLen)；
void PushBufferEncode (char *nv12buf，int len)；
CHAR* PullH264Encode (int* outlen);

#endif

//////////////// 这是我的 encode.cpp ////////////////////////////////////////////////////////////////////////////////////////////////////

#include
#include
#include

#include
#include
#include
#include
#include
#include
#include "buscall.h"


#if 1.
静态易失性 bool bGstreamerEncodeThreadStarted = false；
静态易失性 bool bGstreamerEncodeThreadFined= false；

静态 GstElement *appsrc；
静态 GstElement *appsink;

void* GstreamerEncodeThread (void* pThreadParam)
｛
   GMainLoop *LOOP；
   GstElement *管道，*编码；
   GstBus *总线；
   guint bus_watch_id；
   gboolean bLinkOk；

   流水线= GST_F管线_NEW ("mypipeline")；
   G_ASSERT (流水线)；
   appsrc = gst_element_factory_make ("appsrc"、"mysource")；
   G_ASSERT (appsrc)；
   编码= GST_ELECK_factory_make ("ducatih264en"、"myence")；
   G_ASSERT (编码)；
   appsink = gst_elue_factory_make ("appsink"、"mysink")；
   G_ASSERT (appsink)；

   if (！pipeline ||!appsrc ||!encode ||!appsink)
   ｛
       fprintf (stderr、"不能 gst_element_factory_make、正在终止\n")；
       bGstreamerEncodeThreadStarted = bGstreamerEncodeThreadFined= true；
       返回(void*) 0xDEAD；
   ｝

   GstCaps * capsappsrc2Jpegenc；//在 appsrc 和 jpegenc 之间
   capsappsrc2Jpegenc = gst_caps_new_full (
               GST_structure_new ("视频/x-raw "、
                                 "format"、G_TYPE_string、"NV12"、
                                 "宽度"、G_TYPE_INT、352、
                                 "高度"、G_TYPE_INT、288、
                                 "帧速率"、GST_TYPE_FRATE、15、1、
                                 null)、
               GST_structure_new ("video/x-h264"、
                                 "format"、G_TYPE_string、"NV12"、
                                 "宽度"、G_TYPE_INT、352、
                                 "高度"、G_TYPE_INT、288、
                                 null)、
               null)；

   循环= g_main_loop_new (NULL、false)；
   总线= GST_F管线_GET_BUS (GST_管线(管线))；
   bus_watch_id = gst_bus_add_watch (bus、bus_call、loop)；
   GST_OBJECT_UNREF (BUS)；

   gst_bin_add_many (gst_bin (流水线)、appsrc、编码、appsink、NULL)；

   bLinkOk = gst_element_link_filtered (appsrc、编码、capsappsrc2Jpegenc)；

   if (！bLinkOk)｛
       G_WARNING ("链接 src 编码\n"失败)；
       返回(void*) 0xDEAD；
   ｝


   GST_ELECK_LINK (编码、应用接收器)；
   G_object_set (G_object (appsrc)、
                 "stream-type"、gst_app_stream_type_stream、
                 "format"、gst_format_Bytes、
                 null)；

   G_object_set (G_object (编码)、
                "速率预设"、1、NULL)；

   fprintf (stderr、"将 g_main_loop_run 设置为 gst_state_play\n");
   GST_ELECK_SET_STATE (流水线、GST_STATE_Playing)；
   bGstreamerEncodeThreadStarted = true；
   G_MAIN_LOOP_RUN (LOOP)；
   fprintf (stderr、"g_main_loop_run returned、sterping\n"\})；

   //停止要释放的管道
   GST_ELECK_SET_STATE (流水线、GST_STATE_NULL)；
   fprintf (stderr、"删除管道\n")；
   GST_object_UNREF (GST_object (流水线))；

   g_source_remove (bus_watch_id)；
   G_MAIN_LOOP_UNREF (LOOP)；
   bGstreamerEncodedThreadFined= true；
   GST_OBJECT_UNREF (appsrc)；
   GST_OBJECT_UNREF (编码)；
   GST_OBJECT_UNREF (appsink)；
   GST_OBJECT_UNREF (capsappsrc2Jpegenc)；

   返回空；
｝




bool StartGstreamer()
｛

   unsigned long GtkThreadId；
   pthread_attr_t GtkAttr；

   int 结果= pthread_attr_init (&GtkAttr)；
   如果(结果！= 0)
   ｛
       fprintf (stderr、"pthread_attr_init 返回错误%d\n"、结果)；
       返回 false；
   ｝

   void* pParam =空；
   结果= pthread_create (&GtkThreadId、&GtkAttr、
                           GstreamerEncodeThread、pParam)；
   如果(结果！= 0)
   ｛
       fprintf (stderr、"pthread_create 返回错误%d\n"、结果)；
       返回 false；
   ｝
   返回 true；
｝

空 PushBufferEncode (char *nv12buf，int len)
｛
   GstFlowReturn；
   GstBuffer *缓冲区；

   Buffer = GST_Buffer_new_allocate (NULL、len、NULL)；

   GstMapInfo 信息；
   GST_buffer_map (buffer、&info、GST_MAP_WRITE)；

   unsigned char* buf = info.data；
   memmove (buf、nv12buf、len)；
   GST_buffer_unmap (buffer、&info)；
   RET = GST_APP_src_PUSH_BUFFER (GST_APP_SRC (appsrc)、buffer)；

   if (ret =GST_flow_OK)｛
       printf ("PUSH OK\n")；
   ｝
｝



CHAR* PullH264Encode (int* outlen)
｛
   GstSample*样本；
   SAMPLE = GST_APP_SINK_PULL_SAMPLE (GST_APP_SINK (appSINK))；
   if (采样== NULL)
   ｛
       fprintf (stderr、"gst_app_sink_pull_sample 返回 null)；
       返回空；
   ｝

//   printf ("get data\n")；
   GstBuffer* buffer = GST_SAMPLE_GET_buffer (sample)；
   GstMapInfo 地图；
   GST_buffer_map (buffer、&map、GST_MAP_read)；

   char* pret = new char[map.size]；

   memmove (Pret、map.data、map.size)；
   GST_buffer_unmap (buffer、&map)；
   GST_SAMPLE_UNREF (样本)；

   *outlen = map.size；
   返回 PRT；
｝

int init_encode()
｛

   StartGstreamer()；

   while (bGstreamerEncodeThreadStarted = false)
       usleep(10000);


   if (bGstreamerEncodeThreadFined== true)
   ｛
       fprintf (stderr、
               "GStreamer 线程无法启动、正在终止\n")；
       返回-1；
   ｝
｝



int startEncode (char *nv12buf、int NV12Len、char *encodebedef、int* encodeLen)
｛


//   pthread_mutex_lock (&mutex)；

   char aaa[352*288*3]；
   memset(Aa, 0,352*288*3)；
   int Alen = NV12Len；
   memcpy (aa、nv12buf、Alen)；

   PushBufferEncode (aa、Alen)；

   int len1=0；
   char * buf = PullH264Encode (&len1)；

   *编码 Len = len1；
//   printf ("*encodelen：%d\n"、*encodeLen)；
   if (*编码 Len！=0)
       memcpy (debugebodif、buf、len1)；
   删除[] buf；
｝
#endif







////第二个流水线
///
///
///
///

#if 1.
静态易失性 bool bGstreamerEncodedThreadStartwo = false；
静态易失性 bool bGstreamerEncodeThreadFinishedTwo = false；

静态 GstElement *appsrcTwo；
静态 GstElement *appsinkTwo；

void* gstreamerEncodeThreadTwo (void* pThreadParam)
｛
   GMainLoop *LOOP；
   GstElement *管道，*编码；
   GstBus *总线；
   guint bus_watch_id；
   gboolean bLinkOk；

   流水线= GST_F管线_NEW ("mypipulineTwo)；
   G_ASSERT (流水线)；
   appsrcTwo = gst_element_factory_make ("appsrc"、"mysourceTwo")；
   g_assert (appsrcTwo)；
   编码= GST_ELECT_factory_make ("ducatih264enc"、"myencodeTwo")；
   G_ASSERT (编码)；
   appsinkTwo = gst_elue_factory_make ("appsink"、"mysinkTwo)；
   g_assert (appsinkTwo)；

   if (！pipeline ||！appsrcTwo ||！encode ||！appsinkTwo)
   ｛
       fprintf (stderr、"不能 gst_element_factory_make、正在终止\n")；
       bGstreamerEncodeThreadStarTwo = bGstreamerEncodeThreadFinishedTwo = true；
       返回(void*) 0xDEAD；
   ｝

   GstCaps * capsappsrc2Jpegenc；//在 appsrc 和 jpegenc 之间
   capsappsrc2Jpegenc = gst_caps_new_full (
               GST_structure_new ("视频/x-raw "、
                                 "format"、G_TYPE_string、"NV12"、
                                 "宽度"、G_TYPE_INT、352、
                                 "高度"、G_TYPE_INT、288、
                                 "帧速率"、GST_TYPE_FRATE、15、1、
                                 null)、
               GST_structure_new ("video/x-h264"、
                                 "format"、G_TYPE_string、"NV12"、
                                 "宽度"、G_TYPE_INT、352、
                                 "高度"、G_TYPE_INT、288、
                                 null)、
               null)；

   循环= g_main_loop_new (NULL、false)；
   总线= GST_F管线_GET_BUS (GST_管线(管线))；
   bus_watch_id = gst_bus_add_watch (bus、bus_callTwo、loop)；
   GST_OBJECT_UNREF (BUS)；

   gst_bin_add_many (gst_bin (pipeline)、appsrcTwo、encode、appsinkTwo、NULL)；

   bLinkOk = gst_element_link_filtered (appsrcTwo、编码、capsappsrc2Jpegenc)；

   if (！bLinkOk)｛
       G_WARNING ("链接 src 编码\n"失败)；
       返回(void*) 0xDEAD；
   ｝


   GST_ELECT_LINK (编码、appsinkTwo)；
   G_object_set (G_object (appsrcTwo)、
                 "stream-type"、gst_app_stream_type_stream、
                 "format"、gst_format_Bytes、
                 null)；

   G_object_set (G_object (编码)、
                "速率预设"、1、NULL)；

   fprintf (stderr、"将 g_main_loop_run 设置为 gst_state_play\n");
   GST_ELECK_SET_STATE (流水线、GST_STATE_Playing)；
   bGstreamerEncodeThreadStarTwo = true；
   G_MAIN_LOOP_RUN (LOOP)；
   fprintf (stderr、"g_main_loop_run returned、sterping\n"\})；

   //停止要释放的管道
   GST_ELECK_SET_STATE (流水线、GST_STATE_NULL)；
   fprintf (stderr、"删除管道\n")；
   GST_object_UNREF (GST_object (流水线))；

   g_source_remove (bus_watch_id)；
   G_MAIN_LOOP_UNREF (LOOP)；
   bGstreamerEncodeThreadFinishedTwo = true；
   GST_OBJECT_UNREF (appsrcTwo)；
   GST_OBJECT_UNREF (编码)；
   GST_OBJECT_UNREF (appsinkTwo)；
   GST_OBJECT_UNREF (capsappsrc2Jpegenc)；

   返回空；
｝




bool StartGstreamerTwo()
｛
   unsigned long GtkThreadId；
   pthread_attr_t GtkAttr；

   int 结果= pthread_attr_init (&GtkAttr)；
   如果(结果！= 0)
   ｛
       fprintf (stderr、"pthread_attr_init 返回错误%d\n"、结果)；
       返回 false；
   ｝

   void* pParam =空；
   结果= pthread_create (&GtkThreadId、&GtkAttr、
                           GstreamerEncodeThreadTwo、pParam)；
   如果(结果！= 0)
   ｛
       fprintf (stderr、"pthread_create 返回错误%d\n"、结果)；
       返回 false；
   ｝
   返回 true；
｝

空 PushBufferEncodeTwo (char *nv12buf，int len)
｛
   GstFlowReturn；
   GstBuffer *缓冲区；

   Buffer = GST_Buffer_new_allocate (NULL、len、NULL)；

   GstMapInfo 信息；
   GST_buffer_map (buffer、&info、GST_MAP_WRITE)；

   unsigned char* buf = info.data；
   memmove (buf、nv12buf、len)；
   GST_buffer_unmap (buffer、&info)；
   RET = GST_APP_src_PUSH_BUFFER (GST_APP_SRC (appsrcTwo)、buffer)；

   if (ret =GST_flow_OK)｛
       printf ("PUSH OK\n")；
   ｝
｝



char* pullH264编码器 Two (int* outlen)
｛
   GstSample*样本；
   采样= GST_APP_SINK_PULL_SAMPLE (GST_APP_SINK 两)；
   if (采样== NULL)
   ｛
       fprintf (stderr、"gst_app_sink_pull_sample 返回 null)；
       返回空；
   ｝

//   printf ("get data\n")；
   GstBuffer* buffer = GST_SAMPLE_GET_buffer (sample)；
   GstMapInfo 地图；
   GST_buffer_map (buffer、&map、GST_MAP_read)；

   char* pret = new char[map.size]；

   memmove (Pret、map.data、map.size)；
   GST_buffer_unmap (buffer、&map)；
   GST_SAMPLE_UNREF (样本)；

   *outlen = map.size；
   返回 PRT；
｝

int init_encodeTwo ()
｛
   StartGstreamerTwo()；
   while (bGstreamerEncodeThreadStartedTwo = false)
       usleep(10000);


   if (bGstreamerEncodeThreadFinishedTwo = true)
   ｛
       fprintf (stderr、
               "GStreamer 线程无法启动、正在终止\n")；
       返回-1；
   ｝


｝



int startEncodeTwo (char *nv12buf，int NV12Len，char *encoddebugf，int* encodeLen)
｛

   char aaa[352*288*3]；
   memset(Aa, 0,352*288*3)；
   int Alen = NV12Len；
   memcpy (aa、nv12buf、Alen)；

   PushBufferEncodeTwo (aa、Alen)；

   int len1=0；
   char * buf = PullH264编码器 Two (&len1)；

   *编码 Len = len1；
  printf ("*encodelen：%d\n"、*encodeLen)；
   if (*编码 Len！=0)
       memcpy (debugebodif、buf、len1)；
   删除[] buf；
｝

#endif

//////////// 这是我的 main.cpp ////////////////////

#include
#include "buscall.h"
#include "encode.h"
#include
#include
#include

文件*fpSrc1=NULL，* fpSrc2=NULL，* fpDst1=NULL，* fpDst2=NULL；



//////////////////////////// 螺纹1 //////////////////////////////
void * threadOne (void*)｛

   fpSrc1 = fopen ("/mnt/1.yuv、"rb")；
   fpDst1 = fopen ("/mnt/1.h264、"WB+")；
   if (fpSrc1 =NULL || fpDst1 ==NULL)｛
       printf ("打开错误\n")；
//       返回-1；
   ｝

   printf ("threadOne\n")；
   char encodebefNV121[352*288]=｛'\0'｝；
   int 编码 LenNV121 = 352*288；
   int 编码 Len2641=0；
   字符编码 debugf2641[352*288]=｛'\0'｝；
   内转台；

   printf("352*288:%d\n",352*288);


   init_encode()；

   while (1)
   ｛
       if (fof(fpSrc1)！=0)
       ｛
           fflush (fpDst1)；
           fclose (fpSrc1)；
           fclose (fpDst1)；
           printf ("close src1\n"）；
           中断；
       ｝

       memset (encodebedefNV121、0、encodeLenNV121)；
       memset (encodebedef2641、0、encodeLenNV121)；

//       printf ("read\n")；
       RET =fread (encodebedefNV121、1、encodeLenNV121、fpSrc1)；
       printf ("读取：%d \n"、ret)；

       startEncode (encodebedefNV121、ret、encodebedef2641、encodedLen2641)；
usleep(1000);

       printf ("encodeLen264：%d\n"、encodeLen2641)；
       RET =fwrite (encodebedef2641、1、encodeLen2641、fpDst1)；
        fflush (fpDst1)；
       printf ("写入：%d\n"、ret)；
   ｝

｝

void * threadTwo (void*)｛

   fpSrc2 = fopen ("/mnt/2.yuv、"r")；
   fpDst2 = fopen ("/mnt/2.h264、"WB+")；
   if (fpSrc2 =NULL || fpDst2==NULL)｛
       printf ("打开错误\n")；
//       返回-1；
   ｝

   char encodebefNV122[352*288]=｛'\0'｝；
   int 编码 LenNV122 = 352*288；
   int encodeLen2642=0；
   char encodebedef2642[352*288]=｛'\0'｝；
   int ret=0；


   init_encodeTwo ()；

   while (1)
   ｛
       if (fof(fpSrc2)！=0)
       ｛
           fflush (fpDst2)；
           fclose (fpSrc2)；
           fclose (fpDst2)；
           printf ("close src2\n"）；
           中断；
       ｝

       memset (encodebedefNV122、0、encodeLenNV122)；
       memset (encodebedef2642、0、encodeLenNV122)；

//       printf ("read\n")；
       RET =fread (encodebedefNV122、1、encodeLenNV122、fpSrc2)；
       printf ("read2：%d "、ret)；

       startEncodedTwo (encodebedefNV122、ret、encodebedef2642、encodedLen2642)；
usleep(1000);

       printf ("encodeLen2642：%d\n"、encodeLen2642)；
       RET =fwrite (encodebedef2642、1、encodeLen2642、fpDst2)；
        fflush (fpDst2)；
       printf ("write2：%d\n"、ret)；
   ｝
｝


int main (int argc、char * argv[])
｛

   pthread_t npthId1；
   pthread_t npthId2；
   GST_init (NULL、NULL)；
   int ret =-1；


   RET =pthread_create (_npthId1、NULL、threadOne、NULL)；
   if (ret！= 0)｛
       printf ("creat one is error\n"）；
       返回-1；
   ｝

   RET = pthread_create (&npthId2、NULL、threadTwo、NULL)；
   if (ret！= 0)｛
       printf ("creat two is error\n"）；
       返回-1；
   ｝

   while (1)｛
       睡眠(1)；
   ｝
｝

您好！

第一个管道：

[引用 user="abayyyyyyye]GstElement *管道，*编码；
   GstBus *总线；
   guint bus_watch_id；
   gboolean bLinkOk；

   流水线= GST_F管线_NEW ("mypipeline")；
   G_ASSERT (流水线)；
   appsrc = gst_element_factory_make ("appsrc"、"mysource")；
   G_ASSERT (appsrc)；
   编码= GST_ELECK_factory_make ("ducatih264en"、"myence")；
   G_ASSERT (编码)；
   appsink = gst_elue_factory_make ("appsink"、"mysink")；
   g_assert (appsink)；[/quot]

 第二个管道：

[引用 user="abayyyyyyye]GstElement *管道，*编码；
   GstBus *总线；
   guint bus_watch_id；
   gboolean bLinkOk；

   流水线= GST_F管线_NEW ("mypipulineTwo)；
   G_ASSERT (流水线)；
   appsrcTwo = gst_element_factory_make ("appsrc"、"mysourceTwo")；
   g_assert (appsrcTwo)；
   编码= GST_ELECT_factory_make ("ducatih264enc"、"myencodeTwo")；
   G_ASSERT (编码)；
   appsinkTwo = gst_elue_factory_make ("appsink"、"mysinkTwo)；
   g_assert (appsinkTwo)；

   if (！pipeline ||！appsrcTwo ||！encode ||！appsinkTwo)

…………

   bus_watch_id = gst_bus_add_watch (bus、bus_callTwo、loop)；
   GST_OBJECT_UNREF (BUS)；

   gst_bin_add_many (gst_bin (pipeline)、appsrcTwo、encode、appsinkTwo、NULL)；

   bLinkOk = gst_element_link_filtered (appsrcTwo、编码、capsappsrc2Jpegenc)；

.
   ｛[/报价]

 第二个流水线的编码与第一个流水线匹配。

您能否将  "编码"名称更改为其他名称、如管道中的编码 Two (GST 元件管道相同)？

元素应具有唯一的名称。

遗憾的是、在 gstreamer 教程中、没有在应用程序中运行多个流水线的示例。

BR
玛格丽塔