H264码合成TS专用API

最新推荐文章于 2024-07-09 11:34:32 发布
最新推荐文章于 2024-07-09 11:34:32 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： 流媒体技术 文章标签： C++ visual studio h264 ts api
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiahua882/article/details/52622402
版权

       为方便264码转换为TS码，针对TSTOOL源码进行分析修改，做成函数接口，供方便调用。目前该接口在VS2013工程环境已经测试通过，不废话，直接上货。

   1.函数API-------  void   taransTs(TNAL* pNal)

     输入参数：TNAL* pNal----264码流帧nalu；TNAL结构见下

     返回：  无

     注：生成的ts码流数据在该函数中，用户可根据自己需要决定是否修改

  2.相关函数结构

    1）API函数taransTs具体内容

     

void taransTs(TNAL* pNal)
{
	NALU_t * nalu=NULL;
	Ts_Adaptation_field  ts_adaptation_field_Head;
	Ts_Adaptation_field  ts_adaptation_field_Tail;
	unsigned long  Timestamp_video = 0;    //一帧视频所用时间
	unsigned long  Timestamp_audio = 0;    //一帧音频所用时间 
	unsigned int framerate = 60;
	unsigned int   videoframetype = 0;    //视频帧类型
     //赋值s
	//分配nal 资源
	nalu = AllocNALU(MAX_VIDEO_TAG_BUF_SIZE);
	nalu->len = pNal->size;       //设置包含nal 头的数据长度	
	memcpy(nalu->buf, pNal->data, pNal->size);//拷贝一个nal 数据到数组中
	nalu->forbidden_bit = nalu->buf[4] & 0x80;                     //1 bit  设置nal 头
	nalu->nal_reference_idc = nalu->buf[4] & 0x60;                 // 2 bit
	nalu->nal_unit_type = (nalu->buf[4]) & 0x1f;                   // 5 bit
	//判断帧类型
	GetFrameType(nalu);	
	FreeNALU(nalu);

	//获得数据值
	Take_Out_Pes(&m_video_tspes, Timestamp_video, 0x00, &videoframetype, pNal->size, pNal->data);
	if (nalu->Frametype == FRAME_I || nalu->Frametype == FRAME_P || nalu->Frametype == FRAME_B)
	{
		//填写自适应段标志
		printf("3PES_VIDEO  :  SIZE = %d\n", m_video_tspes.Pes_Packet_Length_Beyond);
		WriteAdaptive_flags_Head(&ts_adaptation_field_Head, Timestamp_video); //填写自适应段标志帧头
		WriteAdaptive_flags_Tail(&ts_adaptation_field_Tail); //填写自适应段标志帧尾
		//计算一帧视频所用时间
		m_video_tspes.Pes_Packet_Length_Beyond = pNal->size;
		PES2TS(&m_video_tspes, TS_H264_PID, &ts_adaptation_field_Head, &ts_adaptation_field_Tail, Timestamp_video, Timestamp_audio);
		Timestamp_video += 1000 * 90 / framerate;   //90khz
	}
	else
	{
		
		//填写自适应段标志
		printf("3+++PES_VIDEO  :  SIZE = %d\n", m_video_tspes.Pes_Packet_Length_Beyond);
		WriteAdaptive_flags_Tail(&ts_adaptation_field_Head); //填写自适应段标志  ,这里注意 其它帧类型不要算pcr 所以都用帧尾代替就行
		WriteAdaptive_flags_Tail(&ts_adaptation_field_Tail); //填写自适应段标志帧尾
		m_video_tspes.Pes_Packet_Length_Beyond = pNal->size;//lzy
		PES2TS(&m_video_tspes, TS_H264_PID, &ts_adaptation_field_Head, &ts_adaptation_field_Tail, Timestamp_video, Timestamp_audio);//具体内容见下

	}

}
   2）输出参数TNAL结构体     

struct DLL_EXPORT TNAL
{
    int size;  //264码nalu长度
    unsigned char* data;  //内容
    TNAL(): size(0), data(NULL) {}
};
3）合成所用的主角函数--PES2TS函数 

int PES2TS(TsPes * ts_pes, unsigned int Video_Audio_PID, Ts_Adaptation_field * ts_adaptation_field_Head, Ts_Adaptation_field * ts_adaptation_field_Tail,
	unsigned long  Videopts, unsigned long Adudiopts)
{
	TsPacketHeader ts_header;
	unsigned int ts_pos = 0;
	unsigned int FirstPacketLoadLength = 0;                                   //分片包的第一个包的负载长度
	unsigned int NeafPacketCount = 0;                                          //分片包的个数
	unsigned int AdaptiveLength = 0;                                           //要填写0XFF的长度
	unsigned char * NeafBuf = NULL;                                            //分片包 总负载的指针
	unsigned char TSbuf[TS_PACKET_SIZE];

	memset(TSbuf, 0, TS_PACKET_SIZE);
	FirstPacketLoadLength = 188 - 4 - 1 - ts_adaptation_field_Head->adaptation_field_length - 14; //计算分片包的第一个包的负载长度
	NeafPacketCount += 1;                                                                   //第一个分片包  

	//一个包的情况
	//	printf("Pes_Packet_Length_Beyond=%d,FirstPacketLoadLength=%d\n", ts_pes->Pes_Packet_Length_Beyond, FirstPacketLoadLength);

	if (ts_pes->Pes_Packet_Length_Beyond < FirstPacketLoadLength)                           //这里是 sps ，pps ，sei等
		// if (lens < FirstPacketLoadLength)                           //这里是 sps ，pps ，sei等 lzy
	{
		memset(TSbuf, 0xFF, TS_PACKET_SIZE);
		WriteStruct_Packetheader(TSbuf, Video_Audio_PID, 0x01, 0x03);                          //PID = TS_H264_PID,有效荷载单元起始指示符_play_init = 0x01, ada_field_C,0x03,含有调整字段和有效负载 ；
		ts_pos += 4;
		TSbuf[ts_pos + 0] = 184 - ts_pes->Pes_Packet_Length_Beyond - 9 - 5 - 1;
		TSbuf[ts_pos + 1] = 0x00;
		ts_pos += 2;
		memset(TSbuf + ts_pos, 0xFF, (184 - ts_pes->Pes_Packet_Length_Beyond - 9 - 5 - 2));
		ts_pos += (184 - ts_pes->Pes_Packet_Length_Beyond - 9 - 5 - 2);

		TSbuf[ts_pos + 0] = (ts_pes->packet_start_code_prefix >> 16) & 0xFF;
		TSbuf[ts_pos + 1] = (ts_pes->packet_start_code_prefix >> 8) & 0xFF;
		TSbuf[ts_pos + 2] = ts_pes->packet_start_code_prefix & 0xFF;
		TSbuf[ts_pos + 3] = ts_pes->stream_id;
		TSbuf[ts_pos + 4] = ((ts_pes->PES_packet_length) >> 8) & 0xFF;
		TSbuf[ts_pos + 5] = (ts_pes->PES_packet_length) & 0xFF;
		TSbuf[ts_pos + 6] = ts_pes->marker_bit << 6 | ts_pes->PES_scrambling_control << 4 | ts_pes->PES_priority << 3 |
			ts_pes->data_alignment_indicator << 2 | ts_pes->copyright << 1 | ts_pes->original_or_copy;
		TSbuf[ts_pos + 7] = ts_pes->PTS_DTS_flags << 6 | ts_pes->ESCR_flag << 5 | ts_pes->ES_rate_flag << 4 |
			ts_pes->DSM_trick_mode_flag << 3 | ts_pes->additional_copy_info_flag << 2 | ts_pes->PES_CRC_flag << 1 | ts_pes->PES_extension_flag;
		TSbuf[ts_pos + 8] = ts_pes->PES_header_data_length;
		ts_pos += 9;

		if (ts_pes->stream_id == TS_H264_STREAM_ID)
		{
			TSbuf[ts_pos + 0] = (((0x3 << 4) | ((Videopts >> 29) & 0x0E) | 0x01) & 0xff);
			TSbuf[ts_pos + 1] = (((((Videopts >> 14) & 0xfffe) | 0x01) >> 8) & 0xff);
			TSbuf[ts_pos + 2] = ((((Videopts >> 14) & 0xfffe) | 0x01) & 0xff);
			TSbuf[ts_pos + 3] = (((((Videopts << 1) & 0xfffe) | 0x01) >> 8) & 0xff);
			TSbuf[ts_pos + 4] = ((((Videopts << 1) & 0xfffe) | 0x01) & 0xff);
			ts_pos += 5;

		}
		else if (ts_pes->stream_id == TS_AAC_STREAM_ID)
		{
			TSbuf[ts_pos + 0] = (((0x3 << 4) | ((Adudiopts >> 29) & 0x0E) | 0x01) & 0xff);
			TSbuf[ts_pos + 1] = (((((Adudiopts >> 14) & 0xfffe) | 0x01) >> 8) & 0xff);
			TSbuf[ts_pos + 2] = ((((Adudiopts >> 14) & 0xfffe) | 0x01) & 0xff);
			TSbuf[ts_pos + 3] = (((((Adudiopts << 1) & 0xfffe) | 0x01) >> 8) & 0xff);
			TSbuf[ts_pos + 4] = ((((Adudiopts << 1) & 0xfffe) | 0x01) & 0xff);
			ts_pos += 5;
		}
		else
		{
			printf("ts_pes->stream_id  error 0x%x \n", ts_pes->stream_id);
			return getchar();
		}
		memcpy(TSbuf + ts_pos, ts_pes->Es, ts_pes->Pes_Packet_Length_Beyond);

		//将包写入文件
		fwrite(TSbuf, 188, 1, pVideo_Audio_Ts_File);                               //将一包数据写入文件
		memcpy(fTo, TSbuf, 188);


		WritePacketNum++;                                                      //已经写入文件的包个数++
		return WritePacketNum;
	}

	NeafPacketCount += (ts_pes->Pes_Packet_Length_Beyond - FirstPacketLoadLength) / 184;
	NeafPacketCount += 1;                                                                   //最后一个分片包
	AdaptiveLength = 188 - 4 - 1 - ((ts_pes->Pes_Packet_Length_Beyond - FirstPacketLoadLength) % 184);  //要填写0XFF的长度
	if ((WritePacketNum % 40) == 0)                                                         //每40个包打一个 pat,一个pmt
	{
		Write_Pat(m_One_Frame_Buf);                                                         //创建PAT，具体内容见下
		Write_Pmt(m_One_Frame_Buf);                                                         //创建PMT，具体内容见下
	}
	//开始处理第一个包,分片包的个数最少也会是两个 
	WriteStruct_Packetheader(TSbuf, Video_Audio_PID, 0x01, 0x03);                              //PID = TS_H264_PID,有效荷载单元起始指示符_play_init = 0x01, ada_field_C,0x03,含有调整字段和有效负载 ；
	ts_pos += 4;
	TSbuf[ts_pos] = ts_adaptation_field_Head->adaptation_field_length;                      //自适应字段的长度，自己填写的
	ts_pos += 1;

	CreateAdaptive_Ts(ts_adaptation_field_Head, TSbuf + ts_pos, (188 - 4 - 1 - 14));          //填写自适应字段
	ts_pos += ts_adaptation_field_Head->adaptation_field_length;                            //填写自适应段所需要的长度

	TSbuf[ts_pos + 0] = (ts_pes->packet_start_code_prefix >> 16) & 0xFF;
	TSbuf[ts_pos + 1] = (ts_pes->packet_start_code_prefix >> 8) & 0xFF;
	TSbuf[ts_pos + 2] = ts_pes->packet_start_code_prefix & 0xFF;
	TSbuf[ts_pos + 3] = ts_pes->stream_id;
	TSbuf[ts_pos + 4] = ((ts_pes->PES_packet_length) >> 8) & 0xFF;
	TSbuf[ts_pos + 5] = (ts_pes->PES_packet_length) & 0xFF;
	TSbuf[ts_pos + 6] = ts_pes->marker_bit << 6 | ts_pes->PES_scrambling_control << 4 | ts_pes->PES_priority << 3 |
		ts_pes->data_alignment_indicator << 2 | ts_pes->copyright << 1 | ts_pes->original_or_copy;
	TSbuf[ts_pos + 7] = ts_pes->PTS_DTS_flags << 6 | ts_pes->ESCR_flag << 5 | ts_pes->ES_rate_flag << 4 |
		ts_pes->DSM_trick_mode_flag << 3 | ts_pes->additional_copy_info_flag << 2 | ts_pes->PES_CRC_flag << 1 | ts_pes->PES_extension_flag;
	TSbuf[ts_pos + 8] = ts_pes->PES_header_data_length;
	ts_pos += 9;

	if (ts_pes->stream_id == TS_H264_STREAM_ID)
	{
		TSbuf[ts_pos + 0] = (((0x3 << 4) | ((Videopts >> 29) & 0x0E) | 0x01) & 0xff);
		TSbuf[ts_pos + 1] = (((((Videopts >> 14) & 0xfffe) | 0x01) >> 8) & 0xff);
		TSbuf[ts_pos + 2] = ((((Videopts >> 14) & 0xfffe) | 0x01) & 0xff);
		TSbuf[ts_pos + 3] = (((((Videopts << 1) & 0xfffe) | 0x01) >> 8) & 0xff);
		TSbuf[ts_pos + 4] = ((((Videopts << 1) & 0xfffe) | 0x01) & 0xff);
		ts_pos += 5;

	}
	else if (ts_pes->stream_id == TS_AAC_STREAM_ID)
	{
		TSbuf[ts_pos + 0] = (((0x3 << 4) | ((Adudiopts >> 29) & 0x0E) | 0x01) & 0xff);
		TSbuf[ts_pos + 1] = (((((Adudiopts >> 14) & 0xfffe) | 0x01) >> 8) & 0xff);
		TSbuf[ts_pos + 2] = ((((Adudiopts >> 14) & 0xfffe) | 0x01) & 0xff);
		TSbuf[ts_pos + 3] = (((((Adudiopts << 1) & 0xfffe) | 0x01) >> 8) & 0xff);
		TSbuf[ts_pos + 4] = ((((Adudiopts << 1) & 0xfffe) | 0x01) & 0xff);
		ts_pos += 5;
	}
	else
	{
		printf("ts_pes->stream_id  error 0x%x \n", ts_pes->stream_id);
		return getchar();
	}

	NeafBuf = ts_pes->Es;



	memcpy(TSbuf + ts_pos, NeafBuf, FirstPacketLoadLength);

	NeafBuf += FirstPacketLoadLength;
	ts_pes->Pes_Packet_Length_Beyond -= FirstPacketLoadLength;
	//将包写入文件
	fwrite(TSbuf, 188, 1, pVideo_Audio_Ts_File);                               //将一包数据写入文件  lzy
	memcpy(fTo,TSbuf,188);


	WritePacketNum++;                                                      //已经写入文件的包个数++

	while (ts_pes->Pes_Packet_Length_Beyond)
	{
		ts_pos = 0;
		memset(TSbuf, 0, TS_PACKET_SIZE);

		if ((WritePacketNum % 40) == 0)                                                         //每40个包打一个 pat,一个pmt
		{
			Write_Pat(m_One_Frame_Buf);                                                         //创建PAT
			Write_Pmt(m_One_Frame_Buf);                                                         //创建PMT
		}
		if (ts_pes->Pes_Packet_Length_Beyond >= 184)
		{
			//处理中间包   
			WriteStruct_Packetheader(TSbuf, Video_Audio_PID, 0x00, 0x01);     //PID = TS_H264_PID,不是有效荷载单元起始指示符_play_init = 0x00, ada_field_C,0x01,仅有有效负载；    
			ts_pos += 4;
			memcpy(TSbuf + ts_pos, NeafBuf, 184);
			NeafBuf += 184;
			ts_pes->Pes_Packet_Length_Beyond -= 184;
			fwrite(TSbuf, 188, 1, pVideo_Audio_Ts_File);
			memcpy(fTo, TSbuf, 188);
		}
		else
		{
			if (ts_pes->Pes_Packet_Length_Beyond == 183 || ts_pes->Pes_Packet_Length_Beyond == 182)
			{
				if ((WritePacketNum % 40) == 0)                                                         //每40个包打一个 pat,一个pmt
				{
					Write_Pat(m_One_Frame_Buf);                                                         //创建PAT
					Write_Pmt(m_One_Frame_Buf);                                                         //创建PMT
				}

				WriteStruct_Packetheader(TSbuf, Video_Audio_PID, 0x00, 0x03);   //PID = TS_H264_PID,不是有效荷载单元起始指示符_play_init = 0x00, ada_field_C,0x03,含有调整字段和有效负载；
				ts_pos += 4;
				TSbuf[ts_pos + 0] = 0x01;
				TSbuf[ts_pos + 1] = 0x00;
				ts_pos += 2;
				memcpy(TSbuf + ts_pos, NeafBuf, 182);

				NeafBuf += 182;
				ts_pes->Pes_Packet_Length_Beyond -= 182;
				fwrite(TSbuf, 188, 1, pVideo_Audio_Ts_File);
				memcpy(fTo, TSbuf, 188);
			
			}
			else
			{
				if ((WritePacketNum % 40) == 0)                                                         //每40个包打一个 pat,一个pmt
				{
					Write_Pat(m_One_Frame_Buf);                                                         //创建PAT
					Write_Pmt(m_One_Frame_Buf);                                                         //创建PMT
				}

				WriteStruct_Packetheader(TSbuf, Video_Audio_PID, 0x00, 0x03);  //PID = TS_H264_PID,不是有效荷载单元起始指示符_play_init = 0x00, ada_field_C,0x03,含有调整字段和有效负载；
				ts_pos += 4;
				TSbuf[ts_pos + 0] = 184 - ts_pes->Pes_Packet_Length_Beyond - 1;
				TSbuf[ts_pos + 1] = 0x00;
				ts_pos += 2;
				memset(TSbuf + ts_pos, 0xFF, (184 - ts_pes->Pes_Packet_Length_Beyond - 2));
				ts_pos += (184 - ts_pes->Pes_Packet_Length_Beyond - 2);
				memcpy(TSbuf + ts_pos, NeafBuf, ts_pes->Pes_Packet_Length_Beyond);
				ts_pes->Pes_Packet_Length_Beyond = 0;
				fwrite(TSbuf, 188, 1, pVideo_Audio_Ts_File);   //将一包数据写入文件
				memcpy(fTo, TSbuf, 188);

				WritePacketNum++;
			}
		}
		WritePacketNum++;
	}
	printf("\nWritePacketNum=%d\n", WritePacketNum);
	return WritePacketNum;
}
注：该函数中，合成的TS流都放置在 TSbuf中。


4）写PAT函数---Write_Pat、Write_Pmt函数

int Write_Pat(unsigned char * buf)
{
	WriteStruct_Pat(buf);
	memcpy(fTo, (char *)buf,188);
	printf("pmt++++");
	return WriteFile(pVideo_Audio_Ts_File, (char *)buf, TS_PACKET_SIZE);
	
}
<pre name="code" class="cpp">int Write_Pmt(unsigned char * buf)
{
	WriteStruct_Pmt(buf);
	memcpy(fTo, (char *)buf, 188);
	return WriteFile(pVideo_Audio_Ts_File, (char *)buf, TS_PACKET_SIZE);

}


 

以上为该API中重要函数，但是由于该API在tstool基础上改编而来，自然少不了要加上TSTOOL库文件。
 

 

库文件我已经打包，下载地址为：http://download.csdn.net/detail/xiahua882/9636902。
 

最后，上一张我在VS2013工程中引用图
 


 
 


 
 


 
 
 

 

                

        

        

    




    

      

        

            

              
                
                  xiahua882
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
CMMB中的H264和AAC打包成ts流

				
			

			

				

					zs_pro_popper的专栏
				

				

					11-13
					
					4006
					
				

			

		

		

			
				
参照tstools这个开源项目完成了CMMB的merge aac with 264 to TS.


在做的过程中，分成了几个阶段。先试着将H264打包成TS,这花了最大的精力和时间；接着将AAC打包成TS；最后将其合并起来。


一、处理H264
     1、H264 -> pes
     在查找了大量资料后，对H264有了初步的认识。H264的结构从大到小依次为视频序列(s

			
		

	



                

              
                



	

		

			

				
					
H264合成TS流源码

				
			

			

				

					09-22
				

			

		

		

			
				
VS2013工程下利用tstool实现h264合成TS流

			
		

	



                


  
              

                


	

		

			

				
					
音视频封装demo：将h264数据和aac数据封装(mux)成TS文件(纯手工，不依赖第三方开源库)

					
最新发布

				
			

			

				

					weixin_44498318的博客
				

				

					07-09
					
					631
					
				

			

		

		

			
				
$ make clean && make DEBUG=1
$
$ ./ts_mux_h264_aac
Usage:
   ./ts_mux_h264_aac avfile/test1_856x480_24fps.h264 24 avfile/test1_44100_stereo.aac out1.ts
   ./ts_mux_h264_aac avfile/test2_720x480_30fps.h264 60 avfile/test2_48000_stereo.aac out2.ts
   ./ts_mu

			
		

	





	

		

			

				
					
将H264与AAC打包Ipad可播放的TS流的总结

				
			

			

				

					
				

				

					03-29
					
					660
					
				

			

		

		

			
				
由于要在crtmpserver中实现Http Live Streaming ，本人花了接近3个星期的时间，研究将H264与AAC打包为TS流并能在Ipad上通过HTML5播放，由于没有任何现成代码可供参考，打包代码全部手写，打包格式主要参考ISO/ICE 18318-1.pdf。期间碰到很多问题，走了不少弯路，符合标准的TS不一定能在Ipad上播放，但是Ipad上播放的TS一定是符合标准...

			
		

	



		

			
		



	

		

			

				
					
H264和音频流打包成TS流 (MPEG2-TS)

				
			

			

				

					07-03
				

			

		

		

			
				
基于C/C++提供一个TS流的打包库TsMuxer.dll，并提供DEMO测试程序

			
		

	





	

		

			

				
					
h264,aac ts封装

				
			

			

				

					05-31
				

			

		

		

			
				
标题中的“h264,aac ts封装”指的是将H.264编码的视频流和AAC编码的音频流合并并封装成TS（Transport Stream）格式的过程。在多媒体处理领域，TS格式常用于数字电视、流媒体传输等领域，因为它具有良好的错误恢复...

			
		

	





	

		

			

				
					
4k_h264.ts

				
			

			

				

					09-15
				

			

		

		

			
				
h264码流；

			
		

	





	

		

			

				
					
H264转TS测试代码

				
			

			

				

					01-03
				

			

		

		

			
				
1. **解析H264流**：首先，我们需要解析H264码流，提取NAL单元（Network Abstraction Layer Unit），这是H264编码的基本单位，包含了视频帧的信息。  2. **生成PES包**：将NAL单元封装成PES（Packetized Elementary ...

			
		

	





	

		

			

				
					
h264编码封装ts流及hls切片list

				
			

			

				

					07-15
				

			

		

		

			
				
本文将深入探讨“h264编码封装ts流及hls切片list”这一主题，基于湖南卫视的一个实例，该实例包含5个10秒的视频切片，全部采用h264编码，并以TS（Transport Stream）封装，用于HLS（HTTP Live Streaming）流媒体服务...

			
		

	





	

		

			

				
					
ts与h264关系

				
			

			

				

					chengcheng1024的博客
				

				

					05-11
					
					1103
					
				

			

		

		

			
				
ts文件为传输流文件，视频编码主要格式h264/mpeg4，音频为acc/MP3。
详见https://blog.csdn.net/heiyeshuwu/article/details/52316738



			
		

	





	

		

			

				
					
TS和H264文件

				
			

			

				

					12-03
				

			

		

		

			
				
简单的TS和H264文件,方便自己以后查找

			
		

	





	

		

			

				
					
基于rtmpdump的rtmp包转解码打包ts(h264+aac)

				
			

			

				

					01-16
				

			

		

		

			
				
基于rtmpdump的rtmp包转解码打包ts(h264+aac),通过rtmpdump收流，调用系统接口，转码音视频数据包成h264视频和aac的音频。供封转ts使用

			
		

	





	

		

			

				
					
MPEG4,H264，多种音频，ES，PS,TS 互转及RTP发送

				
			

			

				

					04-15
				

			

		

		

			
				
MPEG4/H264/ ES,PS,TS 互转及RTP发送

			
		

	





	

		

			

				
					
tstool-0.1.09.tar

				
			

			

				

					07-15
				

			

		

		

			
				
完成读取H264文件和AAC文件，并将其封装成TS文件，完成读取H264文件和AAC文件，并将其封装成TS文件

			
		

	





	

		

			

				
					
H264 TS/ES

				
			

			

				

					maopig的专栏
				

				

					02-01
					
					2399
					
				

			

		

		

			
				
http://blog.csdn.net/heanyu/article/details/6229724

			
		

	





	

		

			

				
					
H.264 打包 MPEG-TS 流

				
			

			

				

					maetelibom的博客
				

				

					11-20
					
					4080
					
				

			

		

		

			
				
H.264 打包 MPEG-TS 流– 作者 Amour Wang1.简要说明本文主要介绍了H264打包成MPEG-TS 流的关键部分，及中间碰到的一些问题。至于H264 和TS 流的相关标准这边不再做详细介绍。2.H264 打包TS 流过程TS 流组成说明（这边针对本文例子中的情况，其他情况参照TS 标准）:TS 流以包为单位，每个包的大小为188，主要包含了几种不同类型的包 
1. PAT 表：

			
		

	





	

		

			

				
					
音视频流: [ H264打包成TS流 ] ＞流程顺序

				
			

			

				

					总是春的博客
				

				

					03-22
					
					242
					
				

			

		

		

			
				
音视频流: [ H264打包成TS流 ] ＞流程顺序

			
		

	





	

		

			

				
					
H264解码之TS流解析

				
			

			

				

					学无止尽，谨言慎行！
				

				

					07-29
					
					2694
					
				

			

		

		

			
				
TS包头格式
TS流，即传输流，是对PES包的进一步封装，基本单位为TS包，固定每包大小为188字节(或204字节，在188字节后加上16字节的CRC校验数据)，由TS包头和payload组成；其组成如下图：

其中包头由4个字节的固定头部和其后的adaptation field数据构成，字节顺序依次如下：


sync_byte：同步码，其大小为固定8个bit，值为0x47；


transpo...

			
		

	





	

		

			

				
					
FFmpeg  保存 h264 acc为 ts文件

				
			

			

				

					06-07
				

			

		

		

			
				
要使用 FFmpeg 将 H.264 和 AAC 流保存为 TS 文件，可以使用以下命令：

```
ffmpeg -i input.mp4 -c:v copy -c:a copy -f mpegts output.ts
```

这将从 `input.mp4` 中提取 H.264 视频和 AAC 音频流，并将它们复制到一个 TS 文件 `output.ts` 中。

如果输入文件中包含多个音频流，你可以使用 `-map` 参数选择要复制的音频流。例如，如果你想要选择第二个音频流：

```
ffmpeg -i input.mp4 -c:v copy -c:a:1 copy -f mpegts output.ts
```

在上面的命令中，`-c:a:1` 表示选择第二个音频流。

如果你想要将 H.264 视频重新编码为另一种视频编解码器，例如 H.265，可以使用以下命令：

```
ffmpeg -i input.mp4 -c:v libx265 -c:a copy -f mpegts output.ts
```

这将使用 libx265 编码器将 H.264 视频重新编码为 H.265，并将音频流复制到 TS 文件中。

注意：如果你想要在 Android 应用程序中使用 FFmpeg，你需要将 FFmpeg 编译为 Android 平台上的静态库，并在你的应用程序中使用它。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值