安科网

FFMPEG ffmpeg + cocos2d video test

ShoppingChen

ShoppingChen

2020-06-25

关注 关注

//核心

{

void AVdio::update(float delta)
{
	auto video = (Sprite*)(this->getChildByName("video"));
	if (video != nullptr)
	{
		double      tims = fl->_pts * fl->_timeBase * 1000;
		double      elsped = _timestamp.getElapsedTimeInMilliSec();
		double      sleeps = (tims - elsped);

		s = sleeps + elsped;

		if (elsped - s > 0.0001)
		{
			is = ffReader.readFrame(*fl);
			if (is)
			{
				texture->initWithData((const unsigned char*)fl->_data, fl->_dataSize, Texture2D::PixelFormat::RGB888,
					fl->_width, fl->_height,
					Size(fl->_width, fl->_height));

				video->initWithTexture(texture);
				video->setContentSize(Size(displayex.width - 10, displayex.height - 50));
			}
			else
			{
				video->removeFromParent();
			}
		}
	}

}

}

.h

{

#ifndef __AVDIO_H__
#define __AVDIO_H__

#include "cocos2d.h"
using namespace cocos2d;
#include <string.h>
#include <iostream>
#include "cocos/ui/CocosGUI.h"
#include "socket/Private/ThreadPool.h"
#include "Tools/Tools.h"
#include "xml/XML.h"
#include "iconv/UTF8.h"
#ifdef _WIN32
#include "ATBAudioEngine/ATBAudioEngine.h"
#endif
using namespace std;
using namespace ui;


class AVdio :public LayerColor, EditBoxDelegate
{
	Tools m_Tools;
public:

	static cocos2d::LayerColor* createAVdio();

	~AVdio();

	virtual bool init();

	CREATE_FUNC(AVdio);



	void OnCallback(cocos2d::Ref* pSender);
	virtual bool onTouchBegan(Touch *touch, Event *unused_event) override;
	virtual void update(float delta);

	virtual void editBoxEditingDidBegin(EditBox* editBox)override;
	CC_DEPRECATED_ATTRIBUTE virtual void editBoxEditingDidEnd(EditBox* editBox)override;
	virtual void editBoxTextChanged(EditBox* editBox, const std::string& text)override;
	virtual void editBoxReturn(EditBox* editBox)override;
	virtual void editBoxEditingDidEndWithAction(EditBox* editBox, EditBoxDelegate::EditBoxEndAction action)override;
private:
	void initVideoStream(string filename);
	void initInput();
};

extern "C"
{
#include <libavutil/imgutils.h>
#include <libavutil/parseutils.h>
#include <libswscale/swscale.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavformat/avio.h>
#include <libavutil/file.h>
#include <libavdevice/avdevice.h>
}

struct  FrameInfor
{
	void*   _data;
	int     _dataSize;
	int     _width;
	int     _height;
	int64_t _pts;
	double  _timeBase;

};
class   FFVideoReader
{
public:
	AVFormatContext*_formatCtx;
	int             _videoIndex;
	AVCodecContext* _codecCtx;
	AVCodec*        _codec;
	AVFrame*        _frame;
	AVFrame*        _frameRGB;
	SwsContext*     _convertCtx;
public:
	int             _screenW;
	int             _screenH;

	int             _imageSize;
public:
	FFVideoReader()
	{
		_formatCtx = 0;
		_videoIndex = -1;
		_codecCtx = 0;
		_codec = 0;
		_frame = 0;
		_frameRGB = 0;
		_convertCtx = 0;
		_screenW = 0;
		_screenH = 0;

	}

	~FFVideoReader()
	{
		sws_freeContext(_convertCtx);
		av_free(_frameRGB);
		av_free(_frame);
		avcodec_close(_codecCtx);
		avformat_close_input(&_formatCtx);
	}

	void    setup()
	{
		av_register_all();
		_formatCtx = avformat_alloc_context();
	}
	int     load(const char* filepath = "11.flv")
	{
		int     ret = 0;

		//! 打开文件
		if (avformat_open_input(&_formatCtx, filepath, NULL, NULL) != 0)
		{
			return -1;
		}
		//! 检测文件中是否存在数据流
		if (avformat_find_stream_info(_formatCtx, NULL) < 0)
		{
			printf("检测文件中是否存在数据流");
			return -1;
		}
		//! 获取视频流索引
		_videoIndex = -1;
		for (int i = 0; i < _formatCtx->nb_streams; i++)
		{
			if (_formatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
			{
				_videoIndex = i;
				break;
			}
		}
		/**
		*   没有视频流，则返回
		*/
		if (_videoIndex == -1)
		{
			return -1;
		}
		_codecCtx = _formatCtx->streams[_videoIndex]->codec;

		double dur = _formatCtx->duration / double(AV_TIME_BASE);
		_codec = avcodec_find_decoder(_codecCtx->codec_id);
		if (_codec == NULL)
		{
			printf("find decoder faild !!\n");
			return -1;
		}
		/**
		*   打开解码器
		*/
		if (avcodec_open2(_codecCtx, _codec, NULL) < 0)
		{
			return -1;
		}
		_frame = av_frame_alloc();
		_frameRGB = av_frame_alloc();

		_screenW = _codecCtx->width;
		_screenH = _codecCtx->height;

		_convertCtx = sws_getContext(
			_codecCtx->width
			, _codecCtx->height
			, _codecCtx->pix_fmt
			, _codecCtx->width
			, _codecCtx->height
			, AV_PIX_FMT_RGB24
			, SWS_BICUBIC
			, NULL
			, NULL
			, NULL
		);

		int     numBytes = avpicture_get_size(AV_PIX_FMT_RGB24, _codecCtx->width, _codecCtx->height);
		uint8_t*buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));
		avpicture_fill((AVPicture *)_frameRGB, buffer, AV_PIX_FMT_RGB24, _codecCtx->width, _codecCtx->height);
		_imageSize = numBytes;
		return  0;
	}

	bool    readFrame(FrameInfor& infor)
	{
		AVPacket packet;
		av_init_packet(&packet);
		for (;;)
		{
			if (av_read_frame(_formatCtx, &packet))
			{
				av_free_packet(&packet);
				return false;
			}
			if (packet.stream_index != _videoIndex)
			{
				continue;
			}
			int frame_finished = 0;

			int res = avcodec_decode_video2(_codecCtx, _frame, &frame_finished, &packet);

			if (frame_finished)
			{
				AVStream*   streams = _formatCtx->streams[_videoIndex];
				double      tmbase = av_q2d(streams->time_base);
				int64_t     pts = _frame->pts;

				char        buf[128];
				sprintf(buf, "pts = %I64d     dts =  %I64d\n", packet.pts, packet.dts);
				int res = sws_scale(
					_convertCtx
					, (const uint8_t* const*)_frame->data
					, _frame->linesize
					, 0
					, _codecCtx->height
					, _frameRGB->data
					, _frameRGB->linesize
				);
				av_packet_unref(&packet);

				infor._data = _frameRGB->data[0];
				infor._dataSize = _imageSize;
				infor._width = _screenW;
				infor._height = _screenH;
				infor._pts = _frame->pts;
				infor._timeBase = av_q2d(streams->time_base);

				return  true;
			}
		}
		return  false;
	}
	void*   readFrame()
	{
		AVPacket packet;
		av_init_packet(&packet);
		for (;;)
		{
			if (av_read_frame(_formatCtx, &packet))
			{
				av_free_packet(&packet);
				return 0;
			}
			if (packet.stream_index != _videoIndex)
			{
				continue;
			}
			int frame_finished = 0;

			int res = avcodec_decode_video2(_codecCtx, _frame, &frame_finished, &packet);

			if (frame_finished)
			{
				AVStream*   streams = _formatCtx->streams[_videoIndex];
				double      tmbase = av_q2d(streams->time_base);
				int64_t     pts = _frame->pts;

				char        buf[128];
				sprintf(buf, "pts = %I64d     dts =  %I64d\n", packet.pts, packet.dts);
				int res = sws_scale(
					_convertCtx
					, (const uint8_t* const*)_frame->data
					, _frame->linesize
					, 0
					, _codecCtx->height
					, _frameRGB->data
					, _frameRGB->linesize
				);
				av_packet_unref(&packet);

				return  _frameRGB->data[0];
			}
		}
		return  0;
	}
};



#include <windows.h>

class Timestamp
{
public:
	Timestamp()
	{
		QueryPerformanceFrequency(&_frequency);
		QueryPerformanceCounter(&_startCount);
	}
	~Timestamp()
	{}

	void    update()
	{
		QueryPerformanceCounter(&_startCount);
	}
	/**
	*   获取当前秒
	*/
	double getElapsedSecond()
	{
		return  getElapsedTimeInMicroSec() * 0.000001;
	}
	/**
	*   获取毫秒
	*/
	double getElapsedTimeInMilliSec()
	{
		return this->getElapsedTimeInMicroSec() * 0.001;
	}
	/**
	*   获取微妙
	*/
	double getElapsedTimeInMicroSec()
	{
		LARGE_INTEGER endCount;
		QueryPerformanceCounter(&endCount);

		double  startTimeInMicroSec = _startCount.QuadPart * (1000000.0 / _frequency.QuadPart);
		double  endTimeInMicroSec = endCount.QuadPart * (1000000.0 / _frequency.QuadPart);

		return  endTimeInMicroSec - startTimeInMicroSec;
	}
protected:
	LARGE_INTEGER   _frequency;
	LARGE_INTEGER   _startCount;
};





#endif

}

.cpp

{

#include "AVdio.h"

#ifndef DISPLAY
#define DISPLAY Director::getInstance()->getVisibleSize()
#endif
#ifndef displayex
#define displayex Director::getInstance()->getVisibleSize()
#endif


FFVideoReader   ffReader;
FrameInfor *fl = new (std::nothrow) FrameInfor;
auto texture = new (std::nothrow) Texture2D();
bool is = false;
Timestamp       _timestamp;
double s = 0;


cocos2d::LayerColor* AVdio::createAVdio()
{
	auto LC = AVdio::create();
	if (LC)
	{
		return LC;
	}
	else
	{
		return nullptr;
	}
}

AVdio::~AVdio()
{

}

void AVdio::update(float delta)
{
	auto video = (Sprite*)(this->getChildByName("video"));
	if (video != nullptr)
	{
		double      tims = fl->_pts * fl->_timeBase * 1000;
		double      elsped = _timestamp.getElapsedTimeInMilliSec();
		double      sleeps = (tims - elsped);

		s = sleeps + elsped;

		if (elsped - s > 0.0001)
		{
			is = ffReader.readFrame(*fl);
			if (is)
			{
				texture->initWithData((const unsigned char*)fl->_data, fl->_dataSize, Texture2D::PixelFormat::RGB888,
					fl->_width, fl->_height,
					Size(fl->_width, fl->_height));

				video->initWithTexture(texture);
				video->setContentSize(Size(displayex.width - 10, displayex.height - 50));
			}
			else
			{
				video->removeFromParent();
			}
		}
	}

}

bool AVdio::init()
{
	if (!LayerColor::init())
	{
		return false;
	}

	auto display = Director::getInstance()->getVisibleSize();
	Vec2 origin = Director::getInstance()->getVisibleOrigin();

	this->setTouchEnabled(true);
	auto ELTOBO = EventListenerTouchOneByOne::create();
	ELTOBO->setSwallowTouches(true);
	ELTOBO->onTouchBegan = std::move(std::bind(&AVdio::onTouchBegan, this, std::placeholders::_1, std::placeholders::_2));
	this->getEventDispatcher()->addEventListenerWithSceneGraphPriority(ELTOBO, this);




	auto background = cocos2d::LayerColor::create(cocos2d::Color4B(0, 0, 0, 255));
	this->addChild(background);

	//close button
	string file("res/Button.png");
	auto btn = cocos2d::ui::Button::create(file, file, file);
	btn->setColor(Color3B(24, 48, 64));
	btn->setPressedActionEnabled(true);
	btn->setScale9Enabled(true);
	btn->setContentSize(Size(100, 50));
	btn->setPosition(Vec2(displayex.width - btn->getContentSize().width / 2,
		displayex.height - btn->getContentSize().height / 2));
	btn->setTitleColor(Color3B::RED);
	btn->setTitleFontSize(50);
	btn->setName("X");
	btn->setTitleText("X");
	btn->addClickEventListener(std::bind(&AVdio::OnCallback, this, std::placeholders::_1));
	this->addChild(btn);


	//this->initVideoStream();

	this->initInput();
}

void AVdio::initInput()
{
	auto edit = ui::EditBox::create(Size(800, 50), "res/input.png");
	edit->setPosition(Vec2(0, displayex.height - edit->getContentSize().height / 2));
	edit->setAnchorPoint(Vec2(0.0f, 0.5f));
	edit->setName("videoPath");
	edit->setFontColor(Color4B::YELLOW);
	edit->setDelegate(this);
	this->addChild(edit);

	string file("res/Button.png");
	auto btn = cocos2d::ui::Button::create(file, file, file);
	btn->setColor(Color3B(24, 48, 64));
	btn->setPressedActionEnabled(true);
	btn->setScale9Enabled(true);
	btn->setContentSize(Size(150, 50));
	btn->setPosition(Vec2(displayex.width - (displayex.width - edit->getContentSize().width) + btn->getContentSize().width / 2,
		edit->getPosition().y));
	btn->setTitleColor(Color3B::RED);
	btn->setTitleFontSize(50);
	btn->setName("PLAY");
	btn->setTitleText("PLAY");
	btn->addClickEventListener(std::bind(&AVdio::OnCallback, this, std::placeholders::_1));
	this->addChild(btn);
}

void AVdio::initVideoStream(string filename)
{
	this->unscheduleUpdate();

	_timestamp.update();
	
	

	ATBAE::GetInstance()->PauseAllMusicAndEffects();
	auto video = (Sprite*)(this->getChildByName("video"));
	if (video != nullptr)
	{
		video->removeFromParent();
	}

	s = 0;

	auto display = Director::getInstance()->getVisibleSize();
	Vec2 origin = Director::getInstance()->getVisibleOrigin();

	auto ret = avdevice_version();
	std::cout << ret << std::endl;

	ffReader.~FFVideoReader();
	ffReader.setup();
	ffReader.load(filename.c_str());

	ATBAE::GetInstance()->LoadMusicsAndPlay(filename.c_str());


	is = ffReader.readFrame(*fl);

	texture->initWithData((const unsigned char*)fl->_data, fl->_dataSize, Texture2D::PixelFormat::RGB888,
		fl->_width - 1, fl->_height - 1,
		Size(500, 500));

	auto s = Sprite::create("06a03.jpg");
	s->initWithTexture(texture);
	s->setName("video");
	s->setPosition(Vec2(display.width / 2, display.height / 2 - 25));
	this->addChild(s);

	this->scheduleUpdate();
}


void AVdio::OnCallback(cocos2d::Ref* pSender)
{
	string name = ((Node*)(pSender))->getName();
	if (name == "X")
	{
		auto action = Sequence::create(MoveTo::create(0.2f, Vec3(-(displayex.width), 0, 0)),
			DelayTime::create(0.1f),
			CallFunc::create([=]()
		{
			this->removeFromParent();
			ATBAE::GetInstance()->PauseAllMusicAndEffects();
		}), nullptr);
		this->runAction(action);
	}
	else if (name == "PLAY")
	{
		auto edit = (ui::EditBox*)this->getChildByName("videoPath");
		string path = edit->getText();
		if (path.length() > 0)
		{
			this->initVideoStream(path);
		}
		
	}
}
bool AVdio::onTouchBegan(Touch *touch, Event *unused_event)
{
	return true;
}


void AVdio::editBoxEditingDidBegin(EditBox* editBox)
{

}
void AVdio::editBoxEditingDidEnd(EditBox* editBox)
{

}
void AVdio::editBoxTextChanged(EditBox* editBox, const std::string& text)
{

}
void AVdio::editBoxReturn(EditBox* editBox)
{

}
void AVdio::editBoxEditingDidEndWithAction(EditBox* editBox, EditBoxDelegate::EditBoxEndAction action)
{

}

}

ffmpeg test cocos2d video

ShoppingChen

ShoppingChen

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

ffmpeg coco2d-x lua test

TOLUA_API int lua_yffmpeg(lua_State* L);int argc = 0;bool ok = true;tolua_Error tolua_err;if (!tolua_isusertable(tolua_S, 1, &q

wqiaofujiang 2020-07-05

Python调用ffmpeg开源视频处理库，批量处理视频

strcmd = r'ffprobe -print_format json -show_streams -i "{}"'.format. strcmd = 'ffmpeg -i "{}" -vcodec copy -

dingwun 2020-11-16

c++ opencv ffmpeg 图片序列化视频

ffmpeg -y -framerate 10 -start_number 1 -i E:\Image\Image_%d.bmp E:\test.mp4. fps, cv::Size/*图片大小，一定不能出错*/, 0);

wangdaren 2020-08-15

ffmpeg合并音频和视频

ffmpeg -i video.mp4 -i audio.wav -c:v copy -c:a aac -strict experimental output.mp4. 如果视频中已经包含了音频，这个时候还可以替换视频中的音频，使用下面命令行。ffmpeg

PGzxc 2020-07-04

ffmpeg安装

搭一个 ffmpeg + nginx服务器 实现实时推流。手把手教你搭建Nginx-rtmp流媒体服务器+使用ffmpeg推流

83096129 2020-07-04

ffmpeg 常用知识点收集

FFmpeg是一个自由软件，可以运行音频和视频多种格式的录影、转换、流功能1，包含了libavcodec ─这是一个用于多个项目中音频和视频的解码器库，以及libavformat——一个音频与视频格式转换库。FFmpeg视频文件转换命令行工具,也支持经过实

cherayliu 2020-06-17

ffmpeg 编译Android

4.#!

cherayliu 2020-06-13

centos7 安装ffmpeg

5. ffmpeg -h #查看参数 这样就完成了 ffmpeg 就是一个流媒体简单的工具 所以也是很简单的

chancle 2020-06-12

通过命令或工具进行视频码率测试

在工作中，需要对视频的码率做验证，用到了俩种方法。一种是通过FFmpeg命令，另一种是安装VLC工具。b.快捷键Windows+R打开运行窗口，输入命令 FFmpeg -version,出现下图,安装成功。　　c.安装成功，进行ffmpeg配置，此电脑--

83096129 2020-06-08

ffmpeg新旧API对比

5. 关于codec问题有的可以直接改为codecpar，但有的时候这样这样是不对的，所以我也还在探索，这里记录一个对pCodecCtx和pCodec赋值方式的改变

83096129 2020-06-08

FFmpeg源码结构

*AVFormatContext是API层直接接触到的结构体，它会进行格式的封装与解封装，它的数据部分由底层提供，底层使用了AVIOContext,这个AVIOContext实际上就是为普通的I/O增加了一层Buffer缓冲区，再往底层就是URLConte

PGzxc 2020-06-01

FFmpeg常用命令

AVFoundation indev @ 0x7ff068403c00] AVFoundation video devices:[AVFoundation indev @ 0x7ff068403c00] [0] FaceTime HD Camera[AVF

ShoppingChen 2020-05-29

编程必备基础-音视频小白系统入门课

5G 的商用，使高效高清的直播和视频成为刚需，短视频、娱乐直播等都与音视频联系紧密，各大互联网公司都在储备音视频方向的开发者。但是，网络上关于音视频的学习资料非常少，且几乎没有系统讲解音视频的入门课程。于是这门课应运而生。它系统讲解音视频基础原理，并实战如

cherayliu 2020-05-11

实现简单网页rtmp直播：nginx+ckplayer+linux

安装带有rtmp模块的nginx服务器，此处使用nginx服务器，简单方便。安装请参考我的CSDN：nginx安装，经过多次安装实践，此方法适用于rhel和centos系统，ubuntu可能会不适用，如果安装过程中出现大量错误，请另行百度安装方法。注意需要

ShoppingChen 2020-05-11

【音视频连载-011】第二季 FFmpeg 一层一层获取文件信息

本篇文章主要是讲解如何通过 FFmpeg 代码来获取文件信息。首先准备一个文件，用命令行来查看它的基本信息。这个文件很有意思，它的内容是一个时钟，每隔一秒，秒针都会跳动，同时还会发出滴答的声音，很方便后续做音视频同步处理。以上这些信息都可以在一个叫 AVF

83096129 2020-05-10

高清视频压缩工具ffmpeg

FFmpeg 本身是一个庞大的项目，包含许多组件和库文件，最常用的是它的命令行工具。./ffmpeg.exe -i .\dd.mp4 -vcodec h264 -r 30 -b:v 2048k ./ee.mp4 -y

PGzxc 2020-05-07

【音视频连载-010】第二季 FFmpeg 日志打印

音视频连载系列已经停更一段时间，再这么停下去估计就要掉粉了，捡起来继续更新~~~接下来主要是讲解 FFmpeg 相关的内容，比如这篇就从简单的日志打印开始说起。其中 level 参数指的是日志级别，后面的 fmt 和 ... 代表日志内容，和调用 prin

cherayliu 2020-04-27

网络视频m3u8解密及ts文件合并

直接用ffmpeg下载是排队逐个下载，嫌慢就写了个脚本多线程下载能快一些,，然后用ffmpeg合并ts文件。进入chrome开发者模式，然后Network选项卡，如果文件已经加载就刷新下页面，可以看到以下文件列表：。index.m3u8有两个同名文件，都下

cherayliu 2020-04-11

音乐格式转换

下载完毕解压后的目录结构如下图：。常用命令：获取视频的信息 ffmpeg -i video.avi将图片序列合成视频 ffmpeg -f image2 -i image%d.jpg video.mpg 上面的命令会把当前目录下的图片（名字如：image1.

PGzxc 2020-03-27

ffmpeg

ffmpeg -i 20191223_165517.mp4 -an -vcodec copy -bsf:v h264_mp4toannexb 20191223_165517.h264ffmpeg -i 20191223_173017.mp4 -an -vc

yuuuuy 2020-03-05
ShoppingChen

ShoppingChen

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号