[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Gnash-commit] [SCM] Gnash branch, master, updated. release_0_8_9_final-
|
From: |
Bastiaan Jacques |
|
Subject: |
[Gnash-commit] [SCM] Gnash branch, master, updated. release_0_8_9_final-2035-g759defb |
|
Date: |
Tue, 20 May 2014 21:26:08 +0000 |
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Gnash".
The branch, master has been updated
via 759defb2e90b16f75549cd2a380c0c05e269972b (commit)
from ba743ab96334ac0573e323019f0df2b85dddd64e (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://git.savannah.gnu.org/cgit//commit/?id=759defb2e90b16f75549cd2a380c0c05e269972b
commit 759defb2e90b16f75549cd2a380c0c05e269972b
Author: Bastiaan Jacques <address@hidden>
Date: Tue May 20 23:25:23 2014 +0200
Use standard integer types from namespace std instead of namespace boost.
diff --git a/cygnal/cgi-bin/echo/echo.cpp b/cygnal/cgi-bin/echo/echo.cpp
index 3080cb8..56b8a85 100644
--- a/cygnal/cgi-bin/echo/echo.cpp
+++ b/cygnal/cgi-bin/echo/echo.cpp
@@ -82,7 +82,7 @@ extern "C" {
// GNASH_REPORT_RETURN;
}
- size_t echo_write_func(boost::uint8_t *data, size_t size)
+ size_t echo_write_func(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
@@ -216,7 +216,7 @@ EchoTest::~EchoTest()
// Parse an Echo Request message coming from the Red5 echo_test. This
// method should only be used for testing purposes.
vector<std::shared_ptr<cygnal::Element > >
-EchoTest::parseEchoRequest(boost::uint8_t *ptr, size_t size)
+EchoTest::parseEchoRequest(std::uint8_t *ptr, size_t size)
{
// GNASH_REPORT_FUNCTION;
@@ -276,7 +276,7 @@ EchoTest::formatEchoResponse(double num, cygnal::Buffer
&data)
}
std::shared_ptr<cygnal::Buffer>
-EchoTest::formatEchoResponse(double num, boost::uint8_t *data, size_t size)
+EchoTest::formatEchoResponse(double num, std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
diff --git a/cygnal/cgi-bin/echo/echo.h b/cygnal/cgi-bin/echo/echo.h
index 1ee4d06..8c63b50 100644
--- a/cygnal/cgi-bin/echo/echo.h
+++ b/cygnal/cgi-bin/echo/echo.h
@@ -45,12 +45,12 @@ public:
// Parse an Echo Request message coming from the Red5 echo_test.
std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(cygnal::Buffer &buf)
{ return parseEchoRequest(buf.reference(), buf.size()); };
- std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(boost::uint8_t *buf, size_t size);
+ std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(std::uint8_t *buf, size_t size);
// format a response to the 'echo' test used for testing Gnash.
std::shared_ptr<cygnal::Buffer> formatEchoResponse(double num,
cygnal::Element &el);
std::shared_ptr<cygnal::Buffer> formatEchoResponse(double num,
cygnal::Buffer &data);
- std::shared_ptr<cygnal::Buffer> formatEchoResponse(double num,
boost::uint8_t *data, size_t size);
+ std::shared_ptr<cygnal::Buffer> formatEchoResponse(double num,
std::uint8_t *data, size_t size);
std::shared_ptr<cygnal::Buffer> getResponse() { return _response; };
void setResponse(std::shared_ptr<cygnal::Buffer> &x) { _response = x; };
@@ -75,7 +75,7 @@ extern "C" {
std::shared_ptr<Handler::cygnal_init_t>echo_init_func(std::shared_ptr<gnash::RTMPMsg>
&msg);
std::shared_ptr<cygnal::Buffer> echo_read_func();
- size_t echo_write_func(boost::uint8_t *data, size_t size);
+ size_t echo_write_func(std::uint8_t *data, size_t size);
}
} // end of cygnal namespace
diff --git a/cygnal/cgi-bin/echo/gateway.cpp b/cygnal/cgi-bin/echo/gateway.cpp
index 5e6cd7d..0cbc1d3 100644
--- a/cygnal/cgi-bin/echo/gateway.cpp
+++ b/cygnal/cgi-bin/echo/gateway.cpp
@@ -68,7 +68,7 @@ extern "C" {
// GNASH_REPORT_RETURN;
}
- size_t gateway_write_func(boost::uint8_t *data, size_t size)
+ size_t gateway_write_func(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
@@ -236,18 +236,18 @@ GatewayTest::~GatewayTest()
// Parse an Echo Request message coming from the Red5 echo_test. This
// method should only be used for testing purposes.
vector<std::shared_ptr<amf::Element > >
-GatewayTest::parseEchoRequest(boost::uint8_t *data, size_t size)
+GatewayTest::parseEchoRequest(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
vector<std::shared_ptr<amf::Element > > headers;
// skip past the header bytes, we don't care about them.
- boost::uint8_t *tmpptr = data + 6;
+ std::uint8_t *tmpptr = data + 6;
- boost::uint16_t length;
- length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
- tmpptr += sizeof(boost::uint16_t);
+ std::uint16_t length;
+ length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
+ tmpptr += sizeof(std::uint16_t);
// Get the first name, which is a raw string, and not preceded by
// a type byte.
@@ -256,7 +256,7 @@ GatewayTest::parseEchoRequest(boost::uint8_t *data, size_t
size)
// If the length of the name field is corrupted, then we get out of
// range quick, and corrupt memory. This is a bit of a hack, but
// reduces memory errors caused by some of the corrupted tes cases.
- boost::uint8_t *endstr = std::find(tmpptr, tmpptr+length, '\0');
+ std::uint8_t *endstr = std::find(tmpptr, tmpptr+length, '\0');
if (endstr != tmpptr+length) {
log_debug("Caught corrupted string! length was %d, null at %d",
length, endstr-tmpptr);
@@ -268,8 +268,8 @@ GatewayTest::parseEchoRequest(boost::uint8_t *data, size_t
size)
// Get the second name, which is a raw string, and not preceded by
// a type byte.
- length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
- tmpptr += sizeof(boost::uint16_t);
+ length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
+ tmpptr += sizeof(std::uint16_t);
std::shared_ptr<amf::Element > el2(new amf::Element);
// std::string name2(reinterpret_cast<const char *>(tmpptr), length);
@@ -340,11 +340,11 @@ GatewayTest::formatEchoResponse(const std::string &num,
amf::Buffer &data)
}
amf::Buffer &
-GatewayTest::formatEchoResponse(const std::string &num, boost::uint8_t *data,
size_t size)
+GatewayTest::formatEchoResponse(const std::string &num, std::uint8_t *data,
size_t size)
{
// GNASH_REPORT_FUNCTION;
- //boost::uint8_t *tmpptr = data;
+ //std::uint8_t *tmpptr = data;
// FIXME: temporary hacks while debugging
amf::Buffer fixme("00 00 00 00 00 01");
diff --git a/cygnal/cgi-bin/echo/gateway.h b/cygnal/cgi-bin/echo/gateway.h
index d4744ae..023ca37 100644
--- a/cygnal/cgi-bin/echo/gateway.h
+++ b/cygnal/cgi-bin/echo/gateway.h
@@ -42,12 +42,12 @@ public:
// Parse an Echo Request message coming from the Red5 echo_test.
std::vector<std::shared_ptr<amf::Element > > parseEchoRequest(amf::Buffer
&buf)
{ return parseEchoRequest(buf.reference(), buf.size()); };
- std::vector<std::shared_ptr<amf::Element > >
parseEchoRequest(boost::uint8_t *buf, size_t size);
+ std::vector<std::shared_ptr<amf::Element > > parseEchoRequest(std::uint8_t
*buf, size_t size);
// format a response to the 'echo' test used for testing Gnash.
amf::Buffer &formatEchoResponse(const std::string &num, amf::Element &el);
amf::Buffer &formatEchoResponse(const std::string &num, amf::Buffer &data);
- amf::Buffer &formatEchoResponse(const std::string &num, boost::uint8_t
*data, size_t size);
+ amf::Buffer &formatEchoResponse(const std::string &num, std::uint8_t
*data, size_t size);
private:
};
diff --git a/cygnal/cgi-bin/fitcDemo/fitcDemo.cpp
b/cygnal/cgi-bin/fitcDemo/fitcDemo.cpp
index ca85bd0..c6ad29a 100644
--- a/cygnal/cgi-bin/fitcDemo/fitcDemo.cpp
+++ b/cygnal/cgi-bin/fitcDemo/fitcDemo.cpp
@@ -66,7 +66,7 @@ extern "C" {
return init;
}
- size_t fitcDemo_read_func(boost::uint8_t *data, size_t size)
+ size_t fitcDemo_read_func(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
@@ -87,7 +87,7 @@ extern "C" {
// GNASH_REPORT_RETURN;
}
- size_t fitcDemo_write_func(boost::uint8_t *data, size_t size)
+ size_t fitcDemo_write_func(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
@@ -221,7 +221,7 @@ FitcDemoTest::~FitcDemoTest()
// Parse an FitcDemo Request message coming from the Red5 fitcDemo_test. This
// method should only be used for testing purposes.
vector<std::shared_ptr<amf::Element > >
-FitcDemoTest::parseFitcDemoRequest(boost::uint8_t *ptr, size_t size)
+FitcDemoTest::parseFitcDemoRequest(std::uint8_t *ptr, size_t size)
{
// GNASH_REPORT_FUNCTION;
@@ -281,7 +281,7 @@ FitcDemoTest::formatFitcDemoResponse(double num,
amf::Buffer &data)
}
std::shared_ptr<amf::Buffer>
-FitcDemoTest::formatFitcDemoResponse(double num, boost::uint8_t *data, size_t
size)
+FitcDemoTest::formatFitcDemoResponse(double num, std::uint8_t *data, size_t
size)
{
// GNASH_REPORT_FUNCTION;
diff --git a/cygnal/cgi-bin/fitcDemo/fitcDemo.h
b/cygnal/cgi-bin/fitcDemo/fitcDemo.h
index 2862300..656a2b5 100644
--- a/cygnal/cgi-bin/fitcDemo/fitcDemo.h
+++ b/cygnal/cgi-bin/fitcDemo/fitcDemo.h
@@ -44,12 +44,12 @@ public:
// Parse an FitcDemo Request message coming from the Red5 fitcDemo_test.
std::vector<std::shared_ptr<amf::Element > >
parseFitcDemoRequest(amf::Buffer &buf)
{ return parseFitcDemoRequest(buf.reference(), buf.size()); };
- std::vector<std::shared_ptr<amf::Element > >
parseFitcDemoRequest(boost::uint8_t *buf, size_t size);
+ std::vector<std::shared_ptr<amf::Element > >
parseFitcDemoRequest(std::uint8_t *buf, size_t size);
// format a response to the 'fitcDemo' test used for testing Gnash.
std::shared_ptr<amf::Buffer> formatFitcDemoResponse(double num,
amf::Element &el);
std::shared_ptr<amf::Buffer> formatFitcDemoResponse(double num,
amf::Buffer &data);
- std::shared_ptr<amf::Buffer> formatFitcDemoResponse(double num,
boost::uint8_t *data, size_t size);
+ std::shared_ptr<amf::Buffer> formatFitcDemoResponse(double num,
std::uint8_t *data, size_t size);
std::shared_ptr<amf::Buffer> getResponse() { return _response; };
void setResponse(std::shared_ptr<amf::Buffer> &x) { _response = x; };
@@ -61,8 +61,8 @@ private:
extern "C" {
std::shared_ptr<Handler::cygnal_init_t> fitcDemo_class_init();
// the standard API
- size_t fitcDemo_read_func(boost::uint8_t *data, size_t size);
- size_t fitcDemo_write_func(boost::uint8_t *data, size_t size);
+ size_t fitcDemo_read_func(std::uint8_t *data, size_t size);
+ size_t fitcDemo_write_func(std::uint8_t *data, size_t size);
}
} // end of cygnal namespace
diff --git a/cygnal/cgi-bin/oflaDemo/oflaDemo.cpp
b/cygnal/cgi-bin/oflaDemo/oflaDemo.cpp
index 19133e9..1e76000 100644
--- a/cygnal/cgi-bin/oflaDemo/oflaDemo.cpp
+++ b/cygnal/cgi-bin/oflaDemo/oflaDemo.cpp
@@ -135,7 +135,7 @@ extern "C" {
// GNASH_REPORT_RETURN;
}
- size_t oflaDemo_write_func(boost::uint8_t *data, size_t size)
+ size_t oflaDemo_write_func(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
@@ -385,7 +385,7 @@ OflaDemoTest::~OflaDemoTest()
// Parse an OflaDemo Request message coming from the Red5 oflaDemo_test. This
// method should only be used for testing purposes.
vector<std::shared_ptr<cygnal::Element > >
-OflaDemoTest::parseOflaDemoRequest(boost::uint8_t *ptr, size_t size)
+OflaDemoTest::parseOflaDemoRequest(std::uint8_t *ptr, size_t size)
{
GNASH_REPORT_FUNCTION;
@@ -556,7 +556,7 @@ OflaDemoTest::formatOflaDemoResponse(double num,
cygnal::Buffer &data)
}
std::shared_ptr<cygnal::Buffer>
-OflaDemoTest::formatOflaDemoResponse(double num, boost::uint8_t *data, size_t
size)
+OflaDemoTest::formatOflaDemoResponse(double num, std::uint8_t *data, size_t
size)
{
// GNASH_REPORT_FUNCTION;
diff --git a/cygnal/cgi-bin/oflaDemo/oflaDemo.h
b/cygnal/cgi-bin/oflaDemo/oflaDemo.h
index 825b926..17c960e 100644
--- a/cygnal/cgi-bin/oflaDemo/oflaDemo.h
+++ b/cygnal/cgi-bin/oflaDemo/oflaDemo.h
@@ -72,12 +72,12 @@ public:
// Parse an OflaDemo Request message coming from the Red5 oflaDemo_test.
std::vector<std::shared_ptr<cygnal::Element > >
parseOflaDemoRequest(cygnal::Buffer &buf)
{ return parseOflaDemoRequest(buf.reference(), buf.size()); };
- std::vector<std::shared_ptr<cygnal::Element > >
parseOflaDemoRequest(boost::uint8_t *buf, size_t size);
+ std::vector<std::shared_ptr<cygnal::Element > >
parseOflaDemoRequest(std::uint8_t *buf, size_t size);
// format a response to the 'oflaDemo' test used for testing Gnash.
std::shared_ptr<cygnal::Buffer> formatOflaDemoResponse(double num,
cygnal::Element &el);
std::shared_ptr<cygnal::Buffer> formatOflaDemoResponse(double num,
cygnal::Buffer &data);
- std::shared_ptr<cygnal::Buffer> formatOflaDemoResponse(double num,
boost::uint8_t *data, size_t size);
+ std::shared_ptr<cygnal::Buffer> formatOflaDemoResponse(double num,
std::uint8_t *data, size_t size);
std::shared_ptr<cygnal::Buffer> getResponse() { return _response; };
void setResponse(std::shared_ptr<cygnal::Buffer> &x) { _response = x; };
@@ -102,7 +102,7 @@ extern "C" {
std::shared_ptr<Handler::cygnal_init_t>oflaDemo_init_func(std::shared_ptr<gnash::RTMPMsg>
&msg);
std::shared_ptr<cygnal::Buffer> oflaDemo_read_func();
- size_t oflaDemo_write_func(boost::uint8_t *data, size_t size);
+ size_t oflaDemo_write_func(std::uint8_t *data, size_t size);
}
} // end of cygnal namespace
diff --git a/cygnal/crc.cpp b/cygnal/crc.cpp
index 1464e7b..2fb53d7 100644
--- a/cygnal/crc.cpp
+++ b/cygnal/crc.cpp
@@ -34,7 +34,7 @@
#include <sys/types.h>
#include "GnashSystemIOHeaders.h" // for getuid()
#include <sys/stat.h>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <cctype> // for toupper
#include <string>
diff --git a/cygnal/cygnal.h b/cygnal/cygnal.h
index a93a0a0..3f9e610 100644
--- a/cygnal/cygnal.h
+++ b/cygnal/cygnal.h
@@ -19,7 +19,7 @@
#ifndef __CYGNAL_H__
#define __CYGNAL_H__
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/thread.hpp>
#include <vector>
#include <string>
diff --git a/cygnal/handler.cpp b/cygnal/handler.cpp
index c6cc416..fe04326 100644
--- a/cygnal/handler.cpp
+++ b/cygnal/handler.cpp
@@ -356,7 +356,7 @@ Handler::initModule(const std::string& str)
}
size_t
-Handler::writeToPlugin(boost::uint8_t *data, size_t size)
+Handler::writeToPlugin(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
size_t ret = 0;
diff --git a/cygnal/handler.h b/cygnal/handler.h
index a063eae..018011f 100644
--- a/cygnal/handler.h
+++ b/cygnal/handler.h
@@ -20,7 +20,7 @@
#define __HANDLER_H__ 1
#include <map>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/thread/mutex.hpp>
#include <memory>
//#include <boost/thread/condition.hpp>
@@ -88,7 +88,7 @@ public:
} pub_stream_e;
/// This typedef is only used for the io function that must be
/// supported by the plugin.
- typedef size_t (*cygnal_io_write_t)(boost::uint8_t *data, size_t size);
+ typedef size_t (*cygnal_io_write_t)(std::uint8_t *data, size_t size);
typedef std::shared_ptr<cygnal::Buffer> (*cygnal_io_read_t)();
typedef struct {
std::string version;
@@ -177,7 +177,7 @@ public:
/// This method writes raw data to a plugin.
size_t writeToPlugin(cygnal::Buffer &buf) {
return writeToPlugin(buf.begin(), buf.allocated()); };
- size_t writeToPlugin(boost::uint8_t *data, size_t size);
+ size_t writeToPlugin(std::uint8_t *data, size_t size);
// These methods handle control of the file streaming, and are
// used by both HTTP and RTMP*
diff --git a/cygnal/http_server.cpp b/cygnal/http_server.cpp
index fb4e69c..6f7c6aa 100644
--- a/cygnal/http_server.cpp
+++ b/cygnal/http_server.cpp
@@ -290,7 +290,7 @@ HTTPServer::processPostRequest(int fd, cygnal::Buffer * /*
bufFIXME */)
// cerr << __FUNCTION__ << buf->allocated() << " : " <<
hexify(buf->reference(), buf->allocated(), true) << endl;
clearHeader();
- boost::uint8_t *data = processHeaderFields(buf.get());
+ std::uint8_t *data = processHeaderFields(buf.get());
size_t length = strtol(getField("content-length").c_str(), NULL, 0);
std::shared_ptr<cygnal::Buffer> content(new cygnal::Buffer(length));
int ret = 0;
@@ -478,7 +478,7 @@ HTTPServer::formatGetReply(size_t size, http_status_e code)
formatHeader(size, code);
// int ret = Network::writeNet(_header.str());
-// boost::uint8_t *ptr = (boost::uint8_t *)_body.str().c_str();
+// std::uint8_t *ptr = (std::uint8_t *)_body.str().c_str();
// buf->copy(ptr, _body.str().size());
// _handler->dump();
@@ -531,18 +531,18 @@ HTTPServer::formatPostReply(rtmpt_cmd_e /* code */)
// Parse an Echo Request message coming from the Red5 echo_test. This
// method should only be used for testing purposes.
vector<std::shared_ptr<cygnal::Element > >
-HTTPServer::parseEchoRequest(boost::uint8_t *data, size_t size)
+HTTPServer::parseEchoRequest(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
vector<std::shared_ptr<cygnal::Element > > headers;
// skip past the header bytes, we don't care about them.
- boost::uint8_t *tmpptr = data + 6;
+ std::uint8_t *tmpptr = data + 6;
- boost::uint16_t length;
- length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
- tmpptr += sizeof(boost::uint16_t);
+ std::uint16_t length;
+ length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
+ tmpptr += sizeof(std::uint16_t);
// Get the first name, which is a raw string, and not preceded by
// a type byte.
@@ -551,7 +551,7 @@ HTTPServer::parseEchoRequest(boost::uint8_t *data, size_t
size)
// If the length of the name field is corrupted, then we get out of
// range quick, and corrupt memory. This is a bit of a hack, but
// reduces memory errors caused by some of the corrupted tes cases.
- boost::uint8_t *endstr = std::find(tmpptr, tmpptr+length, '\0');
+ std::uint8_t *endstr = std::find(tmpptr, tmpptr+length, '\0');
if (endstr != tmpptr+length) {
log_debug("Caught corrupted string! length was %d, null at %d",
length, endstr-tmpptr);
@@ -563,8 +563,8 @@ HTTPServer::parseEchoRequest(boost::uint8_t *data, size_t
size)
// Get the second name, which is a raw string, and not preceded by
// a type byte.
- length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
- tmpptr += sizeof(boost::uint16_t);
+ length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
+ tmpptr += sizeof(std::uint16_t);
std::shared_ptr<cygnal::Element > el2(new cygnal::Element);
// std::string name2(reinterpret_cast<const char *>(tmpptr), length);
@@ -635,11 +635,11 @@ HTTPServer::formatEchoResponse(const std::string &num,
cygnal::Buffer &data)
}
cygnal::Buffer &
-HTTPServer::formatEchoResponse(const std::string &num, boost::uint8_t *data,
size_t size)
+HTTPServer::formatEchoResponse(const std::string &num, std::uint8_t *data,
size_t size)
{
// GNASH_REPORT_FUNCTION;
- //boost::uint8_t *tmpptr = data;
+ //std::uint8_t *tmpptr = data;
// FIXME: temporary hacks while debugging
cygnal::Buffer fixme("00 00 00 00 00 01");
@@ -707,7 +707,7 @@ HTTPServer::formatEchoResponse(const std::string &num,
boost::uint8_t *data, siz
/// <index>
/// is a consecutive number that seems to be used to detect missing packages
HTTP::rtmpt_cmd_e
-HTTP::extractRTMPT(boost::uint8_t *data)
+HTTP::extractRTMPT(std::uint8_t *data)
{
GNASH_REPORT_FUNCTION;
@@ -776,7 +776,7 @@ HTTP::extractRTMPT(boost::uint8_t *data)
/// <index>
/// is a consecutive number that seems to be used to detect missing packages
HTTPServer::rtmpt_cmd_e
-HTTPServer::extractRTMPT(boost::uint8_t *data)
+HTTPServer::extractRTMPT(std::uint8_t *data)
{
GNASH_REPORT_FUNCTION;
@@ -831,7 +831,7 @@ HTTPServer::extractRTMPT(boost::uint8_t *data)
#if 0
HTTPServer::http_method_e
-HTTPServer::extractCommand(boost::uint8_t *data)
+HTTPServer::extractCommand(std::uint8_t *data)
{
GNASH_REPORT_FUNCTION;
@@ -864,9 +864,9 @@ HTTPServer::extractCommand(boost::uint8_t *data)
// For valid requests, the second argument, delimited by spaces
// is the filespec of the file being requested or transmitted.
if (cmd != HTTP::HTTP_NONE) {
- boost::uint8_t *start = std::find(data, data+7, ' ') + 1;
- boost::uint8_t *end = std::find(start + 2, data+PATH_MAX, ' ');
- boost::uint8_t *params = std::find(start, end, '?');
+ std::uint8_t *start = std::find(data, data+7, ' ') + 1;
+ std::uint8_t *end = std::find(start + 2, data+PATH_MAX, ' ');
+ std::uint8_t *params = std::find(start, end, '?');
if (params != end) {
_params = std::string(params+1, end);
_filespec = std::string(start, params);
@@ -890,7 +890,7 @@ HTTPServer::extractCommand(boost::uint8_t *data)
return cmd;
}
-boost::uint8_t *
+std::uint8_t *
HTTPServer::processHeaderFields(cygnal::Buffer &buf)
{
// GNASH_REPORT_FUNCTION;
@@ -943,8 +943,8 @@ HTTPServer::processHeaderFields(cygnal::Buffer &buf)
// cerr << "FIXME: " << (void *)i << " : " << dec << end << endl;
} else {
- const boost::uint8_t *cmd = reinterpret_cast<const boost::uint8_t
*>(i->c_str());
- if (extractCommand(const_cast<boost::uint8_t *>(cmd)) ==
HTTP::HTTP_NONE) {
+ const std::uint8_t *cmd = reinterpret_cast<const std::uint8_t
*>(i->c_str());
+ if (extractCommand(const_cast<std::uint8_t *>(cmd)) ==
HTTP::HTTP_NONE) {
break;
#if 1
} else {
@@ -1058,11 +1058,11 @@ HTTPServer::http_handler(Handler *hand, int netfd,
cygnal::Buffer *buf)
cerr << "FIXME no cache hit for: " << www.getFilespec() << endl;
// www.clearHeader();
// cygnal::Buffer &ss = www.formatHeader(filestream->getFileSize(),
HTTP::LIFE_IS_GOOD);
-// www.writeNet(args->netfd, (boost::uint8_t
*)www.getHeader().c_str(), www.getHeader().size());
+// www.writeNet(args->netfd, (std::uint8_t *)www.getHeader().c_str(),
www.getHeader().size());
// cache.addResponse(www.getFilespec(), www.getHeader());
} else {
cerr << "FIXME cache hit on: " << www.getFilespec() << endl;
- www.writeNet(args->netfd, (boost::uint8_t *)response.c_str(),
response.size());
+ www.writeNet(args->netfd, (std::uint8_t *)response.c_str(),
response.size());
}
#endif
diff --git a/cygnal/http_server.h b/cygnal/http_server.h
index 3884604..594ec48 100644
--- a/cygnal/http_server.h
+++ b/cygnal/http_server.h
@@ -65,27 +65,27 @@ public:
// These methods extract data from an RTMPT message. RTMP is an
// extension to HTTP that adds commands to manipulate the
// connection's persistance.
- rtmpt_cmd_e extractRTMPT(boost::uint8_t *data);
+ rtmpt_cmd_e extractRTMPT(std::uint8_t *data);
rtmpt_cmd_e extractRTMPT(cygnal::Buffer &data)
{ return extractRTMPT(data.reference()); };
#if 0
// Examine the beginning of the data for an HTTP request command
// like GET or POST, etc...
- http_method_e extractCommand(boost::uint8_t *data);
+ http_method_e extractCommand(std::uint8_t *data);
http_method_e extractCommand(cygnal::Buffer &data)
{ return extractCommand(data.reference()); };
// process all the header fields in the Buffer, storing them internally
// in _fields. The address returned is the address where the Content data
// starts, and is "Content-Length" bytes long, of "Content-Type" data.
- boost::uint8_t *processHeaderFields(cygnal::Buffer &buf);
+ std::uint8_t *processHeaderFields(cygnal::Buffer &buf);
#endif
#if 0
// Parse an Echo Request message coming from the Red5 echo_test.
std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(gnash::cygnal::Buffer &buf) { return
parseEchoRequest(buf.reference(), buf.size()); };
- std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(boost::uint8_t *buf, size_t size);
+ std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(std::uint8_t *buf, size_t size);
// format a response to the 'echo' test used for testing Gnash.
gnash::cygnal::Buffer &formatEchoResponse(const std::string &num,
cygnal::Element &el);
diff --git a/cygnal/libamf/amf.cpp b/cygnal/libamf/amf.cpp
index 2f013e5..98e66d4 100644
--- a/cygnal/libamf/amf.cpp
+++ b/cygnal/libamf/amf.cpp
@@ -29,7 +29,7 @@
#include <string>
#include <vector>
#include <map>
-#include <boost/cstdint.hpp>
+#include <cstdint>
namespace cygnal
{
@@ -101,10 +101,10 @@ void *
swapBytes(void *word, size_t size)
{
union {
- boost::uint16_t s;
+ std::uint16_t s;
struct {
- boost::uint8_t c0;
- boost::uint8_t c1;
+ std::uint8_t c0;
+ std::uint8_t c1;
} c;
} u;
@@ -117,7 +117,7 @@ swapBytes(void *word, size_t size)
// Little-endian machine: byte-swap the word
// A conveniently-typed pointer to the source data
- boost::uint8_t *x = static_cast<boost::uint8_t *>(word);
+ std::uint8_t *x = static_cast<std::uint8_t *>(word);
/// Handle odd as well as even counts of bytes
std::reverse(x, x+size);
@@ -162,7 +162,7 @@ AMF::encodeBoolean(bool flag)
// Encode a boolean value. 0 for false, 1 for true
std::shared_ptr<Buffer> buf(new Buffer(2));
*buf = Element::BOOLEAN_AMF0;
- *buf += static_cast<boost::uint8_t>(flag);
+ *buf += static_cast<std::uint8_t>(flag);
return buf;
}
@@ -174,7 +174,7 @@ std::shared_ptr<Buffer>
AMF::encodeObject(const cygnal::Element &data)
{
// GNASH_REPORT_FUNCTION;
- boost::uint32_t length;
+ std::uint32_t length;
length = data.propertySize();
gnash::log_debug(_("Encoded data size has %d properties"), length);
std::shared_ptr<cygnal::Buffer> buf;
@@ -254,7 +254,7 @@ AMF::encodeUnsupported()
///
/// @return a binary AMF packet in big endian format
std::shared_ptr<Buffer>
-AMF::encodeDate(const boost::uint8_t *date)
+AMF::encodeDate(const std::uint8_t *date)
{
// GNASH_REPORT_FUNCTION;
// std::shared_ptr<Buffer> buf;
@@ -292,7 +292,7 @@ AMF::encodeNull()
///
/// @return a binary AMF packet in big endian format
std::shared_ptr<Buffer>
-AMF::encodeXMLObject(const boost::uint8_t * /*data */, size_t /* size */)
+AMF::encodeXMLObject(const std::uint8_t * /*data */, size_t /* size */)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<Buffer> buf;
@@ -314,7 +314,7 @@ AMF::encodeTypedObject(const cygnal::Element &data)
// GNASH_REPORT_FUNCTION;
size_t size = 0;
- boost::uint32_t props;
+ std::uint32_t props;
props = data.propertySize();
std::shared_ptr<cygnal::Buffer> buf;
// log_debug("Encoded data size has %d properties", props);
@@ -333,7 +333,7 @@ AMF::encodeTypedObject(const cygnal::Element &data)
*buf = Element::TYPED_OBJECT_AMF0;
size_t length = data.getNameSize();
- boost::uint16_t enclength = length;
+ std::uint16_t enclength = length;
swapBytes(&enclength, 2);
*buf += enclength;
@@ -376,13 +376,13 @@ AMF::encodeTypedObject(const cygnal::Element &data)
///
/// @return a binary AMF packet in big endian format (header,data)
std::shared_ptr<Buffer>
-AMF::encodeReference(boost::uint16_t index)
+AMF::encodeReference(std::uint16_t index)
{
// GNASH_REPORT_FUNCTION;
- boost::uint16_t num = index;
+ std::uint16_t num = index;
std::shared_ptr<cygnal::Buffer> buf(new Buffer(3));
*buf = Element::REFERENCE_AMF0;
- swapBytes(&num, sizeof(boost::uint16_t));
+ swapBytes(&num, sizeof(std::uint16_t));
*buf += num;
return buf;
@@ -396,7 +396,7 @@ AMF::encodeReference(boost::uint16_t index)
///
/// @return a binary AMF packet in big endian format (header,data)
std::shared_ptr<Buffer>
-AMF::encodeMovieClip(const boost::uint8_t * /*data */, size_t /* size */)
+AMF::encodeMovieClip(const std::uint8_t * /*data */, size_t /* size */)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<Buffer> buf;
@@ -418,7 +418,7 @@ std::shared_ptr<Buffer>
AMF::encodeECMAArray(const cygnal::Element &data)
{
// GNASH_REPORT_FUNCTION;
- boost::uint32_t length;
+ std::uint32_t length;
bool sparse = false;
//size_t counter = 0;
@@ -432,7 +432,7 @@ AMF::encodeECMAArray(const cygnal::Element &data)
}
*buf = Element::ECMA_ARRAY_AMF0;
length = 0;
- swapBytes(&length, sizeof(boost::uint32_t));
+ swapBytes(&length, sizeof(std::uint32_t));
*buf += length;
// At lest for red5, it seems to encode from the last item to the
@@ -487,7 +487,7 @@ AMF::encodeECMAArray(const cygnal::Element &data)
///
/// @return a binary AMF packet in big endian format
std::shared_ptr<Buffer>
-AMF::encodeLongString(const boost::uint8_t * /* data */, size_t /* size */)
+AMF::encodeLongString(const std::uint8_t * /* data */, size_t /* size */)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<Buffer> buf;
@@ -504,7 +504,7 @@ AMF::encodeLongString(const boost::uint8_t * /* data */,
size_t /* size */)
///
/// @return a binary AMF packet in big endian format
std::shared_ptr<Buffer>
-AMF::encodeRecordSet(const boost::uint8_t * /* data */, size_t /* size */)
+AMF::encodeRecordSet(const std::uint8_t * /* data */, size_t /* size */)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<Buffer> buf;
@@ -526,7 +526,7 @@ std::shared_ptr<Buffer>
AMF::encodeStrictArray(const cygnal::Element &data)
{
// GNASH_REPORT_FUNCTION;
- boost::uint32_t items;
+ std::uint32_t items;
items = data.propertySize();
// log_debug("Encoded data size has %d properties", items);
std::shared_ptr<cygnal::Buffer> buf(new cygnal::Buffer);
@@ -539,7 +539,7 @@ AMF::encodeStrictArray(const cygnal::Element &data)
// buf.reset(new cygnal::Buffer(5));
}
*buf = Element::STRICT_ARRAY_AMF0;
- swapBytes(&items, sizeof(boost::uint32_t));
+ swapBytes(&items, sizeof(std::uint32_t));
*buf += items;
if (data.propertySize() > 0) {
@@ -562,10 +562,10 @@ AMF::encodeStrictArray(const cygnal::Element &data)
// When returning an ECMA array for a sparsely populated
// array, Red5 adds one more to the count to be 1 based,
// instead of zero based.
- boost::uint32_t moreitems = data.propertySize() + 1;
- swapBytes(&moreitems, sizeof(boost::uint32_t));
- boost::uint8_t *ptr = buf->reference() + 1;
- memcpy(ptr, &moreitems, sizeof(boost::uint32_t));
+ std::uint32_t moreitems = data.propertySize() + 1;
+ swapBytes(&moreitems, sizeof(std::uint32_t));
+ std::uint8_t *ptr = buf->reference() + 1;
+ memcpy(ptr, &moreitems, sizeof(std::uint32_t));
sparse = true;
}
continue;
@@ -606,7 +606,7 @@ AMF::encodeStrictArray(const cygnal::Element &data)
std::shared_ptr<Buffer>
AMF::encodeString(const std::string &str)
{
- boost::uint8_t *ptr = const_cast<boost::uint8_t *>(reinterpret_cast<const
boost::uint8_t *>(str.c_str()));
+ std::uint8_t *ptr = const_cast<std::uint8_t *>(reinterpret_cast<const
std::uint8_t *>(str.c_str()));
return encodeString(ptr, str.size());
}
@@ -618,7 +618,7 @@ AMF::encodeString(const std::string &str)
///
/// @return a binary AMF packet in big endian format
std::shared_ptr<Buffer>
-AMF::encodeString(boost::uint8_t *data, size_t size)
+AMF::encodeString(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<Buffer>buf(new Buffer(size + AMF_HEADER_SIZE));
@@ -627,7 +627,7 @@ AMF::encodeString(boost::uint8_t *data, size_t size)
// it can be printed by to_string() efficiently. The NULL terminator
// doesn't get written when encoding a string as it has a byte count
// instead.
- boost::uint16_t length = size;
+ std::uint16_t length = size;
// log_debug("Encoded data size is going to be %d", length);
swapBytes(&length, 2);
*buf += length;
@@ -644,7 +644,7 @@ std::shared_ptr<Buffer>
AMF::encodeNullString()
{
// GNASH_REPORT_FUNCTION;
- boost::uint16_t length;
+ std::uint16_t length;
std::shared_ptr<Buffer> buf(new Buffer(AMF_HEADER_SIZE));
*buf = Element::STRING_AMF0;
@@ -791,14 +791,14 @@ AMF::encodeElement(const cygnal::Element& el)
std::shared_ptr<Buffer> bigbuf;
if (el.getName() && (el.getType() != Element::TYPED_OBJECT_AMF0)) {
if (buf) {
- bigbuf.reset(new cygnal::Buffer(el.getNameSize() +
sizeof(boost::uint16_t) + buf->size()));
+ bigbuf.reset(new cygnal::Buffer(el.getNameSize() +
sizeof(std::uint16_t) + buf->size()));
} else {
- bigbuf.reset(new cygnal::Buffer(el.getNameSize() +
sizeof(boost::uint16_t)));
+ bigbuf.reset(new cygnal::Buffer(el.getNameSize() +
sizeof(std::uint16_t)));
}
// Add the length of the string for the name of the variable
size_t length = el.getNameSize();
- boost::uint16_t enclength = length;
+ std::uint16_t enclength = length;
swapBytes(&enclength, 2);
*bigbuf = enclength;
// Now the name itself
@@ -833,7 +833,7 @@ AMF::encodeProperty(std::shared_ptr<cygnal::Element> el)
// Add the length of the string for the name of the property
size_t length = el->getNameSize();
- boost::uint16_t enclength = length;
+ std::uint16_t enclength = length;
swapBytes(&enclength, 2);
*buf = enclength;
@@ -882,8 +882,8 @@ std::shared_ptr<cygnal::Element>
AMF::extractAMF(std::shared_ptr<Buffer> buf)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t* start = buf->reference();
- boost::uint8_t* tooFar = start+buf->size();
+ std::uint8_t* start = buf->reference();
+ std::uint8_t* tooFar = start+buf->size();
return extractAMF(start, tooFar);
}
@@ -900,12 +900,12 @@ AMF::extractAMF(std::shared_ptr<Buffer> buf)
///
/// @remarks May throw a ParserException
std::shared_ptr<cygnal::Element>
-AMF::extractAMF(boost::uint8_t *in, boost::uint8_t* tooFar)
+AMF::extractAMF(std::uint8_t *in, std::uint8_t* tooFar)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *tmpptr = in;
- boost::uint16_t length;
+ std::uint8_t *tmpptr = in;
+ std::uint16_t length;
std::shared_ptr<cygnal::Element> el(new Element);
if (in == 0) {
@@ -913,7 +913,7 @@ AMF::extractAMF(boost::uint8_t *in, boost::uint8_t* tooFar)
return el;
}
- std::map<boost::uint16_t, cygnal::Element> references;
+ std::map<std::uint16_t, cygnal::Element> references;
// All elements look like this:
// the first two bytes is the length of name of the element
@@ -971,8 +971,8 @@ AMF::extractAMF(boost::uint8_t *in, boost::uint8_t* tooFar)
break;
case Element::STRING_AMF0:
// get the length of the name
- length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
- tmpptr += sizeof(boost::uint16_t);
+ length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
+ tmpptr += sizeof(std::uint16_t);
if (length >= SANE_STR_SIZE) {
gnash::log_error(_("%d bytes for a string is over the safe "
"limit of %d, line %d"), length,
@@ -1027,8 +1027,8 @@ AMF::extractAMF(boost::uint8_t *in, boost::uint8_t*
tooFar)
break;
case Element::REFERENCE_AMF0:
{
- length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
- tmpptr += sizeof(boost::uint16_t);
+ length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
+ tmpptr += sizeof(std::uint16_t);
el->makeReference(length);
// FIXME: connect reference Element to the object
// pointed to by the index.
@@ -1041,7 +1041,7 @@ AMF::extractAMF(boost::uint8_t *in, boost::uint8_t*
tooFar)
case Element::ECMA_ARRAY_AMF0:
{
el->makeECMAArray();
- tmpptr += sizeof(boost::uint32_t);
+ tmpptr += sizeof(std::uint32_t);
#if 1
while (tmpptr < tooFar) { // FIXME: was tooFar - AMF_HEADER_SIZE)
if (*tmpptr+3 == TERMINATOR) {
@@ -1065,10 +1065,10 @@ AMF::extractAMF(boost::uint8_t *in, boost::uint8_t*
tooFar)
break;
#else
// get the number of elements in the array
- boost::uint32_t items =
- ntohl((*(boost::uint32_t *)tmpptr) & 0xffffffff);
+ std::uint32_t items =
+ ntohl((*(std::uint32_t *)tmpptr) & 0xffffffff);
- tmpptr += sizeof(boost::uint32_t);
+ tmpptr += sizeof(std::uint32_t);
while (items--) {
std::shared_ptr<cygnal::Element> child =
amf_obj.extractProperty(tmpptr, tooFar);
@@ -1090,9 +1090,9 @@ AMF::extractAMF(boost::uint8_t *in, boost::uint8_t*
tooFar)
{
el->makeStrictArray();
// get the number of numbers in the array
- boost::uint32_t items = ntohl((*(boost::uint32_t *)tmpptr));
+ std::uint32_t items = ntohl((*(std::uint32_t *)tmpptr));
// Skip past the length field to get to the start of the data
- tmpptr += sizeof(boost::uint32_t);
+ tmpptr += sizeof(std::uint32_t);
while (items) {
std::shared_ptr<cygnal::Element> child =
amf_obj.extractAMF(tmpptr, tooFar);
@@ -1132,8 +1132,8 @@ AMF::extractAMF(boost::uint8_t *in, boost::uint8_t*
tooFar)
{
el->makeTypedObject();
- length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
- tmpptr += sizeof(boost::uint16_t);
+ length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
+ tmpptr += sizeof(std::uint16_t);
if (length > 0) {
std::string name(reinterpret_cast<const char*>(tmpptr),
length);
//log_debug("Typed object name is: %s", el->getName());
@@ -1191,8 +1191,8 @@ AMF::extractProperty(std::shared_ptr<Buffer> buf)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t* start = buf->reference();
- boost::uint8_t* tooFar = start+buf->size();
+ std::uint8_t* start = buf->reference();
+ std::uint8_t* tooFar = start+buf->size();
return extractProperty(start, tooFar);
}
@@ -1210,17 +1210,17 @@ AMF::extractProperty(std::shared_ptr<Buffer> buf)
///
/// @remarks May throw a ParserException
std::shared_ptr<cygnal::Element>
-AMF::extractProperty(boost::uint8_t *in, boost::uint8_t* tooFar)
+AMF::extractProperty(std::uint8_t *in, std::uint8_t* tooFar)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *tmpptr = in;
- boost::uint16_t length;
+ std::uint8_t *tmpptr = in;
+ std::uint16_t length;
std::shared_ptr<cygnal::Element> el;
- length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
+ length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
// go past the length bytes, which leaves us pointing at the raw data
- tmpptr += sizeof(boost::uint16_t);
+ tmpptr += sizeof(std::uint16_t);
// sanity check the length of the data. The length is usually only zero if
// we've gone all the way to the end of the object.
diff --git a/cygnal/libamf/amf.h b/cygnal/libamf/amf.h
index 5d3e29e..389fcc7 100644
--- a/cygnal/libamf/amf.h
+++ b/cygnal/libamf/amf.h
@@ -29,7 +29,7 @@
#include <string>
#include <cstring>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "element.h"
#include "dsodefs.h"
@@ -47,7 +47,7 @@ const size_t AMF0_NUMBER_SIZE = 0x08;
/// \brief The header size in bytes of an common AMF object.
/// The size of an AMF header is a type field (1 byte), followed by a
/// length field. (short)
-const boost::uint8_t AMF_HEADER_SIZE = 3;
+const std::uint8_t AMF_HEADER_SIZE = 3;
/// \brief The header size of a property.
/// A property is a little different. It always assumes the the
@@ -55,20 +55,20 @@ const boost::uint8_t AMF_HEADER_SIZE = 3;
/// type byte like a regular AMF object and length is used for the
/// data. So a property object header is then only 5 bytes instead
/// of the 6 that one assumes would be used.
-const boost::uint8_t AMF_PROP_HEADER_SIZE = 5;
+const std::uint8_t AMF_PROP_HEADER_SIZE = 5;
/// AMF version 0 is supported by default
-const boost::uint8_t AMF_VERSION = 0;
+const std::uint8_t AMF_VERSION = 0;
/// For terminating sequences, a byte with value 0x09 is used.
-const boost::uint8_t TERMINATOR = 0x09;
+const std::uint8_t TERMINATOR = 0x09;
/// \brief The maximum size for a string.
/// As if there is a parsing error, we'll often see the symptom of the length
/// for the following value is bogus. Although the length field is a short, it
/// seems silly to assume we'll ever see a string 65,000 characters long.
Still,
/// it makes sense to make this an adjustable thing.
-const boost::uint16_t SANE_STR_SIZE = 65535;
+const std::uint16_t SANE_STR_SIZE = 65535;
/// Binary representation of an ActionScript object.
//
@@ -144,7 +144,7 @@ public:
///
/// @return a binary AMF packet in big endian format
///
- static std::shared_ptr<Buffer> encodeString(boost::uint8_t *data,
+ static std::shared_ptr<Buffer> encodeString(std::uint8_t *data,
size_t size);
/// Encode a String object to its serialized representation.
@@ -191,7 +191,7 @@ public:
///
/// @return a binary AMF packet in big endian format
///
- static std::shared_ptr<Buffer> encodeXMLObject(const boost::uint8_t *data,
+ static std::shared_ptr<Buffer> encodeXMLObject(const std::uint8_t *data,
size_t nbytes);
/// Encode a Typed Object to its serialized representation.
@@ -212,7 +212,7 @@ public:
///
/// @return a binary AMF packet in big endian format (header,data)
///
- static std::shared_ptr<Buffer> encodeReference(boost::uint16_t index);
+ static std::shared_ptr<Buffer> encodeReference(std::uint16_t index);
/// Encode a Movie Clip (swf data) to its serialized representation.
//
@@ -222,7 +222,7 @@ public:
///
/// @return a binary AMF packet in big endian format (header,data)
///
- static std::shared_ptr<Buffer> encodeMovieClip(const boost::uint8_t *data,
+ static std::shared_ptr<Buffer> encodeMovieClip(const std::uint8_t *data,
size_t size);
/// Encode an ECMA Array to its serialized representation.
@@ -246,7 +246,7 @@ public:
///
/// @return a binary AMF packet in big endian format
///
- static std::shared_ptr<Buffer> encodeLongString(const boost::uint8_t *data,
+ static std::shared_ptr<Buffer> encodeLongString(const std::uint8_t *data,
size_t size);
/// Encode a Record Set to its serialized representation.
@@ -257,7 +257,7 @@ public:
///
/// @return a binary AMF packet in big endian format
///
- static std::shared_ptr<Buffer> encodeRecordSet(const boost::uint8_t *data,
+ static std::shared_ptr<Buffer> encodeRecordSet(const std::uint8_t *data,
size_t size);
/// Encode a Date to its serialized representation.
@@ -266,7 +266,7 @@ public:
///
/// @return a binary AMF packet in big endian format
///
- static std::shared_ptr<Buffer> encodeDate(const boost::uint8_t *data);
+ static std::shared_ptr<Buffer> encodeDate(const std::uint8_t *data);
/// Encode a Strict Array to its serialized representation.
//
@@ -341,7 +341,7 @@ public:
///
/// @return The data type from the header
///
- static Element::amf0_type_e extractElementHeader(boost::uint8_t *in)
+ static Element::amf0_type_e extractElementHeader(std::uint8_t *in)
{ return *(reinterpret_cast<Element::amf0_type_e
*>(in)); };
/// Extract an AMF object from an array of raw bytes.
@@ -357,7 +357,7 @@ public:
///
/// @remarks May throw a ParserException
///
- std::shared_ptr<cygnal::Element> extractAMF(boost::uint8_t *in,
boost::uint8_t* tooFar);
+ std::shared_ptr<cygnal::Element> extractAMF(std::uint8_t *in,
std::uint8_t* tooFar);
/// Extract an AMF object from an array of raw bytes.
//
@@ -384,7 +384,7 @@ public:
///
/// @remarks May throw a ParserException
///
- std::shared_ptr<cygnal::Element> extractProperty(boost::uint8_t *in,
boost::uint8_t* tooFar);
+ std::shared_ptr<cygnal::Element> extractProperty(std::uint8_t *in,
std::uint8_t* tooFar);
/// Extract a Property.
//
diff --git a/cygnal/libamf/amf_msg.cpp b/cygnal/libamf/amf_msg.cpp
index cff9ccf..ca6da89 100644
--- a/cygnal/libamf/amf_msg.cpp
+++ b/cygnal/libamf/amf_msg.cpp
@@ -28,7 +28,7 @@
#include "GnashSystemNetHeaders.h"
#include <string>
-#include <boost/cstdint.hpp> // For C99 int types
+#include <cstdint> // For C99 int types
using gnash::GnashException;
using gnash::log_error;
@@ -40,8 +40,8 @@ namespace cygnal
{
std::shared_ptr<cygnal::Buffer>
-AMF_msg::encodeContextHeader(boost::uint16_t version, boost::uint16_t headers,
- boost::uint16_t messages)
+AMF_msg::encodeContextHeader(std::uint16_t version, std::uint16_t headers,
+ std::uint16_t messages)
{
// GNASH_REPORT_FUNCTION;
size_t size = sizeof(AMF_msg::context_header_t);
@@ -50,7 +50,7 @@ AMF_msg::encodeContextHeader(boost::uint16_t version,
boost::uint16_t headers,
// use a short as a temporary, as it turns out htons() returns a 32bit int
// instead when compiling with -O2. This forces appending bytes to get the
// right size.
- boost::uint16_t swapped = htons(version);
+ std::uint16_t swapped = htons(version);
*buf = swapped;
swapped = htons(headers);
*buf += swapped;
@@ -76,12 +76,12 @@ AMF_msg::encodeMsgHeader(AMF_msg::message_header_t *head)
{
// GNASH_REPORT_FUNCTION;
// The size of the buffer are the two strings, their lenght fields, and
the integer.
-// size_t size = head->target.size() + head->response.size() +
sizeof(boost::uint32_t)
-// + (sizeof(boost::uint16_t) * 2);
+// size_t size = head->target.size() + head->response.size() +
sizeof(std::uint32_t)
+// + (sizeof(std::uint16_t) * 2);
std::shared_ptr<cygnal::Buffer> buf (new
cygnal::Buffer(sizeof(AMF_msg::message_header_t)));
// Encode the target URI, which usually looks something like ."getway"
- boost::uint16_t length = head->target.size();
+ std::uint16_t length = head->target.size();
*buf = length;
*buf += head->target;
@@ -91,7 +91,7 @@ AMF_msg::encodeMsgHeader(AMF_msg::message_header_t *head)
*buf += head->target;
// Encode the size of the encoded message
- *buf += static_cast<boost::uint32_t>(head->size);
+ *buf += static_cast<std::uint32_t>(head->size);
return buf;
}
@@ -105,16 +105,16 @@ AMF_msg::parseContextHeader(cygnal::Buffer &data)
}
std::shared_ptr<AMF_msg::context_header_t>
-AMF_msg::parseContextHeader(boost::uint8_t *data, size_t /* size */)
+AMF_msg::parseContextHeader(std::uint8_t *data, size_t /* size */)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<AMF_msg::context_header_t> msg (new
AMF_msg::context_header_t);
- boost::uint16_t tmpnum = *reinterpret_cast<boost::uint16_t *>(data);
+ std::uint16_t tmpnum = *reinterpret_cast<std::uint16_t *>(data);
msg->version = tmpnum;
- tmpnum = *reinterpret_cast<boost::uint16_t *>(data +
sizeof(boost::uint16_t));
+ tmpnum = *reinterpret_cast<std::uint16_t *>(data + sizeof(std::uint16_t));
msg->headers = ntohs(tmpnum);
- tmpnum = *reinterpret_cast<boost::uint16_t *>(data +
sizeof(boost::uint32_t));
+ tmpnum = *reinterpret_cast<std::uint16_t *>(data + sizeof(std::uint32_t));
msg->messages = ntohs(tmpnum);
return msg;
@@ -128,21 +128,21 @@ AMF_msg::parseMessageHeader(cygnal::Buffer &data)
}
std::shared_ptr<AMF_msg::message_header_t>
-AMF_msg::parseMessageHeader(boost::uint8_t *data, size_t size)
+AMF_msg::parseMessageHeader(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
AMF amf;
- boost::uint8_t *tmpptr = data;
+ std::uint8_t *tmpptr = data;
std::shared_ptr<AMF_msg::message_header_t> msg (new
AMF_msg::message_header_t);
// The target is a standard length->bytes field
- boost::uint16_t length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
+ std::uint16_t length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
if (length == 0) {
boost::format msg("Length of string shouldn't be zero!
amf_msg.cpp::%1%(): %2%");
msg % __FUNCTION__ % __LINE__;
throw GnashException(msg.str());
}
- tmpptr += sizeof(boost::uint16_t);
+ tmpptr += sizeof(std::uint16_t);
std::string str1(reinterpret_cast<const char *>(tmpptr), length);
msg->target = str1;
if ((tmpptr - data) > static_cast<int>(size)) {
@@ -154,13 +154,13 @@ AMF_msg::parseMessageHeader(boost::uint8_t *data, size_t
size)
}
// The response is a standard length->bytes field
- length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
+ length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
if (length == 0) {
boost::format msg("Length of string shouldn't be zero!
amf_msg.cpp::%1%(): %2%");
msg % __FUNCTION__ % __LINE__;
throw GnashException(msg.str());
}
- tmpptr += sizeof(boost::uint16_t);
+ tmpptr += sizeof(std::uint16_t);
std::string str2(reinterpret_cast<const char *>(tmpptr), length);
msg->response = str2;
tmpptr += length;
@@ -171,7 +171,7 @@ AMF_msg::parseMessageHeader(boost::uint8_t *data, size_t
size)
}
// The length is a 4 word integer
- msg->size = ntohl((*(boost::uint32_t *)tmpptr));
+ msg->size = ntohl((*(std::uint32_t *)tmpptr));
if (msg->target.empty()) {
log_error(_("AMF Message \'target\' field missing!"));
@@ -197,11 +197,11 @@ AMF_msg::parseAMFPacket(cygnal::Buffer &data)
}
std::shared_ptr<AMF_msg::context_header_t>
-AMF_msg::parseAMFPacket(boost::uint8_t *data, size_t size)
+AMF_msg::parseAMFPacket(std::uint8_t *data, size_t size)
{
GNASH_REPORT_FUNCTION;
// _messages.push_back();
- boost::uint8_t *ptr = data + sizeof(AMF_msg::context_header_t);
+ std::uint8_t *ptr = data + sizeof(AMF_msg::context_header_t);
std::shared_ptr<context_header_t> header =
AMF_msg::parseContextHeader(data, size);
// log_debug("%s: %s", __PRETTY_FUNCTION__, hexify(data, size, true));
@@ -214,8 +214,8 @@ AMF_msg::parseAMFPacket(boost::uint8_t *data, size_t size)
std::shared_ptr<AMF_msg::message_header_t> msghead =
AMF_msg::parseMessageHeader(ptr, size);
if (msghead) {
ptr += msghead->target.size() + msghead->response.size()
- + (sizeof(boost::uint16_t) * 2)
- + (sizeof(boost::uint32_t));
+ + (sizeof(std::uint16_t) * 2)
+ + (sizeof(std::uint32_t));
std::shared_ptr<cygnal::Element> el = amf.extractAMF(ptr,
ptr+size);
msgpkt->header.target = msghead->target;
msgpkt->header.response = msghead->response;
@@ -277,22 +277,22 @@ AMF_msg::encodeMsgHeader(const std::string &target,
const std::string &response, size_t size)
{
// GNASH_REPORT_FUNCTION;
- size_t total = target.size() + sizeof(boost::uint16_t);
- total += response.size() + sizeof(boost::uint16_t);
- total += sizeof(boost::uint32_t);
+ size_t total = target.size() + sizeof(std::uint16_t);
+ total += response.size() + sizeof(std::uint16_t);
+ total += sizeof(std::uint32_t);
std::shared_ptr<cygnal::Buffer> buf (new cygnal::Buffer(total));
- boost::uint16_t length = target.size();
- swapBytes(&length, sizeof(boost::uint16_t));
+ std::uint16_t length = target.size();
+ swapBytes(&length, sizeof(std::uint16_t));
*buf += length;
*buf += target;
length = response.size();
- swapBytes(&length, sizeof(boost::uint16_t));
+ swapBytes(&length, sizeof(std::uint16_t));
*buf += length;
*buf += response;
- boost::uint32_t swapped = htonl(size);
+ std::uint32_t swapped = htonl(size);
*buf += swapped;
return buf;
diff --git a/cygnal/libamf/amf_msg.h b/cygnal/libamf/amf_msg.h
index c158cb1..338cada 100644
--- a/cygnal/libamf/amf_msg.h
+++ b/cygnal/libamf/amf_msg.h
@@ -30,7 +30,7 @@
#include <string>
#include <vector>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "element.h"
#include "dsodefs.h"
@@ -57,9 +57,9 @@ class DSOEXPORT AMF_msg {
AMF3 = 0x11
} amf_version_e;
typedef struct {
- boost::uint16_t version;
- boost::uint16_t headers;
- boost::uint16_t messages;
+ std::uint16_t version;
+ std::uint16_t headers;
+ std::uint16_t messages;
} context_header_t;
typedef struct {
std::string target;
@@ -80,9 +80,9 @@ class DSOEXPORT AMF_msg {
// These methods create the raw data of the AMF packet from Elements
static std::shared_ptr<cygnal::Buffer>
encodeContextHeader(context_header_t *head);
- static std::shared_ptr<cygnal::Buffer> encodeContextHeader(boost::uint16_t
version,
- boost::uint16_t
headers,
- boost::uint16_t
messages);
+ static std::shared_ptr<cygnal::Buffer> encodeContextHeader(std::uint16_t
version,
+ std::uint16_t
headers,
+ std::uint16_t
messages);
static std::shared_ptr<cygnal::Buffer> encodeMsgHeader(message_header_t
*head);
static std::shared_ptr<cygnal::Buffer> encodeMsgHeader(const std::string
&target,
@@ -90,14 +90,14 @@ class DSOEXPORT AMF_msg {
// These methods parse the raw data of the AMF packet into data structures
static std::shared_ptr<context_header_t> parseContextHeader(cygnal::Buffer
&data);
- static std::shared_ptr<context_header_t> parseContextHeader(boost::uint8_t
*data, size_t size);
+ static std::shared_ptr<context_header_t> parseContextHeader(std::uint8_t
*data, size_t size);
static std::shared_ptr<message_header_t> parseMessageHeader(cygnal::Buffer
&data);
- static std::shared_ptr<message_header_t> parseMessageHeader(boost::uint8_t
*data, size_t size);
+ static std::shared_ptr<message_header_t> parseMessageHeader(std::uint8_t
*data, size_t size);
// These methods parse the entire packet. which consists of multiple
messages
std::shared_ptr<context_header_t> parseAMFPacket(cygnal::Buffer &buf);
- std::shared_ptr<context_header_t> parseAMFPacket(boost::uint8_t *data,
+ std::shared_ptr<context_header_t> parseAMFPacket(std::uint8_t *data,
size_t size);
// This methods create an entire packet from multiple messages, already
parsed in
diff --git a/cygnal/libamf/buffer.cpp b/cygnal/libamf/buffer.cpp
index ab1429f..fc4cafd 100644
--- a/cygnal/libamf/buffer.cpp
+++ b/cygnal/libamf/buffer.cpp
@@ -20,7 +20,7 @@
#include "gnashconfig.h"
#endif
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <iostream>
#include <boost/random/uniform_int.hpp>
#include <boost/random/mersenne_twister.hpp>
@@ -43,8 +43,8 @@ namespace cygnal
/// @param digit The digit as a hex value
///
/// @return The byte as a decimal value.
-boost::uint8_t
-Buffer::hex2digit (boost::uint8_t digit)
+std::uint8_t
+Buffer::hex2digit (std::uint8_t digit)
{
if (digit == 0)
return 0;
@@ -73,10 +73,10 @@ Buffer::hex2mem(const std::string &str)
// GNASH_REPORT_FUNCTION;
size_t count = str.size();
size_t size = (count/3) + 4;
- boost::uint8_t ch = 0;
+ std::uint8_t ch = 0;
- boost::uint8_t *ptr = const_cast<boost::uint8_t *>(reinterpret_cast<const
boost::uint8_t *>(str.c_str()));
- boost::uint8_t *end = ptr + count;
+ std::uint8_t *ptr = const_cast<std::uint8_t *>(reinterpret_cast<const
std::uint8_t *>(str.c_str()));
+ std::uint8_t *end = ptr + count;
init(size);
@@ -126,7 +126,7 @@ Buffer::init(size_t size)
{
// GNASH_REPORT_FUNCTION;
if (!_data) {
- _data.reset(new boost::uint8_t[size]);
+ _data.reset(new std::uint8_t[size]);
_seekptr = _data.get();
}
_seekptr = _data.get();
@@ -195,7 +195,7 @@ Buffer::~Buffer()
///
/// @return A reference to a Buffer.
Buffer &
-Buffer::copy(boost::uint8_t *data, size_t nbytes)
+Buffer::copy(std::uint8_t *data, size_t nbytes)
{
// GNASH_REPORT_FUNCTION;
if (_data) {
@@ -221,7 +221,7 @@ Buffer::copy(boost::uint8_t *data, size_t nbytes)
///
/// @return A reference to a Buffer.
Buffer &
-Buffer::append(boost::uint8_t *data, size_t nbytes)
+Buffer::append(std::uint8_t *data, size_t nbytes)
{
// GNASH_REPORT_FUNCTION;
if (_data) {
@@ -262,7 +262,7 @@ Buffer &
Buffer::operator+=(cygnal::Element::amf0_type_e type)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t nb = static_cast<boost::uint8_t>(type);
+ std::uint8_t nb = static_cast<std::uint8_t>(type);
return operator+=(nb);
}
@@ -276,7 +276,7 @@ Buffer &
Buffer::operator+=(char byte)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t nb = static_cast<boost::uint8_t>(byte);
+ std::uint8_t nb = static_cast<std::uint8_t>(byte);
return operator+=(nb);
}
@@ -289,7 +289,7 @@ Buffer &
Buffer::operator+=(bool flag)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t nb = static_cast<boost::uint8_t>(flag);
+ std::uint8_t nb = static_cast<std::uint8_t>(flag);
return operator+=(nb);
}
@@ -299,12 +299,12 @@ Buffer::operator+=(bool flag)
///
/// @return A reference to a Buffer.
Buffer &
-Buffer::operator+=(boost::uint8_t byte)
+Buffer::operator+=(std::uint8_t byte)
{
// GNASH_REPORT_FUNCTION;
if ((_seekptr + 1) <= (_data.get() + _nbytes)) {
*_seekptr = byte;
- _seekptr += sizeof(boost::uint8_t);
+ _seekptr += sizeof(std::uint8_t);
}
return *this;
}
@@ -319,7 +319,7 @@ Buffer &
Buffer::operator+=(const char *str)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = const_cast<boost::uint8_t *>(reinterpret_cast<const
boost::uint8_t *>(str));
+ std::uint8_t *ptr = const_cast<std::uint8_t *>(reinterpret_cast<const
std::uint8_t *>(str));
return append(ptr, strlen(str));
}
@@ -334,7 +334,7 @@ Buffer &
Buffer::operator+=(const std::string &str)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = const_cast<boost::uint8_t *>(reinterpret_cast<const
boost::uint8_t *>(str.c_str()));
+ std::uint8_t *ptr = const_cast<std::uint8_t *>(reinterpret_cast<const
std::uint8_t *>(str.c_str()));
return append(ptr, str.size());
}
@@ -348,7 +348,7 @@ Buffer &
Buffer::operator+=(double num)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = reinterpret_cast<boost::uint8_t *>(&num);
+ std::uint8_t *ptr = reinterpret_cast<std::uint8_t *>(&num);
return append(ptr, AMF0_NUMBER_SIZE);
}
@@ -358,11 +358,11 @@ Buffer::operator+=(double num)
///
/// @return A reference to a Buffer.
Buffer &
-Buffer::operator+=(boost::uint16_t length)
+Buffer::operator+=(std::uint16_t length)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = reinterpret_cast<boost::uint8_t *>(&length);
- return append(ptr, sizeof(boost::uint16_t));
+ std::uint8_t *ptr = reinterpret_cast<std::uint8_t *>(&length);
+ return append(ptr, sizeof(std::uint16_t));
}
/// \brief Append an integer to existing data in the buffer.
@@ -371,11 +371,11 @@ Buffer::operator+=(boost::uint16_t length)
///
/// @return A reference to a Buffer.
Buffer &
-Buffer::operator+=(boost::uint32_t length)
+Buffer::operator+=(std::uint32_t length)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = reinterpret_cast<boost::uint8_t *>(&length);
- return append(ptr, sizeof(boost::uint32_t));
+ std::uint8_t *ptr = reinterpret_cast<std::uint8_t *>(&length);
+ return append(ptr, sizeof(std::uint32_t));
}
/// \brief Append a Buffer class to existing data in the buffer.
@@ -419,7 +419,7 @@ Buffer &
Buffer::operator=(const std::string &str)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = const_cast<boost::uint8_t *>(reinterpret_cast<const
boost::uint8_t *>(str.c_str()));
+ std::uint8_t *ptr = const_cast<std::uint8_t *>(reinterpret_cast<const
std::uint8_t *>(str.c_str()));
return copy(ptr, str.size());
}
@@ -427,7 +427,7 @@ Buffer &
Buffer::operator=(const char *str)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = const_cast<boost::uint8_t *>(reinterpret_cast<const
boost::uint8_t *>(str));
+ std::uint8_t *ptr = const_cast<std::uint8_t *>(reinterpret_cast<const
std::uint8_t *>(str));
return copy(ptr, strlen(str));
}
@@ -441,7 +441,7 @@ Buffer &
Buffer::operator=(double num)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = reinterpret_cast<boost::uint8_t *>(&num);
+ std::uint8_t *ptr = reinterpret_cast<std::uint8_t *>(&num);
return copy(ptr, AMF0_NUMBER_SIZE);
}
@@ -452,11 +452,11 @@ Buffer::operator=(double num)
///
/// @return A reference to a Buffer.
Buffer &
-Buffer::operator=(boost::uint16_t length)
+Buffer::operator=(std::uint16_t length)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = reinterpret_cast<boost::uint8_t *>(&length);
- return copy(ptr, sizeof(boost::uint16_t));
+ std::uint8_t *ptr = reinterpret_cast<std::uint8_t *>(&length);
+ return copy(ptr, sizeof(std::uint16_t));
}
/// \brief Copy a AMF0 type into the buffer.
@@ -468,7 +468,7 @@ Buffer::operator=(boost::uint16_t length)
Buffer &
Buffer::operator=(cygnal::Element::amf0_type_e type)
{
- boost::uint8_t nb = static_cast<boost::uint8_t>(type);
+ std::uint8_t nb = static_cast<std::uint8_t>(type);
return operator=(nb);
}
@@ -481,7 +481,7 @@ Buffer::operator=(cygnal::Element::amf0_type_e type)
Buffer &
Buffer::operator=(bool flag)
{
- boost::uint8_t nb = static_cast<boost::uint8_t>(flag);
+ std::uint8_t nb = static_cast<std::uint8_t>(flag);
return operator=(nb);
}
@@ -492,7 +492,7 @@ Buffer::operator=(bool flag)
///
/// @return A reference to a Buffer.
Buffer &
-Buffer::operator=(boost::uint8_t byte)
+Buffer::operator=(std::uint8_t byte)
{
// GNASH__FUNCTION;
@@ -506,7 +506,7 @@ Buffer::operator=(boost::uint8_t byte)
///
/// @return A reference to a Buffer.
Buffer &
-Buffer::operator=(boost::uint8_t *data)
+Buffer::operator=(std::uint8_t *data)
{
// GNASH_REPORT_FUNCTION;
if (data) {
@@ -559,11 +559,11 @@ Buffer::operator==(Buffer &buf)
/// @param byte The byte to remove from the buffer.
///
/// @return A real pointer to the base address of the buffer.
-boost::uint8_t *
-Buffer::remove(boost::uint8_t c)
+std::uint8_t *
+Buffer::remove(std::uint8_t c)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *start = std::find(begin(), end(), c);
+ std::uint8_t *start = std::find(begin(), end(), c);
// log_debug("Byte is at %x", (void *)start);
@@ -587,7 +587,7 @@ Buffer::remove(boost::uint8_t c)
/// Buffer
///
/// @return A real pointer to the base address of the Buffer.
-boost::uint8_t *
+std::uint8_t *
Buffer::remove(int start)
{
// GNASH_REPORT_FUNCTION;
@@ -611,7 +611,7 @@ Buffer::remove(int start)
/// @param range The amount of bytes to remove from the Buffer.
///
/// @return A real pointer to the base address of the Buffer.
-boost::uint8_t *
+std::uint8_t *
Buffer::remove(int start, int range)
{
// GNASH_REPORT_FUNCTION;
@@ -665,7 +665,7 @@ Buffer &
Buffer::resize(size_t size)
{
// GNASH_REPORT_FUNCTION;
- std::unique_ptr<boost::uint8_t[]> tmp;
+ std::unique_ptr<std::uint8_t[]> tmp;
// If there is no size, don't do anything
if (size == 0) {
@@ -675,7 +675,7 @@ Buffer::resize(size_t size)
// If we don't have any data yet in this buffer, resizing is cheap, as
// we don't havce to copy any data.
if (_seekptr == _data.get()) {
- _data.reset(new boost::uint8_t[size]);
+ _data.reset(new std::uint8_t[size]);
_nbytes= size;
return *this;
}
@@ -711,7 +711,7 @@ Buffer::resize(size_t size)
gnash::log_error(_("cygnal::Buffer::resize(%d): Truncating data (%d
bytes) while resizing!"), size, used - size);
used = size;
}
- boost::uint8_t *newptr = new boost::uint8_t[size];
+ std::uint8_t *newptr = new std::uint8_t[size];
std::copy(_data.get(), _data.get() + used, newptr);
_data.reset(newptr);
diff --git a/cygnal/libamf/buffer.h b/cygnal/libamf/buffer.h
index cd9078b..709e1ff 100644
--- a/cygnal/libamf/buffer.h
+++ b/cygnal/libamf/buffer.h
@@ -24,7 +24,7 @@
#endif
#include <vector>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <iostream> // for output operator
#include <string>
@@ -145,7 +145,7 @@ public:
/// @param nbytes The number of bytes to copy.
///
/// @return A reference to a Buffer.
- Buffer ©(boost::uint8_t *data, size_t nbytes);
+ Buffer ©(std::uint8_t *data, size_t nbytes);
/// \brief Copy a Buffer class into the buffer.
/// This overwrites all data, and resets the seek ptr.
@@ -177,21 +177,21 @@ public:
/// @param num A numeric short value.
///
/// @return A reference to a Buffer.
- Buffer &operator=(boost::uint16_t length);
+ Buffer &operator=(std::uint16_t length);
/// \brief Copy a byte into the buffer.
/// This overwrites all data, and resets the seek ptr.
///
/// @param byte A single byte.
///
/// @return A reference to a Buffer.
- Buffer &operator=(boost::uint8_t byte);
+ Buffer &operator=(std::uint8_t byte);
/// \brief Copy a byte into the buffer.
/// This overwrites all data, and resets the seek ptr.
///
/// @param byte A pointer to a single byte.
///
/// @return A reference to a Buffer.
- Buffer &operator=(boost::uint8_t *byte);
+ Buffer &operator=(std::uint8_t *byte);
/// \brief Copy a AMF0 type into the buffer.
/// This overwrites all data, and resets the seek ptr.
///
@@ -215,7 +215,7 @@ public:
/// @param nbytes The number of bytes to append.
///
/// @return A reference to a Buffer.
- Buffer &append(boost::uint8_t *data, size_t nbytes);
+ Buffer &append(std::uint8_t *data, size_t nbytes);
/// \brief Append a Buffer class to existing data in the buffer.
///
@@ -245,19 +245,19 @@ public:
/// @param num A numeric integer value.
///
/// @return A reference to a Buffer.
- Buffer &operator+=(boost::uint32_t length);
+ Buffer &operator+=(std::uint32_t length);
/// \brief Append a short to existing data in the buffer.
///
/// @param num A numeric short value.
///
/// @return A reference to a Buffer.
- Buffer &operator+=(boost::uint16_t length);
+ Buffer &operator+=(std::uint16_t length);
/// \brief Append a byte to existing data in the buffer.
///
/// @param byte A single byte.
///
/// @return A reference to a Buffer.
- Buffer &operator+=(boost::uint8_t byte);
+ Buffer &operator+=(std::uint8_t byte);
Buffer &operator+=(char byte);
/// \brief Append an AMF0 type to existing data in the buffer.
///
@@ -280,7 +280,7 @@ public:
/// @param byte The byte to remove from the buffer.
///
/// @return A real pointer to the base address of the buffer.
- boost::uint8_t *remove(boost::uint8_t c);
+ std::uint8_t *remove(std::uint8_t c);
/// \brief Drop a byte without resizing.
/// This will remove the byte from the Buffer, and then
/// move the remaining data to be in the correct
@@ -290,7 +290,7 @@ public:
/// Buffer
///
/// @return A real pointer to the base address of the Buffer.
- boost::uint8_t *remove(int index);
+ std::uint8_t *remove(int index);
/// \brief Drop bytes without resizing.
/// This will remove the bytes from the Buffer, and then
/// move the remaining data to be in the correct
@@ -305,22 +305,22 @@ public:
/// @param range The amoiunt of bytes to remove from the Buffer.
///
/// @return A real pointer to the base address of the Buffer.
- boost::uint8_t *remove(int start, int range);
+ std::uint8_t *remove(int start, int range);
// Network::byte_t *remove(char c);
/// \brief Return the base address of the Buffer.
///
/// @return A real pointer to the base address of the Buffer.
- boost::uint8_t *begin() { return _data.get() ; };
- boost::uint8_t *reference() { return _data.get(); }
- const boost::uint8_t *reference() const { return _data.get(); }
+ std::uint8_t *begin() { return _data.get() ; };
+ std::uint8_t *reference() { return _data.get(); }
+ const std::uint8_t *reference() const { return _data.get(); }
/// \brief Return the last address of the Buffer
/// Which is the base address plus the total size of the
/// Buffer.
///
/// @return A real pointer to the last address of the Buffer with data.
- boost::uint8_t *end() { return _seekptr; };
+ std::uint8_t *end() { return _seekptr; };
/// \brief Get the size of the Buffer.
///
@@ -339,7 +339,7 @@ public:
void setSize(size_t nbytes) { _nbytes = nbytes; };
/// \brief Set the real pointer to a block of Memory.
- void setPointer(boost::uint8_t *ptr) { _data.reset(ptr); };
+ void setPointer(std::uint8_t *ptr) { _data.reset(ptr); };
/// \brief Test equivalance against another Buffer.
/// This compares all the data on the current Buffer with
@@ -357,7 +357,7 @@ public:
/// get.
///
/// @return The byte at the specified location.
- boost::uint8_t operator[](int index) { return _data[index]; };
+ std::uint8_t operator[](int index) { return _data[index]; };
/// \brief Get the byte at a specified location.
///
@@ -365,7 +365,7 @@ public:
/// get.
///
/// @return A real pointer to the byte at the specified location.
- boost::uint8_t *at(int index) { return _data.get() + index; };
+ std::uint8_t *at(int index) { return _data.get() + index; };
/// \brief How much room is left in the buffer past the seek pointer.
/// This is primarily used to see if the buffer is fully
@@ -386,7 +386,7 @@ public:
/// @param ptr the real pointer to set the seek pointer to
///
/// @return nothing
- void setSeekPointer(boost::uint8_t *ptr) { _seekptr = ptr; };
+ void setSeekPointer(std::uint8_t *ptr) { _seekptr = ptr; };
void setSeekPointer(off_t offset) { _seekptr = _data.get() + offset; };
/// \brief Dump the internal data of this class in a human readable form.
@@ -399,12 +399,12 @@ public:
/// \var _seekptr
/// \brief This is a pointer to the address in the Buffer to
/// write data to then next time some is appended.
- boost::uint8_t *_seekptr;
+ std::uint8_t *_seekptr;
/// \var _data
/// \brief This is the container of the actual data in this
/// Buffer.
- std::unique_ptr<boost::uint8_t[]> _data;
+ std::unique_ptr<std::uint8_t[]> _data;
/// \var _nbytes
/// \brief This is the total allocated size of the Buffer.
@@ -432,7 +432,7 @@ public:
/// @param digit The digit as a hex value
///
/// @return The byte as a decimal value.
- boost::uint8_t hex2digit (boost::uint8_t digit);
+ std::uint8_t hex2digit (std::uint8_t digit);
};
/// \brief Dump to the specified output stream.
diff --git a/cygnal/libamf/element.cpp b/cygnal/libamf/element.cpp
index 7211c59..1f666fe 100644
--- a/cygnal/libamf/element.cpp
+++ b/cygnal/libamf/element.cpp
@@ -22,7 +22,7 @@
#include <vector>
#include <cmath>
#include <climits>
-#include <boost/cstdint.hpp> // for boost::?int??_t
+#include <cstdint> // for boost::?int??_t
#include "buffer.h"
#include "log.h"
@@ -249,12 +249,12 @@ Element::to_number() const
/// \brief Cast the data in this Element to a short value.
///
/// @return short value.
-boost::uint16_t
+std::uint16_t
Element::to_short() const
{
// GNASH_REPORT_FUNCTION;
if (_buffer) {
- return *(reinterpret_cast<boost::uint16_t *>(_buffer->reference()));
+ return *(reinterpret_cast<std::uint16_t *>(_buffer->reference()));
}
// return ::nan("NaN");
return -1;
@@ -263,12 +263,12 @@ Element::to_short() const
/// \brief Cast the data in this Element to a short value.
///
/// @return short value.
-boost::uint32_t
+std::uint32_t
Element::to_integer() const
{
// GNASH_REPORT_FUNCTION;
if (_buffer) {
- return *(reinterpret_cast<boost::uint32_t *>(_buffer->reference()));
+ return *(reinterpret_cast<std::uint32_t *>(_buffer->reference()));
}
// return ::nan("NaN");
return -1;
@@ -306,7 +306,7 @@ Element::to_bool() const
/// \brief Cast the data in this Element to an real pointer to data.
///
/// @return A real pointer to the base address of the raw data in memory.
-boost::uint8_t *
+std::uint8_t *
Element::to_reference()
{
// GNASH_REPORT_FUNCTION;
@@ -316,7 +316,7 @@ Element::to_reference()
return 0;
}
-const boost::uint8_t *
+const std::uint8_t *
Element::to_reference() const
{
// GNASH_REPORT_FUNCTION;
@@ -412,7 +412,7 @@ Element::calculateSize(cygnal::Element &el) const
// If thr name is set, it's a property, so the length is
// prefixed to the name string.
if (el.getNameSize()) {
- outsize += el.getNameSize() + sizeof(boost::uint16_t);
+ outsize += el.getNameSize() + sizeof(std::uint16_t);
}
// If there is any data, then the size of the data plus the header
// of the type and the length is next.
@@ -423,7 +423,7 @@ Element::calculateSize(cygnal::Element &el) const
// If an array has no data, it's undefined, so has a length of zero.
if (el.getType() == Element::STRICT_ARRAY_AMF0) {
if (el.getDataSize() == 0) {
- outsize = sizeof(boost::uint32_t) + 1;
+ outsize = sizeof(std::uint32_t) + 1;
}
}
@@ -482,12 +482,12 @@ Element::encode(bool notobject)
}
if (_name > static_cast<char *>(0)) {
size_t length = getNameSize();
- boost::uint16_t enclength = length;
+ std::uint16_t enclength = length;
swapBytes(&enclength, 2);
*buf += enclength;
string str = _name;
*buf += str;
- boost::uint8_t byte = static_cast<boost::uint8_t>(0x5);
+ std::uint8_t byte = static_cast<std::uint8_t>(0x5);
*buf += byte;
}
@@ -505,7 +505,7 @@ Element::encode(bool notobject)
}
// log_debug("FIXME: Terminating object");
if (!notobject) {
- boost::uint8_t pad = 0;
+ std::uint8_t pad = 0;
*buf += pad;
*buf += pad;
*buf += TERMINATOR;
@@ -606,7 +606,7 @@ Element::operator=(bool flag)
///
/// @return A reference to this Element.
Element &
-Element::makeString(boost::uint8_t *data, size_t size)
+Element::makeString(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
_type = Element::STRING_AMF0;
@@ -649,7 +649,7 @@ Element::makeNullString()
// GNASH_REPORT_FUNCTION;
_type = Element::STRING_AMF0;
try {
- check_buffer(sizeof(boost::uint8_t));
+ check_buffer(sizeof(std::uint8_t));
} catch (std::exception& e) {
log_error("%s", e.what());
return *this;
@@ -671,7 +671,7 @@ Element::makeString(const char *str, size_t size)
{
// GNASH_REPORT_FUNCTION;
_type = Element::STRING_AMF0;
- boost::uint8_t *ptr = reinterpret_cast<boost::uint8_t *>(const_cast<char
*>(str));
+ std::uint8_t *ptr = reinterpret_cast<std::uint8_t *>(const_cast<char
*>(str));
return makeString(ptr, size);
}
@@ -723,7 +723,7 @@ Element::makeNumber(std::shared_ptr<cygnal::Buffer> buf)
///
/// @return A reference to this Element.
Element &
-Element::makeNumber(boost::uint8_t *data)
+Element::makeNumber(std::uint8_t *data)
{
// GNASH_REPORT_FUNCTION;
double num = *reinterpret_cast<const double*>(data);
@@ -777,10 +777,10 @@ Element::makeNumber(const string &name, double num)
return makeNumber(num);
}
-/// \overload Element::makeNumber(const std::string &name, boost::uint8_t
*data);
+/// \overload Element::makeNumber(const std::string &name, std::uint8_t *data);
/// The size isn't needed as a double is always the same size.
Element &
-Element::makeNumber(const std::string &name, boost::uint8_t *data)
+Element::makeNumber(const std::string &name, std::uint8_t *data)
{
// GNASH_REPORT_FUNCTION;
if (name.size()) {
@@ -844,7 +844,7 @@ Element::makeBoolean(const string &name, bool flag)
///
/// @return A reference to this Element.
Element &
-Element::makeBoolean(boost::uint8_t *data)
+Element::makeBoolean(std::uint8_t *data)
{
// GNASH_REPORT_FUNCTION;
bool flag = *reinterpret_cast<const bool*>(data);
@@ -987,7 +987,7 @@ Element::makeXMLObject()
return *this;
}
Element &
-Element::makeXMLObject(boost::uint8_t * /*data*/)
+Element::makeXMLObject(std::uint8_t * /*data*/)
{
// GNASH_REPORT_FUNCTION;
_type = Element::XML_OBJECT_AMF0;
@@ -1070,7 +1070,7 @@ Element::makeTypedObject()
///
/// @return A reference to this Element.
Element &
-Element::makeTypedObject(boost::uint8_t */*data*/)
+Element::makeTypedObject(std::uint8_t */*data*/)
{
// GNASH_REPORT_FUNCTION;
_type = Element::TYPED_OBJECT_AMF0;
@@ -1091,12 +1091,12 @@ Element::makeReference()
}
Element &
-Element::makeReference(boost::uint16_t index)
+Element::makeReference(std::uint16_t index)
{
// GNASH_REPORT_FUNCTION;
_type = Element::REFERENCE_AMF0;
- boost::uint8_t *ptr = reinterpret_cast<boost::uint8_t *>(&index);
- return makeReference(ptr, sizeof(boost::uint16_t));
+ std::uint8_t *ptr = reinterpret_cast<std::uint8_t *>(&index);
+ return makeReference(ptr, sizeof(std::uint16_t));
return *this;
}
@@ -1109,7 +1109,7 @@ Element::makeReference(boost::uint16_t index)
///
/// @return A reference to this Element.
Element &
-Element::makeReference(boost::uint8_t *indata, size_t size)
+Element::makeReference(std::uint8_t *indata, size_t size)
{
// GNASH_REPORT_FUNCTION;
_type = Element::REFERENCE_AMF0;
@@ -1143,7 +1143,7 @@ Element::makeMovieClip()
///
/// @return A reference to this Element.
Element &
-Element::makeMovieClip(boost::uint8_t *indata, size_t size)
+Element::makeMovieClip(std::uint8_t *indata, size_t size)
{
// GNASH_REPORT_FUNCTION;
_type = Element::MOVIECLIP_AMF0;
@@ -1294,7 +1294,7 @@ Element::makeUnsupported()
///
/// @return A reference to this Element.
Element &
-Element::makeUnsupported(boost::uint8_t *data)
+Element::makeUnsupported(std::uint8_t *data)
{
UNUSED(data);
_type = Element::UNSUPPORTED_AMF0;
@@ -1320,7 +1320,7 @@ Element::makeLongString()
///
/// @return A reference to this Element.
Element &
-Element::makeLongString(boost::uint8_t *indata)
+Element::makeLongString(std::uint8_t *indata)
{
UNUSED(indata);
_type = Element::LONG_STRING_AMF0;
@@ -1340,7 +1340,7 @@ Element::makeRecordSet()
return *this;
}
Element &
-Element::makeRecordSet(boost::uint8_t *data)
+Element::makeRecordSet(std::uint8_t *data)
{
UNUSED(data);
_type = Element::RECORD_SET_AMF0;
@@ -1362,7 +1362,7 @@ Element::makeDate()
}
Element &
-Element::makeDate(boost::uint8_t *date)
+Element::makeDate(std::uint8_t *date)
{
// GNASH_REPORT_FUNCTION;
@@ -1376,7 +1376,7 @@ Element &
Element::makeDate(double date)
{
// GNASH_REPORT_FUNCTION;
- //boost::uint8_t *ptr = reinterpret_cast<boost::uint8_t *>(&date);
+ //std::uint8_t *ptr = reinterpret_cast<std::uint8_t *>(&date);
_type = Element::DATE_AMF0;
try {
check_buffer(AMF0_NUMBER_SIZE);
@@ -1433,7 +1433,7 @@ void
Element::setName(const char *name, size_t size)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = reinterpret_cast<boost::uint8_t *>(const_cast<char
*>(name));
+ std::uint8_t *ptr = reinterpret_cast<std::uint8_t *>(const_cast<char
*>(name));
return setName(ptr, size);
}
@@ -1448,7 +1448,7 @@ Element::setName(const char *name, size_t size)
///
/// @remarks This adds a NULL string terminator so the name can be printed.
void
-Element::setName(boost::uint8_t *name, size_t size)
+Element::setName(std::uint8_t *name, size_t size)
{
// GNASH_REPORT_FUNCTION;
if ((size > 0) && (name != 0)) {
diff --git a/cygnal/libamf/element.h b/cygnal/libamf/element.h
index e992936..8d669ac 100644
--- a/cygnal/libamf/element.h
+++ b/cygnal/libamf/element.h
@@ -23,7 +23,7 @@
#include <string>
#include <cstring>
#include <iostream> // for output operator
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <memory>
//#include "network.h"
@@ -221,8 +221,8 @@ public:
///
/// @return A reference to this Element.
Element &makeString(const char *str, size_t size);
- /// \overload Element::makeString(boost::uint8_t *data, size_t size)
- Element &makeString(boost::uint8_t *data, size_t size);
+ /// \overload Element::makeString(std::uint8_t *data, size_t size)
+ Element &makeString(std::uint8_t *data, size_t size);
/// \brief Make this Element with an ASCII string value.
///
@@ -261,7 +261,7 @@ public:
/// @param str The double to use as the value.
///
/// @return A reference to this Element.
- Element &makeNumber(boost::uint8_t *data);
+ Element &makeNumber(std::uint8_t *data);
/// \brief Make this Element a Property with a double value
///
@@ -269,9 +269,9 @@ public:
///
/// @param num The double to use as the value of the property.
Element &makeNumber(const std::string &name, double num) ;
- /// \overload Element::makeNumber(const std::string &name, boost::uint8_t
*data);
+ /// \overload Element::makeNumber(const std::string &name, std::uint8_t
*data);
/// The size isn't needed as a double is always the same
size.
- Element &makeNumber(const std::string &name, boost::uint8_t *data);
+ Element &makeNumber(const std::string &name, std::uint8_t *data);
/// \brief Make this Element with a boolean value.
/// The size isn't needed as a boolean is always the same
size.
@@ -279,7 +279,7 @@ public:
/// @param data A real pointer to the boolean use as the value.
///
/// @return A reference to this Element.
- Element &makeBoolean(boost::uint8_t *data);
+ Element &makeBoolean(std::uint8_t *data);
/// \brief Make this Element with a boolean value.
///
@@ -383,7 +383,7 @@ public:
///
/// @return A reference to this Element.
Element &makeXMLObject(const std::string &name, const std::string &data);
- Element &makeXMLObject(boost::uint8_t *data);
+ Element &makeXMLObject(std::uint8_t *data);
/// \brief Make this Element a Property with an ECMA Array as the value.
/// This is a mixed array of any AMF types. These are stored
@@ -466,13 +466,13 @@ public:
/// @param size The number of bytes to use as the value.
///
/// @return A reference to this Element.
- Element &makeTypedObject(boost::uint8_t *data);
+ Element &makeTypedObject(std::uint8_t *data);
/// \brief Make this Element a Property with an Object Reference as the
value.
///
/// @return A reference to this Element.
Element &makeReference();
- Element &makeReference(boost::uint16_t index);
+ Element &makeReference(std::uint16_t index);
/// \brief Make this Element a Property with an Object Reference as the
value.
///
@@ -481,7 +481,7 @@ public:
/// @param size The number of bytes to use as the value.
///
/// @return A reference to this Element.
- Element &makeReference(boost::uint8_t *data, size_t size);
+ Element &makeReference(std::uint8_t *data, size_t size);
/// \brief Make this Element a Property with a Movie Clip (SWF data) as
the value.
///
@@ -495,7 +495,7 @@ public:
/// @param size The number of bytes to use as the value.
///
/// @return A reference to this Element.
- Element &makeMovieClip(boost::uint8_t *data, size_t size);
+ Element &makeMovieClip(std::uint8_t *data, size_t size);
/// \brief Make this Element a Property with a UTF8 String as the value.
///
@@ -509,7 +509,7 @@ public:
/// @param size The number of bytes to use as the value.
///
/// @return A reference to this Element.
- Element &makeLongString(boost::uint8_t *data);
+ Element &makeLongString(std::uint8_t *data);
/// \brief Make this Element a Property with a Record Set as the value.
///
@@ -523,7 +523,7 @@ public:
/// @param size The number of bytes to use as the value.
///
/// @return A reference to this Element.
- Element &makeRecordSet(boost::uint8_t *data);
+ Element &makeRecordSet(std::uint8_t *data);
/// \brief Make this Element a Property with a Date as the value.
///
@@ -535,7 +535,7 @@ public:
/// @param data A real pointer to the raw data to use as the value.
///
/// @return A reference to this Element.
- Element &makeDate(boost::uint8_t *data);
+ Element &makeDate(std::uint8_t *data);
Element &makeDate(double data);
/// \brief Make this Element a Property with an Unsupported value.
@@ -550,7 +550,7 @@ public:
/// @param size The number of bytes to use as the value.
///
/// @return A reference to this Element.
- Element &makeUnsupported(boost::uint8_t *data);
+ Element &makeUnsupported(std::uint8_t *data);
/// \brief Test equivalance against another Element.
/// This compares all the data and the data type in the
@@ -625,12 +625,12 @@ public:
/// \brief Cast the data in this Element to a short (2 bytes) value.
///
/// @return short (2 bytes) value.
- boost::uint16_t to_short() const;
+ std::uint16_t to_short() const;
/// \brief Cast the data in this Element to an integer (4 bytes) value.
///
/// @return integer (4 bytes) value.
- boost::uint32_t to_integer() const;
+ std::uint32_t to_integer() const;
/// \brief Cast the data in this Element to an ASCII string value.
///
@@ -640,8 +640,8 @@ public:
/// \brief Cast the data in this Element to an real pointer to data.
///
/// @return A real pointer to the base address of the raw data in memory.
- boost::uint8_t *to_reference();
- const boost::uint8_t *to_reference() const;
+ std::uint8_t *to_reference();
+ const std::uint8_t *to_reference() const;
// Manipulate the name of a property
@@ -677,7 +677,7 @@ public:
/// @return nothing.
///
/// @remarks This add a NULL string terminator so the name can be printed.
- void setName(boost::uint8_t *name, size_t size);
+ void setName(std::uint8_t *name, size_t size);
// Manipulate the children Elements of an object
diff --git a/cygnal/libamf/flv.cpp b/cygnal/libamf/flv.cpp
index d9a52aa..c9e0769 100644
--- a/cygnal/libamf/flv.cpp
+++ b/cygnal/libamf/flv.cpp
@@ -31,7 +31,7 @@
#include <vector>
#include <cmath>
#include <climits>
-#include <boost/cstdint.hpp>
+#include <cstdint>
using gnash::log_debug;
using gnash::log_error;
@@ -61,27 +61,27 @@ Flv::~Flv()
// Encode the data into a Buffer
std::shared_ptr<cygnal::Buffer>
-Flv::encodeHeader(boost::uint8_t type)
+Flv::encodeHeader(std::uint8_t type)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<cygnal::Buffer> buf(new Buffer(sizeof(Flv::flv_header_t)));
buf->clear();
- boost::uint8_t version = 0x1;
+ std::uint8_t version = 0x1;
*buf = "FLV";
*buf += version;
*buf += type;
- boost::uint32_t size = htonl(0x9);
- buf->append((boost::uint8_t *)&size, sizeof(boost::uint32_t));
+ std::uint32_t size = htonl(0x9);
+ buf->append((std::uint8_t *)&size, sizeof(std::uint32_t));
return buf;
}
// Decode a Buffer into a header
std::shared_ptr<Flv::flv_header_t>
-Flv::decodeHeader(boost::uint8_t *data)
+Flv::decodeHeader(std::uint8_t *data)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<flv_header_t> header(new flv_header_t);
@@ -112,9 +112,9 @@ Flv::decodeHeader(boost::uint8_t *data)
// Be lazy, as head_size is an array of 4 bytes, and not an integer in the
data
// structure. This is to get around possible padding done to the data
structure
// done by some compilers.
- boost::uint32_t size = *(reinterpret_cast<boost::uint32_t
*>(header->head_size));
+ std::uint32_t size = *(reinterpret_cast<std::uint32_t
*>(header->head_size));
// The header size is big endian
- swapBytes(header->head_size, sizeof(boost::uint32_t));
+ swapBytes(header->head_size, sizeof(std::uint32_t));
// The header size is always 9, guess it could change some day in the far
future, so
// we should use it.
@@ -134,12 +134,12 @@ Flv::decodeMetaData(std::shared_ptr<cygnal::Buffer> buf)
}
std::shared_ptr<cygnal::Element>
-Flv::decodeMetaData(boost::uint8_t *buf, size_t size)
+Flv::decodeMetaData(std::uint8_t *buf, size_t size)
{
// GNASH_REPORT_FUNCTION;
AMF amf;
- boost::uint8_t *ptr = buf;
- boost::uint8_t *tooFar = ptr + size;
+ std::uint8_t *ptr = buf;
+ std::uint8_t *tooFar = ptr + size;
// Extract the onMetaData object name
// In disk files, I always see the 0x2 type field for
@@ -149,13 +149,13 @@ Flv::decodeMetaData(boost::uint8_t *buf, size_t size)
ptr++;
}
- boost::uint16_t length;
- length = ntohs((*(boost::uint16_t *)ptr) & 0xffff);
+ std::uint16_t length;
+ length = ntohs((*(std::uint16_t *)ptr) & 0xffff);
if (length >= SANE_STR_SIZE) {
log_error(_("%d bytes for a string is over the safe limit of %d"),
length, SANE_STR_SIZE);
}
- ptr += sizeof(boost::uint16_t);
+ ptr += sizeof(std::uint16_t);
std::string name(reinterpret_cast<const char *>(ptr), length);
ptr += length;
@@ -170,7 +170,7 @@ Flv::decodeMetaData(boost::uint8_t *buf, size_t size)
}
std::shared_ptr<Flv::flv_audio_t>
-Flv::decodeAudioData(boost::uint8_t byte)
+Flv::decodeAudioData(std::uint8_t byte)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<flv_audio_t> audio(new flv_audio_t);
@@ -229,7 +229,7 @@ Flv::decodeAudioData(boost::uint8_t byte)
}
std::shared_ptr<Flv::flv_video_t>
-Flv::decodeVideoData(boost::uint8_t byte)
+Flv::decodeVideoData(std::uint8_t byte)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<flv_video_t> video(new flv_video_t);
@@ -270,16 +270,16 @@ Flv::decodeVideoData(boost::uint8_t byte)
}
// Convert a 24 bit integer to a 32 bit one so we can use it.
-boost::uint32_t
-Flv::convert24(boost::uint8_t *num)
+std::uint32_t
+Flv::convert24(std::uint8_t *num)
{
// GNASH_REPORT_FUNCTION;
- boost::uint32_t bodysize = 0;
+ std::uint32_t bodysize = 0;
#ifdef BOOST_BIG_ENDIAN
- bodysize = *(reinterpret_cast<boost::uint32_t *>(num)) >> 8;
+ bodysize = *(reinterpret_cast<std::uint32_t *>(num)) >> 8;
#else
- bodysize = *(reinterpret_cast<boost::uint32_t *>(num)) << 8;
+ bodysize = *(reinterpret_cast<std::uint32_t *>(num)) << 8;
bodysize = ntohl(bodysize);
#endif
@@ -288,7 +288,7 @@ Flv::convert24(boost::uint8_t *num)
// Decode the tag header
std::shared_ptr<Flv::flv_tag_t>
-Flv::decodeTagHeader(boost::uint8_t *buf)
+Flv::decodeTagHeader(std::uint8_t *buf)
{
// GNASH_REPORT_FUNCTION;
flv_tag_t *data = reinterpret_cast<flv_tag_t *>(buf);
diff --git a/cygnal/libamf/flv.h b/cygnal/libamf/flv.h
index 7d8fbc6..de845af 100644
--- a/cygnal/libamf/flv.h
+++ b/cygnal/libamf/flv.h
@@ -22,7 +22,7 @@
#include <vector>
#include <string>
#include <cstring>
-#include <boost/cstdint.hpp> // for boost::?int??_t
+#include <cstdint> // for boost::?int??_t
//#include "buffer.h"
#include "element.h"
@@ -39,7 +39,7 @@ namespace cygnal
const size_t FLV_HEADER_SIZE = 0x9;
/// \brief The maximum value that can be held in a 32 bit word.
-const boost::uint32_t FLV_MAX_LENGTH = 0xffffff;
+const std::uint32_t FLV_MAX_LENGTH = 0xffffff;
/// \class Flv
/// This class abstracts an FLV file into something usable by Gnash.
@@ -47,7 +47,7 @@ class DSOEXPORT Flv {
public:
/// \typedef previous_size_t
/// This is the size in bytes of the previous MetaTag.
- typedef boost::uint32_t previous_size_t;
+ typedef std::uint32_t previous_size_t;
/// \enum Flv::flv_type_e
/// The two flv file types
typedef enum {
@@ -143,19 +143,19 @@ class DSOEXPORT Flv {
/// \struct Flv::flv_header_t.
typedef struct {
- boost::uint8_t sig[3]; // always "FLV"
- boost::uint8_t version; // version, always seems to be 1
- boost::uint8_t type; // Bitmask: 0x4 for audio, 0x1 for video
- boost::uint8_t head_size[4];// size of header, always seems to be 9
+ std::uint8_t sig[3]; // always "FLV"
+ std::uint8_t version; // version, always seems to be 1
+ std::uint8_t type; // Bitmask: 0x4 for audio, 0x1 for video
+ std::uint8_t head_size[4];// size of header, always seems to be 9
} flv_header_t;
/// \struct Flv::flv_tag_t.
typedef struct {
- boost::uint8_t type; // the type. audio, video, or meta
- boost::uint8_t bodysize[3]; // body size (tag size -
sizeof(flv_tag_t))
- boost::uint8_t timestamp[3]; // timestamp in milliseconds
- boost::uint8_t extended; // extended timestamp
- boost::uint8_t streamid[3]; // always 0
+ std::uint8_t type; // the type. audio, video, or meta
+ std::uint8_t bodysize[3]; // body size (tag size - sizeof(flv_tag_t))
+ std::uint8_t timestamp[3]; // timestamp in milliseconds
+ std::uint8_t extended; // extended timestamp
+ std::uint8_t streamid[3]; // always 0
} flv_tag_t;
Flv();
@@ -166,7 +166,7 @@ class DSOEXPORT Flv {
/// @param type The data type for the header
///
/// @return a smart pointer to a Buffer containing the data in big endian
format.
- std::shared_ptr<cygnal::Buffer> encodeHeader(boost::uint8_t type);
+ std::shared_ptr<cygnal::Buffer> encodeHeader(std::uint8_t type);
/// \brief Decode a Buffer into a header
///
@@ -174,7 +174,7 @@ class DSOEXPORT Flv {
///
/// @return a smart pointer to data structure that contains the data.
std::shared_ptr<flv_header_t> decodeHeader(std::shared_ptr<cygnal::Buffer>
buf) { return decodeHeader(buf->reference()); };
- std::shared_ptr<flv_header_t> decodeHeader(boost::uint8_t *data);
+ std::shared_ptr<flv_header_t> decodeHeader(std::uint8_t *data);
/// \brief Decode a MetaData object.
/// This is after the header, but before all the other tags
usually
@@ -192,21 +192,21 @@ class DSOEXPORT Flv {
/// @param size The size of the data in bytes
///
/// @return a smart pointer to an Element that contains the data.
- std::shared_ptr<cygnal::Element> decodeMetaData(boost::uint8_t *data,
size_t size);
+ std::shared_ptr<cygnal::Element> decodeMetaData(std::uint8_t *data, size_t
size);
/// \brief Decode an Audio object.
///
/// @param flags The data to deserialize.
///
/// @return a smart pointer to an audio data structure that contains the
data.
- std::shared_ptr<flv_audio_t> decodeAudioData(boost::uint8_t flags);
+ std::shared_ptr<flv_audio_t> decodeAudioData(std::uint8_t flags);
/// \brief Decode an Video object.
///
/// @param flags The data to deserialize.
///
/// @return a smart pointer to an video data structure that contains the
data.
- std::shared_ptr<flv_video_t> decodeVideoData(boost::uint8_t flags);
+ std::shared_ptr<flv_video_t> decodeVideoData(std::uint8_t flags);
/// \brief Decode an MetaData object.
///
@@ -214,7 +214,7 @@ class DSOEXPORT Flv {
///
/// @return a smart pointer to an video data structure that contains the
data.
std::shared_ptr<flv_tag_t> decodeTagHeader(std::shared_ptr<cygnal::Buffer>
&buf) { return decodeTagHeader(buf->reference()); };
- std::shared_ptr<flv_tag_t> decodeTagHeader(boost::uint8_t *data);
+ std::shared_ptr<flv_tag_t> decodeTagHeader(std::uint8_t *data);
/// \brief Find the named property for this Object.
///
@@ -235,7 +235,7 @@ class DSOEXPORT Flv {
/// \brief Convert a 24 bit integer to a 32 bit one so we can use it.
///
/// @return An unsigned 32 bit integer
- boost::uint32_t convert24(boost::uint8_t *);
+ std::uint32_t convert24(std::uint8_t *);
/// \brief Dump the internal data of this class in a human readable form.
/// @remarks This should only be used for debugging purposes.
@@ -246,7 +246,7 @@ class DSOEXPORT Flv {
/// A stored copy of the Flv file header.
flv_header_t _header;
-// boost::uint32_t _previous_tag_size;
+// std::uint32_t _previous_tag_size;
/// \var Flv::_tag
/// A stored copy of the main onMetaTag data. Althought
/// there may be more than one MetaTag in an FLV, I've
diff --git a/cygnal/libamf/lcshm.cpp b/cygnal/libamf/lcshm.cpp
index 1cf59e3..6c94c61 100644
--- a/cygnal/libamf/lcshm.cpp
+++ b/cygnal/libamf/lcshm.cpp
@@ -21,7 +21,7 @@
#include <vector>
#include <string>
#include <cstring>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "log.h"
#include "buffer.h"
@@ -107,7 +107,7 @@ LcShm::LcShm()
/// \brief Construct an initialized shared memory segment.
///
/// @param addr The address to use for the memory segment.
-LcShm::LcShm(boost::uint8_t *addr)
+LcShm::LcShm(std::uint8_t *addr)
:
SharedMem(64528)
{
@@ -145,7 +145,7 @@ Listener::Listener()
///
/// @param baseaddr The address to use for the block of
/// Listeners.
-Listener::Listener(boost::uint8_t *x)
+Listener::Listener(std::uint8_t *x)
{
// GNASH_REPORT_FUNCTION;
_baseaddr = x;
@@ -168,7 +168,7 @@ Listener::findListener(const string &name)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *addr = _baseaddr + LC_LISTENERS_START;
+ std::uint8_t *addr = _baseaddr + LC_LISTENERS_START;
char *item = reinterpret_cast<char *>(addr);
// Walk through the list to the end
while (*item != 0) {
@@ -194,7 +194,7 @@ Listener::addListener(const string &name)
{
GNASH_REPORT_FUNCTION;
- boost::uint8_t *addr = _baseaddr + LC_LISTENERS_START;
+ std::uint8_t *addr = _baseaddr + LC_LISTENERS_START;
char *item = reinterpret_cast<char *>(addr);
if (findListener(name)) {
@@ -252,7 +252,7 @@ Listener::removeListener(const string &name)
{
GNASH_REPORT_FUNCTION;
- boost::uint8_t *addr = _baseaddr + LC_LISTENERS_START;
+ std::uint8_t *addr = _baseaddr + LC_LISTENERS_START;
int len = 0;
int dest= 0;
@@ -304,7 +304,7 @@ Listener::listListeners()
// GNASH_REPORT_FUNCTION;
std::unique_ptr< vector<string> > listeners ( new vector<string> );
if (_baseaddr != 0) {
- boost::uint8_t *addr = _baseaddr + LC_LISTENERS_START;
+ std::uint8_t *addr = _baseaddr + LC_LISTENERS_START;
const char *item = reinterpret_cast<const char *>(addr);
while (*item != 0) {
@@ -361,11 +361,11 @@ LcShm::close()
/// @return A real pointer to the data after the headers has been parsed.
///
/// @remarks May throw a ParserException
-boost::uint8_t *
-LcShm::parseHeader(boost::uint8_t *data, boost::uint8_t* tooFar)
+std::uint8_t *
+LcShm::parseHeader(std::uint8_t *data, std::uint8_t* tooFar)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = data;
+ std::uint8_t *ptr = data;
if (data == 0) {
log_debug(_("No data pointer to parse!"));
@@ -432,22 +432,22 @@ LcShm::parseHeader(boost::uint8_t *data, boost::uint8_t*
tooFar)
/// @param domain The domain the hostname is in.
///
/// @return A real pointer to a header for a memory segment.
-boost::uint8_t *
+std::uint8_t *
LcShm::formatHeader(const std::string &con, const std::string &host, bool /*
domain */ )
{
// GNASH_REPORT_FUNCTION;
-// boost::uint8_t *ptr = data + LC_HEADER_SIZE;
+// std::uint8_t *ptr = data + LC_HEADER_SIZE;
int size = con.size() + host.size() + 9;
// Buffer *buf;
// Si:
// Assign the value of header and ptr directly.
-// boost::uint8_t *header = new boost::uint8_t[size + 1];
-// boost::uint8_t *ptr = header;
+// std::uint8_t *header = new std::uint8_t[size + 1];
+// std::uint8_t *ptr = header;
- boost::uint8_t *header = Listener::getBaseAddress();
- boost::uint8_t *ptr_FH = Listener::getBaseAddress();
+ std::uint8_t *header = Listener::getBaseAddress();
+ std::uint8_t *ptr_FH = Listener::getBaseAddress();
// log_debug("Base address in 'formatHeader' is: 0x%x, 0x%x",(unsigned
int) header, (unsigned int) ptr_FH);
// This is the initial 16 bytes of the header
@@ -520,9 +520,9 @@ LcShm::connect(const string& names)
return false;
}
- boost::uint8_t* baseAddress = reinterpret_cast<boost::uint8_t
*>(SharedMem::begin());
+ std::uint8_t* baseAddress = reinterpret_cast<std::uint8_t
*>(SharedMem::begin());
- boost::uint8_t* tooFar = SharedMem::end();
+ std::uint8_t* tooFar = SharedMem::end();
Listener::setBaseAddress(baseAddress);
_baseaddr = baseAddress;
parseHeader(baseAddress, tooFar);
@@ -561,8 +561,8 @@ LcShm::connect(key_t key)
return false;
}
- boost::uint8_t* baseAddress = reinterpret_cast<boost::uint8_t
*>(SharedMem::begin());
- boost::uint8_t* tooFar = SharedMem::end();
+ std::uint8_t* baseAddress = reinterpret_cast<std::uint8_t
*>(SharedMem::begin());
+ std::uint8_t* tooFar = SharedMem::end();
Listener::setBaseAddress(baseAddress);
_baseaddr = baseAddress;
parseHeader(baseAddress, tooFar);
@@ -601,8 +601,8 @@ LcShm::send(const string& name , const string& domainname
,
if (!Listener::getBaseAddress()) return;
//The base address
- boost::uint8_t *baseptr = Listener::getBaseAddress();
- boost::uint8_t *ptr = baseptr;
+ std::uint8_t *baseptr = Listener::getBaseAddress();
+ std::uint8_t *ptr = baseptr;
// Compute the time
// Please check before use.
@@ -669,7 +669,7 @@ LcShm::send(const string& name , const string& domainname
,
// Update the connection name
#if 0
-// boost::uint8_t *tmp = AMF::encodeElement(name.c_str());
+// std::uint8_t *tmp = AMF::encodeElement(name.c_str());
// memcpy(ptr, tmp, name.size());
// ptr += name.size() + AMF_HEADER_SIZE;
// delete[] tmp;
@@ -679,7 +679,7 @@ LcShm::send(const string& name , const string& domainname
,
// ptr += domainname.size() + AMF_HEADER_SIZE;
// ptr += LC_HEADER_SIZE;
-// boost::uint8_t *x = ptr; // just for debugging from gdb. temporary
+// std::uint8_t *x = ptr; // just for debugging from gdb. temporary
// This is the initial 16 bytes of the header
memset(ptr, 0, LC_HEADER_SIZE + 200);
@@ -712,8 +712,8 @@ LcShm::send(const string& name , const string& domainname
,
// ptr += AMF_BOOLEAN_SIZE;
- vector<boost::uint8_t> *vec = AMF::encodeElement(data);
- vector<boost::uint8_t>::iterator vit;
+ vector<std::uint8_t> *vec = AMF::encodeElement(data);
+ vector<std::uint8_t>::iterator vit;
// Can't do a memcpy with a std::vector
// log_debug("Number of bytes in the vector: %x", vec->size());
for (vit = vec->begin(); vit != vec->end(); vit++) {
@@ -761,10 +761,10 @@ LcShm::send(const string& name , const string&
domainname ,
/// if findListener()
/// Make sure the object is the listener for certain connection name
/// 2: Parse the header
-/// boost::uint8_t *parseHeader(boost::uint8_t *data, boost::uint8_t*
tooFar);
+/// std::uint8_t *parseHeader(std::uint8_t *data, std::uint8_t*
tooFar);
/// This should be easy if parseHeader function has been finished.
/// 3: Parse the body of the shared memory
-/// std::vector<std::shared_ptr<cygnal::Element> >
parseBody(boost::uint8_t *data);
+/// std::vector<std::shared_ptr<cygnal::Element> >
parseBody(std::uint8_t *data);
/// This should be easy if parseHeader function has been finished.
/// 4: The listened should implement these commands somehow automatically .
/// Handler?
diff --git a/cygnal/libamf/lcshm.h b/cygnal/libamf/lcshm.h
index 0f098e9..d71a880 100644
--- a/cygnal/libamf/lcshm.h
+++ b/cygnal/libamf/lcshm.h
@@ -19,7 +19,7 @@
#ifndef __LCSHM_H__
#define __LCSHM_H__
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <string>
#include <vector>
@@ -49,7 +49,7 @@ public:
///
/// @param baseaddr The address to use for the block of
/// Listeners.
- Listener(boost::uint8_t *baseaddr);
+ Listener(std::uint8_t *baseaddr);
/// \brief Delete the Listener block
~Listener();
@@ -89,13 +89,13 @@ public:
/// @param addr The address for the block of Listeners.
///
/// @return nothing.
- void setBaseAddress(boost::uint8_t *addr) { _baseaddr = addr; };
+ void setBaseAddress(std::uint8_t *addr) { _baseaddr = addr; };
/// \brief Set the base address for the block of Listeners.
///
/// @return A real pointer to the base address of the block of
/// Listeners in the memory segment.
- boost::uint8_t *getBaseAddress() { return _baseaddr; };
+ std::uint8_t *getBaseAddress() { return _baseaddr; };
protected:
/// \var LcShm::_name
@@ -104,7 +104,7 @@ protected:
/// \var LcShm::_baseaddr
/// The base address of the block of Listeners.
- boost::uint8_t *_baseaddr;
+ std::uint8_t *_baseaddr;
// std::vector<std::string> _listeners;
};
@@ -116,11 +116,11 @@ public:
/// \struct LcShm::lc_header_t
/// Hold the data in the memory segment's header.
typedef struct {
- boost::uint32_t unknown1;
- boost::uint32_t unknown2;
- boost::uint32_t timestamp; // number of milliseconds that
have
+ std::uint32_t unknown1;
+ std::uint32_t unknown2;
+ std::uint32_t timestamp; // number of milliseconds that
have
// elapsed since the system was started
- boost::uint32_t length;
+ std::uint32_t length;
} lc_header_t;
/// \struct LcShm::lc_message_t
/// Hold the data for a single message in the memory
segment.
@@ -149,7 +149,7 @@ public:
/// \brief Construct an initialized shared memory segment.
///
/// @param baseaddr The address to use for the memory segment.
- LcShm(boost::uint8_t *baseaddr);
+ LcShm(std::uint8_t *baseaddr);
/// \brief Construct an initialized shared memory segment.
///
@@ -210,7 +210,7 @@ public:
///
/// @return A vector of smart pointers to the AMF0 Elements in
/// this memopry segment.
- std::vector<std::shared_ptr<cygnal::Element> > parseBody(boost::uint8_t
*data);
+ std::vector<std::shared_ptr<cygnal::Element> > parseBody(std::uint8_t
*data);
/// \brief Parse the header of the memory segment.
///
@@ -222,7 +222,7 @@ public:
/// @return A real pointer to the data after the headers has been parsed.
///
/// @remarks May throw a ParserException
- boost::uint8_t *parseHeader(boost::uint8_t *data, boost::uint8_t* tooFar);
+ std::uint8_t *parseHeader(std::uint8_t *data, std::uint8_t* tooFar);
/// \brief Format the header for the memory segment.
///
@@ -233,7 +233,7 @@ public:
/// @param domain The domain the hostname is in.
///
/// @return A real pointer to a header for a memory segment.
- boost::uint8_t *formatHeader(const std::string &con, const std::string
&host, bool domain);
+ std::uint8_t *formatHeader(const std::string &con, const std::string
&host, bool domain);
/// \brief Set the name for this connection to the memory segment.
///
@@ -269,7 +269,7 @@ public:
/// @param addr The address to use for opening the memory segment.
///
/// @return nothing.
- void setBaseAddr(boost::uint8_t *addr) { _baseaddr = addr; };
+ void setBaseAddr(std::uint8_t *addr) { _baseaddr = addr; };
/// \brief Dump the internal data of this class in a human readable form.
/// @remarks This should only be used for debugging purposes.
@@ -283,7 +283,7 @@ public:
private:
/// \var LcShm::_baseaddr.
/// The base address of the memory segment.
- boost::uint8_t *_baseaddr;
+ std::uint8_t *_baseaddr;
/// \var LcShm::_header
/// A stored copy of the header for the memory segment.
diff --git a/cygnal/libamf/sol.cpp b/cygnal/libamf/sol.cpp
index 6929a47..d93d507 100644
--- a/cygnal/libamf/sol.cpp
+++ b/cygnal/libamf/sol.cpp
@@ -25,7 +25,7 @@
#include "log.h"
#include "GnashException.h"
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <cerrno>
#include <string>
#include <vector>
@@ -49,10 +49,10 @@ using gnash::log_error;
// Object Name - variable (the name of the object as an AMF encoded string)
// Padding - 4 bytes
// After this is a series of AMF objects
-const boost::uint16_t SOL_MAGIC = 0x00bf; // is in big-endian format,
this is the first
+const std::uint16_t SOL_MAGIC = 0x00bf; // is in big-endian format,
this is the first
// two bytes. of the .sol file.
//char *SOL_FILETYPE = "TCSO";
-const boost::uint16_t SOL_BLOCK_MARK = 0x0004;
+const std::uint16_t SOL_BLOCK_MARK = 0x0004;
/// \define ENSUREBYTES
///
@@ -149,10 +149,10 @@ SOL::formatHeader(const std::string &name)
template <typename T>
void
-appendSwapped(std::vector<boost::uint8_t>& container, T val)
+appendSwapped(std::vector<std::uint8_t>& container, T val)
{
- boost::uint8_t *ptr =
- static_cast<boost::uint8_t*>(swapBytes(&val, sizeof(val)));
+ std::uint8_t *ptr =
+ static_cast<std::uint8_t*>(swapBytes(&val, sizeof(val)));
container.insert(container.end(), ptr, ptr+sizeof(val));
}
@@ -176,7 +176,7 @@ SOL::formatHeader(const std::string &name, int filesize)
// includes the padding in the header, the mystery bytes, and the
// padding, plus the length of the name itself.
filesize += name.size() + 16;
- boost::uint32_t len = filesize;
+ std::uint32_t len = filesize;
appendSwapped(_header, len);
// Then the mystery block, but as the value never seems to every change,
@@ -188,19 +188,19 @@ SOL::formatHeader(const std::string &name, int filesize)
// then the 0x0004 bytes, also a mystery
appendSwapped(_header, SOL_BLOCK_MARK);
// finally a bunch of zeros to pad things for this field
- _header.insert(_header.end(), '\0', sizeof(boost::uint32_t));
+ _header.insert(_header.end(), '\0', sizeof(std::uint32_t));
// Encode the name. This is not a string object, which has a type field
// one byte field precedding the length as a file type of AMF::STRING.
// First the length in two bytes
- boost::uint16_t size = name.size();
+ std::uint16_t size = name.size();
appendSwapped(_header, size);
// then the string itself
_header.insert(_header.end(), name.begin(), name.end());
// finally a bunch of zeros to pad things at the end of the header
- _header.insert(_header.end(), '\0', sizeof(boost::uint32_t));
+ _header.insert(_header.end(), '\0', sizeof(std::uint32_t));
#if 0
unsigned char *hexint;
@@ -231,7 +231,7 @@ SOL::writeFile(const std::string &filespec, const
std::string &name)
return false;
}
- vector<boost::uint8_t>::iterator it;
+ vector<std::uint8_t>::iterator it;
vector<std::shared_ptr<cygnal::Element> >::iterator ita;
AMF amf_obj;
char *ptr;
@@ -255,7 +255,7 @@ SOL::writeFile(const std::string &filespec, const
std::string &name)
for (ita = _amfobjs.begin(); ita != _amfobjs.end(); ++ita) {
std::shared_ptr<Element> el = (*(ita));
std::shared_ptr<cygnal::Buffer> var = amf_obj.encodeProperty(el);
- // boost::uint8_t *var = amf_obj.encodeProperty(el, outsize);
+ // std::uint8_t *var = amf_obj.encodeProperty(el, outsize);
if (!var) {
continue;
}
@@ -303,7 +303,7 @@ SOL::writeFile(const std::string &filespec, const
std::string &name)
}
_filesize = ptr - body.get();
- int len = name.size() + sizeof(boost::uint16_t) + 16;
+ int len = name.size() + sizeof(std::uint16_t) + 16;
std::unique_ptr<char[]> head ( new char[len + 4] );
memset(head.get(), 0, len);
ptr = head.get();
@@ -340,7 +340,7 @@ SOL::readFile(const std::string &filespec)
{
// GNASH_REPORT_FUNCTION;
struct stat st;
- boost::uint16_t size;
+ std::uint16_t size;
size_t bodysize;
// Make sure it's an SOL file
@@ -348,16 +348,16 @@ SOL::readFile(const std::string &filespec)
try {
- boost::uint8_t *ptr = 0;
+ std::uint8_t *ptr = 0;
std::ifstream ifs(filespec.c_str(), std::ios::binary);
_filesize = st.st_size;
- std::unique_ptr<boost::uint8_t[]> buf(
- new boost::uint8_t[_filesize + sizeof(int)]);
+ std::unique_ptr<std::uint8_t[]> buf(
+ new std::uint8_t[_filesize + sizeof(int)]);
ptr = buf.get();
- boost::uint8_t* tooFar = buf.get() + _filesize;
+ std::uint8_t* tooFar = buf.get() + _filesize;
bodysize = st.st_size - 6;
_filespec = filespec;
@@ -371,7 +371,7 @@ SOL::readFile(const std::string &filespec)
ptr += 2;
// extract the file size
- boost::uint32_t length = *(reinterpret_cast<boost::uint32_t
*>(ptr));
+ std::uint32_t length = *(reinterpret_cast<std::uint32_t *>(ptr));
length = ntohl(length);
ptr += 4;
@@ -399,7 +399,7 @@ SOL::readFile(const std::string &filespec)
// 2 bytes for the length of the object name, but it's also
// null terminated
- size = *(reinterpret_cast<boost::uint16_t *>(ptr));
+ size = *(reinterpret_cast<std::uint16_t *>(ptr));
size = ntohs(size);
ptr += 2;
diff --git a/cygnal/libamf/sol.h b/cygnal/libamf/sol.h
index ca78e86..2d4e46d 100644
--- a/cygnal/libamf/sol.h
+++ b/cygnal/libamf/sol.h
@@ -19,7 +19,7 @@
#ifndef GNASH_SOL_H
#define GNASH_SOL_H
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <cassert>
#include <string>
#include <vector>
@@ -70,7 +70,7 @@ public:
/// .sol file data.
///
/// @return true if this succeeded. false if it doesn't.
- bool extractHeader(const std::vector<boost::uint8_t> &data);
+ bool extractHeader(const std::vector<std::uint8_t> &data);
/// \brief Extract the header from the file.
///
@@ -85,7 +85,7 @@ public:
/// .sol file data.
///
/// @return true if this succeeded. false if it doesn't.
- bool formatHeader(const std::vector<boost::uint8_t> &data);
+ bool formatHeader(const std::vector<std::uint8_t> &data);
/// \brief Create the file header.
///
@@ -127,7 +127,7 @@ public:
/// \brief Get the stored copy of the header
///
/// @return A vector of raw bytes that is a binary form of the header.
- std::vector<boost::uint8_t> getHeader() { return _header; };
+ std::vector<std::uint8_t> getHeader() { return _header; };
/// \brief Add the AMF objects that are the data of the file
//
@@ -192,11 +192,11 @@ public:
private:
/// \var SOL::_header
/// A stored copy of the SOL file header.
- std::vector<boost::uint8_t> _header;
+ std::vector<std::uint8_t> _header;
/// \var SOL::_data
/// The vector that contains the raw dats for this .sol
file.
- std::vector<boost::uint8_t> _data;
+ std::vector<std::uint8_t> _data;
/// \var SOL::_objname
/// The name of the SharedObject in the .sol file.
diff --git a/cygnal/libnet/cque.cpp b/cygnal/libnet/cque.cpp
index f729416..50d6202 100644
--- a/cygnal/libnet/cque.cpp
+++ b/cygnal/libnet/cque.cpp
@@ -108,7 +108,7 @@ CQue::push(std::shared_ptr<cygnal::Buffer> data)
// Push data
bool
-CQue::push(boost::uint8_t *data, int nbytes)
+CQue::push(std::uint8_t *data, int nbytes)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<cygnal::Buffer> buf(new cygnal::Buffer);
diff --git a/cygnal/libnet/cque.h b/cygnal/libnet/cque.h
index 79f00fe..eb337f8 100644
--- a/cygnal/libnet/cque.h
+++ b/cygnal/libnet/cque.h
@@ -20,7 +20,7 @@
#define __CQUE_H__
#include <string>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/thread/mutex.hpp>
#include <boost/thread/condition.hpp>
#include <deque>
@@ -49,7 +49,7 @@ public:
CQue(const std::string &str) { _name = str; };
~CQue();
// Push data onto the que
- bool push(boost::uint8_t *data, int nbytes);
+ bool push(std::uint8_t *data, int nbytes);
bool push(std::shared_ptr<cygnal::Buffer> data);
// Pop the first date element off the que
std::shared_ptr<cygnal::Buffer> DSOEXPORT pop();
diff --git a/cygnal/libnet/cqueue.cpp b/cygnal/libnet/cqueue.cpp
index eec6901..280358a 100644
--- a/cygnal/libnet/cqueue.cpp
+++ b/cygnal/libnet/cqueue.cpp
@@ -47,7 +47,7 @@ CQueue::~CQueue()
#if 0
void
-memcpy(boost::uint8_t *data, size_t size,
+memcpy(std::uint8_t *data, size_t size,
vector<uint8_t> *ptr)
{
// GNASH_REPORT_FUNCTION;
@@ -70,7 +70,7 @@ bool
CQueue::push(uint8_t *data, int nbytes)
{
// GNASH_REPORT_FUNCTION;
- vector<boost::uint8_t> *ptr = new vector<boost::uint8_t>;
+ vector<std::uint8_t> *ptr = new vector<std::uint8_t>;
ptr->reserve(nbytes);
std::copy(data, data + nbytes, ptr->begin());
_queue.push_back(ptr);
diff --git a/cygnal/libnet/cqueue.h b/cygnal/libnet/cqueue.h
index 3d58a81..f8feec5 100644
--- a/cygnal/libnet/cqueue.h
+++ b/cygnal/libnet/cqueue.h
@@ -22,7 +22,7 @@
#define __CQUEUE_H__ 1
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/thread/mutex.hpp>
#include <boost/date_time/gregorian/gregorian.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
@@ -40,21 +40,21 @@ public:
~CQueue();
// Push bytes on the FIFO
- bool push(boost::uint8_t *data, int nbytes);
- bool push(std::vector<boost::uint8_t> *data);
+ bool push(std::uint8_t *data, int nbytes);
+ bool push(std::vector<std::uint8_t> *data);
// Pop the first date element off the FIFO
std::vector<uint8_t> *pop();
// Peek at the first data element without removing it
std::vector<uint8_t> *peek();
-// void memcpy(boost::uint8_t *data, size_t size,
-// std::vector<boost::uint8_t> *ptr);
-// void memcpy(std::vector<boost::uint8_t> *ptr,
-// boost::uint8_t *data, size_t size);
+// void memcpy(std::uint8_t *data, size_t size,
+// std::vector<std::uint8_t> *ptr);
+// void memcpy(std::vector<std::uint8_t> *ptr,
+// std::uint8_t *data, size_t size);
size_t size() { return _queue.size(); };
// Dump internal data.
void dump();
private:
- std::vector<std::vector<boost::uint8_t> *> _queue;
+ std::vector<std::vector<std::uint8_t> *> _queue;
};
diff --git a/cygnal/libnet/diskstream.cpp b/cygnal/libnet/diskstream.cpp
index 888854e..a3bedae 100644
--- a/cygnal/libnet/diskstream.cpp
+++ b/cygnal/libnet/diskstream.cpp
@@ -23,7 +23,7 @@
#endif
#include <sys/types.h>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <sys/stat.h>
#include <fcntl.h>
#include <iostream>
@@ -163,7 +163,7 @@ DiskStream::DiskStream(const string &str)
#endif
}
-DiskStream::DiskStream(const string &str, boost::uint8_t *data, size_t size)
+DiskStream::DiskStream(const string &str, std::uint8_t *data, size_t size)
: _state(DiskStream::NO_STATE),
_filefd(0),
_netfd(0),
@@ -197,7 +197,7 @@ DiskStream::DiskStream(const string &str, boost::uint8_t
*data, size_t size)
#endif
#endif
- _dataptr = new boost::uint8_t[size];
+ _dataptr = new std::uint8_t[size];
// Note that this is a copy operation, which may effect performance. We do
this for now
// incase the top level pointer gets deleted. This should really be using
// boost::scoped_array, but we don't want that complexity till this code
stabalizes.
@@ -245,7 +245,7 @@ DiskStream::DiskStream(const string &str, cygnal::Buffer
&buf)
#endif
#endif
- _dataptr = new boost::uint8_t[buf.size()];
+ _dataptr = new std::uint8_t[buf.size()];
// Note that this is a copy operation, which may effect performance. We do
this for now
// incase the top level pointer gets deleted. This should really be using
// boost::scoped_array, but we don't want that complexity till this code
stabalizes.
@@ -388,7 +388,7 @@ DiskStream::close()
///
/// @return A real pointer to the location of the data at the
/// location pointed to by the offset.
-boost::uint8_t *
+std::uint8_t *
DiskStream::loadToMem(off_t offset)
{
// GNASH_REPORT_FUNCTION;
@@ -396,7 +396,7 @@ DiskStream::loadToMem(off_t offset)
return loadToMem(_filesize, offset);
}
-boost::uint8_t *
+std::uint8_t *
DiskStream::loadToMem(size_t filesize, off_t offset)
{
GNASH_REPORT_FUNCTION;
@@ -443,7 +443,7 @@ DiskStream::loadToMem(size_t filesize, off_t offset)
return _dataptr + offset;
}
- boost::uint8_t *dataptr = 0;
+ std::uint8_t *dataptr = 0;
if (_filefd) {
/// If the data pointer is legit, then we need to unmap that page
@@ -478,14 +478,14 @@ DiskStream::loadToMem(size_t filesize, off_t offset)
HANDLE handle = CreateFileMapping((HANDLE)_get_osfhandle(_filefd), NULL,
PAGE_WRITECOPY, 0, 0, NULL);
if (handle != NULL) {
- dataptr = static_cast<boost::uint8_t *>(MapViewOfFile(handle,
FILE_MAP_COPY, 0, offset, page));
+ dataptr = static_cast<std::uint8_t *>(MapViewOfFile(handle,
FILE_MAP_COPY, 0, offset, page));
CloseHandle(handle);
}
#elif defined(__amigaos4__)
- dataptr = static_cast<boost::uint8_t *>(malloc(loadsize));
+ dataptr = static_cast<std::uint8_t *>(malloc(loadsize));
#else
- dataptr = static_cast<boost::uint8_t *>(mmap(0, loadsize,
+ dataptr = static_cast<std::uint8_t *>(mmap(0, loadsize,
PROT_READ, MAP_SHARED,
_filefd, page));
#endif
@@ -508,7 +508,7 @@ DiskStream::loadToMem(size_t filesize, off_t offset)
_offset = 0;
}
- boost::uint8_t *ptr = dataptr;
+ std::uint8_t *ptr = dataptr;
if (_filetype == FILETYPE_FLV) {
// FIXME: for now, assume all media files are in FLV format
_flv.reset(new cygnal::Flv);
@@ -575,7 +575,7 @@ DiskStream::writeToDisk(const std::string &filespec,
cygnal::Buffer &data)
}
bool
-DiskStream::writeToDisk(const std::string &filespec, boost::uint8_t *data,
size_t size)
+DiskStream::writeToDisk(const std::string &filespec, std::uint8_t *data,
size_t size)
{
// GNASH_REPORT_FUNCTION;
@@ -666,7 +666,7 @@ DiskStream::open(const string &filespec, int netfd,
Statistics &statistics)
_filefd = ::open(_filespec.c_str(), O_RDONLY);
log_debug (_("Opening file %s (fd #%d), %lld bytes in size."),
_filespec, _filefd,
- (boost::int64_t) _filesize);
+ (std::int64_t) _filesize);
_state = OPEN;
_filetype = determineFileType(filespec);
loadToMem(0); // load the first page into memory
@@ -891,7 +891,7 @@ DiskStream::pause()
/// seek to.
///
/// @return A real pointer to the location of the data seeked to.
-boost::uint8_t *
+std::uint8_t *
DiskStream::seek(off_t offset)
{
// GNASH_REPORT_FUNCTION;
@@ -1044,7 +1044,7 @@ DiskStream::determineFileType(const string &filespec)
}
DiskStream::filetype_e
-DiskStream::determineFileType( boost::uint8_t *data)
+DiskStream::determineFileType( std::uint8_t *data)
{
// GNASH_REPORT_FUNCTION;
diff --git a/cygnal/libnet/diskstream.h b/cygnal/libnet/diskstream.h
index 4b7d0c3..5eed482 100644
--- a/cygnal/libnet/diskstream.h
+++ b/cygnal/libnet/diskstream.h
@@ -90,7 +90,7 @@ public:
DSOEXPORT DiskStream();
DSOEXPORT DiskStream(const std::string &filespec);
DSOEXPORT DiskStream(const std::string &filespec, cygnal::Buffer &buf);
- DSOEXPORT DiskStream(const std::string &filespec, boost::uint8_t *data,
size_t size);
+ DSOEXPORT DiskStream(const std::string &filespec, std::uint8_t *data,
size_t size);
DSOEXPORT DiskStream(const std::string &filespec, int netfd);
DSOEXPORT ~DiskStream();
@@ -160,7 +160,7 @@ public:
/// seek to.
///
/// @return A real pointer to the location of the data seeked to.
- boost::uint8_t * seek(off_t offset);
+ std::uint8_t * seek(off_t offset);
/// \brief Upload a file into a sandbox.
/// The sandbox is an area where uploaded files can get
@@ -186,9 +186,9 @@ public:
///
/// @return A real pointer to the location of the data at the
/// location pointed to by the offset.
- DSOEXPORT boost::uint8_t *loadToMem(size_t filesize, off_t offset);
- DSOEXPORT boost::uint8_t *loadToMem(off_t offset);
- DSOEXPORT boost::uint8_t *loadToMem() { return loadToMem(_offset); };
+ DSOEXPORT std::uint8_t *loadToMem(size_t filesize, off_t offset);
+ DSOEXPORT std::uint8_t *loadToMem(off_t offset);
+ DSOEXPORT std::uint8_t *loadToMem() { return loadToMem(_offset); };
/// \brief Write the data in memory to disk
///
@@ -200,7 +200,7 @@ public:
/// @param size The amount of data in bytes to be written
///
/// @return true if the operation suceeded, false if it failed.
- DSOEXPORT bool writeToDisk(const std::string &filespec, boost::uint8_t
*data, size_t size);
+ DSOEXPORT bool writeToDisk(const std::string &filespec, std::uint8_t
*data, size_t size);
DSOEXPORT bool writeToDisk(const std::string &filespec, cygnal::Buffer
&data);
DSOEXPORT bool writeToDisk(const std::string &filespec);
DSOEXPORT bool writeToDisk();
@@ -239,7 +239,7 @@ public:
///
/// @return A real pointer to the base address data in the file, but after
/// the header bytes.
- boost::uint8_t *get() { return _dataptr; };
+ std::uint8_t *get() { return _dataptr; };
bool fullyPopulated();
// bool fullyPopulated() { return ((_seekptr - _filesize) == _dataptr); };
@@ -304,7 +304,7 @@ private:
/// \var DiskStream::_dataptr
/// The base address of the memory page.
- boost::uint8_t *_dataptr;
+ std::uint8_t *_dataptr;
/// \var DiskStream::_max_memload
/// The maximum amount of data to load into memory
@@ -313,7 +313,7 @@ private:
/// \var DiskStream::_seekptr
/// The current location within the current memory page
where
/// the data ends, which is in increments of the empry page
size.
- boost::uint8_t *_seekptr;
+ std::uint8_t *_seekptr;
/// \var DiskStream::_filesize
/// The size of the disk file to stream.
@@ -334,7 +334,7 @@ private:
///
/// @return an AMF filetype
filetype_e determineFileType();
- filetype_e determineFileType( boost::uint8_t *data);
+ filetype_e determineFileType( std::uint8_t *data);
filetype_e determineFileType(const std::string &filespec);
// Get the file stats, so we know how to set the
diff --git a/cygnal/libnet/http.cpp b/cygnal/libnet/http.cpp
index 19b7e5d..fdb7ebf 100644
--- a/cygnal/libnet/http.cpp
+++ b/cygnal/libnet/http.cpp
@@ -136,7 +136,7 @@ HTTP::operator = (HTTP& /*obj*/)
}
-boost::uint8_t *
+std::uint8_t *
HTTP::processHeaderFields(cygnal::Buffer *buf)
{
// GNASH_REPORT_FUNCTION;
@@ -188,8 +188,8 @@ HTTP::processHeaderFields(cygnal::Buffer *buf)
// cerr << "FIXME: " << (void *)i << " : " << dec << end << endl;
} else {
- const boost::uint8_t *cmd = reinterpret_cast<const boost::uint8_t
*>(i->c_str());
- if (extractCommand(const_cast<boost::uint8_t *>(cmd)) ==
HTTP::HTTP_NONE) {
+ const std::uint8_t *cmd = reinterpret_cast<const std::uint8_t
*>(i->c_str());
+ if (extractCommand(const_cast<std::uint8_t *>(cmd)) ==
HTTP::HTTP_NONE) {
break;
#if 1
} else {
@@ -234,18 +234,18 @@ HTTP::processHeaderFields(cygnal::Buffer *buf)
// // Parse an Echo Request message coming from the Red5 echo_test. This
// // method should only be used for testing purposes.
// vector<std::shared_ptr<cygnal::Element > >
-// HTTP::parseEchoRequest(boost::uint8_t *data, size_t size)
+// HTTP::parseEchoRequest(std::uint8_t *data, size_t size)
// {
// // GNASH_REPORT_FUNCTION;
// vector<std::shared_ptr<cygnal::Element > > headers;
// // skip past the header bytes, we don't care about them.
-// boost::uint8_t *tmpptr = data + 6;
+// std::uint8_t *tmpptr = data + 6;
-// boost::uint16_t length;
-// length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
-// tmpptr += sizeof(boost::uint16_t);
+// std::uint16_t length;
+// length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
+// tmpptr += sizeof(std::uint16_t);
// // Get the first name, which is a raw string, and not preceded by
// // a type byte.
@@ -254,7 +254,7 @@ HTTP::processHeaderFields(cygnal::Buffer *buf)
// // If the length of the name field is corrupted, then we get out of
// // range quick, and corrupt memory. This is a bit of a hack, but
// // reduces memory errors caused by some of the corrupted tes cases.
-// boost::uint8_t *endstr = std::find(tmpptr, tmpptr+length, '\0');
+// std::uint8_t *endstr = std::find(tmpptr, tmpptr+length, '\0');
// if (endstr != tmpptr+length) {
// log_debug("Caught corrupted string! length was %d, null at %d",
// length, endstr-tmpptr);
@@ -266,8 +266,8 @@ HTTP::processHeaderFields(cygnal::Buffer *buf)
// // Get the second name, which is a raw string, and not preceded by
// // a type byte.
-// length = ntohs((*(boost::uint16_t *)tmpptr) & 0xffff);
-// tmpptr += sizeof(boost::uint16_t);
+// length = ntohs((*(std::uint16_t *)tmpptr) & 0xffff);
+// tmpptr += sizeof(std::uint16_t);
// std::shared_ptr<cygnal::Element > el2(new cygnal::Element);
// // std::string name2(reinterpret_cast<const char *>(tmpptr), length);
@@ -397,7 +397,7 @@ HTTP::processGetRequest(int fd)
{
GNASH_REPORT_FUNCTION;
-// boost::uint8_t buffer[readsize+1];
+// std::uint8_t buffer[readsize+1];
// const char *ptr = reinterpret_cast<const char *>(buffer);
// memset(buffer, 0, readsize+1);
@@ -521,7 +521,7 @@ HTTP::processPostRequest(int fd)
// cerr << __FUNCTION__ << buf->allocated() << " : " <<
hexify(buf->reference(), buf->allocated(), true) << endl;
clearHeader();
- boost::uint8_t *data = processHeaderFields(*buf);
+ std::uint8_t *data = processHeaderFields(*buf);
size_t length = strtol(getField("content-length").c_str(), NULL, 0);
std::shared_ptr<cygnal::Buffer> content(new cygnal::Buffer(length));
int ret = 0;
@@ -1018,7 +1018,7 @@ HTTP::formatContentLength()
}
cygnal::Buffer &
-HTTP::formatContentLength(boost::uint32_t filesize)
+HTTP::formatContentLength(std::uint32_t filesize)
{
// GNASH_REPORT_FUNCTION;
// _header << "Content-Length: " << filesize << "\r\n";
@@ -1137,11 +1137,11 @@ HTTP::formatEchoResponse(const std::string &num,
cygnal::Buffer &data)
}
cygnal::Buffer &
-HTTP::formatEchoResponse(const std::string &num, boost::uint8_t *data, size_t
size)
+HTTP::formatEchoResponse(const std::string &num, std::uint8_t *data, size_t
size)
{
// GNASH_REPORT_FUNCTION;
- //boost::uint8_t *tmpptr = data;
+ //std::uint8_t *tmpptr = data;
// FIXME: temporary hacks while debugging
cygnal::Buffer fixme("00 00 00 00 00 01");
@@ -1248,7 +1248,7 @@ HTTP::formatRequest(const string &url, http_method_e cmd)
HTTP::http_method_e
-HTTP::extractCommand(boost::uint8_t *data)
+HTTP::extractCommand(std::uint8_t *data)
{
// GNASH_REPORT_FUNCTION;
@@ -1283,9 +1283,9 @@ HTTP::extractCommand(boost::uint8_t *data)
// For valid requests, the second argument, delimited by spaces
// is the filespec of the file being requested or transmitted.
if (cmd != HTTP::HTTP_NONE) {
- boost::uint8_t *start = std::find(data, data+7, ' ') + 1;
- boost::uint8_t *end = std::find(start + 2, data+PATH_MAX, ' ');
- boost::uint8_t *params = std::find(start, end, '?');
+ std::uint8_t *start = std::find(data, data+7, ' ') + 1;
+ std::uint8_t *end = std::find(start + 2, data+PATH_MAX, ' ');
+ std::uint8_t *params = std::find(start, end, '?');
if (params != end) {
_params = std::string(params+1, end);
_filespec = std::string(start, params);
@@ -1346,7 +1346,7 @@ HTTP::sendMsg(int /* fd */)
///
/// @return The number of bytes sent
int DSOEXPORT
-HTTP::sendMsg(const boost::uint8_t *data, size_t size)
+HTTP::sendMsg(const std::uint8_t *data, size_t size)
{
GNASH_REPORT_FUNCTION;
// _header
@@ -1355,7 +1355,7 @@ HTTP::sendMsg(const boost::uint8_t *data, size_t size)
}
size_t
-HTTP::recvChunked(boost::uint8_t *data, size_t size)
+HTTP::recvChunked(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
bool done = false;
@@ -1373,7 +1373,7 @@ HTTP::recvChunked(boost::uint8_t *data, size_t size)
// field can have other attributes, but the OpenStreetMap server doesn't
// use the semi-colon, as it's optional, and rarely used anyway.
std::shared_ptr<cygnal::Buffer> buf;
- boost::uint8_t *start = std::find(data, data+size, '\r') + 2;
+ std::uint8_t *start = std::find(data, data+size, '\r') + 2;
if (start != data+size) {
// extract the total size of the chunk
std::string bytes(data, start-2);
diff --git a/cygnal/libnet/http.h b/cygnal/libnet/http.h
index 136be24..f7a396a 100644
--- a/cygnal/libnet/http.h
+++ b/cygnal/libnet/http.h
@@ -135,7 +135,7 @@ public:
// // Parse an Echo Request message coming from the Red5 echo_test.
std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(cygnal::Buffer &buf) { return
parseEchoRequest(buf.reference(), buf.size()); };
- std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(boost::uint8_t *buf, size_t size);
+ std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(std::uint8_t *buf, size_t size);
// Convert the Content-Length field to a number we can use
size_t getContentLength();
@@ -143,7 +143,7 @@ public:
// process all the header fields in the Buffer, storing them internally
// in _fields. The address returned is the address where the Content data
// starts, and is "Content-Length" bytes long, of "Content-Type" data.
- boost::uint8_t *processHeaderFields(cygnal::Buffer *buf);
+ std::uint8_t *processHeaderFields(cygnal::Buffer *buf);
// Get the field for header 'name' that was stored by processHeaderFields()
std::string &getField(const std::string &name) { return _fields[name]; };
@@ -193,7 +193,7 @@ public:
// format a response to the 'echo' test used for testing Gnash.
cygnal::Buffer &formatEchoResponse(const std::string &num, cygnal::Element
&el);
cygnal::Buffer &formatEchoResponse(const std::string &num, cygnal::Buffer
&data);
- cygnal::Buffer &formatEchoResponse(const std::string &num, boost::uint8_t
*data, size_t size);
+ cygnal::Buffer &formatEchoResponse(const std::string &num, std::uint8_t
*data, size_t size);
cygnal::Buffer &formatMethod(const std::string &data)
{return formatCommon("Method: " + data); };
@@ -207,7 +207,7 @@ public:
cygnal::Buffer &formatKeepAlive(const std::string &data)
{return formatCommon("Keep-Alive: " + data); };
cygnal::Buffer &formatContentLength();
- cygnal::Buffer &formatContentLength(boost::uint32_t filesize);
+ cygnal::Buffer &formatContentLength(std::uint32_t filesize);
cygnal::Buffer &formatContentType();
cygnal::Buffer &formatContentType(DiskStream::filetype_e type);
cygnal::Buffer &formatHost(const std::string &data)
@@ -235,7 +235,7 @@ public:
// cygnal::Buffer &formatErrorResponse(http_status_e err);
// Return the header that's been built up.
- boost::uint8_t *getHeader() { return _buffer.reference(); };
+ std::uint8_t *getHeader() { return _buffer.reference(); };
// Return the header that's been built up.
cygnal::Buffer &getBuffer() { return _buffer; };
@@ -257,7 +257,7 @@ public:
int recvMsg(int fd);
int recvMsg(int fd, size_t size);
- size_t recvChunked(boost::uint8_t *data, size_t size);
+ size_t recvChunked(std::uint8_t *data, size_t size);
/// \brief Send a message to the other end of the network connection.
///
@@ -271,11 +271,11 @@ public:
/// @return The number of bytes sent
int sendMsg();
int sendMsg(int fd);
- int sendMsg(const boost::uint8_t *data, size_t size);
+ int sendMsg(const std::uint8_t *data, size_t size);
int sendMsg(std::shared_ptr<cygnal::Buffer> &buf)
{ return sendMsg(buf->reference(), buf->size()); };
int sendMsg(std::stringstream &sstr)
- { return sendMsg(reinterpret_cast<const boost::uint8_t
*>(sstr.str().c_str()), sstr.str().size()); };
+ { return sendMsg(reinterpret_cast<const std::uint8_t
*>(sstr.str().c_str()), sstr.str().size()); };
// These accessors are used mostly just for debugging.
bool keepAlive() { return _keepalive; }
@@ -308,7 +308,7 @@ public:
protected:
// Examine the beginning of the data for an HTTP request command
// like GET or POST, etc...
- http_method_e extractCommand(boost::uint8_t *data);
+ http_method_e extractCommand(std::uint8_t *data);
http_method_e extractCommand(cygnal::Buffer &data)
{ return extractCommand(data.reference()); };
@@ -322,7 +322,7 @@ protected:
DiskStream::filetype_e _filetype;
std::string _filespec;
std::string _params;
- boost::uint32_t _filesize;
+ std::uint32_t _filesize;
std::map<int, struct status_codes *> _status_codes;
std::map<std::string, std::string> _fields;
diff --git a/cygnal/libnet/network.h b/cygnal/libnet/network.h
index c495e85..6522b09 100644
--- a/cygnal/libnet/network.h
+++ b/cygnal/libnet/network.h
@@ -46,7 +46,7 @@
#endif
#include <memory>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/thread/mutex.hpp>
#include <vector>
#include <cassert>
@@ -144,7 +144,7 @@ public:
std::string hostname;
protocols_supported_e protocol;
} thread_params_t;
- typedef boost::uint8_t byte_t;
+ typedef std::uint8_t byte_t;
typedef bool entry_t (thread_params_t *);
Network();
diff --git a/cygnal/libnet/rtmp.cpp b/cygnal/libnet/rtmp.cpp
index 9efcfb6..d9cba66 100644
--- a/cygnal/libnet/rtmp.cpp
+++ b/cygnal/libnet/rtmp.cpp
@@ -166,7 +166,7 @@ const char *response_str[] = {
};
int
-RTMP::headerSize(boost::uint8_t header)
+RTMP::headerSize(std::uint8_t header)
{
// GNASH_REPORT_FUNCTION;
int headersize = header & RTMP_HEADSIZE_MASK;
@@ -260,12 +260,12 @@ RTMP::decodeHeader(cygnal::Buffer &buf)
}
std::shared_ptr<RTMP::rtmp_head_t>
-RTMP::decodeHeader(boost::uint8_t *in)
+RTMP::decodeHeader(std::uint8_t *in)
{
// GNASH_REPORT_FUNCTION;
std::shared_ptr<RTMP::rtmp_head_t> head(new RTMP::rtmp_head_t);
- boost::uint8_t *tmpptr = in;
+ std::uint8_t *tmpptr = in;
head->channel = *tmpptr & RTMP_INDEX_MASK;
// log_network (_("The AMF channel index is %d"), head->channel);
@@ -331,7 +331,7 @@ RTMP::decodeHeader(boost::uint8_t *in)
}
if (head->head_size >= 8) {
- boost::uint8_t byte = *tmpptr;
+ std::uint8_t byte = *tmpptr;
head->type = (content_types_e)byte;
_type[head->channel] = head->type;
tmpptr++;
@@ -379,7 +379,7 @@ RTMP::encodeHeader(int amf_index, rtmp_headersize_e
head_size)
// GNASH_REPORT_FUNCTION;
std::shared_ptr<cygnal::Buffer> buf(new cygnal::Buffer(1));
buf->clear();
- boost::uint8_t *ptr = buf->reference();
+ std::uint8_t *ptr = buf->reference();
// Make the channel index & header size byte
*ptr = head_size & RTMP_HEADSIZE_MASK;
@@ -411,7 +411,7 @@ RTMP::encodeHeader(int amf_index, rtmp_headersize_e
head_size,
buf.reset(new cygnal::Buffer(12));
break;
}
- boost::uint8_t *ptr = buf->reference();
+ std::uint8_t *ptr = buf->reference();
// Make the channel index & header size byte
// *ptr = head_size & RTMP_HEADSIZE_MASK;
@@ -441,13 +441,13 @@ RTMP::encodeHeader(int amf_index, rtmp_headersize_e
head_size,
if (head_size == HEADER_12 && type != RTMP::USER) {
if (type != RTMP::AUDIO_DATA && type != RTMP::VIDEO_DATA) {
// log_network(_("The routing is: 0x%x"), routing);
- boost::uint32_t swapped = htonl(routing);
+ std::uint32_t swapped = htonl(routing);
memcpy(ptr, &swapped, 4);
} else {
// FIXME: I have no idea why these two empty messages
// don't handle the routing field for 12 byte headers
// the same as all the other types.
- boost::uint8_t swapped = 0x1;
+ std::uint8_t swapped = 0x1;
*ptr = swapped;
}
ptr += 4;
@@ -470,8 +470,8 @@ RTMP::packetRead(cygnal::Buffer &buf)
// int packetsize = 0;
size_t amf_index, headersize;
- boost::uint8_t *ptr = buf.reference();
- boost::uint8_t *tooFar = ptr+buf.size();
+ std::uint8_t *ptr = buf.reference();
+ std::uint8_t *tooFar = ptr+buf.size();
AMF amf;
ptr += 1; // skip past the RTMP header byte
@@ -492,9 +492,9 @@ RTMP::packetRead(cygnal::Buffer &buf)
}
#if 1
- boost::uint8_t *end = buf.remove(0xc3);
+ std::uint8_t *end = buf.remove(0xc3);
#else
- boost::uint8_t *end = buf.find(0xc3);
+ std::uint8_t *end = buf.find(0xc3);
log_network(_("END is %x"), (void *)end);
*end = '*';
#endif
@@ -591,28 +591,28 @@ RTMP::dump()
// system channel 2
// 02 00 00 00 00 00 06 04 00 00 00 00 00 00 00 00 00 00
std::shared_ptr<RTMP::rtmp_ping_t>
-RTMP::decodePing(boost::uint8_t *data)
+RTMP::decodePing(std::uint8_t *data)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = reinterpret_cast<boost::uint8_t *>(data);
+ std::uint8_t *ptr = reinterpret_cast<std::uint8_t *>(data);
std::shared_ptr<rtmp_ping_t> ping(new rtmp_ping_t);
// All the data fields in a ping message are 2 bytes long.
- boost::uint16_t type = ntohs(*reinterpret_cast<boost::uint16_t *>(ptr));
+ std::uint16_t type = ntohs(*reinterpret_cast<std::uint16_t *>(ptr));
ping->type = static_cast<rtmp_ping_e>(type);
- ptr += sizeof(boost::uint16_t);
+ ptr += sizeof(std::uint16_t);
- ping->target = ntohs(*reinterpret_cast<boost::uint16_t *>(ptr));
- ptr += sizeof(boost::uint16_t);
+ ping->target = ntohs(*reinterpret_cast<std::uint16_t *>(ptr));
+ ptr += sizeof(std::uint16_t);
- ping->param1 = ntohs(*reinterpret_cast<boost::uint16_t *>(ptr));
- ptr += sizeof(boost::uint16_t);
+ ping->param1 = ntohs(*reinterpret_cast<std::uint16_t *>(ptr));
+ ptr += sizeof(std::uint16_t);
-// ping->param2 = ntohs(*reinterpret_cast<boost::uint16_t *>(ptr));
-// ptr += sizeof(boost::uint16_t);
+// ping->param2 = ntohs(*reinterpret_cast<std::uint16_t *>(ptr));
+// ptr += sizeof(std::uint16_t);
-// ping->param3 = ntohs(*reinterpret_cast<boost::uint16_t *>(ptr));
+// ping->param3 = ntohs(*reinterpret_cast<std::uint16_t *>(ptr));
ping->param3 = 0;
return ping;
@@ -632,19 +632,19 @@ RTMP::decodeUserControl(cygnal::Buffer &buf)
}
std::shared_ptr<RTMP::user_event_t>
-RTMP::decodeUserControl(boost::uint8_t *data)
+RTMP::decodeUserControl(std::uint8_t *data)
{
// GNASH_REPORT_FUNCTION;
- boost::uint8_t *ptr = reinterpret_cast<boost::uint8_t *>(data);
+ std::uint8_t *ptr = reinterpret_cast<std::uint8_t *>(data);
std::shared_ptr<user_event_t> user(new RTMP::user_event_t);
- boost::uint16_t type = ntohs(*reinterpret_cast<boost::uint16_t *>(ptr));
- boost::uint16_t eventid = static_cast<user_control_e>(type);
- ptr += sizeof(boost::uint16_t);
+ std::uint16_t type = ntohs(*reinterpret_cast<std::uint16_t *>(ptr));
+ std::uint16_t eventid = static_cast<user_control_e>(type);
+ ptr += sizeof(std::uint16_t);
- boost::uint32_t param1 = ntohl(*reinterpret_cast<boost::uint32_t *>(ptr));
- ptr += sizeof(boost::uint32_t);
+ std::uint32_t param1 = ntohl(*reinterpret_cast<std::uint32_t *>(ptr));
+ ptr += sizeof(std::uint32_t);
user->type = static_cast<user_control_e>(type);
user->param1 = param1;
@@ -660,8 +660,8 @@ RTMP::decodeUserControl(boost::uint8_t *data)
case STREAM_NODATA:
case STREAM_BUFFER:
{
- boost::uint32_t param2 = ntohl(*reinterpret_cast<boost::uint32_t
*>(ptr));
- ptr += sizeof(boost::uint32_t);
+ std::uint32_t param2 = ntohl(*reinterpret_cast<std::uint32_t *>(ptr));
+ ptr += sizeof(std::uint32_t);
user->param2 = param2;
break;
}
@@ -682,20 +682,20 @@ RTMP::decodeUserControl(boost::uint8_t *data)
// Stream Start -
// 02 00 00 00 00 00 06 04 00 00 00 00 00 00 00 00 00 01
std::shared_ptr<cygnal::Buffer>
-RTMP::encodeUserControl(user_control_e eventid, boost::uint32_t data)
+RTMP::encodeUserControl(user_control_e eventid, std::uint32_t data)
{
// GNASH_REPORT_FUNCTION;
- boost::uint32_t swapped = 0;
+ std::uint32_t swapped = 0;
std::shared_ptr<cygnal::Buffer> buf;
if (eventid == STREAM_BUFFER) {
- buf.reset(new cygnal::Buffer(sizeof(boost::uint16_t) * 5));
+ buf.reset(new cygnal::Buffer(sizeof(std::uint16_t) * 5));
} else {
- buf.reset(new cygnal::Buffer(sizeof(boost::uint16_t) * 3));
+ buf.reset(new cygnal::Buffer(sizeof(std::uint16_t) * 3));
}
// Set the type of this ping message
- boost::uint16_t typefield = htons(eventid);
+ std::uint16_t typefield = htons(eventid);
*buf = typefield;
// All events have only 4 bytes of data, except Set Buffer, which
@@ -707,17 +707,17 @@ RTMP::encodeUserControl(user_control_e eventid,
boost::uint32_t data)
case STREAM_EOF:
case STREAM_NODATA:
swapped = data;
- cygnal::swapBytes(&swapped, sizeof(boost::uint32_t));
+ cygnal::swapBytes(&swapped, sizeof(std::uint32_t));
*buf += swapped;
break;
case STREAM_BUFFER:
- buf.reset(new cygnal::Buffer(sizeof(boost::uint16_t) * 5));
+ buf.reset(new cygnal::Buffer(sizeof(std::uint16_t) * 5));
break;
case STREAM_LIVE:
case STREAM_PING:
case STREAM_PONG:
swapped = data;
- cygnal::swapBytes(&swapped, sizeof(boost::uint32_t));
+ cygnal::swapBytes(&swapped, sizeof(std::uint32_t));
*buf += swapped;
break;
default:
@@ -728,12 +728,12 @@ RTMP::encodeUserControl(user_control_e eventid,
boost::uint32_t data)
}
std::shared_ptr<RTMPMsg>
-RTMP::decodeMsgBody(boost::uint8_t *data, size_t size)
+RTMP::decodeMsgBody(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
cygnal::AMF amf_obj;
- boost::uint8_t *ptr = data;
- boost::uint8_t* tooFar = data + size;
+ std::uint8_t *ptr = data;
+ std::uint8_t* tooFar = data + size;
bool status = false;
std::shared_ptr<RTMPMsg> msg(new RTMPMsg);
@@ -809,8 +809,8 @@ RTMP::encodeChunkSize(int size)
{
GNASH_REPORT_FUNCTION;
- boost::uint32_t swapped = htonl(size);
- std::shared_ptr<cygnal::Buffer> buf(new
cygnal::Buffer(sizeof(boost::uint32_t)));
+ std::uint32_t swapped = htonl(size);
+ std::shared_ptr<cygnal::Buffer> buf(new
cygnal::Buffer(sizeof(std::uint32_t)));
*buf += swapped;
return buf;
@@ -820,7 +820,7 @@ void
RTMP::decodeChunkSize()
{
GNASH_REPORT_FUNCTION;
- // _chunksize[rthead->channel] = ntohl(*reinterpret_cast<boost::uint32_t
*>(ptr + rthead->head_size));
+ // _chunksize[rthead->channel] = ntohl(*reinterpret_cast<std::uint32_t
*>(ptr + rthead->head_size));
// log_network("Setting packet chunk size to %d.", _chunksize);
log_unimpl(__PRETTY_FUNCTION__);
}
@@ -970,7 +970,7 @@ RTMP::sendMsg(int fd, int channel, rtmp_headersize_e
head_size,
bool
RTMP::sendMsg(int channel, rtmp_headersize_e head_size,
size_t total_size, content_types_e type,
- RTMPMsg::rtmp_source_e routing, boost::uint8_t *data, size_t size)
+ RTMPMsg::rtmp_source_e routing, std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
return sendMsg(getFileFd(), channel, head_size, total_size, type, routing,
data, size);
@@ -979,7 +979,7 @@ RTMP::sendMsg(int channel, rtmp_headersize_e head_size,
bool
RTMP::sendMsg(int fd, int channel, rtmp_headersize_e head_size,
size_t total_size, content_types_e type,
- RTMPMsg::rtmp_source_e routing, boost::uint8_t *data, size_t size)
+ RTMPMsg::rtmp_source_e routing, std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
int ret = 0;
@@ -1012,7 +1012,7 @@ RTMP::sendMsg(int fd, int channel, rtmp_headersize_e
head_size,
std::shared_ptr<cygnal::Buffer> cont_head = encodeHeader(channel,
RTMP::HEADER_1);
#else
std::shared_ptr<cygnal::Buffer> cont_head(new cygnal::Buffer(1));
- boost::uint8_t foo = 0xc3;
+ std::uint8_t foo = 0xc3;
*cont_head = foo;
#endif
@@ -1112,7 +1112,7 @@ RTMP::sendRecvMsg(cygnal::Buffer &bufin)
RTMP::rtmp_head_t *rthead = 0;
RTMPMsg *msg = 0;
std::shared_ptr<cygnal::Buffer> buf;
- boost::uint8_t *ptr = 0;
+ std::uint8_t *ptr = 0;
buf = recvMsg(1); // use a 1 second timeout
@@ -1144,7 +1144,7 @@ RTMP::sendRecvMsg(cygnal::Buffer &bufin)
switch (rthead->type) {
case CHUNK_SIZE:
log_networ(_("Got CHUNK_SIZE packet!!!"));
- _chunksize[rthead->channel] =
ntohl(*reinterpret_cast<boost::uint32_t *>(ptr + rthead->head_size));
+ _chunksize[rthead->channel] =
ntohl(*reinterpret_cast<std::uint32_t *>(ptr + rthead->head_size));
log_network(_("Setting packet chunk size to %d."),
_chunksize);
// decodeChunkSize();
break;
@@ -1320,7 +1320,7 @@ RTMP::split(cygnal::Buffer &buf)
}
std::shared_ptr<RTMP::queues_t>
-RTMP::split(boost::uint8_t *data, size_t size)
+RTMP::split(std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
@@ -1331,7 +1331,7 @@ RTMP::split(boost::uint8_t *data, size_t size)
std::shared_ptr<RTMP::queues_t> channels(new RTMP::queues_t);
// split the buffer at the chunksize boundary
- boost::uint8_t *ptr = 0;
+ std::uint8_t *ptr = 0;
std::shared_ptr<rtmp_head_t> rthead(new rtmp_head_t);
size_t pktsize = 0;
//size_t nbytes = 0;
diff --git a/cygnal/libnet/rtmp.h b/cygnal/libnet/rtmp.h
index 038eafc..f8f816a 100644
--- a/cygnal/libnet/rtmp.h
+++ b/cygnal/libnet/rtmp.h
@@ -20,7 +20,7 @@
#define GNASH_LIBNET_RTMP_H
#include <deque>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <memory>
#include <boost/lexical_cast.hpp>
#include <string>
@@ -69,7 +69,7 @@ namespace gnash
const int RTMP_HANDSHAKE_VERSION_SIZE = 1;
/// \var RTMP_VERSION
/// The RTMP version number for now is always a 3.
-const boost::uint8_t RTMP_VERSION = 0x3;
+const std::uint8_t RTMP_VERSION = 0x3;
/// \var
/// This is the total size of an RTMP packet, not including the
/// version field.
@@ -128,9 +128,9 @@ const char TERMINATOR = 0x09;
// The third and fourth bytes form an integer value that specifies the
// number of headers.
typedef struct {
- boost::uint8_t version;
- boost::uint8_t source;
- boost::uint32_t count;
+ std::uint8_t version;
+ std::uint8_t source;
+ std::uint32_t count;
} amfpacket_t;
typedef enum {
@@ -242,15 +242,15 @@ public:
} rtmp_op_e;
typedef struct {
rtmp_ping_e type; // the type of the ping message
- boost::uint16_t target; // all Ping message data fields
- boost::uint16_t param1; // are 2 bytes long
- boost::uint16_t param2;
- boost::uint16_t param3;
+ std::uint16_t target; // all Ping message data fields
+ std::uint16_t param1; // are 2 bytes long
+ std::uint16_t param2;
+ std::uint16_t param3;
} rtmp_ping_t;
typedef struct {
user_control_e type;
- boost::uint32_t param1;
- boost::uint32_t param2; // only used by
+ std::uint32_t param1;
+ std::uint32_t param2; // only used by
} user_event_t;
typedef enum {
RTMP_STATE_HANDSHAKE_SEND,
@@ -295,8 +295,8 @@ public:
content_types_e type;
} rtmp_head_t;
typedef struct {
- boost::uint32_t uptime;
- boost::uint8_t version[4];
+ std::uint32_t uptime;
+ std::uint8_t version[4];
} rtmp_handshake_head_t;
typedef enum {
HEADER_12 = 0x0,
@@ -314,7 +314,7 @@ public:
// typedef struct {
// amf::amfutf8_t target;
// amf::amfutf8_t response;
-// boost::uint32_t length;
+// std::uint32_t length;
// void *data;
// } rtmp_body_t;
@@ -322,7 +322,7 @@ public:
virtual ~RTMP();
// Decode
- std::shared_ptr<rtmp_head_t> decodeHeader(boost::uint8_t *header);
+ std::shared_ptr<rtmp_head_t> decodeHeader(std::uint8_t *header);
std::shared_ptr<rtmp_head_t> decodeHeader(cygnal::Buffer &data);
std::shared_ptr<cygnal::Buffer> encodeHeader(int amf_index,
@@ -337,7 +337,7 @@ public:
void addProperty(std::string &name, cygnal::Element &el);
cygnal::Element &getProperty(const std::string &name);
// void setHandler(Handler *hand) { _handler = hand; };
- int headerSize(boost::uint8_t header);
+ int headerSize(std::uint8_t header);
rtmp_head_t *getHeader() { return &_header; };
int getHeaderSize() { return _header.head_size; };
@@ -348,15 +348,15 @@ public:
int getMysteryWord() { return _mystery_word; };
// Decode an RTMP message
- std::shared_ptr<RTMPMsg> decodeMsgBody(boost::uint8_t *data, size_t size);
+ std::shared_ptr<RTMPMsg> decodeMsgBody(std::uint8_t *data, size_t size);
std::shared_ptr<RTMPMsg> decodeMsgBody(cygnal::Buffer &buf);
- virtual std::shared_ptr<rtmp_ping_t> decodePing(boost::uint8_t *data);
+ virtual std::shared_ptr<rtmp_ping_t> decodePing(std::uint8_t *data);
std::shared_ptr<rtmp_ping_t> decodePing(cygnal::Buffer &buf);
- virtual std::shared_ptr<user_event_t> decodeUserControl(boost::uint8_t
*data);
+ virtual std::shared_ptr<user_event_t> decodeUserControl(std::uint8_t
*data);
std::shared_ptr<user_event_t> decodeUserControl(cygnal::Buffer &buf);
- virtual std::shared_ptr<cygnal::Buffer> encodeUserControl(user_control_e,
boost::uint32_t data);
+ virtual std::shared_ptr<cygnal::Buffer> encodeUserControl(user_control_e,
std::uint32_t data);
// These are handlers for the various types
@@ -405,10 +405,10 @@ public:
RTMPMsg::rtmp_source_e routing, cygnal::Buffer &data);
bool sendMsg(int channel, rtmp_headersize_e head_size,
size_t total_size, content_types_e type,
- RTMPMsg::rtmp_source_e routing, boost::uint8_t *data, size_t
size);
+ RTMPMsg::rtmp_source_e routing, std::uint8_t *data, size_t
size);
bool sendMsg(int fd, int channel, rtmp_headersize_e head_size,
size_t total_size, content_types_e type,
- RTMPMsg::rtmp_source_e routing, boost::uint8_t *data, size_t
size);
+ RTMPMsg::rtmp_source_e routing, std::uint8_t *data, size_t
size);
#if 0
// Send a Msg, and expect a response back of some kind.
@@ -422,7 +422,7 @@ public:
// bytes another 1 byte RTMP header. The header itself is not part of the
byte
// count.
std::shared_ptr<queues_t> split(cygnal::Buffer &buf);
- std::shared_ptr<queues_t> split(boost::uint8_t *data, size_t size);
+ std::shared_ptr<queues_t> split(std::uint8_t *data, size_t size);
CQue &operator[] (size_t x) { return _queues[x]; }
@@ -430,10 +430,10 @@ public:
/// The time on most systems these days is a 64 bit long, but swf
/// is old, so it only uses a 32 bit integer instead. We know casting
/// looses precision, but that's just the way it is in RTMP.
- boost::uint32_t getTime() {
+ std::uint32_t getTime() {
time_t t;
time(&t);
- return boost::lexical_cast<boost::uint32_t>(t);
+ return boost::lexical_cast<std::uint32_t>(t);
};
void dump();
diff --git a/cygnal/libnet/rtmp_client.cpp b/cygnal/libnet/rtmp_client.cpp
index f4d9d01..df12f65 100644
--- a/cygnal/libnet/rtmp_client.cpp
+++ b/cygnal/libnet/rtmp_client.cpp
@@ -296,7 +296,7 @@ RTMPClient::connectToServer(const std::string &url)
newbuf->append(ncbuf->reference() + nbytes, chunk);
nbytes += chunk;
if (chunk == static_cast<size_t>(RTMP_VIDEO_PACKET_SIZE)) {
- boost::uint8_t headone = 0xc3;
+ std::uint8_t headone = 0xc3;
*newbuf += headone;
}
} while (nbytes < ncbuf->allocated());
@@ -549,7 +549,7 @@ std::shared_ptr<cygnal::Buffer>
RTMPClient::handShakeRequest()
{
GNASH_REPORT_FUNCTION;
- boost::uint32_t zero = 0;
+ std::uint32_t zero = 0;
// Make a buffer to hold the handshake data.
std::shared_ptr<cygnal::Buffer> handshake(new
cygnal::Buffer(RTMP_HANDSHAKE_SIZE+1));
@@ -568,7 +568,7 @@ RTMPClient::handShakeRequest()
// The handshake contains random data after the initial header
for (int i=0; i<RTMP_RANDOM_SIZE; i++) {
- boost::uint8_t pad = i^256;
+ std::uint8_t pad = i^256;
*handshake += pad;
}
@@ -638,7 +638,7 @@ RTMPClient::clientFinish(cygnal::Buffer &data)
handshake1->allocated());
}
- _handshake_header.uptime = ntohl(*reinterpret_cast<boost::uint32_t *>
+ _handshake_header.uptime = ntohl(*reinterpret_cast<std::uint32_t *>
(handshake1->reference() + 1));
log_network(_("RTMP Handshake header: Uptime: %u"),
@@ -659,25 +659,25 @@ RTMPClient::clientFinish(cygnal::Buffer &data)
RTMP_HANDSHAKE_SIZE + data.allocated()));
// Copy the timestamp from the message we just received.
- handshake2->copy(handshake1->reference()+1, sizeof(boost::uint32_t));
+ handshake2->copy(handshake1->reference()+1, sizeof(std::uint32_t));
#if 1
// The next timestamp is the one we just received bumped up a tiny bit.
// I have no clue if this is correct, but fom hex dumps the previous
// timestamp should be the baseline, and this is just that time plus
// whatever it took to get the message. The 7 is a bit randomly chosen.
- boost::uint32_t tt = htonl(_handshake_header.uptime + 7);
+ std::uint32_t tt = htonl(_handshake_header.uptime + 7);
#else
// Get the uptime for the header
// yes, we loose precision here but it's only a 4 byte field
time_t t;
time(&t);
- boost::uint32_t tt = t;
+ std::uint32_t tt = t;
#endif
*handshake2 += tt;
// Add the handshake data
- boost::uint8_t *start = handshake1->reference() + RTMP_HANDSHAKE_SIZE
+ std::uint8_t *start = handshake1->reference() + RTMP_HANDSHAKE_SIZE
+ 1 + 8;
handshake2->append(start, RTMP_RANDOM_SIZE);
// Add the NetConnection::connect() packet
@@ -731,7 +731,7 @@ RTMPClient::recvResponse()
// when doing remoting calls I don't see this problem with an empty packet
from Red5,
// but when I do streaming, it's always there, so we need to remove it.
- boost::uint8_t *pktstart = response->reference();
+ std::uint8_t *pktstart = response->reference();
if (*pktstart == 0xff) {
log_network(_("Got empty packet in buffer."));
pktstart++;
diff --git a/cygnal/libnet/rtmp_client.h b/cygnal/libnet/rtmp_client.h
index 5516d3a..d09377b 100644
--- a/cygnal/libnet/rtmp_client.h
+++ b/cygnal/libnet/rtmp_client.h
@@ -19,7 +19,7 @@
#define _RTMP_CLIENT_H_
#include <deque>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <string>
#include <time.h>
diff --git a/cygnal/libnet/rtmp_msg.h b/cygnal/libnet/rtmp_msg.h
index 5c7edb0..8cac71a 100644
--- a/cygnal/libnet/rtmp_msg.h
+++ b/cygnal/libnet/rtmp_msg.h
@@ -19,7 +19,7 @@
#ifndef _RTMPMSG_H_
#define _RTMPMSG_H_
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <string>
#include <vector>
@@ -106,8 +106,8 @@ public:
void setStatus(rtmp_status_e st) { _status = st; };
rtmp_status_e getStatus() { return _status; };
- void setChannel(boost::uint8_t num) { _channel = num; };
- boost::uint8_t getChannel() { return _channel; } ;
+ void setChannel(std::uint8_t num) { _channel = num; };
+ std::uint8_t getChannel() { return _channel; } ;
std::shared_ptr<cygnal::Element> operator[](size_t x);
std::shared_ptr<cygnal::Element> at(size_t x) { return _amfobjs[x]; };
@@ -131,7 +131,7 @@ public:
std::string _method;
double _transid;
std::vector<std::shared_ptr<cygnal::Element> > _amfobjs;
- boost::uint8_t _channel;
+ std::uint8_t _channel;
};
} // end of gnash namespace
diff --git a/cygnal/libnet/sshclient.cpp b/cygnal/libnet/sshclient.cpp
index be2d91c..e13d90d 100644
--- a/cygnal/libnet/sshclient.cpp
+++ b/cygnal/libnet/sshclient.cpp
@@ -18,7 +18,7 @@
//
#include <boost/thread/mutex.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/array.hpp>
#include <sys/types.h>
#include <sys/stat.h>
@@ -108,7 +108,7 @@ SSHClient::sshRead(cygnal::Buffer &buf)
}
int
-SSHClient::sshRead(boost::uint8_t *buf, size_t size)
+SSHClient::sshRead(std::uint8_t *buf, size_t size)
{
GNASH_REPORT_FUNCTION;
@@ -130,7 +130,7 @@ SSHClient::sshWrite(cygnal::Buffer &buf)
}
int
-SSHClient::sshWrite(const boost::uint8_t *buf, size_t size)
+SSHClient::sshWrite(const std::uint8_t *buf, size_t size)
{
GNASH_REPORT_FUNCTION;
diff --git a/cygnal/libnet/sshclient.h b/cygnal/libnet/sshclient.h
index db572c1..3b37cca 100644
--- a/cygnal/libnet/sshclient.h
+++ b/cygnal/libnet/sshclient.h
@@ -21,7 +21,7 @@
#include <string>
#include <boost/array.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <sstream>
extern "C" {
@@ -54,12 +54,12 @@ public:
// Read bytes from the already opened SSH connection
int sshRead(cygnal::Buffer &buf);
- int sshRead(boost::uint8_t *buf, size_t length);
+ int sshRead(std::uint8_t *buf, size_t length);
int sshRead(std::string &buf);
// Write bytes to the already opened SSH connection
int sshWrite(cygnal::Buffer &buf);
- int sshWrite(const boost::uint8_t *buf, size_t length);
+ int sshWrite(const std::uint8_t *buf, size_t length);
int sshWrite(std::string &buf);
// Shutdown the Context for this connection
diff --git a/cygnal/libnet/sshserver.cpp b/cygnal/libnet/sshserver.cpp
index 964625d..fc1feb5 100644
--- a/cygnal/libnet/sshserver.cpp
+++ b/cygnal/libnet/sshserver.cpp
@@ -18,7 +18,7 @@
//
#include <boost/thread/mutex.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/array.hpp>
#include <sys/types.h>
#include <sys/stat.h>
diff --git a/cygnal/libnet/sshserver.h b/cygnal/libnet/sshserver.h
index 4741e12..1f7ea21 100644
--- a/cygnal/libnet/sshserver.h
+++ b/cygnal/libnet/sshserver.h
@@ -21,7 +21,7 @@
#include <string>
#include <boost/array.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <sstream>
extern "C" {
diff --git a/cygnal/libnet/sslclient.cpp b/cygnal/libnet/sslclient.cpp
index eee05c2..6f8b2e0 100644
--- a/cygnal/libnet/sslclient.cpp
+++ b/cygnal/libnet/sslclient.cpp
@@ -22,7 +22,7 @@
#endif
#include <boost/thread/mutex.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/array.hpp>
#include <sys/types.h>
#include <sys/stat.h>
@@ -124,7 +124,7 @@ SSLClient::sslRead(cygnal::Buffer &buf)
}
int
-SSLClient::sslRead(boost::uint8_t *buf, size_t size)
+SSLClient::sslRead(std::uint8_t *buf, size_t size)
{
GNASH_REPORT_FUNCTION;
@@ -148,7 +148,7 @@ SSLClient::sslWrite(cygnal::Buffer &buf)
}
int
-SSLClient::sslWrite(const boost::uint8_t *buf, size_t length)
+SSLClient::sslWrite(const std::uint8_t *buf, size_t length)
{
GNASH_REPORT_FUNCTION;
diff --git a/cygnal/libnet/sslclient.h b/cygnal/libnet/sslclient.h
index 12b7fa7..288261f 100644
--- a/cygnal/libnet/sslclient.h
+++ b/cygnal/libnet/sslclient.h
@@ -25,7 +25,7 @@
#include <string>
#include <boost/array.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <sstream>
#ifdef HAVE_OPENSSL_SSL_H
@@ -57,12 +57,12 @@ public:
// Read bytes from the already opened SSL connection
int sslRead(cygnal::Buffer &buf);
- int sslRead(boost::uint8_t *buf, size_t length);
+ int sslRead(std::uint8_t *buf, size_t length);
int sslRead(std::string &buf);
// Write bytes to the already opened SSL connection
int sslWrite(cygnal::Buffer &buf);
- int sslWrite(const boost::uint8_t *buf, size_t length);
+ int sslWrite(const std::uint8_t *buf, size_t length);
int sslWrite(std::string &buf);
// Setup the Context for this connection
diff --git a/cygnal/libnet/sslserver.cpp b/cygnal/libnet/sslserver.cpp
index 6fe9c35..0f1facb 100644
--- a/cygnal/libnet/sslserver.cpp
+++ b/cygnal/libnet/sslserver.cpp
@@ -22,7 +22,7 @@
#endif
#include <boost/thread/mutex.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/array.hpp>
#include <sys/types.h>
#include <sys/stat.h>
diff --git a/cygnal/libnet/sslserver.h b/cygnal/libnet/sslserver.h
index 5bb98ac..3a372d9 100644
--- a/cygnal/libnet/sslserver.h
+++ b/cygnal/libnet/sslserver.h
@@ -24,7 +24,7 @@
#endif
#include <boost/array.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <sstream>
#ifdef HAVE_OPENSSL_SSL_H
diff --git a/cygnal/libnet/statistics.h b/cygnal/libnet/statistics.h
index 9030437..42a7658 100644
--- a/cygnal/libnet/statistics.h
+++ b/cygnal/libnet/statistics.h
@@ -79,7 +79,7 @@ private:
browser_e _browser;
ostype_e _os;
std::list<NetStats *> _netstats;
- boost::uint32_t _msg_count;
+ std::uint32_t _msg_count;
std::vector<std::string> _filespec;
};
diff --git a/cygnal/proc.cpp b/cygnal/proc.cpp
index f36fa43..8a4c4dc 100644
--- a/cygnal/proc.cpp
+++ b/cygnal/proc.cpp
@@ -70,7 +70,7 @@ Proc::getDefaultInstance()
bool
-Proc::startCGI(const string &filespec, boost::uint16_t port)
+Proc::startCGI(const string &filespec, std::uint16_t port)
{
// GNASH_REPORT_FUNCTION;
return startCGI(filespec, false, port);
@@ -91,7 +91,7 @@ Proc::startCGI(const string &filespec, bool outflag)
}
bool
-Proc::startCGI(const string &filespec, bool outflag, boost::uint16_t port)
+Proc::startCGI(const string &filespec, bool outflag, std::uint16_t port)
{
// GNASH_REPORT_FUNCTION;
struct stat procstats;
@@ -236,7 +236,7 @@ Proc::getOutput(const string &filespec)
}
bool
-Proc::connectCGI (const string &host, boost::uint16_t port)
+Proc::connectCGI (const string &host, std::uint16_t port)
{
// GNASH_REPORT_FUNCTION;
return createClient(host, port);
diff --git a/cygnal/proc.h b/cygnal/proc.h
index 1cd2105..876eab9 100644
--- a/cygnal/proc.h
+++ b/cygnal/proc.h
@@ -45,15 +45,15 @@ public:
// This starts the process running via the usual fork() & exec()
bool startCGI (void);
bool startCGI (const std::string &filespec);
- bool startCGI (const std::string &filespec, boost::uint16_t port);
+ bool startCGI (const std::string &filespec, std::uint16_t port);
bool startCGI (const std::string &filespec, bool output);
- bool startCGI (const std::string &filespec, bool output, boost::uint16_t
port);
+ bool startCGI (const std::string &filespec, bool output, std::uint16_t
port);
void setDocroot(const std::string &path) { _docroot = path; } ;
std::string &getDocroot() { return _docroot; };
// This opens a network connection to the process
- bool connectCGI (const std::string &host, boost::uint16_t port);
+ bool connectCGI (const std::string &host, std::uint16_t port);
// This finds the process
int findCGI (const std::string &filespec);
diff --git a/cygnal/rtmp_server.cpp b/cygnal/rtmp_server.cpp
index 4bf5719..a75153b 100644
--- a/cygnal/rtmp_server.cpp
+++ b/cygnal/rtmp_server.cpp
@@ -28,7 +28,7 @@
#include <cstdlib>
#include <cstdio>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/detail/endian.hpp>
#include <boost/random/uniform_real.hpp>
#include <boost/random/uniform_int.hpp>
@@ -168,7 +168,7 @@ RTMPServer::processClientHandShake(int fd)
}
// Get the actual start of the data
- boost::uint8_t *ptr = pkt->reference() + qhead->head_size;
+ std::uint8_t *ptr = pkt->reference() + qhead->head_size;
// See if we have enough data to go past the chunksize, which is
// probable. If so, all chunks are the default size of 128, the
@@ -237,9 +237,9 @@ RTMPServer::processClientHandShake(int fd)
}
// Send a Set Client Window Size to the client
- std::shared_ptr<cygnal::Buffer> winsize(new
cygnal::Buffer(sizeof(boost::uint32_t)));
- boost::uint32_t swapped = 0x20000;
- swapBytes(&swapped, sizeof(boost::uint32_t));
+ std::shared_ptr<cygnal::Buffer> winsize(new
cygnal::Buffer(sizeof(std::uint32_t)));
+ std::uint32_t swapped = 0x20000;
+ swapBytes(&swapped, sizeof(std::uint32_t));
*winsize += swapped;
if (RTMP::sendMsg(fd, RTMP_SYSTEM_CHANNEL, RTMP::HEADER_12,
winsize->size(), RTMP::WINDOW_SIZE, RTMPMsg::FROM_CLIENT,
*winsize)) {
@@ -288,7 +288,7 @@ RTMPServer::handShakeResponse(int fd, cygnal::Buffer
&handshake)
{
GNASH_REPORT_FUNCTION;
- // boost::uint8_t byte;
+ // std::uint8_t byte;
// byte = RTMP_VERSION;
// the response handshake is twice the size of the one we just
@@ -297,7 +297,7 @@ RTMPServer::handShakeResponse(int fd, cygnal::Buffer
&handshake)
+ RTMP_HANDSHAKE_VERSION_SIZE));
zeros->clear(); // set entire buffer to zeros
- boost::uint8_t *ptr = zeros->reference();
+ std::uint8_t *ptr = zeros->reference();
// the first byte of the handshake response is the RTMP version
// number.
@@ -313,13 +313,13 @@ RTMPServer::handShakeResponse(int fd, cygnal::Buffer
&handshake)
// timestamp, followed by another field that appears to be another
// timestamp or version number, which is probably ignored.
// the first field of the header is the timestamp
- boost::uint32_t timestamp;
+ std::uint32_t timestamp;
// Get the timestamp of when this message was read
timestamp = RTMP::getTime();
*zeros += timestamp;
// the second field is always zero
- boost::uint32_t pad = 0;
+ std::uint32_t pad = 0;
*zeros += pad;
// the data starts after the vesion and header bytes
@@ -361,13 +361,13 @@ RTMPServer::serverFinish(int fd, cygnal::Buffer
&handshake1, cygnal::Buffer &han
// the first field of the header is the timestamp of the original
// packet sent by this server.
- boost::uint32_t timestamp1 = *reinterpret_cast<boost::uint32_t *>
+ std::uint32_t timestamp1 = *reinterpret_cast<std::uint32_t *>
(handshake1.reference() + RTMP_HANDSHAKE_VERSION_SIZE);
// the second field of the header is the timestamp of the previous
// packet sent by this server.
- boost::uint32_t timestamp2 = *reinterpret_cast<boost::uint32_t *>
- (handshake1.reference() + RTMP_HANDSHAKE_VERSION_SIZE +
sizeof(boost::uint32_t));
+ std::uint32_t timestamp2 = *reinterpret_cast<std::uint32_t *>
+ (handshake1.reference() + RTMP_HANDSHAKE_VERSION_SIZE +
sizeof(std::uint32_t));
log_network("The timestamp delta is %d", timestamp2 - timestamp1);
@@ -397,7 +397,7 @@ RTMPServer::serverFinish(int fd, cygnal::Buffer
&handshake1, cygnal::Buffer &han
amf_size, fd);
buf.reset(new Buffer(amf_size));
// populate the buffer with the AMF data
- boost::uint8_t *ptr = handshake2.reference() + RTMP_HANDSHAKE_SIZE;
+ std::uint8_t *ptr = handshake2.reference() + RTMP_HANDSHAKE_SIZE;
buf->copy(ptr, amf_size);
}
@@ -417,8 +417,8 @@ RTMPServer::packetRead(cygnal::Buffer &buf)
{
GNASH_REPORT_FUNCTION;
- boost::uint8_t amf_index, headersize;
- boost::uint8_t *ptr = buf.reference();
+ std::uint8_t amf_index, headersize;
+ std::uint8_t *ptr = buf.reference();
AMF amf;
if (ptr == 0) {
@@ -445,16 +445,16 @@ RTMPServer::packetRead(cygnal::Buffer &buf)
// }
// #if 1
-// boost::uint8_t *end = buf->remove(0xc3);
+// std::uint8_t *end = buf->remove(0xc3);
// #else
-// boost::uint8_t *end = buf->find(0xc3);
+// std::uint8_t *end = buf->find(0xc3);
// log_network("END is %x", (void *)end);
// *end = '*';
// #endif
decodeHeader(ptr);
ptr += headersize;
- boost::uint8_t* tooFar = ptr+300+sizeof(int); // FIXME:
+ std::uint8_t* tooFar = ptr+300+sizeof(int); // FIXME:
AMF amf_obj;
std::shared_ptr<cygnal::Element> el1 = amf_obj.extractAMF(ptr, tooFar);
@@ -463,7 +463,7 @@ RTMPServer::packetRead(cygnal::Buffer &buf)
int size = 0;
std::shared_ptr<cygnal::Element> el;
- while ( size < static_cast<boost::uint16_t>(_header.bodysize) - 24 ) {
+ while ( size < static_cast<std::uint16_t>(_header.bodysize) - 24 ) {
if (ptr) {
el = amf_obj.extractProperty(ptr, tooFar);
if (el != 0) {
@@ -637,9 +637,9 @@ RTMPServer::encodeResult(gnash::RTMPMsg::rtmp_status_e
status, const std::string
{
// GNASH_REPORT_FUNCTION;
// Buffer *buf = new Buffer;
-// boost::uint8_t *ptr = buf->reference();
+// std::uint8_t *ptr = buf->reference();
// buf->clear(); // default everything to zeros, real data gets
optionally added.
-// ptr += sizeof(boost::uint16_t); // go past the first short
+// ptr += sizeof(std::uint16_t); // go past the first short
// const char *capabilities = 0;
// const char *description = 0;
// const char *code = 0;
@@ -918,7 +918,7 @@ RTMPServer::encodeResult(gnash::RTMPMsg::rtmp_status_e
status, const std::string
std::shared_ptr<cygnal::Buffer> buf(new Buffer(strbuf->size() +
numbuf->size() + topbuf->size()));
*buf += strbuf;
*buf += numbuf;
- boost::uint8_t byte = static_cast<boost::uint8_t>(RTMP::WINDOW_SIZE &
0x000000ff);
+ std::uint8_t byte = static_cast<std::uint8_t>(RTMP::WINDOW_SIZE &
0x000000ff);
*buf += byte;
*buf += topbuf;
@@ -955,22 +955,22 @@ RTMPServer::encodePing(rtmp_ping_e type)
}
std::shared_ptr<Buffer>
-RTMPServer::encodePing(rtmp_ping_e type, boost::uint32_t milliseconds)
+RTMPServer::encodePing(rtmp_ping_e type, std::uint32_t milliseconds)
{
// GNASH_REPORT_FUNCTION;
// An encoded ping message
- std::shared_ptr<cygnal::Buffer> buf(new Buffer(sizeof(boost::uint16_t) *
3));
-// boost::uint8_t *ptr = buf->reference();
+ std::shared_ptr<cygnal::Buffer> buf(new Buffer(sizeof(std::uint16_t) * 3));
+// std::uint8_t *ptr = buf->reference();
// Set the type of this ping message
- boost::uint16_t typefield = htons(type);
+ std::uint16_t typefield = htons(type);
*buf = typefield;
// // go past the first short, which is the type field
-// ptr += sizeof(boost::uint16_t);
+// ptr += sizeof(std::uint16_t);
- boost::uint32_t swapped = 0;
+ std::uint32_t swapped = 0;
switch (type) {
// These two don't appear to have any paramaters
case PING_CLEAR:
@@ -979,16 +979,16 @@ RTMPServer::encodePing(rtmp_ping_e type, boost::uint32_t
milliseconds)
// the third parameter is the buffer time in milliseconds
case PING_TIME:
{
-// ptr += sizeof(boost::uint16_t); // go past the second short
+// ptr += sizeof(std::uint16_t); // go past the second short
swapped = milliseconds;
- swapBytes(&swapped, sizeof(boost::uint32_t));
+ swapBytes(&swapped, sizeof(std::uint32_t));
*buf += swapped;
break;
}
// reset doesn't have any parameters but zeros
case PING_RESET:
{
- boost::uint16_t zero = 0;
+ std::uint16_t zero = 0;
*buf += zero;
*buf += zero;
break;
@@ -999,7 +999,7 @@ RTMPServer::encodePing(rtmp_ping_e type, boost::uint32_t
milliseconds)
{
// swapped = htonl(milliseconds);
swapped = milliseconds;
- swapBytes(&swapped, sizeof(boost::uint32_t));
+ swapBytes(&swapped, sizeof(std::uint32_t));
*buf += swapped;
break;
}
@@ -1047,7 +1047,7 @@ RTMPServer::encodeBWDone(double id)
}
std::shared_ptr<cygnal::Buffer>
-RTMPServer::encodeAudio(boost::uint8_t *data, size_t size)
+RTMPServer::encodeAudio(std::uint8_t *data, size_t size)
{
GNASH_REPORT_FUNCTION;
@@ -1064,7 +1064,7 @@ RTMPServer::encodeAudio(boost::uint8_t *data, size_t size)
}
std::shared_ptr<cygnal::Buffer>
-RTMPServer::encodeVideo(boost::uint8_t * /* data */, size_t /* size */)
+RTMPServer::encodeVideo(std::uint8_t * /* data */, size_t /* size */)
{
GNASH_REPORT_FUNCTION;
@@ -1077,7 +1077,7 @@ RTMPServer::encodeVideo(boost::uint8_t * /* data */,
size_t /* size */)
// Parse an Echo Request message coming from the Red5 echo_test. This
// method should only be used for testing purposes.
vector<std::shared_ptr<cygnal::Element > >
-RTMPServer::parseEchoRequest(boost::uint8_t *ptr, size_t size)
+RTMPServer::parseEchoRequest(std::uint8_t *ptr, size_t size)
{
// GNASH_REPORT_FUNCTION;
AMF amf;
@@ -1129,7 +1129,7 @@ RTMPServer::formatEchoResponse(double num, cygnal::Buffer
&data)
}
std::shared_ptr<cygnal::Buffer>
-RTMPServer::formatEchoResponse(double num, boost::uint8_t *data, size_t size)
+RTMPServer::formatEchoResponse(double num, std::uint8_t *data, size_t size)
{
// GNASH_REPORT_FUNCTION;
@@ -1196,8 +1196,8 @@ RTMPServer::createClientID()
#else
char letters[] =
"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
- boost::uint64_t random_time_bits = 0;
- boost::uint64_t value = 0;
+ std::uint64_t random_time_bits = 0;
+ std::uint64_t value = 0;
# ifdef HAVE_GETTIMEOFDAY
timeval tv;
gettimeofday(&tv, NULL);
@@ -1206,7 +1206,7 @@ RTMPServer::createClientID()
random_time_bits = time(NULL);
# endif
value += random_time_bits ^ getpid();
- boost::uint64_t v = value;
+ std::uint64_t v = value;
id = letters[v % 62];
v /= 62;
id += letters[v % 62];
@@ -1328,7 +1328,7 @@ RTMPServer::sendToClient(std::vector<int> &fds,
cygnal::Buffer &data)
}
size_t
-RTMPServer::sendToClient(std::vector<int> &fds, boost::uint8_t *data,
+RTMPServer::sendToClient(std::vector<int> &fds, std::uint8_t *data,
size_t size)
{
// GNASH_REPORT_FUNCTION;
@@ -1390,7 +1390,7 @@ rtmp_handler(Network::thread_params_t *args)
for (int i=1; i <= hand->getActiveDiskStreams(); i++) {
hand->getDiskStream(i)->dump();
if (hand->getDiskStream(i)->getState() == DiskStream::PLAY) {
- boost::uint8_t *ptr = hand->getDiskStream(i)->get();
+ std::uint8_t *ptr = hand->getDiskStream(i)->get();
if (ptr) {
if (rtmp->sendMsg(hand->getClient(i), 8,
RTMP::HEADER_8, 4096,
@@ -1415,7 +1415,7 @@ rtmp_handler(Network::thread_params_t *args)
}
if (pkt != 0) {
- boost::uint8_t *tmpptr = 0;
+ std::uint8_t *tmpptr = 0;
if (pkt->allocated()) {
std::shared_ptr<RTMP::queues_t> que = rtmp->split(*pkt);
if (!que) {
@@ -1617,7 +1617,7 @@ rtmp_handler(Network::thread_params_t *args)
*response)) {
}
int active_stream = hand->getActiveDiskStreams();
- boost::uint8_t *ptr =
hand->getDiskStream(active_stream)->get();
+ std::uint8_t *ptr =
hand->getDiskStream(active_stream)->get();
if (ptr) {
log_network("Sending %s to client",
hand->getDiskStream(active_stream)->getFilespec());
diff --git a/cygnal/rtmp_server.h b/cygnal/rtmp_server.h
index beed3a8..b483550 100644
--- a/cygnal/rtmp_server.h
+++ b/cygnal/rtmp_server.h
@@ -20,7 +20,7 @@
#define _RTMP_SERVER_H_
#include <vector>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/array.hpp>
#include <string>
#include <map>
@@ -68,24 +68,24 @@ public:
std::shared_ptr<cygnal::Buffer> encodeResult(gnash::RTMPMsg::rtmp_status_e
status, const std::string &filename, double &transid, double &clientid);
// Encode a Ping for the client
- std::shared_ptr<cygnal::Buffer> encodePing(rtmp_ping_e type,
boost::uint32_t milliseconds);
+ std::shared_ptr<cygnal::Buffer> encodePing(rtmp_ping_e type, std::uint32_t
milliseconds);
std::shared_ptr<cygnal::Buffer> encodePing(rtmp_ping_e type);
- // std::shared_ptr<cygnal::Buffer> encodeUser(user_control_e type,
boost::uint32_t milliseconds);
- std::shared_ptr<cygnal::Buffer> encodeAudio(boost::uint8_t *data, size_t
size);
- std::shared_ptr<cygnal::Buffer> encodeVideo(boost::uint8_t *data, size_t
size);
+ // std::shared_ptr<cygnal::Buffer> encodeUser(user_control_e type,
std::uint32_t milliseconds);
+ std::shared_ptr<cygnal::Buffer> encodeAudio(std::uint8_t *data, size_t
size);
+ std::shared_ptr<cygnal::Buffer> encodeVideo(std::uint8_t *data, size_t
size);
// Encode a onBWDone message for the client
std::shared_ptr<cygnal::Buffer> encodeBWDone(double id);
// Parse an Echo Request message coming from the Red5 echo_test.
std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(cygnal::Buffer &buf) { return
parseEchoRequest(buf.reference(), buf.size()); };
- std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(boost::uint8_t *buf, size_t size);
+ std::vector<std::shared_ptr<cygnal::Element > >
parseEchoRequest(std::uint8_t *buf, size_t size);
// format a response to the 'echo' test used for testing Gnash.
std::shared_ptr<cygnal::Buffer> formatEchoResponse(double num,
cygnal::Element &el);
std::shared_ptr<cygnal::Buffer> formatEchoResponse(double num,
cygnal::Buffer &data);
- std::shared_ptr<cygnal::Buffer> formatEchoResponse(double num,
boost::uint8_t *data, size_t size);
- void addReference(boost::uint16_t index, cygnal::Element &el) {
_references[index] = el; };
- cygnal::Element &getReference(boost::uint16_t index) { return
_references[index]; };
+ std::shared_ptr<cygnal::Buffer> formatEchoResponse(double num,
std::uint8_t *data, size_t size);
+ void addReference(std::uint16_t index, cygnal::Element &el) {
_references[index] = el; };
+ cygnal::Element &getReference(std::uint16_t index) { return
_references[index]; };
bool sendFile(int fd, const std::string &filespec);
@@ -102,7 +102,7 @@ public:
void setStreamID(double id) { _streamid = id; };
double getStreamID() { return _streamid; };
- size_t sendToClient(std::vector<int> &fds, boost::uint8_t *data,
+ size_t sendToClient(std::vector<int> &fds, std::uint8_t *data,
size_t size);
size_t sendToClient(std::vector<int> &fds,cygnal::Buffer &data);
@@ -132,8 +132,8 @@ private:
gnash::DiskStream::filetype_e _filetype;
std::string _docroot;
std::string _filespec;
- boost::uint32_t _filesize;
- std::map<boost::uint16_t, cygnal::Element> _references;
+ std::uint32_t _filesize;
+ std::map<std::uint16_t, cygnal::Element> _references;
#ifdef CLIENT_ID_NUMERIC
std::array<double> _clientids;
#else
diff --git a/cygnal/serverSO.cpp b/cygnal/serverSO.cpp
index ff3c48d..53b8ba5 100644
--- a/cygnal/serverSO.cpp
+++ b/cygnal/serverSO.cpp
@@ -32,7 +32,7 @@
#endif
#include <sys/types.h>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <cctype> // for toupper
#include <string>
diff --git a/cygnal/testsuite/libamf.all/test_amf.cpp
b/cygnal/testsuite/libamf.all/test_amf.cpp
index 5e05bed..5dea56f 100644
--- a/cygnal/testsuite/libamf.all/test_amf.cpp
+++ b/cygnal/testsuite/libamf.all/test_amf.cpp
@@ -188,8 +188,8 @@ test_encoding()
{
bool flag = true;
std::shared_ptr<Buffer> buf2(new Buffer("01 01"));
- boost::uint16_t sht = *(boost::uint16_t *)buf2->reference();
- swapBytes(&sht, sizeof(boost::uint16_t)); // we always encode in big
endian format
+ std::uint16_t sht = *(std::uint16_t *)buf2->reference();
+ swapBytes(&sht, sizeof(std::uint16_t)); // we always encode in big
endian format
#if defined(HAVE_MALLINFO) && defined(USE_STATS_MEMORY)
if (memdebug) {
mem->addStats(__LINE__); // take a sample
@@ -207,7 +207,7 @@ test_encoding()
// which are finally only one byte apiece.
if ((*encbool->reference() == Element::BOOLEAN_AMF0) &&
(encbool->size() == 2) &&
- (memcmp(buf2->reference(), encbool->reference(),
sizeof(boost::uint16_t)) == 0)) {
+ (memcmp(buf2->reference(), encbool->reference(),
sizeof(std::uint16_t)) == 0)) {
runtest.pass("Encoded cygnal::AMF Boolean");
} else {
runtest.fail("Encoded cygnal::AMF Boolean");
@@ -255,7 +255,7 @@ test_encoding()
mem->addStats(__LINE__); // take a sample
}
#endif
- boost::uint16_t len = *(boost::uint16_t *)(buf->reference() + 1);
+ std::uint16_t len = *(std::uint16_t *)(buf->reference() + 1);
// A NULL String cygnal::AMF object has just 3 bytes, the type, and a
two byte length, which is zero.
check_equals(*buf->reference(), Element::STRING_AMF0);
@@ -265,7 +265,7 @@ test_encoding()
Element el;
el.makeNullString();
buf = cygnal::AMF::encodeElement(el);
- len = *(boost::uint16_t *)(buf->reference() + 1);
+ len = *(std::uint16_t *)(buf->reference() + 1);
// A NULL String cygnal::AMF object has just 3 bytes, the type, and a
two byte length, which is zero.
check_equals(*buf->reference(), Element::STRING_AMF0);
@@ -275,7 +275,7 @@ test_encoding()
cygnal::AMF amf;
Element el1;
- boost::uint16_t index = 1;
+ std::uint16_t index = 1;
el1.makeReference(index);
if (el1.to_short() == 1) {
runtest.pass("Made Reference");
diff --git a/cygnal/testsuite/libamf.all/test_amfmsg.cpp
b/cygnal/testsuite/libamf.all/test_amfmsg.cpp
index 3b5daa5..f08a1eb 100644
--- a/cygnal/testsuite/libamf.all/test_amfmsg.cpp
+++ b/cygnal/testsuite/libamf.all/test_amfmsg.cpp
@@ -216,7 +216,7 @@ test_encoding()
top.addMessage(msg3);
std::shared_ptr<cygnal::Buffer> buf2 = top.encodeMsgHeader("getway",
"/229", 14);
- boost::uint8_t *ptr1 = buf1->reference() +
sizeof(AMF_msg::context_header_t);
+ std::uint8_t *ptr1 = buf1->reference() + sizeof(AMF_msg::context_header_t);
if (memcmp(ptr1, buf2->reference(), buf2->size()) == 0) {
diff --git a/cygnal/testsuite/libamf.all/test_buffer.cpp
b/cygnal/testsuite/libamf.all/test_buffer.cpp
index e7f013d..8a9704b 100644
--- a/cygnal/testsuite/libamf.all/test_buffer.cpp
+++ b/cygnal/testsuite/libamf.all/test_buffer.cpp
@@ -29,7 +29,7 @@
#include <fstream>
#include <cstring>
#include <vector>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "dejagnu.h"
#include "log.h"
@@ -255,15 +255,15 @@ test_copy()
runtest.fail ("Buffer::operator=(const char *)");
}
- boost::uint16_t length = 12;
+ std::uint16_t length = 12;
Buffer buf3;
buf3 = length;
Network::byte_t *ptr3 = buf3.reference();
- boost::uint16_t newlen = *(reinterpret_cast<boost::uint16_t *>(ptr3));
+ std::uint16_t newlen = *(reinterpret_cast<std::uint16_t *>(ptr3));
if (length == newlen) {
- runtest.pass ("Buffer::operator=(boost::uint16_t)");
+ runtest.pass ("Buffer::operator=(std::uint16_t)");
} else {
- runtest.fail ("Buffer::operator=(boost::uint16_t)");
+ runtest.fail ("Buffer::operator=(std::uint16_t)");
}
double num = 1.2345;
@@ -423,20 +423,20 @@ test_append()
runtest.fail ("Buffer::operator+=(const string &)");
}
- boost::uint16_t length = 1047;
+ std::uint16_t length = 1047;
Buffer buf7(70);
buf7.copy(data1, 10);
buf7 += length;
- if (memcmp(buf7.reference() + 10, &length, sizeof(boost::uint16_t)) == 0) {
- runtest.pass ("Buffer::operator+=(boost::uint16_t)");
+ if (memcmp(buf7.reference() + 10, &length, sizeof(std::uint16_t)) == 0) {
+ runtest.pass ("Buffer::operator+=(std::uint16_t)");
} else {
- runtest.fail ("Buffer::operator+=(boost::uint16_t)");
+ runtest.fail ("Buffer::operator+=(std::uint16_t)");
}
buf7 += buf6;
- // Network::byte_t *ptr1 = buf7.reference() + 10 + sizeof(boost::uint16_t);
+ // Network::byte_t *ptr1 = buf7.reference() + 10 + sizeof(std::uint16_t);
// Network::byte_t *ptr2 = buf6.reference();
- if (memcmp(buf7.reference() + 10 + sizeof(boost::uint16_t),
buf6.reference(), 30) == 0) {
+ if (memcmp(buf7.reference() + 10 + sizeof(std::uint16_t),
buf6.reference(), 30) == 0) {
runtest.pass ("Buffer::operator+=(Buffer &)");
} else {
runtest.fail ("Buffer::operator+=(Buffer &)");
@@ -613,7 +613,7 @@ test_operators()
buf1.clear();
buf2.clear();
- boost::uint8_t *ptr1 = buf1.reference();
+ std::uint8_t *ptr1 = buf1.reference();
for (size_t i=1; i< buf1.size(); i++) {
ptr1[i] = i;
}
@@ -638,7 +638,7 @@ test_operators()
Buffer *buf3, *buf4;
buf3 = new Buffer;
- boost::uint8_t *ptr2 = buf3->reference();
+ std::uint8_t *ptr2 = buf3->reference();
for (size_t i=1; i< buf3->size(); i++) {
ptr2[i] = i + 'a';
}
@@ -662,7 +662,7 @@ test_operators()
Buffer buf5(10);
buf5.clear();
- boost::uint8_t *ptr3 = buf5.reference();
+ std::uint8_t *ptr3 = buf5.reference();
buf5 += 'a';
buf5 += 'b';
buf5 += 'c';
diff --git a/cygnal/testsuite/libamf.all/test_flv.cpp
b/cygnal/testsuite/libamf.all/test_flv.cpp
index ac67f26..88a18fc 100644
--- a/cygnal/testsuite/libamf.all/test_flv.cpp
+++ b/cygnal/testsuite/libamf.all/test_flv.cpp
@@ -141,7 +141,7 @@ test_headers()
if (notest) {
runtest.untested("Decoded FLV header");
} else {
- boost::uint32_t size = *(reinterpret_cast<boost::uint32_t
*>(head->head_size));
+ std::uint32_t size = *(reinterpret_cast<std::uint32_t
*>(head->head_size));
if ((memcmp(head->sig, "FLV", 3) == 0)
&& (head->version == 1)
&& (size == 9)) {
@@ -165,7 +165,7 @@ test_headers()
// Test converting 3 byte "integers" to a real 4 byte one. The
// 0xf on each end should be ignore to be correct.
std::shared_ptr<cygnal::Buffer> hex2(new Buffer("0f 00 00 a4 0f"));
- boost::uint32_t num = flv.convert24(hex2->reference()+1);
+ std::uint32_t num = flv.convert24(hex2->reference()+1);
if (num == 0xa4) {
runtest.pass("Flv::convert24()");
} else {
diff --git a/cygnal/testsuite/libamf.all/test_lc.cpp
b/cygnal/testsuite/libamf.all/test_lc.cpp
index 870c3ce..ed1e740 100644
--- a/cygnal/testsuite/libamf.all/test_lc.cpp
+++ b/cygnal/testsuite/libamf.all/test_lc.cpp
@@ -363,7 +363,7 @@ test_read()
}
}
-// boost::uint8_t *ptr = lc.parseHeader(reinterpret_cast<boost::uint8_t
*>(shmaddr));
+// std::uint8_t *ptr = lc.parseHeader(reinterpret_cast<std::uint8_t
*>(shmaddr));
// vector<cygnal::Element *> ellist = lc.parseBody(ptr);
// cout << "# of AMF Elements in file: " << ellist.size() << endl;
// lc.dump();
@@ -397,7 +397,7 @@ test_write()
runtest.fail("gain set");
}
- boost::uint8_t *foo = amf_obj.encodeVariable(el);
+ std::uint8_t *foo = amf_obj.encodeVariable(el);
char *ptr = (char *)amf_obj.extractVariable(&newel, foo);
if ((el.name == newel.name) &&
(el.length == newel.length) &&
diff --git a/cygnal/testsuite/libamf.all/test_number.cpp
b/cygnal/testsuite/libamf.all/test_number.cpp
index dc39824..f9cbecc 100644
--- a/cygnal/testsuite/libamf.all/test_number.cpp
+++ b/cygnal/testsuite/libamf.all/test_number.cpp
@@ -91,7 +91,7 @@ test_amf()
int fd, ret;
double num;
Element el;
- boost::uint8_t *ptr;
+ std::uint8_t *ptr;
char *buf[AMF_NUMBER_SIZE+1];
memset(buf, 0, AMF_NUMBER_SIZE+1);
@@ -102,7 +102,7 @@ test_amf()
close(fd);
// num = amf_obj.extractNumber(buf);
- ptr = amf_obj.extractVariable(&el, reinterpret_cast<boost::uint8_t
*>(buf));
+ ptr = amf_obj.extractVariable(&el, reinterpret_cast<std::uint8_t *>(buf));
if (el.getType() == Element::NUMBER) {
runtest.pass("Extracted Number AMF object");
diff --git a/cygnal/testsuite/libnet.all/test_cque.cpp
b/cygnal/testsuite/libnet.all/test_cque.cpp
index ec94596..d789133 100644
--- a/cygnal/testsuite/libnet.all/test_cque.cpp
+++ b/cygnal/testsuite/libnet.all/test_cque.cpp
@@ -36,7 +36,7 @@
#include <fstream>
#include <cstring>
#include <vector>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#ifdef HAVE_DEJAGNU_H
#include "dejagnu.h"
@@ -67,13 +67,13 @@ main (int /*argc*/, char** /*argv*/) {
std::shared_ptr<cygnal::Buffer> buf(new Buffer(50));
// populate the buffer
- boost::uint8_t *ptr = buf->reference();
+ std::uint8_t *ptr = buf->reference();
for (Network::byte_t i=1; i< buf->size(); i++) {
*buf += i;
*buf += ' ';
}
-// boost::uint8_t *test = new uint8_t[6];
+// std::uint8_t *test = new uint8_t[6];
// memcpy(test, "hell", 4);
// Push one buffer on the fifo. The default is the incoming fifo,
diff --git a/cygnal/testsuite/libnet.all/test_diskstream.cpp
b/cygnal/testsuite/libnet.all/test_diskstream.cpp
index 558e69d..29d5369 100644
--- a/cygnal/testsuite/libnet.all/test_diskstream.cpp
+++ b/cygnal/testsuite/libnet.all/test_diskstream.cpp
@@ -123,8 +123,8 @@ test()
ds1.open("outbuf.raw");
// ptr should be the base address of the memory plus the offset
- boost::uint8_t *ptr = ds1.loadToMem(48);
-// boost::uint8_t *dsptr = ds1.get(); // cache the initial base address
+ std::uint8_t *ptr = ds1.loadToMem(48);
+// std::uint8_t *dsptr = ds1.get(); // cache the initial base address
if ((ds1.get() == MAP_FAILED) || (ds1.get() == 0)) {
runtest.unresolved("loadToMem(48)");
diff --git a/cygnal/testsuite/libnet.all/test_handler.cpp
b/cygnal/testsuite/libnet.all/test_handler.cpp
index 98212ad..a7903d4 100644
--- a/cygnal/testsuite/libnet.all/test_handler.cpp
+++ b/cygnal/testsuite/libnet.all/test_handler.cpp
@@ -36,7 +36,7 @@
#include <fstream>
#include <cstring>
#include <vector>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#ifdef HAVE_POLL
# include <sys/poll.h>
@@ -193,7 +193,7 @@ test_que()
Handler que;
std::shared_ptr<amf::Buffer> buf(new Buffer);
-// boost::uint8_t *test = new uint8_t[6];
+// std::uint8_t *test = new uint8_t[6];
// memcpy(test, "hell", 4);
// Push one buffer on the fifo. The default is the incoming fifo,
@@ -235,7 +235,7 @@ test_que()
}
// populate the buffer
- boost::uint8_t *ptr = buf->reference();
+ std::uint8_t *ptr = buf->reference();
for (size_t i=1; i< buf->size(); i++) {
ptr[i] = i;
}
diff --git a/cygnal/testsuite/libnet.all/test_http.cpp
b/cygnal/testsuite/libnet.all/test_http.cpp
index 84c1d36..1503df8 100644
--- a/cygnal/testsuite/libnet.all/test_http.cpp
+++ b/cygnal/testsuite/libnet.all/test_http.cpp
@@ -351,7 +351,7 @@ tests()
//
http.clearHeader();
#if 0
- boost::uint8_t *buffer = (boost::uint8_t *)"GET
/software/gnash/tests/flvplayer.swf?file=http://localhost/software/gnash/tests/Ouray_Ice_Festival_Climbing_Competition.flv
HTTP/1.1\r\n"
+ std::uint8_t *buffer = (std::uint8_t *)"GET
/software/gnash/tests/flvplayer.swf?file=http://localhost/software/gnash/tests/Ouray_Ice_Festival_Climbing_Competition.flv
HTTP/1.1\r\n"
"User-Agent: Gnash/0.8.1-cvs (X11; Linux i686; U; en)\r\n"
"Host: localhost:4080\r\n"
"Accept: text/html, application/xml;q=0.9, application/xhtml+xml, image/png,
image/jpeg, image/gif, image/x-xbitmap, */*;q=0.1\r\n"
@@ -384,7 +384,7 @@ tests()
// Check the Server field
Buffer field1;
field1 = "GET /index.html HTTP/1.1";
- // boost::uint8_t *field1 = (boost::uint8_t *)"GET /index.html
HTTP/1.1";
+ // std::uint8_t *field1 = (std::uint8_t *)"GET /index.html HTTP/1.1";
HTTP http1;
// http1.extractCommand(field1);
http1.extractCommand(field1);
@@ -421,7 +421,7 @@ tests()
#endif
#if 0
- boost::uint8_t *field3 = (boost::uint8_t *) "Keep-Alive: 300";
+ std::uint8_t *field3 = (std::uint8_t *) "Keep-Alive: 300";
HTTP http3;
http3.extractKeepAlive(field3);
if ((http3.keepAlive() == true) && (http3.getMaxRequests() == 300)) {
@@ -430,7 +430,7 @@ tests()
runtest.fail ("HTTP::extractKeepAlive(300)");
}
- boost::uint8_t *field4 = (boost::uint8_t *) "Keep-Alive: On";
+ std::uint8_t *field4 = (std::uint8_t *) "Keep-Alive: On";
HTTP http4;
http4.extractKeepAlive(field4);
if (http4.keepAlive() == true) {
@@ -439,7 +439,7 @@ tests()
runtest.fail ("HTTP::extractKeepAlive(On)");
}
- boost::uint8_t *field5 = (boost::uint8_t *) "Keep-Alive: Off";
+ std::uint8_t *field5 = (std::uint8_t *) "Keep-Alive: Off";
HTTP http5;
http5.extractKeepAlive(field5);
if (http5.keepAlive() == false) {
@@ -450,7 +450,7 @@ tests()
// Some browsers have a different synatax, of course, to keep things
// interesting.
- boost::uint8_t *buffer2 = (boost::uint8_t *)"GET
/software/gnash/tests/flvplayer.swf?file=http://localhost/software/gnash/tests/Ouray_Ice_Festival_Climbing_Competition.flv
HTTP/1.1\r\n)"
+ std::uint8_t *buffer2 = (std::uint8_t *)"GET
/software/gnash/tests/flvplayer.swf?file=http://localhost/software/gnash/tests/Ouray_Ice_Festival_Climbing_Competition.flv
HTTP/1.1\r\n)"
"Content-Language: en-US,en;q=0.9\r\n"
"Content-Charset: iso-8859-1, utf-8, utf-16, *;q=0.1\r\n"
"Content-Encoding: deflate, gzip, x-gzip, identity, *;q=0\r\n";
@@ -604,7 +604,7 @@ test_post()
// FIXME: should be moved to server side only test case
// Check the Server field
AMF amf;
- boost::uint8_t *data1 = http.processHeaderFields(&ptr1);
+ std::uint8_t *data1 = http.processHeaderFields(&ptr1);
std::shared_ptr<cygnal::Element> el1 = amf.extractAMF(data1, data1 + 15);
string str1 = el1->to_string();
@@ -633,7 +633,7 @@ test_post()
ptr2 += *encnum;
ptr2.resize(); // shrink the buffer to be the exact size of
the data
- boost::uint8_t *data2 = http.processHeaderFields(&ptr2);
+ std::uint8_t *data2 = http.processHeaderFields(&ptr2);
std::shared_ptr<cygnal::Element> el2 = amf.extractAMF(data2, data2 + 15);
if ((http.getField("host") == "localhost:5080")
&& (el2->to_number() == 1.2345)
diff --git a/cygnal/testsuite/libnet.all/test_rtmp.cpp
b/cygnal/testsuite/libnet.all/test_rtmp.cpp
index e3d2b20..80134e1 100644
--- a/cygnal/testsuite/libnet.all/test_rtmp.cpp
+++ b/cygnal/testsuite/libnet.all/test_rtmp.cpp
@@ -467,7 +467,7 @@ test_system()
runtest.fail("Encoded RTMP Ping Clear message");
}
- boost::uint32_t time = *(reinterpret_cast<boost::uint32_t
*>(buf2->reference() + 2));
+ std::uint32_t time = *(reinterpret_cast<std::uint32_t *>(buf2->reference()
+ 2));
std::shared_ptr<cygnal::Buffer> enc2 =
server.encodePing(RTMP::PING_CLIENT, htonl(time));
// cerr << hexify(buf2->begin(), buf2->size(), false) << endl;
// cerr << hexify(enc2->begin(), enc2->size(), false) << endl;
diff --git a/gui/Player.h b/gui/Player.h
index 572bcec..23df7f7 100644
--- a/gui/Player.h
+++ b/gui/Player.h
@@ -267,7 +267,7 @@ private:
/// @return always the len parameter value (silent stream never ends
/// and is always available)
///
- static unsigned int silentStream(void* udata, boost::int16_t* stream,
+ static unsigned int silentStream(void* udata, std::int16_t* stream,
unsigned int len, bool& atEOF);
void init_sound();
diff --git a/gui/aos4/aos4_agg_glue.h b/gui/aos4/aos4_agg_glue.h
index a5999d2..9041ee5 100644
--- a/gui/aos4/aos4_agg_glue.h
+++ b/gui/aos4/aos4_agg_glue.h
@@ -29,7 +29,7 @@
#include <proto/dos.h>
#include <proto/gadtools.h>
-#include <boost/cstdint.hpp> // for boost::?int??_t
+#include <cstdint> // for boost::?int??_t
#include <vector>
namespace gnash
diff --git a/gui/aos4/aos4_cairo_glue.h b/gui/aos4/aos4_cairo_glue.h
index a7df590..3e1e794 100644
--- a/gui/aos4/aos4_cairo_glue.h
+++ b/gui/aos4/aos4_cairo_glue.h
@@ -31,7 +31,7 @@
#include <cairo.h>
-#include <boost/cstdint.hpp> // for boost::?int??_t
+#include <cstdint> // for boost::?int??_t
#include <vector>
namespace gnash
diff --git a/gui/aos4/aos4_glue.h b/gui/aos4/aos4_glue.h
index 07abe8f..788f4b6 100644
--- a/gui/aos4/aos4_glue.h
+++ b/gui/aos4/aos4_glue.h
@@ -18,7 +18,7 @@
#ifndef __AOS4_GLUE_H__
#define __AOS4_GLUE_H__
-#include <boost/cstdint.hpp> // for boost::?int??_t
+#include <cstdint> // for boost::?int??_t
#include "Renderer.h"
diff --git a/gui/dump/dump.cpp b/gui/dump/dump.cpp
index 98b52f9..8b2e9a0 100644
--- a/gui/dump/dump.cpp
+++ b/gui/dump/dump.cpp
@@ -259,7 +259,7 @@ DumpGui::run()
}
}
- const boost::uint32_t total_time = _clock.elapsed() - _startTime;
+ const std::uint32_t total_time = _clock.elapsed() - _startTime;
std::cout << "TIME=" << total_time << std::endl;
std::cout << "FPS_ACTUAL=" << _fileOutputFPS << std::endl;
@@ -330,7 +330,7 @@ DumpGui::writeSamples()
// And update _samplesFetched..
_samplesFetched += toFetch;
- boost::int16_t samples[1024];
+ std::int16_t samples[1024];
while (toFetch) {
unsigned int n = std::min(toFetch, 1024u);
// Fetching samples should trigger writing to file
diff --git a/gui/fb/fb_glue_agg.cpp b/gui/fb/fb_glue_agg.cpp
index 7248eea..4f179cc 100644
--- a/gui/fb/fb_glue_agg.cpp
+++ b/gui/fb/fb_glue_agg.cpp
@@ -23,7 +23,7 @@
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <cstring>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <fcntl.h>
#include "log.h"
@@ -187,7 +187,7 @@ FBAggGlue::createRenderHandler()
assert(agg_handler != NULL);
// Get the memory buffer to have AGG render into.
- boost::uint8_t *mem = 0;
+ std::uint8_t *mem = 0;
if (rawfb->isSingleBuffered()) {
log_debug(_("Double buffering disabled"));
mem = rawfb->getFBMemory();
diff --git a/gui/fb/fb_glue_agg.h b/gui/fb/fb_glue_agg.h
index e581721..443fe12 100644
--- a/gui/fb/fb_glue_agg.h
+++ b/gui/fb/fb_glue_agg.h
@@ -23,7 +23,7 @@
#include "gnashconfig.h"
#endif
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "Renderer.h"
#include "fbsup.h"
diff --git a/gui/fb/fb_glue_ovg.h b/gui/fb/fb_glue_ovg.h
index 84de344..0c2cef1 100644
--- a/gui/fb/fb_glue_ovg.h
+++ b/gui/fb/fb_glue_ovg.h
@@ -23,7 +23,7 @@
#include "gnashconfig.h"
#endif
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "openvg/OpenVGRenderer.h"
#include "fbsup.h"
#include "fb_glue.h"
diff --git a/gui/fb/fbsup.h b/gui/fb/fbsup.h
index 5ba8959..23f409b 100644
--- a/gui/fb/fbsup.h
+++ b/gui/fb/fbsup.h
@@ -23,7 +23,7 @@
#include "gnashconfig.h"
#endif
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <vector>
#include <linux/fb.h>
diff --git a/gui/gui.cpp b/gui/gui.cpp
index 4f8d3e7..3c528c2 100644
--- a/gui/gui.cpp
+++ b/gui/gui.cpp
@@ -476,10 +476,10 @@ Gui::notifyMouseMove(int ux, int uy)
if ( _stopped ) return;
// A stage pseudopixel is user pixel / _xscale wide
- boost::int32_t x = (ux-_xoffset) / _xscale;
+ std::int32_t x = (ux-_xoffset) / _xscale;
// A stage pseudopixel is user pixel / _xscale high
- boost::int32_t y = (uy-_yoffset) / _yscale;
+ std::int32_t y = (uy-_yoffset) / _yscale;
#ifdef DEBUG_MOUSE_COORDINATES
log_debug("mouse @ %d,%d", x, y);
@@ -1176,11 +1176,11 @@ Gui::fpsCounterTick()
return;
}
- boost::uint64_t current_timer = clocktime::getTicks();
+ std::uint64_t current_timer = clocktime::getTicks();
// TODO: keep fps_timer_interval in milliseconds to avoid the multiplication
// at each fpsCounterTick call...
- boost::uint64_t interval_ms = (boost::uint64_t)(fps_timer_interval * 1000.0);
+ std::uint64_t interval_ms = (std::uint64_t)(fps_timer_interval * 1000.0);
if (fps_counter_total==1) {
fps_timer = current_timer;
diff --git a/gui/gui.h b/gui/gui.h
index efa7241..1bef998 100644
--- a/gui/gui.h
+++ b/gui/gui.h
@@ -546,10 +546,10 @@ private:
float _yscale;
/// Window pixel X offset of stage origin
- boost::int32_t _xoffset;
+ std::int32_t _xoffset;
/// Window pixel Y offset of stage origin
- boost::int32_t _yoffset;
+ std::int32_t _yoffset;
bool display(movie_root* m);
@@ -562,7 +562,7 @@ private:
// the number of calls to movie_advance()
unsigned int fps_counter_total;
- boost::uint64_t fps_timer, fps_start_timer;
+ std::uint64_t fps_timer, fps_start_timer;
/// The time, in seconds, between prints (which also resets the fps
counter).
//
diff --git a/gui/haiku/haiku_agg_glue.cpp b/gui/haiku/haiku_agg_glue.cpp
index bbc2b8b..ad546fc 100644
--- a/gui/haiku/haiku_agg_glue.cpp
+++ b/gui/haiku/haiku_agg_glue.cpp
@@ -326,7 +326,7 @@ HaikuAggGlue::ViewNeeded()
}
bool
-HaikuAggGlue::prepDrawingArea(int width, int height, boost::uint32_t sdl_flags)
+HaikuAggGlue::prepDrawingArea(int width, int height, std::uint32_t sdl_flags)
{
(void) sdl_flags;
@@ -340,7 +340,7 @@ HaikuAggGlue::prepDrawingArea(int width, int height,
boost::uint32_t sdl_flags)
assert(_bpp % 8 == 0);
- boost::uint32_t rmask, gmask, bmask, amask;
+ std::uint32_t rmask, gmask, bmask, amask;
switch(_bpp) {
case 32: // RGBA32
diff --git a/gui/haiku/haiku_agg_glue.h b/gui/haiku/haiku_agg_glue.h
index b813686..c52c373 100644
--- a/gui/haiku/haiku_agg_glue.h
+++ b/gui/haiku/haiku_agg_glue.h
@@ -20,7 +20,7 @@
#define HAIKU_AGG_GLUE_H
#include <vector>
-#include <boost/cstdint.hpp> // for boost::?int??_t
+#include <cstdint> // for boost::?int??_t
#include <Renderer.h>
#include <SupportDefs.h>
@@ -56,8 +56,8 @@ class HaikuAggGlue
void setInvalidatedRegions(const InvalidatedRanges& ranges);
void ViewNoMore();
void ViewNeeded();
- bool prepDrawingArea(int width, int height, boost::uint32_t sdl_flags);
- boost::uint32_t maskFlags(boost::uint32_t sdl_flags);
+ bool prepDrawingArea(int width, int height, std::uint32_t sdl_flags);
+ std::uint32_t maskFlags(std::uint32_t sdl_flags);
void render();
void render(int minx, int miny, int maxx, int maxy);
void Shown();
diff --git a/gui/pythonmod/gnash-view.cpp b/gui/pythonmod/gnash-view.cpp
index 780f33f..00e0cad 100644
--- a/gui/pythonmod/gnash-view.cpp
+++ b/gui/pythonmod/gnash-view.cpp
@@ -372,10 +372,10 @@ motion_notify_event_cb(GtkWidget */*widget*/,
GdkEventMotion *event, gpointer da
float yscale = widget->allocation.height /
view->movie_definition->get_height_pixels();
// A stage pseudopixel is user pixel / _xscale wide
- boost::int32_t x = event->x / xscale;
+ std::int32_t x = event->x / xscale;
// A stage pseudopixel is user pixel / _yscale high
- boost::int32_t y = event->y / yscale;
+ std::int32_t y = event->y / yscale;
if ( view->stage->mouseMoved(x, y) )
{
diff --git a/gui/sdl/sdl.cpp b/gui/sdl/sdl.cpp
index 309f599..78f66ed 100644
--- a/gui/sdl/sdl.cpp
+++ b/gui/sdl/sdl.cpp
@@ -177,7 +177,7 @@ SDLGui::createWindow(const char *title, int width, int
height,
_width = width;
_height = height;
- boost::uint32_t sdl_flags = 0;
+ std::uint32_t sdl_flags = 0;
if (!_core_trap) {
sdl_flags |= SDL_INIT_NOPARACHUTE;
diff --git a/gui/sdl/sdl_agg_glue.cpp b/gui/sdl/sdl_agg_glue.cpp
index df37caa..7cef174 100644
--- a/gui/sdl/sdl_agg_glue.cpp
+++ b/gui/sdl/sdl_agg_glue.cpp
@@ -83,7 +83,7 @@ SdlAggGlue::createRenderHandler(int bpp)
bool
-SdlAggGlue::prepDrawingArea(int width, int height, boost::uint32_t sdl_flags)
+SdlAggGlue::prepDrawingArea(int width, int height, std::uint32_t sdl_flags)
{
int depth_bytes = _bpp / 8; // TODO: <Udo> is this correct? Gives 1 for
15 bit modes!
@@ -98,7 +98,7 @@ SdlAggGlue::prepDrawingArea(int width, int height,
boost::uint32_t sdl_flags)
int stride = width * depth_bytes;
- boost::uint32_t rmask, gmask, bmask, amask;
+ std::uint32_t rmask, gmask, bmask, amask;
switch(_bpp) {
case 32: // RGBA32
diff --git a/gui/sdl/sdl_agg_glue.h b/gui/sdl/sdl_agg_glue.h
index ea2195a..8f2a745 100644
--- a/gui/sdl/sdl_agg_glue.h
+++ b/gui/sdl/sdl_agg_glue.h
@@ -20,7 +20,7 @@
#include <vector>
#include <SDL.h>
-#include <boost/cstdint.hpp> // for boost::?int??_t
+#include <cstdint> // for boost::?int??_t
namespace gnash
{
@@ -34,8 +34,8 @@ class SdlAggGlue : public SdlGlue
bool init(int argc, char **argv[]);
Renderer* createRenderHandler(int depth);
void setInvalidatedRegions(const InvalidatedRanges& ranges);
- bool prepDrawingArea(int width, int height, boost::uint32_t sdl_flags);
- boost::uint32_t maskFlags(boost::uint32_t sdl_flags);
+ bool prepDrawingArea(int width, int height, std::uint32_t sdl_flags);
+ std::uint32_t maskFlags(std::uint32_t sdl_flags);
void render();
void render(int minx, int miny, int maxx, int maxy);
private:
diff --git a/gui/sdl/sdl_cairo_glue.cpp b/gui/sdl/sdl_cairo_glue.cpp
index 1fd8f98..fb9f726 100644
--- a/gui/sdl/sdl_cairo_glue.cpp
+++ b/gui/sdl/sdl_cairo_glue.cpp
@@ -72,7 +72,7 @@ SdlCairoGlue::setInvalidatedRegions(const InvalidatedRanges&
/*ranges*/)
}
bool
-SdlCairoGlue::prepDrawingArea(int width, int height, boost::uint32_t sdl_flags)
+SdlCairoGlue::prepDrawingArea(int width, int height, std::uint32_t sdl_flags)
{
_screen = SDL_SetVideoMode(width, height, _bpp, sdl_flags | SDL_SWSURFACE);
@@ -94,7 +94,7 @@ SdlCairoGlue::prepDrawingArea(int width, int height,
boost::uint32_t sdl_flags)
renderer::cairo::set_context(_renderer, _cairo_handle);
- boost::uint32_t rmask, gmask, bmask, amask;
+ std::uint32_t rmask, gmask, bmask, amask;
rmask = 0x00ff0000;
gmask = 0x0000ff00;
diff --git a/gui/sdl/sdl_cairo_glue.h b/gui/sdl/sdl_cairo_glue.h
index ba46a82..ed267b7 100644
--- a/gui/sdl/sdl_cairo_glue.h
+++ b/gui/sdl/sdl_cairo_glue.h
@@ -38,8 +38,8 @@ class SdlCairoGlue : public SdlGlue
bool init(int argc, char **argv[]);
Renderer* createRenderHandler( int depth);
void setInvalidatedRegions(const InvalidatedRanges& ranges);
- bool prepDrawingArea(int width, int height, boost::uint32_t sdl_flags);
- boost::uint32_t maskFlags(boost::uint32_t sdl_flags);
+ bool prepDrawingArea(int width, int height, std::uint32_t sdl_flags);
+ std::uint32_t maskFlags(std::uint32_t sdl_flags);
void render();
private:
cairo_surface_t *_cairo_surface;
diff --git a/gui/sdl/sdl_glue.h b/gui/sdl/sdl_glue.h
index b842508..be6dc59 100644
--- a/gui/sdl/sdl_glue.h
+++ b/gui/sdl/sdl_glue.h
@@ -18,7 +18,7 @@
#include "gui.h"
-#include <boost/cstdint.hpp> // for boost::?int??_t
+#include <cstdint> // for boost::?int??_t
namespace gnash {
@@ -29,7 +29,7 @@ class SdlGlue
virtual bool init(int argc, char **argv[]) = 0;
virtual void setInvalidatedRegions(const InvalidatedRanges& ranges) = 0;
- virtual bool prepDrawingArea(int width, int height, boost::uint32_t
sdl_flags) = 0;
+ virtual bool prepDrawingArea(int width, int height, std::uint32_t
sdl_flags) = 0;
virtual Renderer* createRenderHandler(int depth) = 0;
virtual void render() = 0;
protected:
diff --git a/gui/sdl/sdl_ogl_glue.cpp b/gui/sdl/sdl_ogl_glue.cpp
index 9aad232..ab93b42 100644
--- a/gui/sdl/sdl_ogl_glue.cpp
+++ b/gui/sdl/sdl_ogl_glue.cpp
@@ -67,7 +67,7 @@ SdlOglGlue::setInvalidatedRegions(const InvalidatedRanges&
/*ranges*/)
}
bool
-SdlOglGlue::prepDrawingArea(int width, int height, boost::uint32_t sdl_flags)
+SdlOglGlue::prepDrawingArea(int width, int height, std::uint32_t sdl_flags)
{
if (_bpp == 16) {
// 16-bit color, surface creation is likely to succeed.
diff --git a/gui/sdl/sdl_ogl_glue.h b/gui/sdl/sdl_ogl_glue.h
index 8fc2519..21733d8 100644
--- a/gui/sdl/sdl_ogl_glue.h
+++ b/gui/sdl/sdl_ogl_glue.h
@@ -31,7 +31,7 @@ class SdlOglGlue : public SdlGlue
bool init(int argc, char **argv[]);
Renderer* createRenderHandler( int depth);
void setInvalidatedRegions(const InvalidatedRanges& ranges);
- bool prepDrawingArea(int width, int height, boost::uint32_t sdl_flags);
+ bool prepDrawingArea(int width, int height, std::uint32_t sdl_flags);
void render();
};
diff --git a/libbase/AMF.cpp b/libbase/AMF.cpp
index 803969d..4d2bac4 100644
--- a/libbase/AMF.cpp
+++ b/libbase/AMF.cpp
@@ -47,7 +47,7 @@ namespace {
}
bool
-readBoolean(const boost::uint8_t*& pos, const boost::uint8_t* _end)
+readBoolean(const std::uint8_t*& pos, const std::uint8_t* _end)
{
if (pos == _end) {
throw AMFException("Read past _end of buffer for boolean type");
@@ -62,7 +62,7 @@ readBoolean(const boost::uint8_t*& pos, const boost::uint8_t*
_end)
}
double
-readNumber(const boost::uint8_t*& pos, const boost::uint8_t* end)
+readNumber(const std::uint8_t*& pos, const std::uint8_t* end)
{
if (end - pos < 8) {
@@ -84,13 +84,13 @@ readNumber(const boost::uint8_t*& pos, const
boost::uint8_t* end)
}
std::string
-readString(const boost::uint8_t*& pos, const boost::uint8_t* end)
+readString(const std::uint8_t*& pos, const std::uint8_t* end)
{
if (end - pos < 2) {
throw AMFException(_("Read past _end of buffer for string length"));
}
- const boost::uint16_t si = readNetworkShort(pos);
+ const std::uint16_t si = readNetworkShort(pos);
pos += 2;
if (end - pos < si) {
@@ -106,15 +106,15 @@ readString(const boost::uint8_t*& pos, const
boost::uint8_t* end)
}
std::string
-readLongString(const boost::uint8_t*& pos, const boost::uint8_t* end)
+readLongString(const std::uint8_t*& pos, const std::uint8_t* end)
{
if (end - pos < 4) {
throw AMFException("Read past _end of buffer for long string length");
}
- const boost::uint32_t si = readNetworkLong(pos);
+ const std::uint32_t si = readNetworkLong(pos);
pos += 4;
- if (static_cast<boost::uint32_t>(end - pos) < si) {
+ if (static_cast<std::uint32_t>(end - pos) < si) {
throw AMFException("Read past _end of buffer for long string type");
}
@@ -185,10 +185,10 @@ void
swapBytes(void* word, size_t size)
{
union {
- boost::uint16_t s;
+ std::uint16_t s;
struct {
- boost::uint8_t c0;
- boost::uint8_t c1;
+ std::uint8_t c0;
+ std::uint8_t c1;
} c;
} u;
@@ -200,7 +200,7 @@ swapBytes(void* word, size_t size)
// Little-endian machine: byte-swap the word
// A conveniently-typed pointer to the source data
- boost::uint8_t *x = static_cast<boost::uint8_t *>(word);
+ std::uint8_t *x = static_cast<std::uint8_t *>(word);
// Handles odd as well as even counts of bytes
std::reverse(x, x + size);
diff --git a/libbase/AMF.h b/libbase/AMF.h
index e1ec5b2..616a690 100644
--- a/libbase/AMF.h
+++ b/libbase/AMF.h
@@ -24,7 +24,7 @@
#define GNASH_AMF_H
#include <string>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "dsodefs.h"
#include "GnashException.h"
@@ -82,8 +82,8 @@ public:
/// be determined from the buffer.
//
/// This function will throw an AMFException if it encounters ill-formed AMF.
-DSOEXPORT double readNumber(const boost::uint8_t*& pos,
- const boost::uint8_t* end);
+DSOEXPORT double readNumber(const std::uint8_t*& pos,
+ const std::uint8_t* end);
/// Read a boolean value from the buffer.
//
@@ -91,8 +91,8 @@ DSOEXPORT double readNumber(const boost::uint8_t*& pos,
/// be determined from the buffer.
//
/// This function will throw an AMFException if it encounters ill-formed AMF.
-DSOEXPORT bool readBoolean(const boost::uint8_t*& pos,
- const boost::uint8_t* end);
+DSOEXPORT bool readBoolean(const std::uint8_t*& pos,
+ const std::uint8_t* end);
/// Read a string value from the buffer.
//
@@ -100,8 +100,8 @@ DSOEXPORT bool readBoolean(const boost::uint8_t*& pos,
/// be determined from the buffer.
//
/// This function will throw an AMFException if it encounters ill-formed AMF.
-DSOEXPORT std::string readString(const boost::uint8_t*& pos,
- const boost::uint8_t* end);
+DSOEXPORT std::string readString(const std::uint8_t*& pos,
+ const std::uint8_t* end);
/// Read a long string value from the buffer.
//
@@ -109,26 +109,26 @@ DSOEXPORT std::string readString(const boost::uint8_t*&
pos,
/// be determined from the buffer.
//
/// This function will throw an AMFException if it encounters ill-formed AMF.
-DSOEXPORT std::string readLongString(const boost::uint8_t*& pos,
- const boost::uint8_t* end);
+DSOEXPORT std::string readLongString(const std::uint8_t*& pos,
+ const std::uint8_t* end);
/// Read an unsigned 16-bit value in network byte order.
//
/// You must ensure that the buffer contains at least 2 bytes!
-inline boost::uint16_t
-readNetworkShort(const boost::uint8_t* buf)
+inline std::uint16_t
+readNetworkShort(const std::uint8_t* buf)
{
- const boost::uint16_t s = buf[0] << 8 | buf[1];
+ const std::uint16_t s = buf[0] << 8 | buf[1];
return s;
}
/// Read an unsigned 32-bit value in network byte order.
//
/// You must ensure that the buffer contains at least 4 bytes!
-inline boost::uint32_t
-readNetworkLong(const boost::uint8_t* buf)
+inline std::uint32_t
+readNetworkLong(const std::uint8_t* buf)
{
- const boost::uint32_t s = buf[0] << 24 | buf[1] << 16 |
+ const std::uint32_t s = buf[0] << 24 | buf[1] << 16 |
buf[2] << 8 | buf[3];
return s;
}
diff --git a/libbase/BitsReader.cpp b/libbase/BitsReader.cpp
index 6bb8694..20cdb45 100644
--- a/libbase/BitsReader.cpp
+++ b/libbase/BitsReader.cpp
@@ -35,7 +35,7 @@ unsigned BitsReader::read_uint(unsigned short bitcount)
{
assert(bitcount <= 32);
- boost::uint32_t value = 0;
+ std::uint32_t value = 0;
unsigned short bits_needed = bitcount;
do
@@ -85,9 +85,9 @@ unsigned BitsReader::read_uint(unsigned short bitcount)
}
-boost::int32_t BitsReader::read_sint(unsigned short bitcount)
+std::int32_t BitsReader::read_sint(unsigned short bitcount)
{
- boost::int32_t value = boost::int32_t(read_uint(bitcount));
+ std::int32_t value = std::int32_t(read_uint(bitcount));
// Sign extend...
if (value & (1 << (bitcount - 1)))
diff --git a/libbase/BitsReader.h b/libbase/BitsReader.h
index 83c3391..da9834e 100644
--- a/libbase/BitsReader.h
+++ b/libbase/BitsReader.h
@@ -26,7 +26,7 @@
#include "log.h"
#include <cassert>
-#include <boost/cstdint.hpp> // for boost::uint32_t used in this file
+#include <cstdint> // for std::uint32_t used in this file
namespace gnash {
@@ -97,43 +97,43 @@ public:
/// Reads a bit-packed little-endian signed integer
/// from the stream. The given bitcount determines the
/// number of bits to read.
- boost::int32_t read_sint(unsigned short bitcount);
+ std::int32_t read_sint(unsigned short bitcount);
/// Read a byte as an unsigned int (aligned)
- boost::uint8_t read_u8()
+ std::uint8_t read_u8()
{
align();
return *ptr++;
}
/// Read one bytes as a signed int (aligned)
- boost::int8_t read_s8()
+ std::int8_t read_s8()
{
- return static_cast<boost::int8_t>(read_u8());
+ return static_cast<std::int8_t>(read_u8());
}
/// Read two bytes as an unsigned int (aligned)
- boost::uint16_t read_u16()
+ std::uint16_t read_u16()
{
align();
assert(ptr+2 < end);
- boost::uint16_t result = *ptr++;
+ std::uint16_t result = *ptr++;
result |= *ptr++ << 8;
return result ;
}
/// Read two bytes as a signed int (aligned)
- boost::int16_t read_s16()
+ std::int16_t read_s16()
{
- return static_cast<boost::int16_t>(read_u16());
+ return static_cast<std::int16_t>(read_u16());
}
/// Read four bytes as an unsigned int (aligned)
- boost::uint32_t read_u32()
+ std::uint32_t read_u32()
{
align();
assert(ptr+4 < end);
- boost::uint32_t result = *ptr++;
+ std::uint32_t result = *ptr++;
result |= *ptr++ << 8;
result |= *ptr++ << 16;
result |= *ptr++ << 24;
@@ -141,9 +141,9 @@ public:
}
/// Read four bytes as an signed int (aligned)
- boost::int32_t read_s32()
+ std::int32_t read_s32()
{
- return static_cast<boost::int32_t>(read_u32());
+ return static_cast<std::int32_t>(read_u32());
}
/// \brief
@@ -155,9 +155,9 @@ public:
}
/// Checks if the stream contains X bits
- bool gotBits(boost::uint32_t nbits) const
+ bool gotBits(std::uint32_t nbits) const
{
- boost::uint32_t gotbits = 8-usedBits +8*(end-ptr-1);
+ std::uint32_t gotbits = 8-usedBits +8*(end-ptr-1);
if (gotbits > nbits) return true;
else return false;
}
diff --git a/libbase/ClockTime.cpp b/libbase/ClockTime.cpp
index a17adaf..f6fd089 100644
--- a/libbase/ClockTime.cpp
+++ b/libbase/ClockTime.cpp
@@ -17,7 +17,7 @@
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "ClockTime.h"
#include "log.h"
@@ -43,7 +43,7 @@ extern long timezone; // for tzset()/long timezone;
namespace gnash {
-boost::uint64_t
+std::uint64_t
clocktime::getTicks()
{
// This needs to return milliseconds. Does it?
@@ -57,7 +57,7 @@ clocktime::getTicks()
namespace gnash {
-boost::uint64_t
+std::uint64_t
clocktime::getTicks()
{
@@ -65,12 +65,12 @@ clocktime::getTicks()
gettimeofday(&tv, 0);
- boost::uint64_t result = static_cast<boost::uint64_t>(tv.tv_sec) *
1000000L;
+ std::uint64_t result = static_cast<std::uint64_t>(tv.tv_sec) * 1000000L;
// Time Unit: microsecond
result += tv.tv_usec;
- return static_cast<boost::uint64_t>(result / 1000.0);
+ return static_cast<std::uint64_t>(result / 1000.0);
}
}
@@ -95,7 +95,7 @@ namespace gnash {
/// It also gets things wrong for very high or low time values, when the
/// localtime implementation fills the gmtoff element with 53 minutes (on
/// at least one machine, anyway).
-boost::int32_t
+std::int32_t
clocktime::getTimeZoneOffset(double time)
{
diff --git a/libbase/ClockTime.h b/libbase/ClockTime.h
index da5f541..d3a79b0 100644
--- a/libbase/ClockTime.h
+++ b/libbase/ClockTime.h
@@ -21,19 +21,19 @@
#ifndef GNASH_TIME_H
#define GNASH_TIME_H
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "dsodefs.h"
namespace gnash {
namespace clocktime {
/// Wall clock timer, returns current POSIX time in milliseconds.
- DSOEXPORT boost::uint64_t getTicks();
+ DSOEXPORT std::uint64_t getTicks();
/// Returns the offset between actual clock time and UTC.
/// It relies on the system's time zone settings, so
/// cannot be regarded as reliable.
- DSOEXPORT boost::int32_t getTimeZoneOffset(double time);
+ DSOEXPORT std::int32_t getTimeZoneOffset(double time);
} // namespace clocktime
} // namespace gnash
diff --git a/libbase/GnashImage.cpp b/libbase/GnashImage.cpp
index f181796..8d660f4 100644
--- a/libbase/GnashImage.cpp
+++ b/libbase/GnashImage.cpp
@@ -49,7 +49,7 @@ namespace {
assert(channels > 0);
- boost::uint32_t maxSize = std::numeric_limits<boost::int32_t>::max();
+ std::uint32_t maxSize = std::numeric_limits<std::int32_t>::max();
if (width >= maxSize || height >= maxSize) return false;
maxSize /= channels;
diff --git a/libbase/GnashImage.h b/libbase/GnashImage.h
index 5652855..afec355 100644
--- a/libbase/GnashImage.h
+++ b/libbase/GnashImage.h
@@ -25,7 +25,7 @@
#define GNASH_GNASHIMAGE_H
#include <boost/noncopyable.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <memory>
#include "GnashEnums.h"
@@ -78,7 +78,7 @@ class DSOEXPORT GnashImage : boost::noncopyable
{
public:
- typedef boost::uint8_t value_type;
+ typedef std::uint8_t value_type;
typedef std::unique_ptr<value_type[]> container_type;
typedef value_type* iterator;
typedef const value_type* const_iterator;
@@ -184,7 +184,7 @@ protected:
/// Construct an empty GnashImage
//
- /// Note: there is an arbitrary limit of boost::int32_t::max bytes for the
+ /// Note: there is an arbitrary limit of std::int32_t::max bytes for the
/// total size of the bitmap constructed with this constructor.
//
/// @param width The width of the image in pixels.
diff --git a/libbase/GnashNumeric.h b/libbase/GnashNumeric.h
index fec31f2..6670eba 100644
--- a/libbase/GnashNumeric.h
+++ b/libbase/GnashNumeric.h
@@ -32,7 +32,7 @@
#include <cassert>
#include <cmath>
#include <algorithm>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <limits>
#include <type_traits>
@@ -98,7 +98,7 @@ twipsToPixels(int i)
}
template<size_t Factor>
-boost::int32_t
+std::int32_t
truncateWithFactor(double a)
{
// If a is NaN, then this function would return -NAN, which when cast to
@@ -118,11 +118,11 @@ truncateWithFactor(double a)
// extremely rare, using this safe version has no implications for
// performance under normal circumstances.
static const double upperUnsignedLimit =
- std::numeric_limits<boost::uint32_t>::max() + 1.0;
+ std::numeric_limits<std::uint32_t>::max() + 1.0;
static const double upperSignedLimit =
- std::numeric_limits<boost::int32_t>::max() / factor;
+ std::numeric_limits<std::int32_t>::max() / factor;
static const double lowerSignedLimit =
- std::numeric_limits<boost::int32_t>::min() / factor;
+ std::numeric_limits<std::int32_t>::min() / factor;
if (a >= lowerSignedLimit && a <= upperSignedLimit) {
return a * Factor;
@@ -130,15 +130,15 @@ truncateWithFactor(double a)
// This slow truncation happens only in very unlikely cases.
return a >= 0 ?
- static_cast<boost::uint32_t>(
+ static_cast<std::uint32_t>(
std::fmod(a * factor, upperUnsignedLimit))
:
- -static_cast<boost::uint32_t>(
+ -static_cast<std::uint32_t>(
std::fmod(-a * factor, upperUnsignedLimit));
}
// truncate when overflow occurs.
-inline boost::int32_t
+inline std::int32_t
pixelsToTwips(double a)
{
return truncateWithFactor<20>(a);
diff --git a/libbase/GnashVaapiImage.cpp b/libbase/GnashVaapiImage.cpp
index 1b66e4b..6cf00dd 100644
--- a/libbase/GnashVaapiImage.cpp
+++ b/libbase/GnashVaapiImage.cpp
@@ -27,16 +27,16 @@
namespace gnash {
/// Get current value of microsecond timer
-static boost::uint64_t get_ticks_usec(void)
+static std::uint64_t get_ticks_usec(void)
{
#ifdef HAVE_CLOCK_GETTIME
struct timespec t;
clock_gettime(CLOCK_REALTIME, &t);
- return (boost::uint64_t)t.tv_sec * 1000000 + t.tv_nsec / 1000;
+ return (std::uint64_t)t.tv_sec * 1000000 + t.tv_nsec / 1000;
#else
struct timeval t;
gettimeofday(&t, NULL);
- return (boost::uint64_t)t.tv_sec * 1000000 + t.tv_usec;
+ return (std::uint64_t)t.tv_sec * 1000000 + t.tv_usec;
#endif
}
@@ -64,7 +64,7 @@ void GnashVaapiImage::update(std::shared_ptr<VaapiSurface>
surface)
_creation_time = get_ticks_usec();
}
-void GnashVaapiImage::update(boost::uint8_t* data)
+void GnashVaapiImage::update(std::uint8_t* data)
{
log_debug(_("GnashVaapi::update(): data %p\n"), data);
@@ -80,7 +80,7 @@ void GnashVaapiImage::update(const image::GnashImage& from)
switch (from.location()) {
case image::GNASH_IMAGE_CPU:
- this->update(const_cast<boost::uint8_t*>(from.begin()));
+ this->update(const_cast<std::uint8_t*>(from.begin()));
break;
case image::GNASH_IMAGE_GPU:
this->update(static_cast<const GnashVaapiImage&>(from).surface());
@@ -111,7 +111,7 @@ GnashVaapiImage::begin()
{
log_debug(_("GnashVaapiImage::data(): surface 0x%08x\n"), _surface->get());
log_debug(_(" -> %u usec from creation\n"),
- (boost::uint32_t)(get_ticks_usec() - _creation_time));
+ (std::uint32_t)(get_ticks_usec() - _creation_time));
if (!transfer()) {
return NULL;
@@ -127,7 +127,7 @@ GnashVaapiImage::begin() const
log_debug(_("GnashVaapiImage::data() const: surface 0x%08x\n"),
_surface->get());
log_debug(_(" -> %u usec from creation\n"),
- (boost::uint32_t)(get_ticks_usec() - _creation_time));
+ (std::uint32_t)(get_ticks_usec() - _creation_time));
/* XXX: awful hack... */
if (!const_cast<GnashVaapiImage *>(this)->transfer()) {
diff --git a/libbase/GnashVaapiImage.h b/libbase/GnashVaapiImage.h
index 60c7cf0..284ef5d 100644
--- a/libbase/GnashVaapiImage.h
+++ b/libbase/GnashVaapiImage.h
@@ -35,7 +35,7 @@ class VaapiSurfaceProxy;
class DSOEXPORT GnashVaapiImage : public image::GnashImage
{
std::shared_ptr<VaapiSurface> _surface;
- boost::uint64_t _creation_time;
+ std::uint64_t _creation_time;
/// Transfer (and convert) VA surface to CPU image data
bool transfer();
@@ -47,7 +47,7 @@ public:
~GnashVaapiImage();
virtual void update(std::shared_ptr<VaapiSurface> surface);
- virtual void update(boost::uint8_t* data);
+ virtual void update(std::uint8_t* data);
virtual void update(const image::GnashImage& from);
/// Get access to the underlying surface
diff --git a/libbase/IOChannel.cpp b/libbase/IOChannel.cpp
index 2c145b8..d9ba0bb 100644
--- a/libbase/IOChannel.cpp
+++ b/libbase/IOChannel.cpp
@@ -24,22 +24,22 @@
namespace gnash
{
-boost::uint32_t
+std::uint32_t
IOChannel::read_le32()
{
- // read_byte() is boost::uint8_t, so no masks with 0xff are required.
- boost::uint32_t result = static_cast<boost::uint32_t>(read_byte());
- result |= static_cast<boost::uint32_t>(read_byte()) << 8;
- result |= static_cast<boost::uint32_t>(read_byte()) << 16;
- result |= static_cast<boost::uint32_t>(read_byte()) << 24;
+ // read_byte() is std::uint8_t, so no masks with 0xff are required.
+ std::uint32_t result = static_cast<std::uint32_t>(read_byte());
+ result |= static_cast<std::uint32_t>(read_byte()) << 8;
+ result |= static_cast<std::uint32_t>(read_byte()) << 16;
+ result |= static_cast<std::uint32_t>(read_byte()) << 24;
return(result);
}
-boost::uint16_t
+std::uint16_t
IOChannel::read_le16()
{
- boost::uint16_t result = static_cast<boost::uint16_t>(read_byte());
- result |= static_cast<boost::uint16_t>(read_byte()) << 8;
+ std::uint16_t result = static_cast<std::uint16_t>(read_byte());
+ result |= static_cast<std::uint16_t>(read_byte()) << 8;
return(result);
}
@@ -59,10 +59,10 @@ IOChannel::read_string(char* dst, int max_length)
return -1;
}
-boost::uint8_t
+std::uint8_t
IOChannel::read_byte()
{
- boost::uint8_t u;
+ std::uint8_t u;
if ( read(&u, 1) == -1 )
{
throw IOException("Could not read a single byte from input");
diff --git a/libbase/IOChannel.h b/libbase/IOChannel.h
index e9a9544..a4cf468 100644
--- a/libbase/IOChannel.h
+++ b/libbase/IOChannel.h
@@ -23,7 +23,7 @@
#include <string>
#include <ios> // for std::streamsize
-#include <boost/cstdint.hpp> // for boost int types
+#include <cstdint> // for boost int types
#include "dsodefs.h" // DSOEXPORT
#include "GnashException.h" // for IOException inheritance
@@ -50,19 +50,19 @@ public:
//
/// Throw IOException on error
///
- boost::uint32_t read_le32();
+ std::uint32_t read_le32();
/// Read a 16-bit word from a little-endian stream.
//
/// Throw IOException on error
///
- boost::uint16_t read_le16();
+ std::uint16_t read_le16();
/// Read a single byte from the stream
//
/// Throw IOException on error
///
- boost::uint8_t read_byte();
+ std::uint8_t read_byte();
/// Read the given number of bytes from the stream
//
diff --git a/libbase/ImageIterators.h b/libbase/ImageIterators.h
index 01ff835..54c4111 100644
--- a/libbase/ImageIterators.h
+++ b/libbase/ImageIterators.h
@@ -75,7 +75,7 @@ public:
/// Writes a 32-bit unsigned value in ARGB byte order to the image
//
/// Take note of the different byte order!
- const ARGB& operator=(boost::uint32_t pixel) const {
+ const ARGB& operator=(std::uint32_t pixel) const {
switch (_t) {
case TYPE_RGBA:
// alpha
@@ -91,8 +91,8 @@ public:
}
/// Convert to uint32_t in ARGB order
- operator boost::uint32_t() const {
- boost::uint32_t ret = 0xff000000;
+ operator std::uint32_t() const {
+ std::uint32_t ret = 0xff000000;
switch (_t) {
case TYPE_RGBA:
// alpha
diff --git a/libbase/Point2d.h b/libbase/Point2d.h
index c8e535d..0b561fe 100644
--- a/libbase/Point2d.h
+++ b/libbase/Point2d.h
@@ -26,7 +26,7 @@
#include <ostream>
#include <cmath> // for sqrt()
-#include <boost/cstdint.hpp>
+#include <cstdint>
namespace gnash {
namespace geometry {
@@ -40,10 +40,10 @@ class Point2d
public:
/// The x coordinate
- boost::int32_t x; // TWIPS
+ std::int32_t x; // TWIPS
/// The y coordinate
- boost::int32_t y; // TWIPS
+ std::int32_t y; // TWIPS
/// Construct a Point2d with default x and y coordinates
Point2d()
@@ -53,7 +53,7 @@ public:
}
/// Construct a Point2d with given x and y ordinates
- Point2d(boost::int32_t cx, boost::int32_t cy)
+ Point2d(std::int32_t cx, std::int32_t cy)
:
x(cx), y(cy)
{
@@ -67,8 +67,8 @@ public:
///
Point2d(const Point2d& p0, const Point2d& p1, float t)
:
- x( p0.x + (boost::int32_t)((p1.x - p0.x) * t)),
- y( p0.y + (boost::int32_t)((p1.y - p0.y) * t))
+ x( p0.x + (std::int32_t)((p1.x - p0.x) * t)),
+ y( p0.y + (std::int32_t)((p1.y - p0.y) * t))
{
}
@@ -76,7 +76,7 @@ public:
//
/// @return a reference to this instance
///
- Point2d& setTo(const boost::int32_t cx, const boost::int32_t cy)
+ Point2d& setTo(const std::int32_t cx, const std::int32_t cy)
{
x = cx;
y = cy;
@@ -93,31 +93,31 @@ public:
///
Point2d& setTo(const Point2d& p0, const Point2d& p1, float t)
{
- x = p0.x + (boost::int32_t)((p1.x - p0.x) * t);
- y = p0.y + (boost::int32_t)((p1.y - p0.y) * t);
+ x = p0.x + (std::int32_t)((p1.x - p0.x) * t);
+ y = p0.y + (std::int32_t)((p1.y - p0.y) * t);
return *this;
}
/// Return square distance between two given points.
static
- boost::int64_t squareDistance(const Point2d& p0, const Point2d& p1)
+ std::int64_t squareDistance(const Point2d& p0, const Point2d& p1)
{
- boost::int64_t hside = p1.x - p0.x;
- boost::int64_t vside = p1.y - p0.y;
+ std::int64_t hside = p1.x - p0.x;
+ std::int64_t vside = p1.y - p0.y;
return hside*hside + vside*vside;
}
/// Return square distance between this and the given point
- boost::int64_t squareDistance(const Point2d& p) const
+ std::int64_t squareDistance(const Point2d& p) const
{
return squareDistance(*this, p);
}
/// Return distance between this and the given point
- boost::int32_t distance(const Point2d& p) const
+ std::int32_t distance(const Point2d& p) const
{
- return (boost::int32_t)( std::sqrt(
static_cast<double>(squareDistance(p)) ) );
+ return (std::int32_t)( std::sqrt(
static_cast<double>(squareDistance(p)) ) );
}
bool operator== (const Point2d& p) const
diff --git a/libbase/RTMP.cpp b/libbase/RTMP.cpp
index 4fb609f..213e87d 100644
--- a/libbase/RTMP.cpp
+++ b/libbase/RTMP.cpp
@@ -45,7 +45,7 @@ namespace {
bool sendBytesReceived(RTMP* r);
- void handleMetadata(RTMP& r, const boost::uint8_t *payload,
+ void handleMetadata(RTMP& r, const std::uint8_t *payload,
unsigned int len);
void handleChangeChunkSize(RTMP& r, const RTMPPacket& packet);
void handleControl(RTMP& r, const RTMPPacket& packet);
@@ -53,12 +53,12 @@ namespace {
void handleClientBW(RTMP& r, const RTMPPacket& packet);
void setupInvokePacket(RTMPPacket& packet);
- boost::uint32_t getUptime();
+ std::uint32_t getUptime();
- boost::int32_t decodeInt32LE(const boost::uint8_t* c);
- int encodeInt32LE(boost::uint8_t *output, int nVal);
- unsigned int decodeInt24(const boost::uint8_t* c);
- boost::uint8_t* encodeInt24(boost::uint8_t *output, boost::uint8_t *outend,
+ std::int32_t decodeInt32LE(const std::uint8_t* c);
+ int encodeInt32LE(std::uint8_t *output, int nVal);
+ unsigned int decodeInt24(const std::uint8_t* c);
+ std::uint8_t* encodeInt24(std::uint8_t *output, std::uint8_t *outend,
int nVal);
static const int packetSize[] = { 12, 8, 4, 1 };
@@ -72,7 +72,7 @@ namespace {
/// TODO: do this properly (it's currently not very random).
struct RandomByte
{
- boost::uint8_t operator()() const {
+ std::uint8_t operator()() const {
return std::rand() % 256;
}
};
@@ -111,8 +111,8 @@ private:
bool stage3();
Socket _socket;
- std::vector<boost::uint8_t> _sendBuf;
- std::vector<boost::uint8_t> _recvBuf;
+ std::vector<std::uint8_t> _sendBuf;
+ std::vector<std::uint8_t> _recvBuf;
bool _error;
bool _complete;
size_t _stage;
@@ -205,10 +205,10 @@ RTMP::connect(const URL& url)
const std::string& p = url.port();
// Default port.
- boost::uint16_t port = 1935;
+ std::uint16_t port = 1935;
if (!p.empty()) {
try {
- port = boost::lexical_cast<boost::uint16_t>(p);
+ port = boost::lexical_cast<std::uint16_t>(p);
}
catch (const boost::bad_lexical_cast&) {}
}
@@ -356,7 +356,7 @@ RTMP::handlePacket(const RTMPPacket& packet)
}
int
-RTMP::readSocket(boost::uint8_t* buffer, int n)
+RTMP::readSocket(std::uint8_t* buffer, int n)
{
assert(n >= 0);
@@ -427,8 +427,8 @@ RTMP::readPacketHeader(RTMPPacket& packet)
RTMPHeader& hr = packet.header;
- boost::uint8_t hbuf[RTMPHeader::headerSize] = { 0 };
- boost::uint8_t* header = hbuf;
+ std::uint8_t hbuf[RTMPHeader::headerSize] = { 0 };
+ std::uint8_t* header = hbuf;
// The first read may fail, but otherwise we expect a complete header.
if (readSocket(hbuf, 1) == 0) {
@@ -461,7 +461,7 @@ RTMP::readPacketHeader(RTMPPacket& packet)
return false;
}
- const boost::uint32_t tmp = (hbuf[2] << 8) + hbuf[1];
+ const std::uint32_t tmp = (hbuf[2] << 8) + hbuf[1];
hr.channel = tmp + 64;
log_debug("%s, channel: %0x", __FUNCTION__, hr.channel);
header += 2;
@@ -495,7 +495,7 @@ RTMP::readPacketHeader(RTMPPacket& packet)
if (nSize >= 3) {
- const boost::uint32_t timestamp = decodeInt24(header);
+ const std::uint32_t timestamp = decodeInt24(header);
// Make our packet timestamp absolute. If the value is 0xffffff,
// the absolute value comes later.
@@ -587,7 +587,7 @@ RTMP::sendPacket(RTMPPacket& packet)
hr.dataSize = payloadSize(packet);
// This is the timestamp for our message.
- const boost::uint32_t uptime = getUptime();
+ const std::uint32_t uptime = getUptime();
// Look at the previous packet on the channel.
bool prev = hasPacket(CHANNELS_OUT, hr.channel);
@@ -610,7 +610,7 @@ RTMP::sendPacket(RTMPPacket& packet)
const RTMPPacket& prevPacket = getPacket(CHANNELS_OUT, hr.channel);
const RTMPHeader& oldh = prevPacket.header;
- const boost::uint32_t prevTimestamp = oldh._timestamp;
+ const std::uint32_t prevTimestamp = oldh._timestamp;
// If this timestamp is later than the other and the difference fits
// in 3 bytes, encode a relative one.
@@ -644,10 +644,10 @@ RTMP::sendPacket(RTMPPacket& packet)
int nSize = packetSize[hr.headerType];
int hSize = nSize;
- boost::uint8_t* header;
- boost::uint8_t* hptr;
- boost::uint8_t* hend;
- boost::uint8_t c;
+ std::uint8_t* header;
+ std::uint8_t* hptr;
+ std::uint8_t* hend;
+ std::uint8_t c;
// If there is a payload, the same buffer is used to write the header.
// Otherwise a separate buffer is used. But as we write them separately
@@ -691,7 +691,7 @@ RTMP::sendPacket(RTMPPacket& packet)
if (hr.headerType == RTMP_PACKET_SIZE_LARGE && hr._timestamp >= 0xffffff) {
// Signify that the extended timestamp field is present.
- const boost::uint32_t t = 0xffffff;
+ const std::uint32_t t = 0xffffff;
hptr = encodeInt24(hptr, hend, t);
}
else if (hr.headerType != RTMP_PACKET_SIZE_MINIMUM) {
@@ -717,7 +717,7 @@ RTMP::sendPacket(RTMPPacket& packet)
}
nSize = hr.dataSize;
- boost::uint8_t *buffer = payloadData(packet);
+ std::uint8_t *buffer = payloadData(packet);
int nChunkSize = _outChunkSize;
std::string hx = hexify(header, payloadEnd(packet) - header, false);
@@ -767,8 +767,8 @@ RTMP::sendPacket(RTMPPacket& packet)
/* we invoked a remote method */
if (hr.packetType == PACKET_TYPE_INVOKE) {
assert(payloadData(packet)[0] == amf::STRING_AMF0);
- const boost::uint8_t* pos = payloadData(packet) + 1;
- const boost::uint8_t* end = payloadEnd(packet);
+ const std::uint8_t* pos = payloadData(packet) + 1;
+ const std::uint8_t* end = payloadEnd(packet);
const std::string& s = amf::readString(pos, end);
log_debug("Calling remote method %s", s);
}
@@ -814,9 +814,9 @@ HandShaker::HandShaker(Socket& s)
_sendBuf[0] = 0x03;
// TODO: do this properly.
- boost::uint32_t uptime = htonl(getUptime());
+ std::uint32_t uptime = htonl(getUptime());
- boost::uint8_t* ourSig = &_sendBuf.front() + 1;
+ std::uint8_t* ourSig = &_sendBuf.front() + 1;
std::memcpy(ourSig, &uptime, 4);
std::fill_n(ourSig + 4, 4, 0);
@@ -893,10 +893,10 @@ HandShaker::stage1()
_recvBuf[0], _sendBuf[0]);
}
- const boost::uint8_t* serverSig = &_recvBuf.front() + 1;
+ const std::uint8_t* serverSig = &_recvBuf.front() + 1;
// decode server response
- boost::uint32_t suptime;
+ std::uint32_t suptime;
std::memcpy(&suptime, serverSig, 4);
suptime = ntohl(suptime);
@@ -936,8 +936,8 @@ HandShaker::stage3()
assert(got == sigSize);
- const boost::uint8_t* serverSig = &_recvBuf.front();
- const boost::uint8_t* ourSig = &_sendBuf.front() + 1;
+ const std::uint8_t* serverSig = &_recvBuf.front();
+ const std::uint8_t* ourSig = &_sendBuf.front() + 1;
const bool match = std::equal(serverSig, serverSig + sigSize, ourSig);
@@ -1009,7 +1009,7 @@ sendBytesReceived(RTMP* r)
void
-handleMetadata(RTMP& /*r*/, const boost::uint8_t* /* payload*/,
+handleMetadata(RTMP& /*r*/, const std::uint8_t* /* payload*/,
unsigned int /*len*/)
{
return;
@@ -1086,7 +1086,7 @@ handleControl(RTMP& r, const RTMPPacket& packet)
void
handleServerBW(RTMP& r, const RTMPPacket& packet)
{
- const boost::uint32_t bw = amf::readNetworkLong(payloadData(packet));
+ const std::uint32_t bw = amf::readNetworkLong(payloadData(packet));
log_debug("Server bandwidth is %s", bw);
r.setServerBandwidth(bw);
}
@@ -1094,7 +1094,7 @@ handleServerBW(RTMP& r, const RTMPPacket& packet)
void
handleClientBW(RTMP& r, const RTMPPacket& packet)
{
- const boost::uint32_t bw = amf::readNetworkLong(payloadData(packet));
+ const std::uint32_t bw = amf::readNetworkLong(payloadData(packet));
r.setBandwidth(bw);
@@ -1106,14 +1106,14 @@ handleClientBW(RTMP& r, const RTMPPacket& packet)
-boost::int32_t
-decodeInt32LE(const boost::uint8_t* c)
+std::int32_t
+decodeInt32LE(const std::uint8_t* c)
{
return (c[3] << 24) | (c[2] << 16) | (c[1] << 8) | c[0];
}
int
-encodeInt32LE(boost::uint8_t *output, int nVal)
+encodeInt32LE(std::uint8_t *output, int nVal)
{
output[0] = nVal;
nVal >>= 8;
@@ -1136,15 +1136,15 @@ setupInvokePacket(RTMPPacket& packet)
}
unsigned int
-decodeInt24(const boost::uint8_t *c)
+decodeInt24(const std::uint8_t *c)
{
unsigned int val;
val = (c[0] << 16) | (c[1] << 8) | c[2];
return val;
}
-boost::uint8_t*
-encodeInt24(boost::uint8_t *output, boost::uint8_t *outend, int nVal)
+std::uint8_t*
+encodeInt24(std::uint8_t *output, std::uint8_t *outend, int nVal)
{
if (output + 3 > outend) return NULL;
@@ -1154,7 +1154,7 @@ encodeInt24(boost::uint8_t *output, boost::uint8_t
*outend, int nVal)
return output+3;
}
-boost::uint32_t
+std::uint32_t
getUptime()
{
// This function returns the uptime in milliseconds, which necessarily
diff --git a/libbase/RTMP.h b/libbase/RTMP.h
index 87f4692..0eacf87 100644
--- a/libbase/RTMP.h
+++ b/libbase/RTMP.h
@@ -19,7 +19,7 @@
#ifndef GNASH_RTMP_H
#define GNASH_RTMP_H
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <memory>
#include <deque>
#include <map>
@@ -171,10 +171,10 @@ struct RTMPHeader
//
/// This is encoded either as in the 3-byte relative timestamp field or the
/// 4 byte extended (absolute) timestamp field.
- boost::uint32_t _timestamp;
+ std::uint32_t _timestamp;
/// This seems to be used for NetStream.play.
- boost::uint32_t _streamID;
+ std::uint32_t _streamID;
size_t channel;
@@ -258,7 +258,7 @@ payloadSize(const RTMPPacket& p)
}
/// Access the payload data section of the buffer.
-inline boost::uint8_t*
+inline std::uint8_t*
payloadData(RTMPPacket& p)
{
assert(hasPayload(p));
@@ -267,7 +267,7 @@ payloadData(RTMPPacket& p)
}
/// Access the payload data section of the buffer.
-inline const boost::uint8_t*
+inline const std::uint8_t*
payloadData(const RTMPPacket& p)
{
assert(hasPayload(p));
@@ -280,7 +280,7 @@ payloadData(const RTMPPacket& p)
/// Note that this is only valid for packets we create, and for packets
/// we have fully read. Stored packets that have not yet received all data
/// have allocated space that has not yet been written.
-inline const boost::uint8_t*
+inline const std::uint8_t*
payloadEnd(const RTMPPacket& p)
{
assert(hasPayload(p));
@@ -435,7 +435,7 @@ struct DSOEXPORT RTMP
void handlePacket(const RTMPPacket& packet);
/// Read from the socket.
- int readSocket(boost::uint8_t* dst, int num);
+ int readSocket(std::uint8_t* dst, int num);
/// Send an RTMPPacket on the connection.
bool sendPacket(RTMPPacket& packet);
@@ -443,28 +443,28 @@ struct DSOEXPORT RTMP
/// Store the server bandwidth
//
/// Not sure why we need this.
- void setServerBandwidth(boost::uint32_t bw) {
+ void setServerBandwidth(std::uint32_t bw) {
_serverBandwidth = bw;
}
/// Get the stored server bandwidth.
- boost::uint32_t serverBandwidth() const {
+ std::uint32_t serverBandwidth() const {
return _serverBandwidth;
}
/// Store our bandwidth
- void setBandwidth(boost::uint32_t bw) {
+ void setBandwidth(std::uint32_t bw) {
_bandwidth = bw;
}
/// Get our bandwidth.
- boost::uint32_t bandwidth() const {
+ std::uint32_t bandwidth() const {
return _bandwidth;
}
int _inChunkSize;
int m_mediaChannel;
- boost::uint8_t m_nClientBW2;
+ std::uint8_t m_nClientBW2;
size_t _bytesIn;
size_t _bytesInSent;
@@ -516,10 +516,10 @@ private:
std::deque<std::shared_ptr<SimpleBuffer> > _flvQueue;
/// Stored server bandwidth (reported by server).
- boost::uint32_t _serverBandwidth;
+ std::uint32_t _serverBandwidth;
/// Stored client bandwidth (ours), reported by server.
- boost::uint32_t _bandwidth;
+ std::uint32_t _bandwidth;
/// Chunk size for sending.
size_t _outChunkSize;
diff --git a/libbase/Range2d.h b/libbase/Range2d.h
index a349096..5cffc7e 100644
--- a/libbase/Range2d.h
+++ b/libbase/Range2d.h
@@ -28,7 +28,7 @@
#include <algorithm>
#include <cassert> // for inlines
#include <cmath> // for floor / ceil
-#include <boost/cstdint.hpp>
+#include <cstdint>
namespace gnash {
@@ -55,8 +55,8 @@ enum RangeKind {
namespace detail {
template <typename U> struct Promote { typedef U type; };
template <> struct Promote<float> { typedef double type; };
- template <> struct Promote<int> { typedef boost::int64_t type; };
- template <> struct Promote<unsigned int> { typedef boost::uint64_t type; };
+ template <> struct Promote<int> { typedef std::int64_t type; };
+ template <> struct Promote<unsigned int> { typedef std::uint64_t type; };
}
/// 2d Range template class
diff --git a/libbase/SWFCtype.cpp b/libbase/SWFCtype.cpp
index b1e7104..d4722e1 100644
--- a/libbase/SWFCtype.cpp
+++ b/libbase/SWFCtype.cpp
@@ -23,14 +23,14 @@
#include <locale>
#include <boost/assign/list_of.hpp>
#include <map>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "log.h"
namespace gnash {
namespace {
- typedef std::map<boost::uint16_t, boost::uint16_t> CharMap;
+ typedef std::map<std::uint16_t, std::uint16_t> CharMap;
const CharMap& lowerMap();
const CharMap& upperMap();
}
diff --git a/libbase/SharedMem.h b/libbase/SharedMem.h
index 94672d9..eba821d 100644
--- a/libbase/SharedMem.h
+++ b/libbase/SharedMem.h
@@ -23,7 +23,7 @@
# include "gnashconfig.h"
#endif
-#include <boost/cstdint.hpp>
+#include <cstdint>
#if defined (WIN32)
// Include for HANDLE
@@ -46,7 +46,7 @@ class SharedMem
{
public:
- typedef boost::uint8_t* iterator;
+ typedef std::uint8_t* iterator;
/// The beginning of the SharedMem section.
//
diff --git a/libbase/SimpleBuffer.h b/libbase/SimpleBuffer.h
index 9f51d34..a4b0ac3 100644
--- a/libbase/SimpleBuffer.h
+++ b/libbase/SimpleBuffer.h
@@ -20,7 +20,7 @@
#define GNASH_SIMPLEBUFFER_H
-#include <boost/cstdint.hpp> // for boost::uint8_t
+#include <cstdint> // for std::uint8_t
#include <algorithm> // for std::copy
#include <memory>
#include <cassert>
@@ -53,7 +53,7 @@ public:
{
if ( _capacity )
{
- _data.reset(new boost::uint8_t[_capacity]);
+ _data.reset(new std::uint8_t[_capacity]);
}
}
@@ -70,7 +70,7 @@ public:
{
if ( _size )
{
- _data.reset(new boost::uint8_t[_size]);
+ _data.reset(new std::uint8_t[_size]);
std::copy(b.data(), b.data()+b.size(), _data.get());
}
}
@@ -99,10 +99,10 @@ public:
size_t capacity() const { return _capacity; }
/// Get a pointer to start of data. May be NULL if size==0.
- boost::uint8_t* data() { return _data.get(); }
+ std::uint8_t* data() { return _data.get(); }
/// Get a pointer to start of data. May be NULL if size==0.
- const boost::uint8_t* data() const { return _data.get(); }
+ const std::uint8_t* data() const { return _data.get(); }
/// Resize the buffer
void resize(size_t newSize)
@@ -119,10 +119,10 @@ public:
// TODO: use smalles power of 2 bigger then newCapacity
_capacity = std::max(newCapacity, _capacity*2);
- std::unique_ptr<boost::uint8_t[]> tmp;
+ std::unique_ptr<std::uint8_t[]> tmp;
tmp.swap(_data);
- _data.reset(new boost::uint8_t[_capacity]);
+ _data.reset(new std::uint8_t[_capacity]);
if ( tmp.get() )
{
@@ -143,8 +143,8 @@ public:
///
void append(const void* inData, size_t size)
{
- const boost::uint8_t* newData =
- reinterpret_cast<const boost::uint8_t*>(inData);
+ const std::uint8_t* newData =
+ reinterpret_cast<const std::uint8_t*>(inData);
size_t curSize = _size;
resize(curSize+size);
std::copy(newData, newData+size, _data.get()+curSize);
@@ -158,7 +158,7 @@ public:
/// @param b
/// Byte to append.
///
- void appendByte(const boost::uint8_t b)
+ void appendByte(const std::uint8_t b)
{
resize(_size + 1);
_data[_size - 1] = b;
@@ -172,7 +172,7 @@ public:
/// Short to append. Will be appended in network order. ie
/// with high order byte first.
///
- void appendNetworkShort(const boost::uint16_t s)
+ void appendNetworkShort(const std::uint16_t s)
{
resize(_size + 2);
_data[_size - 2] = s >> 8;
@@ -187,7 +187,7 @@ public:
/// Long to append. Will be appended in network order. ie
/// with high order bytes first.
///
- void appendNetworkLong(const boost::uint32_t l)
+ void appendNetworkLong(const std::uint32_t l)
{
resize(_size + 4);
_data[_size - 4] = l >> 24;
@@ -207,7 +207,7 @@ public:
void append(const SimpleBuffer& buf)
{
size_t incomingDataSize = buf.size();
- const boost::uint8_t* incomingData = buf.data();
+ const std::uint8_t* incomingData = buf.data();
append(incomingData, incomingDataSize);
}
@@ -215,7 +215,7 @@ private:
size_t _size;
size_t _capacity;
- std::unique_ptr<boost::uint8_t[]> _data;
+ std::unique_ptr<std::uint8_t[]> _data;
};
diff --git a/libbase/Socket.cpp b/libbase/Socket.cpp
index c87f823..f6ce306 100644
--- a/libbase/Socket.cpp
+++ b/libbase/Socket.cpp
@@ -27,7 +27,7 @@
#include <cerrno>
#include <csignal>
#include <boost/lexical_cast.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "GnashSystemNetHeaders.h"
#include "GnashSystemFDHeaders.h"
@@ -124,7 +124,7 @@ Socket::close()
namespace {
-addrinfo* getAddrInfo(const std::string& hostname, boost::uint16_t port)
+addrinfo* getAddrInfo(const std::string& hostname, std::uint16_t port)
{
addrinfo req = addrinfo(), *ans = 0;
@@ -145,7 +145,7 @@ addrinfo* getAddrInfo(const std::string& hostname,
boost::uint16_t port)
}
bool
-Socket::connect(const std::string& hostname, boost::uint16_t port)
+Socket::connect(const std::string& hostname, std::uint16_t port)
{
// We use _socket here because connected() or _connected might not
// be true if a connection attempt is underway but not completed.
diff --git a/libbase/Socket.h b/libbase/Socket.h
index c2d3121..b7abc0e 100644
--- a/libbase/Socket.h
+++ b/libbase/Socket.h
@@ -22,7 +22,7 @@
#define GNASH_SOCKET_H
#include "dsodefs.h"
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "IOChannel.h"
namespace gnash {
@@ -56,7 +56,7 @@ public:
/// @return false if the connection fails. In this case, the
/// Socket is still in a closed state and is ready for
/// a new connection attempt. Otherwise true.
- bool connect(const std::string& hostname, boost::uint16_t port);
+ bool connect(const std::string& hostname, std::uint16_t port);
/// Close the Socket.
//
diff --git a/libbase/WallClockTimer.cpp b/libbase/WallClockTimer.cpp
index ea29220..60454eb 100644
--- a/libbase/WallClockTimer.cpp
+++ b/libbase/WallClockTimer.cpp
@@ -35,10 +35,10 @@ WallClockTimer::restart()
startTimer = clocktime::getTicks();
}
-boost::uint32_t
+std::uint32_t
WallClockTimer::elapsed() const
{
- boost::uint64_t currTime = clocktime::getTicks();
+ std::uint64_t currTime = clocktime::getTicks();
// be aware of time glitches
if ( currTime <= startTimer ) return 0;
diff --git a/libbase/WallClockTimer.h b/libbase/WallClockTimer.h
index 2ef642a..ddf92c4 100644
--- a/libbase/WallClockTimer.h
+++ b/libbase/WallClockTimer.h
@@ -23,7 +23,7 @@
#include "dsodefs.h" // for DSOEXPORT
-#include <boost/cstdint.hpp>
+#include <cstdint>
namespace gnash {
@@ -39,14 +39,14 @@ public:
/// \brief
/// Return time elapsed in milliseconds since construction
/// or last call to ::restart()
- boost::uint32_t elapsed() const;
+ std::uint32_t elapsed() const;
/// Restart the timer
void restart();
private:
- boost::uint64_t startTimer;
+ std::uint64_t startTimer;
};
diff --git a/libbase/log.cpp b/libbase/log.cpp
index 00958aa..be0b364 100644
--- a/libbase/log.cpp
+++ b/libbase/log.cpp
@@ -90,7 +90,7 @@ namespace {
LogFile& dbglogfile = LogFile::getDefaultInstance();
struct Timestamp {
- boost::uint64_t startTicks;
+ std::uint64_t startTicks;
std::map<int, int> threadMap;
Timestamp() : startTicks(clocktime::getTicks()) {}
};
@@ -104,7 +104,7 @@ namespace {
// TODO: notify actual thread id for index
}
- boost::uint64_t diff = clocktime::getTicks() - t.startTicks;
+ std::uint64_t diff = clocktime::getTicks() - t.startTicks;
// should we split in seconds/ms ?
o << getpid() << ":" << htid << "] " << diff;
diff --git a/libbase/rc.cpp b/libbase/rc.cpp
index 1ff2ab9..3acc625 100644
--- a/libbase/rc.cpp
+++ b/libbase/rc.cpp
@@ -25,7 +25,7 @@
#include "rc.h"
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <limits>
#include <cstdlib> // getenv
#include <string>
diff --git a/libbase/rc.h b/libbase/rc.h
index 89769fd..34b3ce1 100644
--- a/libbase/rc.h
+++ b/libbase/rc.h
@@ -25,7 +25,7 @@
#include <vector>
#include <iosfwd>
#include <sstream>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/tokenizer.hpp>
#include "StringPredicates.h"
@@ -34,7 +34,7 @@
#include <sys/shm.h>
#else
#ifdef _WIN32
- typedef boost::uint32_t key_t;
+ typedef std::uint32_t key_t;
#endif // _WIN32
#endif // _WIN32 and __HAIKU__
@@ -442,10 +442,10 @@ protected:
typedef boost::tokenizer< Sep > Tok;
/// The timer delay
- boost::uint32_t _delay;
+ std::uint32_t _delay;
/// Max number of movie clips to store in the library
- boost::uint32_t _movieLibraryLimit;
+ std::uint32_t _movieLibraryLimit;
/// Enable debugging of this class
bool _debug;
@@ -454,7 +454,7 @@ protected:
bool _debugger;
/// Level of debugging output
- boost::uint32_t _verbosity;
+ std::uint32_t _verbosity;
/// Command format to use to open urls
//
@@ -562,7 +562,7 @@ protected:
/// Shared memory segment key (can be set for
/// compatibility with other players.)
- boost::uint32_t _lcshmkey;
+ std::uint32_t _lcshmkey;
/// Whether the player should respond to fscommands
/// (showmenu, quit etc)
diff --git a/libbase/snappingrange.h b/libbase/snappingrange.h
index 111ceaa..d265190 100644
--- a/libbase/snappingrange.h
+++ b/libbase/snappingrange.h
@@ -26,7 +26,7 @@
#include <iterator>
#include <algorithm>
#include <ostream>
-#include <boost/cstdint.hpp>
+#include <cstdint>
namespace gnash {
@@ -652,7 +652,7 @@ inline bool snaptest(const geometry::Range2d<T>& range1,
} // namespace geometry
/// Standard snapping 2d ranges type for invalidated bounds calculation
-typedef geometry::SnappingRanges2d<boost::int32_t> InvalidatedRanges;
+typedef geometry::SnappingRanges2d<std::int32_t> InvalidatedRanges;
} //namespace gnash
diff --git a/libbase/tu_file.cpp b/libbase/tu_file.cpp
index fb80973..10e08ed 100644
--- a/libbase/tu_file.cpp
+++ b/libbase/tu_file.cpp
@@ -34,13 +34,13 @@ public:
/// TODO: define what happens when the stream
/// is in error condition.
///
- boost::uint32_t read_le32()
+ std::uint32_t read_le32()
{
- // read_byte() is boost::uint8_t, so no masks with 0xff are
required.
- boost::uint32_t result = static_cast<boost::uint32_t>(read_byte());
- result |= static_cast<boost::uint32_t>(read_byte()) << 8;
- result |= static_cast<boost::uint32_t>(read_byte()) << 16;
- result |= static_cast<boost::uint32_t>(read_byte()) << 24;
+ // read_byte() is std::uint8_t, so no masks with 0xff are required.
+ std::uint32_t result = static_cast<std::uint32_t>(read_byte());
+ result |= static_cast<std::uint32_t>(read_byte()) << 8;
+ result |= static_cast<std::uint32_t>(read_byte()) << 16;
+ result |= static_cast<std::uint32_t>(read_byte()) << 24;
return(result);
}
@@ -49,10 +49,10 @@ public:
/// TODO: define what happens when the stream
/// is in error condition, see bad().
///
- boost::uint16_t read_le16()
+ std::uint16_t read_le16()
{
- boost::uint16_t result = static_cast<boost::uint16_t>(read_byte());
- result |= static_cast<boost::uint16_t>(read_byte()) << 8;
+ std::uint16_t result = static_cast<std::uint16_t>(read_byte());
+ result |= static_cast<std::uint16_t>(read_byte()) << 8;
return(result);
}
@@ -61,8 +61,8 @@ public:
/// TODO: define what happens when the stream
/// is in error condition, see bad().
///
- boost::uint8_t read_byte() {
- boost::uint8_t u;
+ std::uint8_t read_byte() {
+ std::uint8_t u;
read(&u, 1);
return u;
}
diff --git a/libbase/utf8.cpp b/libbase/utf8.cpp
index 31f3c8e..3d708b8 100644
--- a/libbase/utf8.cpp
+++ b/libbase/utf8.cpp
@@ -23,7 +23,7 @@
#include "utf8.h"
#include <limits>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <string>
#include <vector>
#include <cstdlib>
@@ -32,7 +32,7 @@ namespace gnash {
namespace utf8 {
namespace {
- const boost::uint32_t invalid =
std::numeric_limits<boost::uint32_t>::max();
+ const std::uint32_t invalid = std::numeric_limits<std::uint32_t>::max();
}
std::wstring
@@ -44,7 +44,7 @@ decodeCanonicalString(const std::string& str, int version)
std::string::const_iterator it = str.begin(), e = str.end();
if (version > 5) {
- while (boost::uint32_t code = decodeNextUnicodeCharacter(it, e)) {
+ while (std::uint32_t code = decodeNextUnicodeCharacter(it, e)) {
if (code == invalid) {
continue;
}
@@ -81,7 +81,7 @@ encodeCanonicalString(const std::wstring& wstr, int version)
}
std::string
-encodeLatin1Character(boost::uint32_t ucsCharacter)
+encodeLatin1Character(std::uint32_t ucsCharacter)
{
std::string text;
text.push_back(static_cast<unsigned char>(ucsCharacter));
@@ -89,11 +89,11 @@ encodeLatin1Character(boost::uint32_t ucsCharacter)
}
-boost::uint32_t
+std::uint32_t
decodeNextUnicodeCharacter(std::string::const_iterator& it,
const std::string::const_iterator& e)
{
- boost::uint32_t uc;
+ std::uint32_t uc;
// Security considerations:
//
@@ -123,7 +123,7 @@ decodeNextUnicodeCharacter(std::string::const_iterator& it,
if (it == e || *it == 0) return 0; // End of buffer. Do not advance.
// Conventional 7-bit ASCII; return and increment iterator:
- if ((*it & 0x80) == 0) return static_cast<boost::uint32_t>(*it++);
+ if ((*it & 0x80) == 0) return static_cast<std::uint32_t>(*it++);
// Multi-byte sequences
if ((*it & 0xE0) == 0xC0) {
@@ -162,7 +162,7 @@ decodeNextUnicodeCharacter(std::string::const_iterator& it,
// TODO: buffer as std::string; index (iterator);
std::string
-encodeUnicodeCharacter(boost::uint32_t ucs_character)
+encodeUnicodeCharacter(std::uint32_t ucs_character)
{
std::string text;
@@ -295,7 +295,7 @@ guessEncoding(const std::string &str, int &length,
std::vector<int>& offsets)
offsets.push_back(it - str.begin()); // current position
// Advances the iterator to point to the next
- boost::uint32_t c = utf8::decodeNextUnicodeCharacter(it, e);
+ std::uint32_t c = utf8::decodeNextUnicodeCharacter(it, e);
if (c == utf8::invalid) {
is_sought = false;
diff --git a/libbase/utf8.h b/libbase/utf8.h
index 2be2711..6305223 100644
--- a/libbase/utf8.h
+++ b/libbase/utf8.h
@@ -22,7 +22,7 @@
#define UTF8_H
#include <string>
-#include <boost/cstdint.hpp> // for C99 int types
+#include <cstdint> // for C99 int types
#include <vector>
#include "dsodefs.h" // For DSOEXPORT
@@ -98,18 +98,18 @@ namespace utf8 {
/// as output. Advances string iterator past the character
/// returned, unless the returned character is '\0', in which
/// case the iterator does not advance.
- DSOEXPORT boost::uint32_t
decodeNextUnicodeCharacter(std::string::const_iterator& it,
+ DSOEXPORT std::uint32_t
decodeNextUnicodeCharacter(std::string::const_iterator& it,
const
std::string::const_iterator& e);
/// \brief Encodes the given wide character into a canonical
/// string, theoretically up to 6 chars in length.
- DSOEXPORT std::string encodeUnicodeCharacter(boost::uint32_t
ucs_character);
+ DSOEXPORT std::string encodeUnicodeCharacter(std::uint32_t ucs_character);
/// Encodes the given wide character into an at least 8-bit character.
//
/// Allows storage of Latin1 (ISO-8859-1) characters. This
/// is the format of SWF5 and below.
- DSOEXPORT std::string encodeLatin1Character(boost::uint32_t ucsCharacter);
+ DSOEXPORT std::string encodeLatin1Character(std::uint32_t ucsCharacter);
enum TextEncoding {
encUNSPECIFIED,
diff --git a/libcore/AMFConverter.cpp b/libcore/AMFConverter.cpp
index da68fb6..66975ba 100644
--- a/libcore/AMFConverter.cpp
+++ b/libcore/AMFConverter.cpp
@@ -159,7 +159,7 @@ Writer::writeObject(as_object* obj)
writePlainNumber(_buf, d);
// This should be timezone
- boost::uint16_t tz = 0;
+ std::uint16_t tz = 0;
_buf.appendNetworkShort(tz);
return true;
@@ -290,7 +290,7 @@ Writer::writeNull()
}
void
-Writer::writeData(const boost::uint8_t* data, size_t length)
+Writer::writeData(const std::uint8_t* data, size_t length)
{
_buf.append(data, length);
}
@@ -407,7 +407,7 @@ Reader::readStrictArray()
throw AMFException(_("Read past _end of buffer for strict array
length"));
}
- const boost::uint32_t li = readNetworkLong(_pos);
+ const std::uint32_t li = readNetworkLong(_pos);
_pos += 4;
#ifdef GNASH_DEBUG_AMF_DESERIALIZE
@@ -442,7 +442,7 @@ Reader::readArray()
throw AMFException(_("Read past _end of buffer for array length"));
}
- const boost::uint32_t li = readNetworkLong(_pos);
+ const std::uint32_t li = readNetworkLong(_pos);
_pos += 4;
as_object* array = _global.createArray();
@@ -469,7 +469,7 @@ Reader::readArray()
"block"));
break;
}
- const boost::uint16_t strlen = readNetworkShort(_pos);
+ const std::uint16_t strlen = readNetworkShort(_pos);
_pos += 2;
// _end of ECMA_ARRAY is signalled by an empty string
@@ -556,7 +556,7 @@ Reader::readReference()
if (_end - _pos < 2) {
throw AMFException("Read past _end of buffer for reference index");
}
- const boost::uint16_t si = readNetworkShort(_pos);
+ const std::uint16_t si = readNetworkShort(_pos);
_pos += 2;
#ifdef GNASH_DEBUG_AMF_DESERIALIZE
@@ -592,7 +592,7 @@ Reader::readDate()
throw AMFException("premature _end of input reading "
"timezone from Date type");
}
- const boost::uint16_t tz = readNetworkShort(_pos);
+ const std::uint16_t tz = readNetworkShort(_pos);
if (tz != 0) {
log_error(_("Date type encoded timezone info %1%, even though "
"this field should not be used."), tz);
diff --git a/libcore/AMFConverter.h b/libcore/AMFConverter.h
index 4b08aee..fc16ef2 100644
--- a/libcore/AMFConverter.h
+++ b/libcore/AMFConverter.h
@@ -92,7 +92,7 @@ public:
bool writePropertyName(const std::string& name);
/// Write custom data for special cases.
- void writeData(const boost::uint8_t* data, size_t length);
+ void writeData(const std::uint8_t* data, size_t length);
private:
@@ -132,7 +132,7 @@ public:
/// ensure that pos is not greater than end on every read.
/// @param end The end of the buffer.
/// @param gl A global reference for creating objects when necessary.
- Reader(const boost::uint8_t*& pos, const boost::uint8_t* end, Global_as&
gl)
+ Reader(const std::uint8_t*& pos, const std::uint8_t* end, Global_as& gl)
:
_pos(pos),
_end(end),
@@ -172,10 +172,10 @@ private:
std::vector<as_object*> _objectRefs;
/// The current position in the buffer.
- const boost::uint8_t*& _pos;
+ const std::uint8_t*& _pos;
/// The end of the buffer.
- const boost::uint8_t* const _end;
+ const std::uint8_t* const _end;
/// For creating objects if necessary.
Global_as& _global;
diff --git a/libcore/Bitmap.cpp b/libcore/Bitmap.cpp
index cad8767..a0ab5bc 100644
--- a/libcore/Bitmap.cpp
+++ b/libcore/Bitmap.cpp
@@ -105,7 +105,7 @@ Bitmap::construct(as_object* /*init*/)
}
bool
-Bitmap::pointInShape(boost::int32_t x, boost::int32_t y) const
+Bitmap::pointInShape(std::int32_t x, std::int32_t y) const
{
return pointInBounds(x, y);
}
diff --git a/libcore/Bitmap.h b/libcore/Bitmap.h
index b0f4628..9db7c1c 100644
--- a/libcore/Bitmap.h
+++ b/libcore/Bitmap.h
@@ -72,7 +72,7 @@ public:
virtual SWFRect getBounds() const;
/// Test whether a point is in the Bitmap's bounds.
- virtual bool pointInShape(boost::int32_t x, boost::int32_t y) const;
+ virtual bool pointInShape(std::int32_t x, std::int32_t y) const;
/// Called when the object is placed on stage.
virtual void construct(as_object* init = 0);
diff --git a/libcore/Button.cpp b/libcore/Button.cpp
index dee3297..2be5f77 100644
--- a/libcore/Button.cpp
+++ b/libcore/Button.cpp
@@ -380,7 +380,7 @@ Button::display(Renderer& renderer, const Transform& base)
// Return the topmost entity that the given point covers. NULL if none.
// I.e. check against ourself.
InteractiveObject*
-Button::topmostMouseEntity(boost::int32_t x, boost::int32_t y)
+Button::topmostMouseEntity(std::int32_t x, std::int32_t y)
{
if (!visible() || !isEnabled())
{
@@ -765,7 +765,7 @@ Button::getBounds() const
}
bool
-Button::pointInShape(boost::int32_t x, boost::int32_t y) const
+Button::pointInShape(std::int32_t x, std::int32_t y) const
{
typedef std::vector<const DisplayObject*> Chars;
Chars actChars;
diff --git a/libcore/Button.h b/libcore/Button.h
index 1414564..490ce01 100644
--- a/libcore/Button.h
+++ b/libcore/Button.h
@@ -94,8 +94,8 @@ public:
/// Return the topmost entity that the given point covers. NULL if none.
//
/// I.e. check against ourself.
- virtual InteractiveObject* topmostMouseEntity(boost::int32_t x,
- boost::int32_t y);
+ virtual InteractiveObject* topmostMouseEntity(std::int32_t x,
+ std::int32_t y);
/// Called whenever a mouse event affects this Button.
virtual void mouseEvent(const event_id& event);
@@ -108,7 +108,7 @@ public:
virtual SWFRect getBounds() const;
// See dox in DisplayObject.h
- bool pointInShape(boost::int32_t x, boost::int32_t y) const;
+ bool pointInShape(std::int32_t x, std::int32_t y) const;
bool isEnabled();
diff --git a/libcore/DisplayList.cpp b/libcore/DisplayList.cpp
index 65ae876..418909f 100644
--- a/libcore/DisplayList.cpp
+++ b/libcore/DisplayList.cpp
@@ -298,7 +298,7 @@ DisplayList::replaceDisplayObject(DisplayObject* ch, int
depth,
// the specified depth.
void
DisplayList::moveDisplayObject(int depth, const SWFCxForm* color_xform,
- const SWFMatrix* mat, boost::uint16_t* ratio)
+ const SWFMatrix* mat, std::uint16_t* ratio)
{
testInvariant();
diff --git a/libcore/DisplayList.h b/libcore/DisplayList.h
index 14aedf0..1611312 100644
--- a/libcore/DisplayList.h
+++ b/libcore/DisplayList.h
@@ -161,7 +161,7 @@ public:
/// The new ratio value to assign to the DisplayObject at the given
depth.
/// If NULL the original ratio will be kept.
void moveDisplayObject(int depth, const SWFCxForm* color_xform,
- const SWFMatrix* mat, boost::uint16_t* ratio);
+ const SWFMatrix* mat, std::uint16_t* ratio);
/// Removes the object at the specified depth.
//
diff --git a/libcore/DisplayObject.cpp b/libcore/DisplayObject.cpp
index e04a88f..c7c7cdf 100644
--- a/libcore/DisplayObject.cpp
+++ b/libcore/DisplayObject.cpp
@@ -1256,12 +1256,12 @@ setAlpha(DisplayObject& o, const as_value& val)
SWFCxForm cx = getCxForm(o);
// Overflows are *not* truncated, but set to -32768.
- if (newAlpha > std::numeric_limits<boost::int16_t>::max() ||
- newAlpha < std::numeric_limits<boost::int16_t>::min()) {
- cx.aa = std::numeric_limits<boost::int16_t>::min();
+ if (newAlpha > std::numeric_limits<std::int16_t>::max() ||
+ newAlpha < std::numeric_limits<std::int16_t>::min()) {
+ cx.aa = std::numeric_limits<std::int16_t>::min();
}
else {
- cx.aa = static_cast<boost::int16_t>(newAlpha);
+ cx.aa = static_cast<std::int16_t>(newAlpha);
}
o.setCxForm(cx);
@@ -1273,7 +1273,7 @@ as_value
getMouseX(DisplayObject& o)
{
// Local coord of mouse IN PIXELS.
- boost::int32_t x, y;
+ std::int32_t x, y;
boost::tie(x, y) = getRoot(*getObject(&o)).mousePosition();
SWFMatrix m = getWorldMatrix(o);
@@ -1287,7 +1287,7 @@ as_value
getMouseY(DisplayObject& o)
{
// Local coord of mouse IN PIXELS.
- boost::int32_t x, y;
+ std::int32_t x, y;
boost::tie(x, y) = getRoot(*getObject(&o)).mousePosition();
SWFMatrix m = getWorldMatrix(o);
diff --git a/libcore/DisplayObject.h b/libcore/DisplayObject.h
index 13df4e5..7196461 100644
--- a/libcore/DisplayObject.h
+++ b/libcore/DisplayObject.h
@@ -28,7 +28,7 @@
#include <map>
#include <string>
#include <cassert>
-#include <boost/cstdint.hpp> // For C99 int types
+#include <cstdint> // For C99 int types
#include <boost/noncopyable.hpp>
#include <boost/logic/tribool.hpp>
@@ -357,9 +357,9 @@ public:
}
}
- boost::uint16_t get_ratio() const { return _ratio; }
+ std::uint16_t get_ratio() const { return _ratio; }
- void set_ratio(boost::uint16_t r) {
+ void set_ratio(std::uint16_t r) {
if (r != _ratio) set_invalidated();
_ratio = r;
}
@@ -485,7 +485,7 @@ public:
/// @param y Point y coordinate in world space
/// @return Whether (x, y) is within the DisplayObject's bounds.
/// This ignores _root's transform.
- bool pointInBounds(boost::int32_t x, boost::int32_t y) const
+ bool pointInBounds(std::int32_t x, std::int32_t y) const
{
SWFRect bounds = getBounds();
const SWFMatrix wm = getWorldMatrix(*this, false);
@@ -498,7 +498,7 @@ public:
/// @param x Point x coordinate in world space
/// @param y Point y coordinate in world space
/// @return Whether (x, y) is within the DisplayObject's bounds.
- virtual bool pointInShape(boost::int32_t x, boost::int32_t y) const =
0;
+ virtual bool pointInShape(std::int32_t x, std::int32_t y) const = 0;
/// true if the given point falls in this DisplayObject's visible shape
//
@@ -512,7 +512,7 @@ public:
/// DisplayObject has childs it must take into account the case
/// in which some childs are visible and some are not.
///
- virtual bool pointInVisibleShape(boost::int32_t x, boost::int32_t y) const
+ virtual bool pointInVisibleShape(std::int32_t x, std::int32_t y) const
{
if (!visible()) return false;
if (isDynamicMask() || isMaskLayer()) return false;
@@ -634,8 +634,8 @@ public:
/// DisplayObjects are not a mouse entity by default.
//
/// Override this function for InteractiveObjects.
- virtual InteractiveObject* topmostMouseEntity(boost::int32_t,
- boost::int32_t) {
+ virtual InteractiveObject* topmostMouseEntity(std::int32_t,
+ std::int32_t) {
return 0;
}
@@ -643,8 +643,8 @@ public:
/// point and is not the DisplayObject being dragged or any of its childs.
//
/// Point coordinates in global twips.
- virtual const DisplayObject* findDropTarget(boost::int32_t x,
- boost::int32_t y, DisplayObject* dragging) const
+ virtual const DisplayObject* findDropTarget(std::int32_t x,
+ std::int32_t y, DisplayObject* dragging) const
{
if (this != dragging && visible() && pointInVisibleShape(x, y)) {
return this;
@@ -1049,7 +1049,7 @@ private:
double _xscale, _yscale, _rotation;
/// The depth of this DisplayObject.
- boost::int32_t _depth;
+ std::int32_t _depth;
boost::tribool _focusRect;
@@ -1063,7 +1063,7 @@ private:
///
int _volume;
- boost::uint16_t _ratio;
+ std::uint16_t _ratio;
int m_clip_depth;
/// The DisplayObject masking this instance (if any)
diff --git a/libcore/DragState.h b/libcore/DragState.h
index 251f74d..6f7eac0 100644
--- a/libcore/DragState.h
+++ b/libcore/DragState.h
@@ -53,13 +53,13 @@ public:
/// at time of drag start.
/// Coordinates are in stage space (twips)
///
- void setOffset(boost::int32_t x, boost::int32_t y) {
+ void setOffset(std::int32_t x, std::int32_t y) {
_xoffset = x;
_yoffset = y;
}
- boost::int32_t xOffset() const { return _xoffset; }
- boost::int32_t yOffset() const { return _yoffset; }
+ std::int32_t xOffset() const { return _xoffset; }
+ std::int32_t yOffset() const { return _yoffset; }
bool hasBounds() const {
return (_bounds);
@@ -120,8 +120,8 @@ private:
/// at time of drag start. These are used for non
/// lock-centered dragging.
/// Coordinates are in stage space (TWIPS)
- boost::int32_t _xoffset;
- boost::int32_t _yoffset;
+ std::int32_t _xoffset;
+ std::int32_t _yoffset;
};
diff --git a/libcore/DynamicShape.cpp b/libcore/DynamicShape.cpp
index 0103b60..ab5c774 100644
--- a/libcore/DynamicShape.cpp
+++ b/libcore/DynamicShape.cpp
@@ -160,7 +160,7 @@ DynamicShape::finalize() const
}
void
-DynamicShape::lineStyle(boost::uint16_t thickness, const rgba& color,
+DynamicShape::lineStyle(std::uint16_t thickness, const rgba& color,
bool vScale, bool hScale, bool pixelHinting, bool noClose,
CapStyle startCapStyle, CapStyle endCapStyle,
JoinStyle joinStyle, float miterLimitFactor)
@@ -181,7 +181,7 @@ DynamicShape::resetLineStyle()
}
void
-DynamicShape::moveTo(boost::int32_t x, boost::int32_t y)
+DynamicShape::moveTo(std::int32_t x, std::int32_t y)
{
// It was manually tested that a moveTo, even
// when moving to the same point of current cursor,
@@ -193,7 +193,7 @@ DynamicShape::moveTo(boost::int32_t x, boost::int32_t y)
}
void
-DynamicShape::lineTo(boost::int32_t x, boost::int32_t y, int swfVersion)
+DynamicShape::lineTo(std::int32_t x, std::int32_t y, int swfVersion)
{
if (!_currpath) startNewPath(false);
assert(_currpath);
@@ -224,8 +224,8 @@ DynamicShape::lineTo(boost::int32_t x, boost::int32_t y,
int swfVersion)
}
void
-DynamicShape::curveTo(boost::int32_t cx, boost::int32_t cy,
- boost::int32_t ax, boost::int32_t ay, int swfVersion)
+DynamicShape::curveTo(std::int32_t cx, std::int32_t cy,
+ std::int32_t ax, std::int32_t ay, int swfVersion)
{
if (!_currpath) startNewPath(false);
assert(_currpath);
diff --git a/libcore/DynamicShape.h b/libcore/DynamicShape.h
index c082c23..823928e 100644
--- a/libcore/DynamicShape.h
+++ b/libcore/DynamicShape.h
@@ -53,16 +53,16 @@ public:
void clear();
/// Move pen to given coordinates
- void moveTo(boost::int32_t x, boost::int32_t y);
+ void moveTo(std::int32_t x, std::int32_t y);
/// Draw a straight line from current position to given one
- void lineTo(boost::int32_t x, boost::int32_t y, int swfVersion);
+ void lineTo(std::int32_t x, std::int32_t y, int swfVersion);
/// \brief
/// Draw a curve from current position to given one
/// using given control points.
- void curveTo(boost::int32_t cx, boost::int32_t cy,
- boost::int32_t ax, boost::int32_t ay, int swfVersion);
+ void curveTo(std::int32_t cx, std::int32_t cy,
+ std::int32_t ax, std::int32_t ay, int swfVersion);
/// Start drawing with a solid fill
void beginFill(const FillStyle& f);
@@ -92,7 +92,7 @@ public:
/// @param endCapStyle
/// @param joinStyle
/// @param miterLimitFactor
- void lineStyle(boost::uint16_t thickness, const rgba& color,
+ void lineStyle(std::uint16_t thickness, const rgba& color,
bool vScale=true, bool hScale=true,
bool pixelHinting=false,
bool noClose=false,
@@ -143,7 +143,7 @@ public:
// would result in a triangle and a stroke, which should fail the
last hitTest(2,8).
//
//
- bool pointTestLocal(boost::int32_t x, boost::int32_t y,
+ bool pointTestLocal(std::int32_t x, std::int32_t y,
const SWFMatrix& wm) const
{
finalize();
@@ -189,10 +189,10 @@ private:
size_t _currline;
// Current pen X position
- boost::int32_t _x;
+ std::int32_t _x;
// Current pen Y position
- boost::int32_t _y;
+ std::int32_t _y;
mutable bool _changed;
diff --git a/libcore/FillStyle.cpp b/libcore/FillStyle.cpp
index c212ac7..4af450b 100644
--- a/libcore/FillStyle.cpp
+++ b/libcore/FillStyle.cpp
@@ -113,7 +113,7 @@ BitmapFill::BitmapFill(Type t, const CachedBitmap* bi,
const SWFMatrix& m,
}
BitmapFill::BitmapFill(SWF::FillType t, movie_definition* md,
- boost::uint16_t id, const SWFMatrix& m)
+ std::uint16_t id, const SWFMatrix& m)
:
_type(),
_smoothingPolicy(),
diff --git a/libcore/FillStyle.h b/libcore/FillStyle.h
index 01068d1..1e8a872 100644
--- a/libcore/FillStyle.h
+++ b/libcore/FillStyle.h
@@ -40,14 +40,14 @@ namespace gnash {
class GradientRecord
{
public:
- GradientRecord(boost::uint8_t ratio, const rgba& color)
+ GradientRecord(std::uint8_t ratio, const rgba& color)
:
ratio(ratio),
color(color)
{ }
//data:
- boost::uint8_t ratio;
+ std::uint8_t ratio;
rgba color;
};
@@ -94,7 +94,7 @@ public:
SmoothingPolicy pol);
/// Construct a static BitmapFill using a SWF tag.
- BitmapFill(SWF::FillType t, movie_definition* md, boost::uint16_t id,
+ BitmapFill(SWF::FillType t, movie_definition* md, std::uint16_t id,
const SWFMatrix& m);
/// Destructor
@@ -146,7 +146,7 @@ private:
movie_definition* _md;
// The id of the tag containing the bitmap
- boost::uint16_t _id;
+ std::uint16_t _id;
};
/// A GradientFill
diff --git a/libcore/Filters.h b/libcore/Filters.h
index a22743d..5c1e09e 100644
--- a/libcore/Filters.h
+++ b/libcore/Filters.h
@@ -20,7 +20,7 @@
#ifndef GNASH_FILTERS_H
#define GNASH_FILTERS_H
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <vector>
namespace gnash {
@@ -72,10 +72,10 @@ public:
m_knockout(false)
{}
- BevelFilter(float distance, float angle, boost::uint32_t hcolor,
- boost::uint8_t halpha, boost::uint32_t scolor, boost::uint8_t salpha,
+ BevelFilter(float distance, float angle, std::uint32_t hcolor,
+ std::uint8_t halpha, std::uint32_t scolor, std::uint8_t salpha,
float blurX, float blurY, float strength,
- boost::uint8_t quality, bevel_type type, bool knockout) :
+ std::uint8_t quality, bevel_type type, bool knockout) :
m_distance(distance), m_angle(angle), m_highlightColor(hcolor),
m_highlightAlpha(halpha), m_shadowColor(scolor), m_shadowAlpha(salpha),
m_blurX(blurX), m_blurY(blurY), m_strength(strength),
@@ -84,14 +84,14 @@ public:
float m_distance; // Distance of the filter in pixels.
float m_angle; // Angle of the filter.
- boost::uint32_t m_highlightColor; // Color of the highlight.
- boost::uint8_t m_highlightAlpha; // Alpha of the highlight.
- boost::uint32_t m_shadowColor; // RGB color.
- boost::uint8_t m_shadowAlpha; // Alpha strength, as a percentage(?)
+ std::uint32_t m_highlightColor; // Color of the highlight.
+ std::uint8_t m_highlightAlpha; // Alpha of the highlight.
+ std::uint32_t m_shadowColor; // RGB color.
+ std::uint8_t m_shadowAlpha; // Alpha strength, as a percentage(?)
float m_blurX; // horizontal blur
float m_blurY; // vertical blur
float m_strength; // How strong is the filter.
- boost::uint8_t m_quality; // How many times to apply the filter.
+ std::uint8_t m_quality; // How many times to apply the filter.
bevel_type m_type; // The type of filter. (Rendered as string in AS)
bool m_knockout; // If true, render only the filter effect.
};
@@ -109,13 +109,13 @@ public:
m_blurX(0.0f), m_blurY(0.0f), m_quality(0)
{}
- BlurFilter(float blurX, float blurY, boost::uint8_t quality) :
+ BlurFilter(float blurX, float blurY, std::uint8_t quality) :
m_blurX(blurX), m_blurY(blurY), m_quality(quality)
{}
float m_blurX; // How much horizontal blur.
float m_blurY; // How much vertical blur.
- boost::uint8_t m_quality; // How many passes to take.
+ std::uint8_t m_quality; // How many passes to take.
};
// A color SWFMatrix effect filter.
@@ -162,10 +162,10 @@ public:
_alpha()
{}
- ConvolutionFilter(boost::uint8_t matrixX, boost::uint8_t matrixY,
+ ConvolutionFilter(std::uint8_t matrixX, std::uint8_t matrixY,
const std::vector<float>& _matrix, float divisor, float bias,
- bool preserveAlpha, bool clamp, boost::uint32_t color,
- boost::uint8_t alpha)
+ bool preserveAlpha, bool clamp, std::uint32_t color,
+ std::uint8_t alpha)
:
_matrixX(matrixX),
_matrixY(matrixY),
@@ -179,15 +179,15 @@ public:
{}
protected:
- boost::uint8_t _matrixX; // Number of columns
- boost::uint8_t _matrixY; // Number of rows
+ std::uint8_t _matrixX; // Number of columns
+ std::uint8_t _matrixY; // Number of rows
std::vector<float> _matrix; // The convolution matrix
float _divisor;
float _bias;
bool _preserveAlpha; // If true, don't convolute the alpha channel
bool _clamp; // Whether or not to clamp
- boost::uint32_t _color; // For off-image pixels
- boost::uint8_t _alpha; // For off-image pixels
+ std::uint32_t _color; // For off-image pixels
+ std::uint8_t _alpha; // For off-image pixels
};
// A drop shadow effect filter.
@@ -205,9 +205,9 @@ public:
m_inner(false), m_knockout(false), m_hideObject(false)
{}
- DropShadowFilter(float distance, float angle, boost::uint32_t color,
- boost::uint8_t alpha, float blurX, float blurY, float strength,
- boost::uint8_t quality, bool inner, bool knockout, bool hideObject) :
+ DropShadowFilter(float distance, float angle, std::uint32_t color,
+ std::uint8_t alpha, float blurX, float blurY, float strength,
+ std::uint8_t quality, bool inner, bool knockout, bool hideObject) :
m_distance(distance), m_angle(angle), m_color(color),
m_alpha(alpha), m_blurX(blurX), m_blurY(blurY), m_strength(strength),
m_quality(quality), m_inner(inner), m_knockout(knockout),
@@ -216,12 +216,12 @@ public:
float m_distance; // Distance of the filter in pixels.
float m_angle; // Angle of the filter.
- boost::uint32_t m_color; // RGB color.
- boost::uint8_t m_alpha; // Alpha strength, as a percentage(?)
+ std::uint32_t m_color; // RGB color.
+ std::uint8_t m_alpha; // Alpha strength, as a percentage(?)
float m_blurX; // horizontal blur
float m_blurY; // vertical blur
float m_strength; // How strong is the filter.
- boost::uint8_t m_quality; // How many times to apply the filter.
+ std::uint8_t m_quality; // How many times to apply the filter.
bool m_inner; // Is this an inner shadow?
bool m_knockout; // If true, render only the filter effect.
bool m_hideObject; // Does this hide the object?
@@ -243,20 +243,20 @@ public:
m_inner(false), m_knockout(false)
{}
- GlowFilter(boost::uint32_t color,
- boost::uint8_t alpha, float blurX, float blurY, float strength,
- boost::uint8_t quality, bool inner, bool knockout) :
+ GlowFilter(std::uint32_t color,
+ std::uint8_t alpha, float blurX, float blurY, float strength,
+ std::uint8_t quality, bool inner, bool knockout) :
m_color(color),
m_alpha(alpha), m_blurX(blurX), m_blurY(blurY), m_strength(strength),
m_quality(quality), m_inner(inner), m_knockout(knockout)
{}
- boost::uint32_t m_color; // RGB color.
- boost::uint8_t m_alpha; // Alpha strength, as a percentage(?)
+ std::uint32_t m_color; // RGB color.
+ std::uint8_t m_alpha; // Alpha strength, as a percentage(?)
float m_blurX; // horizontal blur
float m_blurY; // vertical blur
float m_strength; // How strong is the filter.
- boost::uint8_t m_quality; // How many times to apply the filter.
+ std::uint8_t m_quality; // How many times to apply the filter.
bool m_inner; // Is this an inner shadow?
bool m_knockout; // If true, render only the filter effect.
};
@@ -285,11 +285,11 @@ public:
{}
GradientBevelFilter(float distance, float angle,
- std::vector<boost::uint32_t> colors,
- std::vector<boost::uint8_t> alphas,
- std::vector<boost::uint8_t> ratios,
+ std::vector<std::uint32_t> colors,
+ std::vector<std::uint8_t> alphas,
+ std::vector<std::uint8_t> ratios,
float blurX, float blurY, float strength,
- boost::uint8_t quality, glow_types type, bool knockout) :
+ std::uint8_t quality, glow_types type, bool knockout) :
m_distance(distance), m_angle(angle),
m_colors(colors), m_alphas(alphas), m_ratios(ratios),
m_blurX(blurX), m_blurY(blurY), m_strength(strength),
@@ -298,13 +298,13 @@ public:
float m_distance; // Distance of the filter in pixels.
float m_angle; // Angle of the filter.
- std::vector<boost::uint32_t> m_colors; // Colors of the gradients.
- std::vector<boost::uint8_t> m_alphas; // Alphas of the gradients.
- std::vector<boost::uint8_t> m_ratios; // Ratios of the gradients.
+ std::vector<std::uint32_t> m_colors; // Colors of the gradients.
+ std::vector<std::uint8_t> m_alphas; // Alphas of the gradients.
+ std::vector<std::uint8_t> m_ratios; // Ratios of the gradients.
float m_blurX; // horizontal blur
float m_blurY; // vertical blur
float m_strength; // How strong is the filter.
- boost::uint8_t m_quality; // How many times to apply the filter.
+ std::uint8_t m_quality; // How many times to apply the filter.
glow_types m_type; // What type of effect.
bool m_knockout; // If true, render only the filter effect.
};
@@ -332,11 +332,11 @@ public:
{}
GradientGlowFilter(float distance, float angle,
- std::vector<boost::uint32_t> colors,
- std::vector<boost::uint8_t> alphas,
- std::vector<boost::uint8_t> ratios,
+ std::vector<std::uint32_t> colors,
+ std::vector<std::uint8_t> alphas,
+ std::vector<std::uint8_t> ratios,
float blurX, float blurY, float strength,
- boost::uint8_t quality, glow_types type, bool knockout) :
+ std::uint8_t quality, glow_types type, bool knockout) :
m_distance(distance), m_angle(angle), m_colors(colors),
m_alphas(alphas),
m_ratios(ratios), m_blurX(blurX), m_blurY(blurY), m_strength(strength),
m_quality(quality), m_type(type), m_knockout(knockout)
@@ -344,13 +344,13 @@ public:
float m_distance; // Distance of the filter in pixels.
float m_angle; // Angle of the filter.
- std::vector<boost::uint32_t> m_colors; // Colors of the gradients.
- std::vector<boost::uint8_t> m_alphas; // Alphas of the gradients.
- std::vector<boost::uint8_t> m_ratios; // Ratios of the gradients.
+ std::vector<std::uint32_t> m_colors; // Colors of the gradients.
+ std::vector<std::uint8_t> m_alphas; // Alphas of the gradients.
+ std::vector<std::uint8_t> m_ratios; // Ratios of the gradients.
float m_blurX; // horizontal blur
float m_blurY; // vertical blur
float m_strength; // How strong is the filter.
- boost::uint8_t m_quality; // How many times to apply the filter.
+ std::uint8_t m_quality; // How many times to apply the filter.
glow_types m_type; // What type of effect.
bool m_knockout; // If true, render only the filter effect.
};
diff --git a/libcore/Font.cpp b/libcore/Font.cpp
index f92b223..fcba19c 100644
--- a/libcore/Font.cpp
+++ b/libcore/Font.cpp
@@ -44,7 +44,7 @@ class CodeLookup
public:
CodeLookup(const int glyph) : _glyph(glyph) {}
- bool operator()(const std::pair<const boost::uint16_t, int>& p) const {
+ bool operator()(const std::pair<const std::uint16_t, int>& p) const {
return p.second == _glyph;
}
@@ -148,7 +148,7 @@ Font::glyphCount() const
void
-Font::setFlags(boost::uint8_t flags)
+Font::setFlags(std::uint8_t flags)
{
_shiftJISChars = flags & (1 << 6);
_unicodeChars = flags & (1 << 5);
@@ -183,7 +183,7 @@ Font::setName(const std::string& name)
}
-boost::uint16_t
+std::uint16_t
Font::codeTableLookup(int glyph, bool embedded) const
{
const CodeTable& ctable = (embedded && _embeddedCodeTable) ?
@@ -205,7 +205,7 @@ Font::codeTableLookup(int glyph, bool embedded) const
}
int
-Font::get_glyph_index(boost::uint16_t code, bool embedded) const
+Font::get_glyph_index(std::uint16_t code, bool embedded) const
{
const CodeTable& ctable = (embedded && _embeddedCodeTable) ?
*_embeddedCodeTable : _deviceCodeTable;
@@ -281,7 +281,7 @@ Font::unitsPerEM(bool embed) const
}
int
-Font::add_os_glyph(boost::uint16_t code)
+Font::add_os_glyph(std::uint16_t code)
{
FreetypeGlyphsProvider* ft = ftProvider();
if (!ft) return -1;
diff --git a/libcore/Font.h b/libcore/Font.h
index fa1afe4..948a200 100644
--- a/libcore/Font.h
+++ b/libcore/Font.h
@@ -26,7 +26,7 @@
#include <string>
#include <memory>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <memory>
#include <vector>
#include <map>
@@ -50,8 +50,8 @@ namespace gnash {
class kerning_pair
{
public:
- boost::uint16_t m_char0;
- boost::uint16_t m_char1;
+ std::uint16_t m_char0;
+ std::uint16_t m_char1;
bool operator==(const kerning_pair& k) const
{
@@ -91,7 +91,7 @@ class Font : public ref_counted
public:
// This table maps from Unicode DisplayObject number to glyph index.
- typedef std::map<boost::uint16_t, int> CodeTable;
+ typedef std::map<std::uint16_t, int> CodeTable;
Font(std::unique_ptr<SWF::DefineFontTag> ft);
@@ -109,7 +109,7 @@ public:
~Font();
- boost::uint16_t codeTableLookup(int glyph, bool embedded) const;
+ std::uint16_t codeTableLookup(int glyph, bool embedded) const;
/// Return true if this font matches given name and flags
//
@@ -158,7 +158,7 @@ public:
/// positive index to use in subsequent calls to other
/// glyph-index-based methods.
///
- int get_glyph_index(boost::uint16_t code, bool embedded) const;
+ int get_glyph_index(std::uint16_t code, bool embedded) const;
/// Return the advance value for the given glyph index
//
@@ -258,7 +258,7 @@ public:
/// Set the language and encoding flags of the font.
//
/// This is used by SWF::DefineFontInfoTag
- void setFlags(boost::uint8_t flags);
+ void setFlags(std::uint8_t flags);
/// Add a CodeTable to the font.
//
@@ -284,7 +284,7 @@ private:
///
/// @return index of the newly added glyph, or -1 on error.
///
- int add_os_glyph(boost::uint16_t code);
+ int add_os_glyph(std::uint16_t code);
/// If we were constructed from a definition, this is not NULL.
std::unique_ptr<SWF::DefineFontTag> _fontTag;
diff --git a/libcore/FreetypeGlyphsProvider.cpp
b/libcore/FreetypeGlyphsProvider.cpp
index 5e121af..af45102 100644
--- a/libcore/FreetypeGlyphsProvider.cpp
+++ b/libcore/FreetypeGlyphsProvider.cpp
@@ -25,7 +25,7 @@
#include <string>
#include <memory> // for unique_ptr
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/format.hpp>
#include "GnashException.h"
@@ -156,8 +156,8 @@ private:
#ifdef DEBUG_OUTLINE_DECOMPOSITION
log_debug("moveTo: %ld,%ld", to->x, to->y);
#endif
- _x = static_cast<boost::int32_t>(to->x * _scale);
- _y = - static_cast<boost::int32_t>(to->y * _scale);
+ _x = static_cast<std::int32_t>(to->x * _scale);
+ _y = - static_cast<std::int32_t>(to->y * _scale);
_currPath->close();
_subshape.addPath(Path(_x, _y, 1, 0, 0));
_currPath = &_subshape.currentPath();
@@ -169,8 +169,8 @@ private:
#ifdef DEBUG_OUTLINE_DECOMPOSITION
log_debug("lineTo: %ld,%ld", to->x, to->y);
#endif
- _x = static_cast<boost::int32_t>(to->x * _scale);
- _y = - static_cast<boost::int32_t>(to->y * _scale);
+ _x = static_cast<std::int32_t>(to->x * _scale);
+ _y = - static_cast<std::int32_t>(to->y * _scale);
_currPath->drawLineTo(_x, _y);
expandBounds(_x, _y);
return 0;
@@ -181,10 +181,10 @@ private:
#ifdef DEBUG_OUTLINE_DECOMPOSITION
log_debug("conicTo: %ld,%ld %ld,%ld", ctrl->x, ctrl->y, to->x, to->y);
#endif
- boost::int32_t x1 = static_cast<boost::int32_t>(ctrl->x * _scale);
- boost::int32_t y1 = static_cast<boost::int32_t>(ctrl->y * _scale);
- _x = static_cast<boost::int32_t>(to->x * _scale);
- _y = - static_cast<boost::int32_t>(to->y * _scale);
+ std::int32_t x1 = static_cast<std::int32_t>(ctrl->x * _scale);
+ std::int32_t y1 = static_cast<std::int32_t>(ctrl->y * _scale);
+ _x = static_cast<std::int32_t>(to->x * _scale);
+ _y = - static_cast<std::int32_t>(to->y * _scale);
_currPath->drawCurveTo(x1, -y1, _x, _y);
expandBounds(x1, -y1, _x, _y);
return 0;
@@ -199,10 +199,10 @@ private:
#endif
float x = ctrl1->x + ( (ctrl2->x - ctrl1->x) * 0.5 );
float y = ctrl1->y + ( (ctrl2->y - ctrl1->y) * 0.5 );
- boost::int32_t x1 = static_cast<boost::int32_t>(x * _scale);
- boost::int32_t y1 = static_cast<boost::int32_t>(y * _scale);
- _x = static_cast<boost::int32_t>(to->x * _scale);
- _y = - static_cast<boost::int32_t>(to->y * _scale);
+ std::int32_t x1 = static_cast<std::int32_t>(x * _scale);
+ std::int32_t y1 = static_cast<std::int32_t>(y * _scale);
+ _x = static_cast<std::int32_t>(to->x * _scale);
+ _y = - static_cast<std::int32_t>(to->y * _scale);
_currPath->drawCurveTo(x1, -y1, _x, _y);
expandBounds(x1, -y1, _x, _y);
@@ -235,7 +235,7 @@ private:
Path* _currPath;
- boost::int32_t _x, _y;
+ std::int32_t _x, _y;
};
@@ -481,7 +481,7 @@ FreetypeGlyphsProvider::FreetypeGlyphsProvider(const
std::string&, bool, bool)
#ifdef USE_FREETYPE
std::unique_ptr<SWF::ShapeRecord>
-FreetypeGlyphsProvider::getGlyph(boost::uint16_t code, float& advance)
+FreetypeGlyphsProvider::getGlyph(std::uint16_t code, float& advance)
{
std::unique_ptr<SWF::ShapeRecord> glyph;
@@ -549,7 +549,7 @@ FreetypeGlyphsProvider::getGlyph(boost::uint16_t code,
float& advance)
#else // ndef(USE_FREETYPE)
std::unique_ptr<SWF::ShapeRecord>
-FreetypeGlyphsProvider::getGlyph(boost::uint16_t, float& advance)
+FreetypeGlyphsProvider::getGlyph(std::uint16_t, float& advance)
{
abort(); // should never be called...
}
diff --git a/libcore/FreetypeGlyphsProvider.h b/libcore/FreetypeGlyphsProvider.h
index c3952f6..6bc06a3 100644
--- a/libcore/FreetypeGlyphsProvider.h
+++ b/libcore/FreetypeGlyphsProvider.h
@@ -23,7 +23,7 @@
#include <string>
#include <memory> // for unique_ptr
#include <boost/thread/mutex.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#ifdef USE_FREETYPE
# include <ft2build.h>
@@ -101,7 +101,7 @@ public:
/// or a NULL pointer if the given DisplayObject code
/// doesn't exist in this font.
///
- std::unique_ptr<SWF::ShapeRecord> getGlyph(boost::uint16_t code,
+ std::unique_ptr<SWF::ShapeRecord> getGlyph(std::uint16_t code,
float& advance);
/// Return the font's ascender in terms of its EM own square.
diff --git a/libcore/Function.h b/libcore/Function.h
index 476e006..b5eda36 100644
--- a/libcore/Function.h
+++ b/libcore/Function.h
@@ -95,7 +95,7 @@ public:
/// Get the number of registers required for function execution.
//
/// For ordinary Functions this is always 0.
- virtual boost::uint8_t registers() const {
+ virtual std::uint8_t registers() const {
return 0;
}
@@ -109,7 +109,7 @@ public:
//
/// @param reg The register for the argument.
/// @param name The name of the argument.
- void add_arg(boost::uint8_t reg, const ObjectURI& name) {
+ void add_arg(std::uint8_t reg, const ObjectURI& name) {
_args.push_back(Argument(reg, name));
}
@@ -130,8 +130,8 @@ protected:
struct Argument
{
- Argument(boost::uint8_t r, const ObjectURI& n) : reg(r), name(n) {}
- boost::uint8_t reg;
+ Argument(std::uint8_t r, const ObjectURI& n) : reg(r), name(n) {}
+ std::uint8_t reg;
ObjectURI name;
};
diff --git a/libcore/Function2.h b/libcore/Function2.h
index 2b2160f..5466f80 100644
--- a/libcore/Function2.h
+++ b/libcore/Function2.h
@@ -79,15 +79,15 @@ public:
virtual ~Function2() {}
/// Return the number of registers to allocate for this function.
- virtual boost::uint8_t registers() const {
+ virtual std::uint8_t registers() const {
return _registerCount;
}
- void setRegisterCount(boost::uint8_t ct) {
+ void setRegisterCount(std::uint8_t ct) {
_registerCount = ct;
}
- void setFlags(boost::uint16_t flags) {
+ void setFlags(std::uint16_t flags) {
_function2Flags = flags;
}
@@ -97,10 +97,10 @@ public:
private:
/// The number of registers required.
- boost::uint8_t _registerCount;
+ std::uint8_t _registerCount;
/// Used to control implicit arg register assignments
- boost::uint16_t _function2Flags;
+ std::uint16_t _function2Flags;
};
diff --git a/libcore/Geometry.cpp b/libcore/Geometry.cpp
index d8cb7e3..c284e29 100644
--- a/libcore/Geometry.cpp
+++ b/libcore/Geometry.cpp
@@ -21,7 +21,7 @@
#include <cmath>
#include <algorithm>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "log.h"
#include "LineStyle.h"
@@ -123,8 +123,8 @@ int curve_x_crossings(const T x0, const T y0, const T x1,
const T y1,
bool
pointTest(const std::vector<Path>& paths,
- const std::vector<LineStyle>& lineStyles, boost::int32_t x,
- boost::int32_t y, const SWFMatrix& wm)
+ const std::vector<LineStyle>& lineStyles, std::int32_t x,
+ std::int32_t y, const SWFMatrix& wm)
{
/*
diff --git a/libcore/Geometry.h b/libcore/Geometry.h
index 5ec7ca6..6926708 100644
--- a/libcore/Geometry.h
+++ b/libcore/Geometry.h
@@ -55,8 +55,8 @@ public:
ap(0, 0)
{}
- Edge(boost::int32_t cx, boost::int32_t cy, boost::int32_t ax,
- boost::int32_t ay)
+ Edge(std::int32_t cx, std::int32_t cy, std::int32_t ax,
+ std::int32_t ay)
:
cp(cx, cy),
ap(ax, ay)
@@ -90,16 +90,16 @@ public:
static double
squareDistancePtSeg(const point& p, const point& A, const point& B)
{
- boost::int32_t dx = B.x - A.x;
- boost::int32_t dy = B.y - A.y;
+ std::int32_t dx = B.x - A.x;
+ std::int32_t dy = B.y - A.y;
if ( dx == 0 && dy == 0 )
{
return p.squareDistance(A);
}
- boost::int32_t pdx = p.x - A.x;
- boost::int32_t pdy = p.y - A.y;
+ std::int32_t pdx = p.x - A.x;
+ std::int32_t pdy = p.y - A.y;
double u = (static_cast<double>(pdx) * dx + static_cast<double>(pdy) *
dy ) /
(static_cast<double>(dx)*dx + static_cast<double>(dy)*dy );
@@ -152,7 +152,7 @@ public:
/// @param p The point we want to compute distance from
/// @param t the step factor between 0 and 1
///
- static boost::int64_t squareDistancePtCurve(const point& A,
+ static std::int64_t squareDistancePtCurve(const point& A,
const point& C,
const point& B,
const point& p, float t)
@@ -228,7 +228,7 @@ public:
///
/// @param newShape
/// True if this path starts a new subshape
- Path(boost::int32_t ax, boost::int32_t ay,
+ Path(std::int32_t ax, std::int32_t ay,
unsigned fill0, unsigned fill1, unsigned line)
{
reset(ax, ay, fill0, fill1, line);
@@ -251,7 +251,7 @@ public:
/// @param line
/// Line style index for right fill
///
- void reset(boost::int32_t ax, boost::int32_t ay,
+ void reset(std::int32_t ax, std::int32_t ay,
unsigned fill0, unsigned fill1, unsigned line)
// Reset all our members to the given values, and clear our edge list.
{
@@ -328,7 +328,7 @@ public:
/// Y coordinate in TWIPS
///
void
- drawLineTo(boost::int32_t dx, boost::int32_t dy)
+ drawLineTo(std::int32_t dx, std::int32_t dy)
{
m_edges.push_back(Edge(dx, dy, dx, dy));
}
@@ -351,7 +351,7 @@ public:
/// Anchor point's Y ordinate.
///
void
- drawCurveTo(boost::int32_t cdx, boost::int32_t cdy, boost::int32_t adx,
boost::int32_t ady)
+ drawCurveTo(std::int32_t cdx, std::int32_t cdy, std::int32_t adx,
std::int32_t ady)
{
m_edges.push_back(Edge(cdx, cdy, adx, ady));
}
@@ -543,8 +543,8 @@ namespace geometry
{
bool pointTest(const std::vector<Path>& paths,
- const std::vector<LineStyle>& lineStyles, boost::int32_t x,
- boost::int32_t y, const SWFMatrix& wm);
+ const std::vector<LineStyle>& lineStyles, std::int32_t x,
+ std::int32_t y, const SWFMatrix& wm);
} // namespace geometry
diff --git a/libcore/InteractiveObject.h b/libcore/InteractiveObject.h
index c9cdfd7..f6d969d 100644
--- a/libcore/InteractiveObject.h
+++ b/libcore/InteractiveObject.h
@@ -112,8 +112,8 @@ public:
/// @param y
/// Y ordinate of the pointer, in parent's coordiante space.
///
- virtual InteractiveObject* topmostMouseEntity(boost::int32_t /*x*/,
- boost::int32_t /*y*/) = 0;
+ virtual InteractiveObject* topmostMouseEntity(std::int32_t /*x*/,
+ std::int32_t /*y*/) = 0;
/// Called whenever a mouse event affects this InteractiveObject.
//
@@ -129,7 +129,7 @@ public:
/// override and invokes pointInBounds().
///
///
- virtual bool pointInShape(boost::int32_t x, boost::int32_t y) const
+ virtual bool pointInShape(std::int32_t x, std::int32_t y) const
{
log_error("Character %s did not override pointInShape() - "
"using pointInBounds() instead", typeid(*this).name());
diff --git a/libcore/LineStyle.cpp b/libcore/LineStyle.cpp
index e630ad5..eecbe36 100644
--- a/libcore/LineStyle.cpp
+++ b/libcore/LineStyle.cpp
@@ -146,8 +146,8 @@ LineStyle::read(SWFStream& in, SWF::TagType t,
movie_definition& md,
in.ensureBytes(2+2);
m_width = in.read_u16();
- const boost::uint8_t flags1 = in.read_u8();
- const boost::uint8_t flags2 = in.read_u8();
+ const std::uint8_t flags1 = in.read_u8();
+ const std::uint8_t flags2 = in.read_u8();
_startCapStyle = (CapStyle)((flags1 & 0xC0) >> 6);
_joinStyle = (JoinStyle)((flags1 & 0x30) >> 4);
@@ -178,7 +178,7 @@ LineStyle::read(SWFStream& in, SWF::TagType t,
movie_definition& md,
void
LineStyle::set_lerp(const LineStyle& ls1, const LineStyle& ls2, float ratio)
{
- m_width = static_cast<boost::uint16_t>(
+ m_width = static_cast<std::uint16_t>(
frnd(lerp<float>(ls1.getThickness(), ls2.getThickness(), ratio)));
m_color = lerp(ls1.get_color(), ls2.get_color(), ratio);
if ( ls1._scaleVertically != ls2._scaleVertically )
diff --git a/libcore/LineStyle.h b/libcore/LineStyle.h
index 61e8e1d..4d50bac 100644
--- a/libcore/LineStyle.h
+++ b/libcore/LineStyle.h
@@ -66,7 +66,7 @@ public:
/// @param endCapStyle
/// @param joinStyle
/// @param miterLimitFactor
- LineStyle(boost::uint16_t width, const rgba& color,
+ LineStyle(std::uint16_t width, const rgba& color,
bool scaleThicknessVertically=true,
bool scaleThicknessHorizontally=true,
bool pixelHinting=false,
@@ -106,7 +106,7 @@ public:
const RunResources& r, LineStyle *pOther);
/// Return thickness of the line, in TWIPS
- boost::uint16_t getThickness() const {
+ std::uint16_t getThickness() const {
return m_width;
}
@@ -166,7 +166,7 @@ public:
private:
/// Width in twips.
- boost::uint16_t m_width;
+ std::uint16_t m_width;
rgba m_color;
diff --git a/libcore/MorphShape.cpp b/libcore/MorphShape.cpp
index f1f67ee..b063dba 100644
--- a/libcore/MorphShape.cpp
+++ b/libcore/MorphShape.cpp
@@ -37,7 +37,7 @@ MorphShape::MorphShape(movie_root& mr, as_object* object,
}
bool
-MorphShape::pointInShape(boost::int32_t x, boost::int32_t y) const
+MorphShape::pointInShape(std::int32_t x, std::int32_t y) const
{
const SWFMatrix wm = getWorldMatrix(*this).invert();
point lp(x, y);
diff --git a/libcore/MorphShape.h b/libcore/MorphShape.h
index 5910333..d010445 100644
--- a/libcore/MorphShape.h
+++ b/libcore/MorphShape.h
@@ -57,7 +57,7 @@ public:
virtual SWFRect getBounds() const;
- virtual bool pointInShape(boost::int32_t x, boost::int32_t y) const;
+ virtual bool pointInShape(std::int32_t x, std::int32_t y) const;
const SWF::ShapeRecord& shape() const {
return _shape;
diff --git a/libcore/Movie.h b/libcore/Movie.h
index 7642095..4a92ce9 100644
--- a/libcore/Movie.h
+++ b/libcore/Movie.h
@@ -94,13 +94,13 @@ public:
/// This makes the character known to ActionScript for initialization.
/// Exported characters must both be in the definition's list of exports
/// and added with this function before they are available.
- virtual void addCharacter(boost::uint16_t /*id*/) {}
+ virtual void addCharacter(std::uint16_t /*id*/) {}
/// Attempt to mark a character as initialized.
//
/// The default is to return false. Only a SWFMovie can have a list of
/// characters.
- virtual bool initializeCharacter(boost::uint16_t /*id*/) {
+ virtual bool initializeCharacter(std::uint16_t /*id*/) {
return false;
}
diff --git a/libcore/MovieClip.cpp b/libcore/MovieClip.cpp
index c38029c..d661b08 100644
--- a/libcore/MovieClip.cpp
+++ b/libcore/MovieClip.cpp
@@ -259,7 +259,7 @@ class ShapeContainerFinder
{
public:
- ShapeContainerFinder(boost::int32_t x, boost::int32_t y)
+ ShapeContainerFinder(std::int32_t x, std::int32_t y)
:
_found(false),
_x(x),
@@ -278,8 +278,8 @@ public:
private:
bool _found;
- const boost::int32_t _x;
- const boost::int32_t _y;
+ const std::int32_t _x;
+ const std::int32_t _y;
};
/// Find the first visible DisplayObject whose shape contain the point
@@ -290,7 +290,7 @@ class VisibleShapeContainerFinder
{
public:
- VisibleShapeContainerFinder(boost::int32_t x, boost::int32_t y)
+ VisibleShapeContainerFinder(std::int32_t x, std::int32_t y)
:
_found(false),
_x(x),
@@ -310,8 +310,8 @@ public:
private:
bool _found;
- const boost::int32_t _x;
- const boost::int32_t _y;
+ const std::int32_t _x;
+ const std::int32_t _y;
};
/// Find the first hitable DisplayObject whose shape contain the point
@@ -321,7 +321,7 @@ private:
class HitableShapeContainerFinder
{
public:
- HitableShapeContainerFinder(boost::int32_t x, boost::int32_t y)
+ HitableShapeContainerFinder(std::int32_t x, std::int32_t y)
:
_found(false),
_x(x),
@@ -344,10 +344,10 @@ private:
bool _found;
// x position in twips.
- const boost::int32_t _x;
+ const std::int32_t _x;
// y position in twips.
- const boost::int32_t _y;
+ const std::int32_t _y;
};
/// A DisplayList visitor used to compute its overall bounds.
@@ -384,7 +384,7 @@ struct ReachableMarker
class DropTargetFinder
{
public:
- DropTargetFinder(boost::int32_t x, boost::int32_t y, DisplayObject*
dragging)
+ DropTargetFinder(std::int32_t x, std::int32_t y, DisplayObject* dragging)
:
_highestHiddenDepth(std::numeric_limits<int>::min()),
_x(x),
@@ -464,8 +464,8 @@ private:
///
int _highestHiddenDepth;
- boost::int32_t _x;
- boost::int32_t _y;
+ std::int32_t _x;
+ std::int32_t _y;
DisplayObject* _dragging;
mutable const DisplayObject* _dropch;
@@ -1266,7 +1266,7 @@ MovieClip::add_display_object(const SWF::PlaceObject2Tag*
tag,
}
if (tag->hasBlendMode()) {
- boost::uint8_t bm = tag->getBlendMode();
+ std::uint8_t bm = tag->getBlendMode();
ch->setBlendMode(static_cast<DisplayObject::BlendMode>(bm));
}
@@ -1293,7 +1293,7 @@ MovieClip::add_display_object(const SWF::PlaceObject2Tag*
tag,
void
MovieClip::move_display_object(const SWF::PlaceObject2Tag* tag, DisplayList&
dlist)
{
- boost::uint16_t ratio = tag->getRatio();
+ std::uint16_t ratio = tag->getRatio();
// clip_depth is not used in MOVE tag(at least no related tests).
dlist.moveDisplayObject(
tag->getDepth(),
@@ -1311,7 +1311,7 @@ MovieClip::replace_display_object(const
SWF::PlaceObject2Tag* tag,
assert(_def);
assert(tag != NULL);
- const boost::uint16_t id = tag->getID();
+ const std::uint16_t id = tag->getID();
SWF::DefinitionTag* cdef = _def->getDefinitionTag(id);
if (!cdef) {
@@ -1414,7 +1414,7 @@ MovieClip::handleFocus()
}
bool
-MovieClip::pointInShape(boost::int32_t x, boost::int32_t y) const
+MovieClip::pointInShape(std::int32_t x, std::int32_t y) const
{
ShapeContainerFinder finder(x, y);
_displayList.visitBackward(finder);
@@ -1423,7 +1423,7 @@ MovieClip::pointInShape(boost::int32_t x, boost::int32_t
y) const
}
bool
-MovieClip::pointInVisibleShape(boost::int32_t x, boost::int32_t y) const
+MovieClip::pointInVisibleShape(std::int32_t x, std::int32_t y) const
{
if (! visible()) return false;
if (isDynamicMask() && ! mouseEnabled()) {
@@ -1450,7 +1450,7 @@ MovieClip::pointInVisibleShape(boost::int32_t x,
boost::int32_t y) const
}
inline bool
-MovieClip::hitTestDrawable(boost::int32_t x, boost::int32_t y) const
+MovieClip::hitTestDrawable(std::int32_t x, std::int32_t y) const
{
const SWFMatrix wm = getWorldMatrix(*this).invert();
point lp(x, y);
@@ -1460,7 +1460,7 @@ MovieClip::hitTestDrawable(boost::int32_t x,
boost::int32_t y) const
}
bool
-MovieClip::pointInHitableShape(boost::int32_t x, boost::int32_t y) const
+MovieClip::pointInHitableShape(std::int32_t x, std::int32_t y) const
{
if (isDynamicMask() && !mouseEnabled()) return false;
@@ -1475,7 +1475,7 @@ MovieClip::pointInHitableShape(boost::int32_t x,
boost::int32_t y) const
}
InteractiveObject*
-MovieClip::topmostMouseEntity(boost::int32_t x, boost::int32_t y)
+MovieClip::topmostMouseEntity(std::int32_t x, std::int32_t y)
{
if (!visible()) return 0;
@@ -1511,7 +1511,7 @@ MovieClip::topmostMouseEntity(boost::int32_t x,
boost::int32_t y)
}
const DisplayObject*
-MovieClip::findDropTarget(boost::int32_t x, boost::int32_t y,
+MovieClip::findDropTarget(std::int32_t x, std::int32_t y,
DisplayObject* dragging) const
{
if (this == dragging) return 0; // not here...
diff --git a/libcore/MovieClip.h b/libcore/MovieClip.h
index 0bf2290..6618268 100644
--- a/libcore/MovieClip.h
+++ b/libcore/MovieClip.h
@@ -146,16 +146,16 @@ public:
virtual SWFRect getBounds() const;
// See dox in DisplayObject.h
- virtual bool pointInShape(boost::int32_t x, boost::int32_t y) const;
+ virtual bool pointInShape(std::int32_t x, std::int32_t y) const;
// See dox in DisplayObject.h
- virtual bool pointInVisibleShape(boost::int32_t x, boost::int32_t y) const;
+ virtual bool pointInVisibleShape(std::int32_t x, std::int32_t y) const;
/// return true if the given point is located in a(this) hitable sprite.
///
/// all sprites except mouse-insensitive dynamic masks are hitable.
/// _visible property is ignored for hitable DisplayObjects.
- virtual bool pointInHitableShape(boost::int32_t x, boost::int32_t y) const;
+ virtual bool pointInHitableShape(std::int32_t x, std::int32_t y) const;
/// Return 0-based index to current frame
size_t get_current_frame() const
@@ -220,11 +220,11 @@ public:
/// Return the topmost entity that the given point
/// covers that can receive mouse events. NULL if
/// none. Coords are in parent's frame.
- virtual InteractiveObject* topmostMouseEntity(boost::int32_t x,
- boost::int32_t y);
+ virtual InteractiveObject* topmostMouseEntity(std::int32_t x,
+ std::int32_t y);
// see dox in DisplayObject.h
- const DisplayObject* findDropTarget(boost::int32_t x, boost::int32_t y,
+ const DisplayObject* findDropTarget(std::int32_t x, std::int32_t y,
DisplayObject* dragging) const;
void setDropTarget(const std::string& tgt) {
@@ -673,7 +673,7 @@ private:
/// This is possible because the drawable does not have its own
/// transform, so we can use our own. The points are expressed in
/// world space.
- bool hitTestDrawable(boost::int32_t x, boost::int32_t y) const;
+ bool hitTestDrawable(std::int32_t x, std::int32_t y) const;
/// Advance to a previous frame.
//
diff --git a/libcore/PropFlags.h b/libcore/PropFlags.h
index 6874c7f..0b586e5 100644
--- a/libcore/PropFlags.h
+++ b/libcore/PropFlags.h
@@ -20,7 +20,7 @@
#define GNASH_AS_PROP_FLAGS_H
#include <ostream>
-#include <boost/cstdint.hpp>
+#include <cstdint>
namespace gnash {
@@ -76,7 +76,7 @@ public:
}
/// Constructor, from numerical value
- PropFlags(boost::uint16_t flags)
+ PropFlags(std::uint16_t flags)
:
_flags(flags)
{
@@ -117,7 +117,7 @@ public:
}
/// accessor to the numerical flags value
- boost::uint16_t get_flags() const { return _flags; }
+ std::uint16_t get_flags() const { return _flags; }
/// set the numerical flags value (return the new value )
/// If unlocked is false, you cannot un-protect from over-write,
@@ -127,7 +127,7 @@ public:
/// @param setTrue the set of flags to set
/// @param setFalse the set of flags to clear
/// @return true on success, false on failure (is protected)
- bool set_flags(boost::uint16_t setTrue, boost::uint16_t setFalse = 0) {
+ bool set_flags(std::uint16_t setTrue, std::uint16_t setFalse = 0) {
_flags &= ~setFalse;
_flags |= setTrue;
return true;
@@ -136,7 +136,7 @@ public:
private:
/// Numeric flags
- boost::uint16_t _flags;
+ std::uint16_t _flags;
};
diff --git a/libcore/PropertyList.h b/libcore/PropertyList.h
index 53f3681..a33658f 100644
--- a/libcore/PropertyList.h
+++ b/libcore/PropertyList.h
@@ -23,7 +23,7 @@
#include <string> // for use within map
#include <cassert> // for inlines
#include <utility> // for std::pair
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/multi_index/sequenced_index.hpp>
diff --git a/libcore/RGBA.cpp b/libcore/RGBA.cpp
index fedefee..0b6b498 100644
--- a/libcore/RGBA.cpp
+++ b/libcore/RGBA.cpp
@@ -41,7 +41,7 @@ rgba
colorFromHexString(const std::string& color)
{
std::stringstream ss(color);
- boost::uint32_t hexnumber;
+ std::uint32_t hexnumber;
if (!(ss >> std::hex >> hexnumber)) {
log_error(_("Failed to convert string to RGBA value! This is a "
diff --git a/libcore/RGBA.h b/libcore/RGBA.h
index 06af1af..216adf4 100644
--- a/libcore/RGBA.h
+++ b/libcore/RGBA.h
@@ -22,7 +22,7 @@
#define GNASH_RGBA_H
#include <string>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "dsodefs.h" // for DSOTEXPORT
@@ -53,8 +53,8 @@ public:
/// @param g Green
/// @param b Blue
/// @param a Alpha (transparency)
- rgba(boost::uint8_t r, boost::uint8_t g, boost::uint8_t b,
- boost::uint8_t a)
+ rgba(std::uint8_t r, std::uint8_t g, std::uint8_t b,
+ std::uint8_t a)
:
m_r(r),
m_g(g),
@@ -70,10 +70,10 @@ public:
///
/// This function is meant to be used to
/// parse ActionScript colors in numeric format.
- void parseRGB(boost::uint32_t rgbCol) {
- m_r = static_cast<boost::uint8_t>(rgbCol >> 16);
- m_g = static_cast<boost::uint8_t>(rgbCol >> 8);
- m_b = static_cast<boost::uint8_t>(rgbCol);
+ void parseRGB(std::uint32_t rgbCol) {
+ m_r = static_cast<std::uint8_t>(rgbCol >> 16);
+ m_g = static_cast<std::uint8_t>(rgbCol >> 8);
+ m_b = static_cast<std::uint8_t>(rgbCol);
}
/// Return a 32-bit unsigned integer as four packed R,G,B bytes.
@@ -83,7 +83,7 @@ public:
///
/// This function is meant to be used to output ActionScript colors
/// in numeric format.
- boost::uint32_t toRGB() const {
+ std::uint32_t toRGB() const {
return (m_r << 16) + (m_g << 8) + m_b;
}
@@ -93,7 +93,7 @@ public:
///
/// This function is meant to be used to output ActionScript colors
/// in numeric format.
- boost::uint32_t toRGBA() const {
+ std::uint32_t toRGBA() const {
return toRGB() + (m_a << 24);
}
@@ -110,7 +110,7 @@ public:
return !(*this == o);
}
- boost::uint8_t m_r, m_g, m_b, m_a;
+ std::uint8_t m_r, m_g, m_b, m_a;
};
diff --git a/libcore/SWFCxForm.cpp b/libcore/SWFCxForm.cpp
index c07a7f5..2d8f906 100644
--- a/libcore/SWFCxForm.cpp
+++ b/libcore/SWFCxForm.cpp
@@ -56,24 +56,24 @@ SWFCxForm::transform(const rgba& in) const
// transform the given color with our SWFCxForm.
void
-SWFCxForm::transform(boost::uint8_t& r, boost::uint8_t& g, boost::uint8_t& b,
- boost::uint8_t& a) const
+SWFCxForm::transform(std::uint8_t& r, std::uint8_t& g, std::uint8_t& b,
+ std::uint8_t& a) const
{
// force conversion to int16 first, kind of optimization.
- boost::int16_t rt = r;
- boost::int16_t gt = g;
- boost::int16_t bt = b;
- boost::int16_t at = a;
+ std::int16_t rt = r;
+ std::int16_t gt = g;
+ std::int16_t bt = b;
+ std::int16_t at = a;
rt = (rt * ra >> 8) + rb;
gt = (gt * ga >> 8) + gb;
bt = (bt * ba >> 8) + bb;
at = (at * aa >> 8) + ab;
- r = clamp<boost::int16_t>(rt, 0, 255);
- g = clamp<boost::int16_t>(gt, 0, 255);
- b = clamp<boost::int16_t>(bt, 0, 255);
- a = clamp<boost::int16_t>(at, 0, 255);
+ r = clamp<std::int16_t>(rt, 0, 255);
+ g = clamp<std::int16_t>(gt, 0, 255);
+ b = clamp<std::int16_t>(bt, 0, 255);
+ a = clamp<std::int16_t>(at, 0, 255);
}
std::ostream&
diff --git a/libcore/SWFCxForm.h b/libcore/SWFCxForm.h
index 5915dcd..81be5e6 100644
--- a/libcore/SWFCxForm.h
+++ b/libcore/SWFCxForm.h
@@ -23,7 +23,7 @@
#include <string>
#include <iosfwd>
-#include <boost/cstdint.hpp>
+#include <cstdint>
namespace gnash {
class rgba;
@@ -50,14 +50,14 @@ public:
{
}
- boost::int16_t ra; // RedMultTerm, 8.8 fixed point
- boost::int16_t ga; // GreenMultTerm 8.8 fixed point
- boost::int16_t ba; // BlueMultTerm 8.8 fixed point
- boost::int16_t aa; // AlphaMultTerm 8.8 fixed point
- boost::int16_t rb; // RedAddTerm, 16 bit integer(no fraction)
- boost::int16_t gb; // GreenAddTerm 16 bit integer(no fraction)
- boost::int16_t bb; // BlueAddTerm 16 bit integer(no fraction)
- boost::int16_t ab; // AlphaAddTerm 16 bit integer(no fraction)
+ std::int16_t ra; // RedMultTerm, 8.8 fixed point
+ std::int16_t ga; // GreenMultTerm 8.8 fixed point
+ std::int16_t ba; // BlueMultTerm 8.8 fixed point
+ std::int16_t aa; // AlphaMultTerm 8.8 fixed point
+ std::int16_t rb; // RedAddTerm, 16 bit integer(no fraction)
+ std::int16_t gb; // GreenAddTerm 16 bit integer(no fraction)
+ std::int16_t bb; // BlueAddTerm 16 bit integer(no fraction)
+ std::int16_t ab; // AlphaAddTerm 16 bit integer(no fraction)
/// Concatenate SWFCxForm c onto ours.
//
@@ -70,8 +70,8 @@ public:
rgba transform(const rgba& in) const;
/// Transform the given color.
- void transform(boost::uint8_t& r, boost::uint8_t& g, boost::uint8_t& b,
- boost::uint8_t& a) const;
+ void transform(std::uint8_t& r, std::uint8_t& g, std::uint8_t& b,
+ std::uint8_t& a) const;
};
diff --git a/libcore/SWFMatrix.cpp b/libcore/SWFMatrix.cpp
index 220c9ef..c80f9c0 100644
--- a/libcore/SWFMatrix.cpp
+++ b/libcore/SWFMatrix.cpp
@@ -79,17 +79,17 @@ rotationY(const SWFMatrix& m)
return std::atan2(-c, d);
}
-inline boost::int32_t
+inline std::int32_t
toFixed16(double a)
{
return truncateWithFactor<65536>(a);
}
-inline boost::int32_t
-multiplyFixed16(boost::int32_t a, boost::int32_t b)
+inline std::int32_t
+multiplyFixed16(std::int32_t a, std::int32_t b)
{
- return (static_cast<boost::int64_t>(a) *
- static_cast<boost::int64_t>(b) + 0x8000) >> 16;
+ return (static_cast<std::int64_t>(a) *
+ static_cast<std::int64_t>(b) + 0x8000) >> 16;
}
@@ -98,28 +98,28 @@ multiplyFixed16(boost::int32_t a, boost::int32_t b)
void
SWFMatrix::transform(geometry::Point2d& p) const
{
- boost::int32_t t0 = multiplyFixed16(_a, p.x) + multiplyFixed16(_c, p.y) +
_tx;
- boost::int32_t t1 = multiplyFixed16(_b, p.x) + multiplyFixed16(_d, p.y) +
_ty;
+ std::int32_t t0 = multiplyFixed16(_a, p.x) + multiplyFixed16(_c, p.y) +
_tx;
+ std::int32_t t1 = multiplyFixed16(_b, p.x) + multiplyFixed16(_d, p.y) +
_ty;
p.x = t0;
p.y = t1;
}
void
-SWFMatrix::transform(boost::int32_t& x, boost::int32_t& y) const
+SWFMatrix::transform(std::int32_t& x, std::int32_t& y) const
{
- const boost::int32_t t0 = multiplyFixed16(_a, x) + multiplyFixed16(_c, y)
+ _tx;
- const boost::int32_t t1 = multiplyFixed16(_b,x) + multiplyFixed16(_d, y)
+ _ty;
+ const std::int32_t t0 = multiplyFixed16(_a, x) + multiplyFixed16(_c, y) +
_tx;
+ const std::int32_t t1 = multiplyFixed16(_b,x) + multiplyFixed16(_d, y) +
_ty;
x = t0;
y = t1;
}
void
-SWFMatrix::transform(geometry::Range2d<boost::int32_t>& r) const
+SWFMatrix::transform(geometry::Range2d<std::int32_t>& r) const
{
- const boost::int32_t xmin = r.getMinX();
- const boost::int32_t xmax = r.getMaxX();
- const boost::int32_t ymin = r.getMinY();
- const boost::int32_t ymax = r.getMaxY();
+ const std::int32_t xmin = r.getMinX();
+ const std::int32_t xmax = r.getMaxX();
+ const std::int32_t ymin = r.getMinY();
+ const std::int32_t ymax = r.getMaxY();
point p0(xmin, ymin);
point p1(xmin, ymax);
@@ -262,10 +262,10 @@ SWFMatrix::transform(SWFRect& r) const
{
if (r.is_null()) return;
- const boost::int32_t x1 = r.get_x_min();
- const boost::int32_t y1 = r.get_y_min();
- const boost::int32_t x2 = r.get_x_max();
- const boost::int32_t y2 = r.get_y_max();
+ const std::int32_t x1 = r.get_x_min();
+ const std::int32_t y1 = r.get_y_min();
+ const std::int32_t x2 = r.get_x_max();
+ const std::int32_t y2 = r.get_y_max();
point p0(x1, y1);
point p1(x2, y1);
@@ -287,7 +287,7 @@ SWFMatrix::transform(SWFRect& r) const
SWFMatrix&
SWFMatrix::invert()
{
- const boost::int64_t det = determinant();
+ const std::int64_t det = determinant();
if (det == 0) {
set_identity();
@@ -296,12 +296,12 @@ SWFMatrix::invert()
const double dn = 65536.0 * 65536.0 / det;
- const boost::int32_t t0 = (boost::int32_t)(d() * dn);
- _d = (boost::int32_t)(a() * dn);
- _c = (boost::int32_t)(-c() * dn);
- _b = (boost::int32_t)(-b() * dn);
+ const std::int32_t t0 = (std::int32_t)(d() * dn);
+ _d = (std::int32_t)(a() * dn);
+ _c = (std::int32_t)(-c() * dn);
+ _b = (std::int32_t)(-b() * dn);
- const boost::int32_t t4 = -(multiplyFixed16(_tx, t0) +
multiplyFixed16(_ty, _c));
+ const std::int32_t t4 = -(multiplyFixed16(_tx, t0) + multiplyFixed16(_ty,
_c));
_ty = -(multiplyFixed16(_tx, _b) + multiplyFixed16(_ty, _d));
_a = t0;
@@ -333,7 +333,7 @@ SWFMatrix::get_rotation() const
}
// private
-boost::int64_t
+std::int64_t
SWFMatrix::determinant() const
{
// | _a _c _tx |
@@ -343,7 +343,7 @@ SWFMatrix::determinant() const
// Det(T) = ( (_a * _d * 1 ) + (_c * _ty * 0) + (_tx * _b * 0) ) -
// ( (0 * _d * _tx) + (0 * _ty * _a) + (1 * _c * _b) )
// = _a * _d - _b * _c
- return (boost::int64_t)a() * d() - (boost::int64_t)b() * c();
+ return (std::int64_t)a() * d() - (std::int64_t)b() * c();
}
std::ostream&
diff --git a/libcore/SWFMatrix.h b/libcore/SWFMatrix.h
index 3747b70..b8251a9 100644
--- a/libcore/SWFMatrix.h
+++ b/libcore/SWFMatrix.h
@@ -28,7 +28,7 @@
#include "dsodefs.h" // for DSOEXPORT
#include <iosfwd>
-#include <boost/cstdint.hpp>
+#include <cstdint>
// Forward declarations
namespace gnash {
@@ -76,27 +76,27 @@ public:
_ty(y)
{}
- boost::int32_t a() const {
+ std::int32_t a() const {
return _a;
}
- boost::int32_t b() const {
+ std::int32_t b() const {
return _b;
}
- boost::int32_t c() const {
+ std::int32_t c() const {
return _c;
}
- boost::int32_t d() const {
+ std::int32_t d() const {
return _d;
}
- boost::int32_t tx() const {
+ std::int32_t tx() const {
return _tx;
}
- boost::int32_t ty() const {
+ std::int32_t ty() const {
return _ty;
}
@@ -159,7 +159,7 @@ public:
void transform(geometry::Point2d& p) const;
/// Transform the given point by our SWFMatrix.
- void transform(boost::int32_t& x, boost::int32_t& y) const;
+ void transform(std::int32_t& x, std::int32_t& y) const;
/// Transform point 'p' by our SWFMatrix.
//
@@ -171,7 +171,7 @@ public:
//
/// NULL and WORLD ranges are untouched.
///
- void transform(geometry::Range2d<boost::int32_t>& r) const;
+ void transform(geometry::Range2d<std::int32_t>& r) const;
void transform(SWFRect& r) const;
@@ -203,25 +203,25 @@ public:
private:
/// Return the determinant of this SWFMatrix in 32.32 fixed point format.
- boost::int64_t determinant() const;
+ std::int64_t determinant() const;
/// Xscale, 16.16 fixed point. xx in swfdec. 'a' in AS Matrix.
- boost::int32_t _a;
+ std::int32_t _a;
/// Xshear, 16.16 fixed point. yx in swfdec. 'b' in AS Matrix.
- boost::int32_t _b;
+ std::int32_t _b;
/// Yshear, 16.16 fixed point. xy in swfdec. 'c' in AS Matrix.
- boost::int32_t _c;
+ std::int32_t _c;
/// Yscale, 16.16 fixed point. yy in swfdec. 'd' in AS Matrix.
- boost::int32_t _d;
+ std::int32_t _d;
/// Xtranslation, TWIPS. x0 in swfdec. '_tx' in AS Matrix.
- boost::int32_t _tx;
+ std::int32_t _tx;
/// Ytranslation, TWIPS. y0 in swfdec. '_ty' in AS Matrix.
- boost::int32_t _ty;
+ std::int32_t _ty;
}; //end of SWFMatrix
diff --git a/libcore/SWFMovie.cpp b/libcore/SWFMovie.cpp
index e97a540..3754a12 100644
--- a/libcore/SWFMovie.cpp
+++ b/libcore/SWFMovie.cpp
@@ -85,7 +85,7 @@ SWFMovie::advance()
SWF::DefinitionTag*
SWFMovie::exportedCharacter(const std::string& symbol)
{
- const boost::uint16_t id = _def->exportID(symbol);
+ const std::uint16_t id = _def->exportID(symbol);
if (!id) return 0;
Characters::iterator it = _characters.find(id);
if (it == _characters.end()) return 0;
@@ -93,7 +93,7 @@ SWFMovie::exportedCharacter(const std::string& symbol)
}
void
-SWFMovie::addCharacter(boost::uint16_t id)
+SWFMovie::addCharacter(std::uint16_t id)
{
// If a character is already known, we don't want to mark it uninitialized
// again.
@@ -101,7 +101,7 @@ SWFMovie::addCharacter(boost::uint16_t id)
}
bool
-SWFMovie::initializeCharacter(boost::uint16_t cid)
+SWFMovie::initializeCharacter(std::uint16_t cid)
{
Characters::iterator it = _characters.find(cid);
if (it == _characters.end()) {
diff --git a/libcore/SWFMovie.h b/libcore/SWFMovie.h
index d7d6ce8..154208e 100644
--- a/libcore/SWFMovie.h
+++ b/libcore/SWFMovie.h
@@ -51,7 +51,7 @@ class SWFMovie : public Movie
{
/// A container to track known characters and whether they are initialized.
- typedef std::map<boost::uint16_t, bool> Characters;
+ typedef std::map<std::uint16_t, bool> Characters;
public:
@@ -117,7 +117,7 @@ public:
/// If a duplicated character is added, it will not be marked
/// uninitialized, as SWF::DoInitAction tags are only executed once
/// for each id.
- void addCharacter(boost::uint16_t id);
+ void addCharacter(std::uint16_t id);
/// Attempt to mark a character as initialized.
//
@@ -130,7 +130,7 @@ public:
/// or has not yet been placed on stage).
/// 2. The character has already been initialized.
/// true if the character was marked initialized.
- bool initializeCharacter(boost::uint16_t id);
+ bool initializeCharacter(std::uint16_t id);
const movie_definition* definition() const {
return _def.get();
diff --git a/libcore/SWFRect.cpp b/libcore/SWFRect.cpp
index 58cf869..cbc101d 100644
--- a/libcore/SWFRect.cpp
+++ b/libcore/SWFRect.cpp
@@ -27,18 +27,18 @@
namespace gnash {
-const boost::int32_t SWFRect::rectNull;
-const boost::int32_t SWFRect::rectMax;
+const std::int32_t SWFRect::rectNull;
+const std::int32_t SWFRect::rectMax;
// Set ourself to bound a rectangle that has been transformed by m.
void
SWFRect::enclose_transformed_rect(const SWFMatrix& m, const SWFRect& r)
{
- boost::int32_t x1 = r.get_x_min();
- boost::int32_t y1 = r.get_y_min();
- boost::int32_t x2 = r.get_x_max();
- boost::int32_t y2 = r.get_y_max();
+ std::int32_t x1 = r.get_x_min();
+ std::int32_t y1 = r.get_y_min();
+ std::int32_t x2 = r.get_x_max();
+ std::int32_t y2 = r.get_y_max();
point p0(x1, y1);
point p1(x2, y1);
@@ -81,10 +81,10 @@ SWFRect::expand_to_transformed_rect(const SWFMatrix& m,
const SWFRect& r)
return;
}
- const boost::int32_t x1 = r.get_x_min();
- const boost::int32_t y1 = r.get_y_min();
- const boost::int32_t x2 = r.get_x_max();
- const boost::int32_t y2 = r.get_y_max();
+ const std::int32_t x1 = r.get_x_min();
+ const std::int32_t y1 = r.get_y_min();
+ const std::int32_t x2 = r.get_x_max();
+ const std::int32_t y2 = r.get_y_max();
point p0(x1, y1);
point p1(x2, y1);
@@ -124,8 +124,8 @@ void
SWFRect::clamp(point& p) const
{
assert( !is_null() );
- p.x = gnash::clamp<boost::int32_t>(p.x, _xMin, _xMax);
- p.y = gnash::clamp<boost::int32_t>(p.y, _yMin, _yMax);
+ p.x = gnash::clamp<std::int32_t>(p.x, _xMin, _xMax);
+ p.y = gnash::clamp<std::int32_t>(p.y, _yMin, _yMax);
}
std::string
diff --git a/libcore/SWFRect.h b/libcore/SWFRect.h
index 8c814bf..d5cdfe7 100644
--- a/libcore/SWFRect.h
+++ b/libcore/SWFRect.h
@@ -23,7 +23,7 @@
#include <string>
#include <cassert>
#include <ostream>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "dsodefs.h"
#include "Range2d.h"
@@ -46,8 +46,8 @@ class SWFRect
public:
- static const boost::int32_t rectNull = 0x80000000;
- static const boost::int32_t rectMax = 0x7fffffff;
+ static const std::int32_t rectNull = 0x80000000;
+ static const std::int32_t rectMax = 0x7fffffff;
/// Ouput operator
friend std::ostream& operator<< (std::ostream& os, const SWFRect& SWFRect);
@@ -100,47 +100,47 @@ public:
}
/// Return width of this rectangle in TWIPS
- boost::int32_t width() const
+ std::int32_t width() const
{
return _xMax - _xMin;
}
/// Return height of this rectangle in TWIPS
- boost::int32_t height() const
+ std::int32_t height() const
{
return _yMax - _yMin;
}
/// Get the x coordinate of the left-up corner.
- boost::int32_t get_x_min() const
+ std::int32_t get_x_min() const
{
assert(!is_null());
return _xMin;
}
/// Get the x coordinate of the right-down corner.
- boost::int32_t get_x_max() const
+ std::int32_t get_x_max() const
{
assert(!is_null());
return _xMax;
}
/// Get the y coordinate of the left-up corner.
- boost::int32_t get_y_min() const
+ std::int32_t get_y_min() const
{
assert(!is_null());
return _yMin;
}
/// Get the y coordinate of the right-down corner.
- boost::int32_t get_y_max() const
+ std::int32_t get_y_max() const
{
assert(!is_null());
return _yMax;
}
/// Return true if the given point is inside this SWFRect.
- bool point_test(boost::int32_t x, boost::int32_t y) const
+ bool point_test(std::int32_t x, std::int32_t y) const
{
if (is_null()) return false;
@@ -151,15 +151,15 @@ public:
}
/// Set ourself to bound the given point
- void set_to_point(boost::int32_t x, boost::int32_t y)
+ void set_to_point(std::int32_t x, std::int32_t y)
{
_xMin = _xMax = x;
_yMin = _yMax = y;
}
- void set_to_rect(boost::int32_t x1, boost::int32_t y1, boost::int32_t x2,
- boost::int32_t y2)
+ void set_to_rect(std::int32_t x1, std::int32_t y1, std::int32_t x2,
+ std::int32_t y2)
{
_xMin = x1;
_yMin = y1;
@@ -168,7 +168,7 @@ public:
}
/// Expand this rectangle to enclose the given point.
- void expand_to_point(boost::int32_t x, boost::int32_t y)
+ void expand_to_point(std::int32_t x, std::int32_t y)
{
if (is_null()) {
set_to_point(x, y);
@@ -183,8 +183,8 @@ public:
void enclose_transformed_rect(const SWFMatrix& m, const SWFRect& r);
/// Expand this rectangle to enclose the given circle.
- void expand_to_circle(boost::int32_t x, boost::int32_t y,
- boost::int32_t radius)
+ void expand_to_circle(std::int32_t x, std::int32_t y,
+ std::int32_t radius)
{
// I know it's easy to make code work for minus radius.
// would do that untill I see the requirement for a SWF RECTANGLE.
@@ -219,20 +219,20 @@ public:
/// Construct and return a Range2d object.
// TODO: deprecate this.
- geometry::Range2d<boost::int32_t> getRange() const
+ geometry::Range2d<std::int32_t> getRange() const
{
if (is_null())
{
// Range2d has a differnt idea about what is a null SWFRect.
- return geometry::Range2d<boost::int32_t>(geometry::nullRange);
+ return geometry::Range2d<std::int32_t>(geometry::nullRange);
}
else if( is_world() )
{
- return geometry::Range2d<boost::int32_t>(geometry::worldRange);
+ return geometry::Range2d<std::int32_t>(geometry::worldRange);
}
else
{
- return geometry::Range2d<boost::int32_t>(_xMin, _yMin,
+ return geometry::Range2d<std::int32_t>(_xMin, _yMin,
_xMax, _yMax);
}
}
@@ -243,7 +243,7 @@ public:
private:
// make ourself to enclose the given point.
- void expand_to(boost::int32_t x, boost::int32_t y)
+ void expand_to(std::int32_t x, std::int32_t y)
{
_xMin = std::min(_xMin, x);
_yMin = std::min(_yMin, y);
@@ -251,10 +251,10 @@ private:
_yMax = std::max(_yMax, y);
}
- boost::int32_t _xMin; // TWIPS
- boost::int32_t _yMin; // TWIPS
- boost::int32_t _xMax; // TWIPS
- boost::int32_t _yMax; // TWIPS
+ std::int32_t _xMin; // TWIPS
+ std::int32_t _yMin; // TWIPS
+ std::int32_t _xMax; // TWIPS
+ std::int32_t _yMax; // TWIPS
};
diff --git a/libcore/SWFStream.cpp b/libcore/SWFStream.cpp
index 9f9a97c..6001bf7 100644
--- a/libcore/SWFStream.cpp
+++ b/libcore/SWFStream.cpp
@@ -117,7 +117,7 @@ unsigned SWFStream::read_uint(unsigned short bitcount)
{
typedef unsigned char byte;
- boost::uint32_t value = 0;
+ std::uint32_t value = 0;
if (m_unused_bits) // Consume all the unused bits.
{
@@ -192,11 +192,11 @@ SWFStream::read_sint(unsigned short bitcount)
{
assert(bitcount > 0);
- boost::int32_t value = boost::int32_t(read_uint(bitcount));
+ std::int32_t value = std::int32_t(read_uint(bitcount));
// Sign extend...
if (value & (1 << (bitcount - 1))) {
- value |= static_cast<boost::uint32_t>(-1) << bitcount;
+ value |= static_cast<std::uint32_t>(-1) << bitcount;
}
// IF_DEBUG(log_debug("SWFStream::read_sint(%d) == %d\n", bitcount,
value)));
@@ -246,16 +246,16 @@ convert_float_little(const void *p)
// Hairy union for endian detection and munging
union {
float f;
- boost::uint32_t i;
+ std::uint32_t i;
struct { // for endian detection
- boost::uint16_t s0;
- boost::uint16_t s1;
+ std::uint16_t s0;
+ std::uint16_t s1;
} s;
struct { // for byte-swapping
- boost::uint8_t c0;
- boost::uint8_t c1;
- boost::uint8_t c2;
- boost::uint8_t c3;
+ std::uint8_t c0;
+ std::uint8_t c1;
+ std::uint8_t c2;
+ std::uint8_t c3;
} c;
} u;
@@ -266,7 +266,7 @@ convert_float_little(const void *p)
break;
case 0x3f80: // big-endian host
{
- const boost::uint8_t *cp = (const boost::uint8_t *) p;
+ const std::uint8_t *cp = (const std::uint8_t *) p;
u.c.c0 = cp[3];
u.c.c1 = cp[2];
u.c.c2 = cp[1];
@@ -316,20 +316,20 @@ double SWFStream::read_d64()
}
-boost::uint8_t SWFStream::read_u8()
+std::uint8_t SWFStream::read_u8()
{
align();
return m_input->read_byte();
}
-boost::int8_t
+std::int8_t
SWFStream::read_s8()
{
// read_u8 will align
return read_u8();
}
-boost::uint16_t SWFStream::read_u16()
+std::uint16_t SWFStream::read_u16()
{
#ifdef USE_TU_FILE_BYTESWAPPING
align();
@@ -345,26 +345,26 @@ boost::uint16_t SWFStream::read_u16()
throw ParserException(_("Unexpected end of stream while reading"));
}
- boost::uint32_t result = buf[0];
+ std::uint32_t result = buf[0];
result |= (buf[1] << 8);
return result;
#endif
}
-boost::int16_t SWFStream::read_s16()
+std::int16_t SWFStream::read_s16()
{
// read_u16 will align
return read_u16();
}
-boost::uint32_t SWFStream::read_u32()
+std::uint32_t SWFStream::read_u32()
{
#ifdef USE_TU_FILE_BYTESWAPPING
align();
return m_input->read_le32();
#else
- using boost::uint32_t;
+ using std::uint32_t;
const unsigned short dataLength = 4;
@@ -385,7 +385,7 @@ boost::uint32_t SWFStream::read_u32()
#endif
}
-boost::int32_t SWFStream::read_s32()
+std::int32_t SWFStream::read_s32()
{
// read_u32 will align
return read_u32();
diff --git a/libcore/SWFStream.h b/libcore/SWFStream.h
index d35801b..19c8b5f 100644
--- a/libcore/SWFStream.h
+++ b/libcore/SWFStream.h
@@ -27,7 +27,7 @@
#include <string>
#include <sstream>
#include <vector> // for composition
-#include <boost/cstdint.hpp> // for boost::?int??_t
+#include <cstdint> // for boost::?int??_t
// Define the following macro if you want to want Gnash parser
// to assume the underlying SWF is well-formed. It would make
@@ -148,38 +148,38 @@ public:
//
/// aligned read
///
- boost::uint8_t read_u8();
+ std::uint8_t read_u8();
/// Read a aligned signed 8-bit value from the stream.
//
/// aligned read
///
- boost::int8_t read_s8();
+ std::int8_t read_s8();
/// Read a aligned unsigned 16-bit value from the stream.
//
/// aligned read
///
- boost::uint16_t read_u16();
+ std::uint16_t read_u16();
/// Read a aligned signed 16-bit value from the stream.
//
/// aligned read
///
- boost::int16_t read_s16();
+ std::int16_t read_s16();
/// Read a aligned unsigned 32-bit value from the stream.
//
/// aligned read
///
- boost::uint32_t read_u32();
+ std::uint32_t read_u32();
/// \brief
/// Read a aligned signed 32-bit value from the stream.
//
/// aligned read
///
- boost::int32_t read_s32();
+ std::int32_t read_s32();
/// \brief
/// Read a variable length unsigned 32-bit value from the stream.
@@ -188,10 +188,10 @@ public:
//
/// aligned read
///
- boost::uint32_t read_V32()
+ std::uint32_t read_V32()
{
ensureBytes(1);
- boost::uint32_t res = read_u8();
+ std::uint32_t res = read_u8();
if (!(res & 0x00000080)) return res;
ensureBytes(1);
@@ -415,8 +415,8 @@ public:
private:
IOChannel* m_input;
- boost::uint8_t m_current_byte;
- boost::uint8_t m_unused_bits;
+ std::uint8_t m_current_byte;
+ std::uint8_t m_unused_bits;
typedef std::pair<unsigned long,unsigned long> TagBoundaries;
// position of start and end of tag
diff --git a/libcore/Shape.cpp b/libcore/Shape.cpp
index b92ae9f..301cd05 100644
--- a/libcore/Shape.cpp
+++ b/libcore/Shape.cpp
@@ -24,7 +24,7 @@
namespace gnash {
bool
-Shape::pointInShape(boost::int32_t x, boost::int32_t y) const
+Shape::pointInShape(std::int32_t x, std::int32_t y) const
{
SWFMatrix wm = getWorldMatrix(*this);
wm.invert();
diff --git a/libcore/Shape.h b/libcore/Shape.h
index 78d9b87..ea218f9 100644
--- a/libcore/Shape.h
+++ b/libcore/Shape.h
@@ -63,7 +63,7 @@ public:
return _def ? _def->bounds() : _shape->getBounds();
}
- virtual bool pointInShape(boost::int32_t x, boost::int32_t y) const;
+ virtual bool pointInShape(std::int32_t x, std::int32_t y) const;
private:
diff --git a/libcore/StaticText.cpp b/libcore/StaticText.cpp
index badd1b9..875b012 100644
--- a/libcore/StaticText.cpp
+++ b/libcore/StaticText.cpp
@@ -39,14 +39,14 @@ StaticText::getStaticText(std::vector<const
SWF::TextRecord*>& to,
}
void
-StaticText::setSelectionColor(boost::uint32_t color)
+StaticText::setSelectionColor(std::uint32_t color)
{
// Drop any alpha value
_selectionColor.parseRGB(color & 0xffffff);
}
bool
-StaticText::pointInShape(boost::int32_t x, boost::int32_t y) const
+StaticText::pointInShape(std::int32_t x, std::int32_t y) const
{
// TODO: check actual point in shape, as tested
// in misc-ming.all/DefineTextTest.swf
diff --git a/libcore/StaticText.h b/libcore/StaticText.h
index f392a73..cba7729 100644
--- a/libcore/StaticText.h
+++ b/libcore/StaticText.h
@@ -85,13 +85,13 @@ public:
return _selectedText;
}
- void setSelectionColor(boost::uint32_t color);
+ void setSelectionColor(std::uint32_t color);
virtual SWFRect getBounds() const {
return _def->bounds();
}
- virtual bool pointInShape(boost::int32_t x, boost::int32_t y) const;
+ virtual bool pointInShape(std::int32_t x, std::int32_t y) const;
const rgba& selectionColor() const {
return _selectionColor;
diff --git a/libcore/SystemClock.cpp b/libcore/SystemClock.cpp
index 6714b06..8a949f0 100644
--- a/libcore/SystemClock.cpp
+++ b/libcore/SystemClock.cpp
@@ -22,13 +22,13 @@
#include "ClockTime.h" // for getting system time
-#include <boost/cstdint.hpp> // for boost::uint64_t typedef
+#include <cstdint> // for std::uint64_t typedef
namespace gnash {
namespace {
-boost::uint64_t
+std::uint64_t
fetchSystemTime()
{
// ClockTime::getTicks always returns milliseconds
diff --git a/libcore/SystemClock.h b/libcore/SystemClock.h
index 7ba7fb0..9934fbf 100644
--- a/libcore/SystemClock.h
+++ b/libcore/SystemClock.h
@@ -22,7 +22,7 @@
#include "VirtualClock.h" // for inheritance
-#include <boost/cstdint.hpp> // for boost::uint64_t typedef
+#include <cstdint> // for std::uint64_t typedef
#include "dsodefs.h"
namespace gnash
@@ -49,7 +49,7 @@ public:
private:
/// System time at time of start
- boost::uint64_t _startTime;
+ std::uint64_t _startTime;
};
diff --git a/libcore/TextField.cpp b/libcore/TextField.cpp
index 36608cf..dc94848 100644
--- a/libcore/TextField.cpp
+++ b/libcore/TextField.cpp
@@ -249,9 +249,9 @@ TextField::show_cursor(Renderer& renderer, const SWFMatrix&
mat)
if (_textRecords.empty()) {
return;
}
- boost::uint16_t x;
- boost::uint16_t y;
- boost::uint16_t h;
+ std::uint16_t x;
+ std::uint16_t y;
+ std::uint16_t h;
size_t i = cursorRecord();
SWF::TextRecord record = _textRecords[i];
@@ -305,10 +305,10 @@ TextField::display(Renderer& renderer, const Transform&
base)
if ((drawBorder || drawBackground) && !_bounds.is_null()) {
- boost::int32_t xmin = _bounds.get_x_min();
- boost::int32_t xmax = _bounds.get_x_max();
- boost::int32_t ymin = _bounds.get_y_min();
- boost::int32_t ymax = _bounds.get_y_max();
+ std::int32_t xmin = _bounds.get_x_min();
+ std::int32_t xmax = _bounds.get_x_max();
+ std::int32_t ymin = _bounds.get_y_min();
+ std::int32_t ymax = _bounds.get_y_max();
const std::vector<point> coords = boost::assign::list_of
(point(xmin, ymin))
@@ -739,7 +739,7 @@ TextField::mouseEvent(const event_id& ev)
case event_id::PRESS:
{
movie_root& root = stage();
- boost::int32_t x_mouse, y_mouse;
+ std::int32_t x_mouse, y_mouse;
boost::tie(x_mouse, y_mouse) = root.mousePosition();
SWFMatrix m = getMatrix(*this);
@@ -772,7 +772,7 @@ TextField::mouseEvent(const event_id& ev)
}
InteractiveObject*
-TextField::topmostMouseEntity(boost::int32_t x, boost::int32_t y)
+TextField::topmostMouseEntity(std::int32_t x, std::int32_t y)
{
if (!visible()) return 0;
@@ -957,7 +957,7 @@ TextField::setFont(boost::intrusive_ptr<const Font> newfont)
void
-TextField::insertTab(SWF::TextRecord& rec, boost::int32_t& x, float scale)
+TextField::insertTab(SWF::TextRecord& rec, std::int32_t& x, float scale)
{
// tab (ASCII HT)
const int space = 32;
@@ -1047,16 +1047,16 @@ TextField::format_text()
return;
}
- boost::uint16_t fontHeight = getFontHeight();
+ std::uint16_t fontHeight = getFontHeight();
const float scale = fontHeight /
static_cast<float>(_font->unitsPerEM(_embedFonts));
// TODO: work out how leading affects things.
const float fontLeading = 0;
- const boost::uint16_t leftMargin = getLeftMargin();
- const boost::uint16_t indent = getIndent();
- const boost::uint16_t blockIndent = getBlockIndent();
+ const std::uint16_t leftMargin = getLeftMargin();
+ const std::uint16_t indent = getIndent();
+ const std::uint16_t blockIndent = getBlockIndent();
const bool underlined = getUnderlined();
/// Remember the current bounds for autosize.
@@ -1103,8 +1103,8 @@ TextField::format_text()
rec.addGlyph(ge, 4);
}
- boost::int32_t x = static_cast<boost::int32_t>(rec.xOffset());
- boost::int32_t y = static_cast<boost::int32_t>(rec.yOffset());
+ std::int32_t x = static_cast<std::int32_t>(rec.xOffset());
+ std::int32_t y = static_cast<std::int32_t>(rec.yOffset());
// Start the bbox at the upper-left corner of the first glyph.
//reset_bounding_box(x, y + fontHeight);
@@ -1164,7 +1164,7 @@ TextField::format_text()
void
TextField::scrollLines()
{
- boost::uint16_t fontHeight = getFontHeight();
+ std::uint16_t fontHeight = getFontHeight();
const float fontLeading = 0;
_linesindisplay = _bounds.height() / (fontHeight + fontLeading +
PADDING_TWIPS);
@@ -1204,7 +1204,7 @@ TextField::scrollLines()
}
void
-TextField::newLine(boost::int32_t& x, boost::int32_t& y,
+TextField::newLine(std::int32_t& x, std::int32_t& y,
SWF::TextRecord& rec, int& last_space_glyph,
LineStarts::value_type& last_line_start_record,
float div)
{
@@ -1292,8 +1292,8 @@ TextField::newLine(boost::int32_t& x, boost::int32_t& y,
void
TextField::handleChar(std::wstring::const_iterator& it,
- const std::wstring::const_iterator& e, boost::int32_t& x,
- boost::int32_t& y, SWF::TextRecord& rec, int& last_code,
+ const std::wstring::const_iterator& e, std::int32_t& x,
+ std::int32_t& y, SWF::TextRecord& rec, int& last_code,
int& last_space_glyph, LineStarts::value_type& last_line_start_record)
{
LineStarts::iterator linestartit = _line_starts.begin();
@@ -1307,7 +1307,7 @@ TextField::handleChar(std::wstring::const_iterator& it,
const float leading = 0;
const float fontLeading = 0;
- boost::uint32_t code = 0;
+ std::uint32_t code = 0;
while (it != e)
{
code = *it++;
@@ -1435,7 +1435,7 @@ TextField::handleChar(std::wstring::const_iterator& it,
}
else if (s == "FONT") {
//font
- boost::uint16_t originalsize = _fontHeight;
+ std::uint16_t originalsize = _fontHeight;
attloc = attributes.find("COLOR");
if (attloc != attributes.end()) {
std::string hexval(attloc->second);
@@ -1557,11 +1557,11 @@ TextField::handleChar(std::wstring::const_iterator& it,
else if (s == "TEXTFORMAT") {
log_debug("in textformat");
//textformat
- boost::uint16_t originalblockindent =
getBlockIndent();
- boost::uint16_t originalindent = getIndent();
- boost::uint16_t originalleading = getLeading();
- boost::uint16_t originalleftmargin =
getLeftMargin();
- boost::uint16_t originalrightmargin =
getRightMargin();
+ std::uint16_t originalblockindent =
getBlockIndent();
+ std::uint16_t originalindent = getIndent();
+ std::uint16_t originalleading = getLeading();
+ std::uint16_t originalleftmargin = getLeftMargin();
+ std::uint16_t originalrightmargin =
getRightMargin();
std::vector<int> originaltabstops = getTabStops();
attloc = attributes.find("BLOCKINDENT");
if (attloc != attributes.end()) {
@@ -1693,7 +1693,7 @@ TextField::handleChar(std::wstring::const_iterator& it,
// being chosen. Flash can currently only handle 16-bit
// values.
int index = rec.getFont()->get_glyph_index(
- static_cast<boost::uint16_t>(code), _embedFonts);
+ static_cast<std::uint16_t>(code), _embedFonts);
IF_VERBOSE_MALFORMED_SWF (
if (index == -1)
@@ -1777,7 +1777,7 @@ TextField::handleChar(std::wstring::const_iterator& it,
}
int index = rec.getFont()->get_glyph_index(
- static_cast<boost::uint16_t>(code), _embedFonts);
+ static_cast<std::uint16_t>(code), _embedFonts);
x += scale * rec.getFont()->get_advance(index,
_embedFonts);
}
@@ -2189,7 +2189,7 @@ TextField::set_variable_name(const std::string& newname)
}
bool
-TextField::pointInShape(boost::int32_t x, boost::int32_t y) const
+TextField::pointInShape(std::int32_t x, std::int32_t y) const
{
const SWFMatrix wm = getWorldMatrix(*this).invert();
point lp(x, y);
@@ -2291,7 +2291,7 @@ TextField::setWordWrap(bool wrap)
}
void
-TextField::setLeading(boost::int16_t h)
+TextField::setLeading(std::int16_t h)
{
if (_leading != h) {
set_invalidated();
@@ -2365,7 +2365,7 @@ TextField::setAlignment(TextAlignment h)
}
void
-TextField::setIndent(boost::uint16_t h)
+TextField::setIndent(std::uint16_t h)
{
if (_indent != h) {
set_invalidated();
@@ -2374,7 +2374,7 @@ TextField::setIndent(boost::uint16_t h)
}
void
-TextField::setBlockIndent(boost::uint16_t h)
+TextField::setBlockIndent(std::uint16_t h)
{
if (_blockIndent != h) {
set_invalidated();
@@ -2383,7 +2383,7 @@ TextField::setBlockIndent(boost::uint16_t h)
}
void
-TextField::setRightMargin(boost::uint16_t h)
+TextField::setRightMargin(std::uint16_t h)
{
if (_rightMargin != h) {
set_invalidated();
@@ -2392,7 +2392,7 @@ TextField::setRightMargin(boost::uint16_t h)
}
void
-TextField::setLeftMargin(boost::uint16_t h)
+TextField::setLeftMargin(std::uint16_t h)
{
if (_leftMargin != h) {
set_invalidated();
@@ -2401,7 +2401,7 @@ TextField::setLeftMargin(boost::uint16_t h)
}
void
-TextField::setFontHeight(boost::uint16_t h)
+TextField::setFontHeight(std::uint16_t h)
{
if (_fontHeight != h) {
set_invalidated();
diff --git a/libcore/TextField.h b/libcore/TextField.h
index 78df198..26c10f4 100644
--- a/libcore/TextField.h
+++ b/libcore/TextField.h
@@ -128,7 +128,7 @@ public:
//
/// @param x x-coordinate
/// @param y y-coordinate
- InteractiveObject* topmostMouseEntity(boost::int32_t x, boost::int32_t
y);
+ InteractiveObject* topmostMouseEntity(std::int32_t x, std::int32_t y);
/// Return the version of the SWF this was parsed from.
//
@@ -219,7 +219,7 @@ public:
}
// See dox in DisplayObject.h
- bool pointInShape(boost::int32_t x, boost::int32_t y) const;
+ bool pointInShape(std::int32_t x, std::int32_t y) const;
/// Return true if the 'background' should be drawn
bool getDrawBackground() const;
@@ -277,7 +277,7 @@ public:
}
/// Get the current maxChars setting of the TextField
- boost::int32_t maxChars() const {
+ std::int32_t maxChars() const {
return _maxChars;
}
@@ -285,7 +285,7 @@ public:
//
/// @param max The maximum number of characters that can be
/// input by the user (Does not restrict Scripts)
- void maxChars(boost::int32_t max) {
+ void maxChars(std::int32_t max) {
_maxChars = max;
}
@@ -446,40 +446,40 @@ public:
const Font* getFont() { return _font.get(); }
- boost::uint16_t getFontHeight() const
+ std::uint16_t getFontHeight() const
{
return _fontHeight;
}
- void setFontHeight(boost::uint16_t h);
+ void setFontHeight(std::uint16_t h);
- boost::uint16_t getLeftMargin() const
+ std::uint16_t getLeftMargin() const
{
return _leftMargin;
}
- void setLeftMargin(boost::uint16_t h);
+ void setLeftMargin(std::uint16_t h);
- boost::uint16_t getRightMargin() const
+ std::uint16_t getRightMargin() const
{
return _rightMargin;
}
- void setRightMargin(boost::uint16_t h);
+ void setRightMargin(std::uint16_t h);
- boost::uint16_t getIndent() const
+ std::uint16_t getIndent() const
{
return _indent;
}
- void setIndent(boost::uint16_t h);
+ void setIndent(std::uint16_t h);
- boost::uint16_t getBlockIndent() const
+ std::uint16_t getBlockIndent() const
{
return _blockIndent;
}
- void setBlockIndent(boost::uint16_t h);
+ void setBlockIndent(std::uint16_t h);
TextAlignment getAlignment() const
{
@@ -488,12 +488,12 @@ public:
void setAlignment(TextAlignment h);
- boost::int16_t getLeading() const
+ std::int16_t getLeading() const
{
return _leading;
}
- void setLeading(boost::int16_t h);
+ void setLeading(std::int16_t h);
bool getUnderlined() const
{
@@ -608,7 +608,7 @@ private:
void updateHtmlText(const std::wstring& s);
- void insertTab(SWF::TextRecord& rec, boost::int32_t& x, float scale);
+ void insertTab(SWF::TextRecord& rec, std::int32_t& x, float scale);
/// What happens when setFocus() is called on this TextField.
//
@@ -623,7 +623,7 @@ private:
void onChanged();
/// Reset our text bounding box to the given point.
- void reset_bounding_box(boost::int32_t x, boost::int32_t y)
+ void reset_bounding_box(std::int32_t x, std::int32_t y)
{
m_text_bounding_box.set_to_point(x, y);
}
@@ -637,14 +637,14 @@ private:
/// Handles a new line, this will be called several times, so this
/// will hopefully make code cleaner
- void newLine(boost::int32_t& x, boost::int32_t& y,
+ void newLine(std::int32_t& x, std::int32_t& y,
SWF::TextRecord& rec, int& last_space_glyph,
LineStarts::value_type&
last_line_start_record, float div);
/// De-reference and do appropriate action for character iterator
void handleChar(std::wstring::const_iterator& it,
- const std::wstring::const_iterator& e, boost::int32_t& x,
- boost::int32_t& y, SWF::TextRecord& rec, int& last_code,
+ const std::wstring::const_iterator& e, std::int32_t& x,
+ std::int32_t& y, SWF::TextRecord& rec, int& last_code,
int& last_space_glyph,
LineStarts::value_type& last_line_start_record);
@@ -782,18 +782,18 @@ private:
/// never be less than the first.
std::pair<size_t, size_t> _selection;
- boost::int16_t _leading;
- boost::uint16_t _indent;
+ std::int16_t _leading;
+ std::uint16_t _indent;
/// Indentation for every line (including the ones created by
/// effect of a word-wrap.
- boost::uint16_t _blockIndent;
+ std::uint16_t _blockIndent;
- boost::uint16_t _leftMargin;
+ std::uint16_t _leftMargin;
- boost::uint16_t _rightMargin;
+ std::uint16_t _rightMargin;
- boost::uint16_t _fontHeight;
+ std::uint16_t _fontHeight;
/// This flag will be true as soon as the TextField
/// is assigned a text value. Only way to be false is
diff --git a/libcore/UserFunction.h b/libcore/UserFunction.h
index 709cd9e..204ffa3 100644
--- a/libcore/UserFunction.h
+++ b/libcore/UserFunction.h
@@ -42,7 +42,7 @@ public:
//
/// Only Function2 functions require local registers; for all others
/// the value should be 0.
- virtual boost::uint8_t registers() const = 0;
+ virtual std::uint8_t registers() const = 0;
protected:
diff --git a/libcore/Video.cpp b/libcore/Video.cpp
index d3295f4..8ed403d 100644
--- a/libcore/Video.cpp
+++ b/libcore/Video.cpp
@@ -139,7 +139,7 @@ Video::getVideoFrame()
return _lastDecodedVideoFrame.get();
}
- const boost::uint16_t current_frame = get_ratio();
+ const std::uint16_t current_frame = get_ratio();
#ifdef DEBUG_EMBEDDED_VIDEO_DECODING
log_debug("Video instance %s need display video frame (ratio) %d",
@@ -160,7 +160,7 @@ Video::getVideoFrame()
// TODO: find a better way than using -1 to show that no
// frames have been decoded yet.
assert(_lastDecodedVideoFrameNum >= -1);
- boost::uint16_t from_frame = _lastDecodedVideoFrameNum + 1;
+ std::uint16_t from_frame = _lastDecodedVideoFrameNum + 1;
// If current frame is smaller then last decoded frame
// we restart decoding from scratch
diff --git a/libcore/Video.h b/libcore/Video.h
index 78840a8..de6a551 100644
--- a/libcore/Video.h
+++ b/libcore/Video.h
@@ -55,7 +55,7 @@ public:
~Video();
- virtual bool pointInShape(boost::int32_t x, boost::int32_t y) const
+ virtual bool pointInShape(std::int32_t x, std::int32_t y) const
{
// video DisplayObject shape is always a rectangle..
return pointInBounds(x, y);
@@ -120,7 +120,7 @@ private:
bool _embeddedStream;
/// Last decoded frame number
- boost::int32_t _lastDecodedVideoFrameNum;
+ std::int32_t _lastDecodedVideoFrameNum;
/// Last decoded frame
std::unique_ptr<image::GnashImage> _lastDecodedVideoFrame;
diff --git a/libcore/abc/AbcBlock.cpp b/libcore/abc/AbcBlock.cpp
index 94ffb21..1b11bfd 100644
--- a/libcore/abc/AbcBlock.cpp
+++ b/libcore/abc/AbcBlock.cpp
@@ -182,7 +182,7 @@ Trait::finalize_mbody(AbcBlock *block, Method *pMethod)
bool
Trait::read(SWFStream* in, AbcBlock *block)
{
- boost::uint32_t name = in->read_V32();
+ std::uint32_t name = in->read_V32();
if (name >= block->_multinamePool.size())
{
log_error(_("ABC: Bad name for trait."));
@@ -198,7 +198,7 @@ Trait::read(SWFStream* in, AbcBlock *block)
_globalName = block->_multinamePool[name].getGlobalName();
_namespace = block->_multinamePool[name].getNamespace();
- boost::uint8_t kind = in->read_u8();
+ std::uint8_t kind = in->read_u8();
_kind = static_cast<Kind>(kind & 0x0F);
log_abc("Trait name: %s, Trait kind: %s",
@@ -211,7 +211,7 @@ Trait::read(SWFStream* in, AbcBlock *block)
{
_slotID = in->read_V32();
_typeIndex = in->read_V32();
- boost::uint32_t vindex = in->read_V32();
+ std::uint32_t vindex = in->read_V32();
log_abc("Slot ID=%u Type=%s Pool index=%u", _slotID,
block->_stringPool[
block->_multinamePool[_typeIndex].getABCName()], vindex);
@@ -234,7 +234,7 @@ Trait::read(SWFStream* in, AbcBlock *block)
// Ignore the 'disp_id'
in->skip_V32();
- boost::uint32_t offset = in->read_V32();
+ std::uint32_t offset = in->read_V32();
log_abc("Method index=%u", offset);
if (offset >= block->_methods.size()) {
log_error(_("Bad method id in trait."));
@@ -261,7 +261,7 @@ Trait::read(SWFStream* in, AbcBlock *block)
case KIND_FUNCTION:
{
_slotID = in->read_V32();
- boost::uint32_t offset = in->read_V32();
+ std::uint32_t offset = in->read_V32();
if (offset >= block->_methods.size()) {
log_error(_("Bad method id in trait."));
return false;
@@ -277,7 +277,7 @@ Trait::read(SWFStream* in, AbcBlock *block)
// Ignore the metadata, but it must be read to know how to ignore it.
if ((kind >> 4) & 0x04) {
- boost::uint32_t mcount = in->read_V32();
+ std::uint32_t mcount = in->read_V32();
for (size_t i = 0; i < mcount; ++i) {
in->skip_V32();
}
@@ -351,7 +351,7 @@ AbcBlock::prepare(Machine* mach)
}
void
-AbcBlock::check_multiname_name(boost::uint32_t name)
+AbcBlock::check_multiname_name(std::uint32_t name)
{
if (name >= _stringPool.size()) {
@@ -360,7 +360,7 @@ AbcBlock::check_multiname_name(boost::uint32_t name)
}
void
-AbcBlock::check_multiname_namespace(boost::uint32_t ns)
+AbcBlock::check_multiname_namespace(std::uint32_t ns)
{
if (ns >= _namespacePool.size()) {
throw ParserException("ABC: Out of bounds namespace for
Multiname.");
@@ -368,7 +368,7 @@ AbcBlock::check_multiname_namespace(boost::uint32_t ns)
}
void
-AbcBlock::check_multiname_namespaceset(boost::uint32_t nsset)
+AbcBlock::check_multiname_namespaceset(std::uint32_t nsset)
{
if (!nsset)
{
@@ -475,13 +475,13 @@ bool
AbcBlock::read_integer_constants()
{
// count overestimates by 1.
- boost::uint32_t count = _stream->read_V32();
+ std::uint32_t count = _stream->read_V32();
_integerPool.resize(count);
if (count)
_integerPool[0] = 0;
for (unsigned int i = 1; i < count; ++i)
{
- _integerPool[i] = static_cast<boost::int32_t>
(_stream->read_V32());
+ _integerPool[i] = static_cast<std::int32_t>
(_stream->read_V32());
}
return true;
}
@@ -491,7 +491,7 @@ bool
AbcBlock::read_unsigned_integer_constants()
{
// count overestimates by 1.
- boost::uint32_t count = _stream->read_V32();
+ std::uint32_t count = _stream->read_V32();
_uIntegerPool.resize(count);
if (count)
_uIntegerPool[0] = 0;
@@ -506,7 +506,7 @@ AbcBlock::read_unsigned_integer_constants()
bool
AbcBlock::read_double_constants()
{
- boost::uint32_t count = _stream->read_V32();
+ std::uint32_t count = _stream->read_V32();
_doublePool.resize(count);
if (count) _doublePool[0] = 0.0;
@@ -523,7 +523,7 @@ bool
AbcBlock::read_string_constants()
{
log_abc("Begin reading string constants.");
- boost::uint32_t count = _stream->read_V32();
+ std::uint32_t count = _stream->read_V32();
log_abc("There are %u string constants.", count);
_stringPool.resize(count);
@@ -532,7 +532,7 @@ AbcBlock::read_string_constants()
}
for (size_t i = 1; i < count; ++i) {
- boost::uint32_t length = _stream->read_V32();
+ std::uint32_t length = _stream->read_V32();
_stream->read_string_with_length(length, _stringPool[i]);
log_abc("Adding string constant to string pool: index=%u %s",
i, _stringPool[i]);
@@ -547,7 +547,7 @@ bool
AbcBlock::read_namespaces()
{
log_abc("Begin reading namespaces.");
- boost::uint32_t count = _stream->read_V32();
+ std::uint32_t count = _stream->read_V32();
log_abc("There are %u namespaces.", count);
_namespacePool.resize(count);
if (count) {
@@ -559,7 +559,7 @@ AbcBlock::read_namespaces()
NamespaceConstant kind =
static_cast<NamespaceConstant>(_stream->read_u8());
- boost::uint32_t nameIndex = _stream->read_V32();
+ std::uint32_t nameIndex = _stream->read_V32();
log_abc("Namespace %u: %s, index %u, name %s", i, kind,
nameIndex, _stringPool[nameIndex]);
@@ -591,7 +591,7 @@ AbcBlock::read_namespaces()
bool
AbcBlock::read_namespace_sets()
{
- boost::uint32_t count = _stream->read_V32();
+ std::uint32_t count = _stream->read_V32();
_namespaceSetPool.resize(count);
if (count)
{
@@ -599,11 +599,11 @@ AbcBlock::read_namespace_sets()
}
for (unsigned int i = 1; i < count; ++i)
{
- boost::uint32_t icount = _stream->read_V32();
+ std::uint32_t icount = _stream->read_V32();
_namespaceSetPool[i].resize(icount);
for (unsigned int j = 0; j < icount; ++j)
{
- boost::uint32_t selection = _stream->read_V32();
+ std::uint32_t selection = _stream->read_V32();
if (!selection || selection >= _namespacePool.size())
{
log_error(_("ABC: Bad namespace for namespace
set."));
@@ -619,7 +619,7 @@ AbcBlock::read_namespace_sets()
bool
AbcBlock::read_multinames()
{
- boost::uint32_t count = _stream->read_V32();
+ std::uint32_t count = _stream->read_V32();
log_abc("There are %u multinames.", count);
_multinamePool.resize(count);
if (count)
@@ -631,9 +631,9 @@ AbcBlock::read_multinames()
for (unsigned int i = 1; i < count; ++i)
{
MultiName::Kind kind =
static_cast<MultiName::Kind>(_stream->read_u8());
- boost::uint32_t ns = 0;
- boost::uint32_t name = 0;
- boost::uint32_t nsset = 0;
+ std::uint32_t ns = 0;
+ std::uint32_t name = 0;
+ std::uint32_t nsset = 0;
log_abc("Multiname %u has kind %s", i, static_cast<int>(kind));
@@ -697,7 +697,7 @@ AbcBlock::read_multinames()
}
bool
-AbcBlock::pool_value(boost::uint32_t index, PoolConstant type, as_value &v)
+AbcBlock::pool_value(std::uint32_t index, PoolConstant type, as_value &v)
{
if (!index)
return true;
@@ -785,7 +785,7 @@ AbcBlock::read_method_infos()
{
log_abc("Begin read_method_infos.");
- boost::uint32_t count = _stream->read_V32();
+ std::uint32_t count = _stream->read_V32();
log_abc("Method count: %u", count);
_methods.resize(count);
@@ -795,8 +795,8 @@ AbcBlock::read_method_infos()
Method *pMethod = mCH->newMethod();
pMethod->setMethodID(i);
_methods[i] = pMethod;
- boost::uint32_t param_count = _stream->read_V32();
- boost::uint32_t return_type = _stream->read_V32();
+ std::uint32_t param_count = _stream->read_V32();
+ std::uint32_t return_type = _stream->read_V32();
const std::string& rt = return_type ?
_stringPool[_multinamePool[return_type].getABCName()] :
@@ -830,7 +830,7 @@ AbcBlock::read_method_infos()
for (size_t j = 0; j < param_count; ++j) {
log_abc(" Reading parameter %u", j);
// The parameter type.
- boost::uint32_t ptype = _stream->read_V32();
+ std::uint32_t ptype = _stream->read_V32();
const std::string& pt = return_type ?
_stringPool[_multinamePool[ptype].getABCName()] :
@@ -860,9 +860,9 @@ AbcBlock::read_method_infos()
}
}
- boost::uint32_t method_name = _stream->read_V32();
+ std::uint32_t method_name = _stream->read_V32();
log_abc( "Method name=%s %d", _stringPool[method_name],
method_name);
- boost::uint8_t flags = _stream->read_u8();
+ std::uint8_t flags = _stream->read_u8();
log_abc(" Flags: %X", flags | 0x0);
// log_abc("Check if flags and optional args.");
// If there are default parameters, read them now.
@@ -870,13 +870,13 @@ AbcBlock::read_method_infos()
// be assigned to the corresponding parameters.
if (flags & METHOD_OPTIONAL_ARGS) {
- boost::uint32_t ocount = _stream->read_V32();
+ std::uint32_t ocount = _stream->read_V32();
log_abc(" Optional args: %u", ocount);
pMethod->setMinArgumentCount(pMethod->maxArgumentCount() - ocount);
for (unsigned int j = 0; j < ocount; ++j) {
log_abc(" Reading optional arg: %u", j);
- boost::uint32_t index = _stream->read_V32();
+ std::uint32_t index = _stream->read_V32();
PoolConstant kindof =
static_cast<PoolConstant>(_stream->read_u8());
@@ -910,11 +910,11 @@ AbcBlock::read_method_infos()
bool
AbcBlock::skip_metadata()
{
- boost::uint32_t count = _stream->read_V32();
+ std::uint32_t count = _stream->read_V32();
for (unsigned int i = 0; i < count; ++i)
{
_stream->skip_V32(); // A name index.
- boost::uint32_t icount = _stream->read_V32();
+ std::uint32_t icount = _stream->read_V32();
for (unsigned int j = 0; j < icount; ++j)
{
// key/values may not be stored together, but this
still works.
@@ -929,12 +929,12 @@ AbcBlock::skip_metadata()
bool
AbcBlock::read_instances()
{
- boost::uint32_t count = _stream->read_V32();
+ std::uint32_t count = _stream->read_V32();
log_abc("There are %u instances.", count);
_classes.resize(count);
for (size_t i = 0; i < count; ++i) {
//Read multiname index.
- boost::uint32_t index = _stream->read_V32();
+ std::uint32_t index = _stream->read_V32();
// 0 is allowed as a name, typically for the last entry.
if (index >= _multinamePool.size()) {
log_error(_("ABC: Out of bounds instance name."));
@@ -978,7 +978,7 @@ AbcBlock::read_instances()
}
cl->setDeclared();
_classes[i] = cl;
- boost::uint32_t super_index = _stream->read_V32();
+ std::uint32_t super_index = _stream->read_V32();
if (super_index && super_index >= _multinamePool.size()) {
log_error(_("ABC: Bad super type."));
@@ -1018,7 +1018,7 @@ AbcBlock::read_instances()
pSuper->setInherited();
}
- boost::uint8_t flags = _stream->read_u8();
+ std::uint8_t flags = _stream->read_u8();
log_abc("Instance %u(%s) multiname index=%u name=%s super
index=%u "
"flags=%X", i, cl, index,
_stringPool[_multinamePool[index].getABCName()],
@@ -1030,7 +1030,7 @@ AbcBlock::read_instances()
if ((flags & 7) == INSTANCE_DYNAMIC) cl->setDynamic();
if (flags & INSTANCE_PROTECTED_NS) {
- boost::uint32_t ns_index = _stream->read_V32();
+ std::uint32_t ns_index = _stream->read_V32();
if (ns_index >= _namespacePool.size()) {
log_error(_("ABC: Bad namespace for
protected."));
return false;
@@ -1044,10 +1044,10 @@ AbcBlock::read_instances()
// This is the list of interfaces which the instances has
agreed to
// implement. They must be interfaces, and they must exist.
- boost::uint32_t intcount = _stream->read_V32();
+ std::uint32_t intcount = _stream->read_V32();
log_abc("This instance has %u interfaces.", intcount);
for (size_t j = 0; j < intcount; ++j) {
- boost::uint32_t i_index = _stream->read_V32();
+ std::uint32_t i_index = _stream->read_V32();
log_abc("Interface %u has multiname index=%u", i,
i_index);
// 0 is allowed as an interface, typically for the last
one.
if (i_index >= _multinamePool.size()) {
@@ -1067,7 +1067,7 @@ AbcBlock::read_instances()
// The next thing should be the constructor.
// TODO: What does this mean exactly? How does it differ from
the one in
// the class info block?
- boost::uint32_t offset = _stream->read_V32();
+ std::uint32_t offset = _stream->read_V32();
log_abc("Moffset: %u", offset);
if (offset >= _methods.size()) {
log_error(_("ABC: Out of bounds method for
initializer."));
@@ -1077,7 +1077,7 @@ AbcBlock::read_instances()
cl->setConstructor(_methods[offset]);
// Next come the 'traits' of the instance. (The members.)
- boost::uint32_t tcount = _stream->read_V32();
+ std::uint32_t tcount = _stream->read_V32();
log_abc("Trait count: %u", tcount);
for (unsigned int j = 0; j < tcount; ++j)
{
@@ -1096,12 +1096,12 @@ AbcBlock::read_classes()
{
// Count was found in read_instances().
log_abc("Begin reading classes.");
- boost::uint32_t count = _classes.size();
+ std::uint32_t count = _classes.size();
log_abc("There are %u classes.", count);
for (size_t i = 0; i < count; ++i) {
abc::Class* cl = _classes[i];
- boost::uint32_t offset = _stream->read_V32();
+ std::uint32_t offset = _stream->read_V32();
log_abc("Class %u(%s) static constructor index=%u", i, cl,
offset);
if (offset >= _methods.size()) {
@@ -1112,7 +1112,7 @@ AbcBlock::read_classes()
// Don't validate for previous owner.
cl->setStaticConstructor(_methods[offset]);
- boost::uint32_t tcount = _stream->read_V32();
+ std::uint32_t tcount = _stream->read_V32();
log_abc("This class has %u traits.", tcount);
for (size_t j = 0; j < tcount; ++j) {
Trait t;
@@ -1131,7 +1131,7 @@ AbcBlock::read_scripts()
{
log_abc("Begin reading scripts.");
- const boost::uint32_t scriptcount = _stream->read_V32();
+ const std::uint32_t scriptcount = _stream->read_V32();
log_abc("There are %u scripts.", scriptcount);
_scripts.resize(scriptcount);
@@ -1140,7 +1140,7 @@ AbcBlock::read_scripts()
abc::Class* script = mCH->newClass();
_scripts[i] = script;
- boost::uint32_t offset = _stream->read_V32();
+ std::uint32_t offset = _stream->read_V32();
log_abc("Reading script %u(%s) initializer method index=%u", i,
script, offset);
if (offset >= _methods.size()) {
@@ -1150,7 +1150,7 @@ AbcBlock::read_scripts()
script->setConstructor(_methods[offset]);
- const boost::uint32_t tcount = _stream->read_V32();
+ const std::uint32_t tcount = _stream->read_V32();
for (size_t j = 0; j < tcount; ++j) {
Trait t;
@@ -1172,11 +1172,11 @@ AbcBlock::read_scripts()
bool
AbcBlock::read_method_bodies()
{
- boost::uint32_t count = _stream->read_V32();
+ std::uint32_t count = _stream->read_V32();
log_abc("There are %u method bodies.", count);
for (unsigned int i = 0; i < count; ++i)
{
- boost::uint32_t offset = _stream->read_V32();
+ std::uint32_t offset = _stream->read_V32();
log_abc("Method body %u method offset=%u", i, offset);
if (offset >= _methods.size()) {
@@ -1204,7 +1204,7 @@ AbcBlock::read_method_bodies()
method.setMaxScope(_stream->read_V32());
// Code length
- boost::uint32_t clength = _stream->read_V32();
+ std::uint32_t clength = _stream->read_V32();
method.setBodyLength(clength);
// The code.
@@ -1219,7 +1219,7 @@ AbcBlock::read_method_bodies()
// Note: catch type and variable name are documented to be
// indices in the string pool, but they are in fact indices
// in the multiname pool.
- const boost::uint32_t ecount = _stream->read_V32();
+ const std::uint32_t ecount = _stream->read_V32();
for (unsigned int j = 0; j < ecount; ++j) {
asException *ex = mCH->newException();
@@ -1231,7 +1231,7 @@ AbcBlock::read_method_bodies()
ex->setCatch(_stream->read_V32());
// What types should be caught.
- boost::uint32_t catch_type = _stream->read_V32();
+ std::uint32_t catch_type = _stream->read_V32();
if (catch_type >= _multinamePool.size()) {
log_error(_("ABC: Out of bound type for
exception."));
return false;
@@ -1259,7 +1259,7 @@ AbcBlock::read_method_bodies()
// A variable name for the catch type.
// In version 46.15, no names.
if (mVersion != ((46 << 16) | 15)) {
- boost::uint32_t cvn = _stream->read_V32();
+ std::uint32_t cvn = _stream->read_V32();
if (cvn >= _multinamePool.size()) {
log_error(_("ABC: Out of bound name for
caught "
"exception."));
@@ -1271,7 +1271,7 @@ AbcBlock::read_method_bodies()
}
// Traits
- boost::uint32_t tcount = _stream->read_V32();
+ std::uint32_t tcount = _stream->read_V32();
for (unsigned int j = 0; j < tcount; ++j)
{
Trait t;
diff --git a/libcore/abc/AbcBlock.h b/libcore/abc/AbcBlock.h
index eba2c84..2a25d0a 100644
--- a/libcore/abc/AbcBlock.h
+++ b/libcore/abc/AbcBlock.h
@@ -131,9 +131,9 @@ private:
bool _hasValue;
Kind _kind;
- boost::uint32_t _slotID;
- boost::uint32_t _typeIndex;
- boost::uint32_t _classInfoIndex;
+ std::uint32_t _slotID;
+ std::uint32_t _typeIndex;
+ std::uint32_t _classInfoIndex;
as_value _value;
URI _name;
@@ -272,7 +272,7 @@ public:
return _scripts;
}
- boost::uint32_t uIntegerPoolAt(size_t i) const {
+ std::uint32_t uIntegerPoolAt(size_t i) const {
checkBounds(i, _uIntegerPool);
return _uIntegerPool[i];
}
@@ -282,7 +282,7 @@ public:
return _stringPool[i];
}
- boost::int32_t integerPoolAt(size_t i) const {
+ std::int32_t integerPoolAt(size_t i) const {
checkBounds(i, _integerPool);
return _integerPool[i];
}
@@ -318,7 +318,7 @@ private:
friend class abc::Trait;
- bool pool_value(boost::uint32_t index, PoolConstant type, as_value &v);
+ bool pool_value(std::uint32_t index, PoolConstant type, as_value &v);
bool read_version();
bool read_integer_constants();
@@ -335,18 +335,18 @@ private:
bool read_scripts();
bool read_method_bodies();
- void check_multiname_name(boost::uint32_t name);
+ void check_multiname_name(std::uint32_t name);
- void check_multiname_namespace(boost::uint32_t ns);
+ void check_multiname_namespace(std::uint32_t ns);
- void check_multiname_namespaceset(boost::uint32_t nsset);
+ void check_multiname_namespaceset(std::uint32_t nsset);
void setMultinameNames(MultiName *n, abc::URI ABCName);
void setNamespaceURI(Namespace *ns, abc::URI ABCName);
- std::vector<boost::int32_t> _integerPool;
- std::vector<boost::uint32_t> _uIntegerPool;
+ std::vector<std::int32_t> _integerPool;
+ std::vector<std::uint32_t> _uIntegerPool;
std::vector<double> _doublePool;
std::vector<std::string> _stringPool;
std::vector<Namespace*> _namespacePool;
@@ -362,7 +362,7 @@ private:
abc::Class *mTheObject;
ClassHierarchy *mCH;
- boost::uint32_t mVersion;
+ std::uint32_t mVersion;
};
diff --git a/libcore/abc/Class.cpp b/libcore/abc/Class.cpp
index 94395a5..0faf13b 100644
--- a/libcore/abc/Class.cpp
+++ b/libcore/abc/Class.cpp
@@ -40,7 +40,7 @@ namespace abc {
bool
Class::addValue(string_table::key name, Namespace *ns,
- boost::uint32_t slotId, Class *type, as_value& val, bool isconst,
+ std::uint32_t slotId, Class *type, as_value& val, bool isconst,
bool isstatic)
{
Global_as* g = VM::get().getGlobal();
@@ -88,14 +88,14 @@ Class::initTraits(AbcBlock& bl)
bool
Class::addMemberScript(string_table::key name, Namespace *ns,
- boost::uint32_t slotId, Class *type, bool isstatic)
+ std::uint32_t slotId, Class *type, bool isstatic)
{
return addSlot(name, ns, slotId, type, isstatic);
}
bool
Class::addSlotFunction(string_table::key name, Namespace *ns,
- boost::uint32_t slotId, Method *method, bool isstatic)
+ std::uint32_t slotId, Method *method, bool isstatic)
{
Class a;
a.setName(NSV::CLASS_FUNCTION);
@@ -105,7 +105,7 @@ Class::addSlotFunction(string_table::key name, Namespace
*ns,
bool
Class::addSlot(string_table::key name, Namespace* ns,
- boost::uint32_t slotId, Class* /*type*/, bool /*isstatic*/)
+ std::uint32_t slotId, Class* /*type*/, bool /*isstatic*/)
{
string_table::key nsname = ns ? ns->getURI() : 0;
@@ -172,7 +172,7 @@ Class::addSetter(string_table::key name, Namespace *ns,
Method *method,
#if 0 // TODO
bool
-Class::addValue(string_table::key name, Namespace *ns, boost::uint32_t slotId,
+Class::addValue(string_table::key name, Namespace *ns, std::uint32_t slotId,
Class *type, as_value& val, bool isconst, bool isstatic,
ClassHierarchy *CH)
{
@@ -185,7 +185,7 @@ Class::addValue(string_table::key name, Namespace *ns,
boost::uint32_t slotId,
}
bool
-Class::addSlot(string_table::key name, Namespace *ns, boost::uint32_t slotId,
+Class::addSlot(string_table::key name, Namespace *ns, std::uint32_t slotId,
Class *type, bool isstatic, ClassHierarchy *CH)
{
asBoundValue *bv = CH->newBoundValue();
@@ -207,7 +207,7 @@ Class::addMethod(string_table::key name, Namespace *ns,
Method *method,
bool
Class::addMemberScript(string_table::key name, Namespace *ns,
- boost::uint32_t slotId, Class *type, bool isstatic)
+ std::uint32_t slotId, Class *type, bool isstatic)
{
if (!isstatic)
return addBinding(name, asBinding(ns, type, slotId, isstatic));
@@ -217,7 +217,7 @@ Class::addMemberScript(string_table::key name, Namespace
*ns,
// TODO: Figure out how this differs from addMethod
bool
Class::addSlotFunction(string_table::key name, Namespace *ns,
- boost::uint32_t slotId, Method *method, bool isstatic)
+ std::uint32_t slotId, Method *method, bool isstatic)
{
if (!isstatic)
return addBinding(name, asBinding(ns, method, slotId,
isstatic));
diff --git a/libcore/abc/Class.h b/libcore/abc/Class.h
index 9143082..8a793ff 100644
--- a/libcore/abc/Class.h
+++ b/libcore/abc/Class.h
@@ -111,11 +111,11 @@ public:
void dump();
bool addValue(string_table::key name, Namespace *ns,
- boost::uint32_t slotID, Class *type, as_value& val,
+ std::uint32_t slotID, Class *type, as_value& val,
bool isconst, bool isstatic);
bool addSlot(string_table::key name, Namespace *ns,
- boost::uint32_t slotID, Class *type, bool isstatic);
+ std::uint32_t slotID, Class *type, bool isstatic);
bool addMethod(string_table::key name, Namespace *ns, Method *method,
bool isstatic);
@@ -127,11 +127,11 @@ public:
bool isstatic);
bool addMemberScript(string_table::key name, Namespace *ns,
- boost::uint32_t slotID, Class *type, bool isstatic);
+ std::uint32_t slotID, Class *type, bool isstatic);
// TODO: Figure out how this differs from addMethod
bool addSlotFunction(string_table::key name, Namespace *ns,
- boost::uint32_t slotID, Method *method, bool isstatic);
+ std::uint32_t slotID, Method *method, bool isstatic);
/// Is the class final?
bool isFinal() const { return _final; }
diff --git a/libcore/abc/CodeStream.cpp b/libcore/abc/CodeStream.cpp
index 5141ffc..73776e7 100644
--- a/libcore/abc/CodeStream.cpp
+++ b/libcore/abc/CodeStream.cpp
@@ -23,13 +23,13 @@
namespace gnash {
/// Read a variable length encoded 32 bit unsigned integer
-boost::uint32_t
+std::uint32_t
CodeStream::read_V32()
{
char data;
read(&data,1);
- boost::uint32_t result = data;
+ std::uint32_t result = data;
if (!(result & 0x00000080)) return result;
read(&data,1);
@@ -50,7 +50,7 @@ CodeStream::read_V32()
}
/// Read an opcode for ActionScript 3
-boost::uint8_t
+std::uint8_t
CodeStream::read_as3op()
{
char data;
@@ -59,7 +59,7 @@ CodeStream::read_as3op()
return 0;
}
else{
- return static_cast<boost::uint8_t> (data);
+ return static_cast<std::uint8_t> (data);
}
}
@@ -78,7 +78,7 @@ CodeStream::seekTo(unsigned int set)
}
//TODO: Is there a better way to read a 24 bit signed int?
-boost::int32_t
+std::int32_t
CodeStream::read_S24()
{
char buffer[3];
@@ -90,7 +90,7 @@ CodeStream::read_S24()
result |= -1 << 24;
}
- return static_cast<boost::int32_t>(result);
+ return static_cast<std::int32_t>(result);
}
/// Read a signed 8-bit character.
@@ -103,12 +103,12 @@ CodeStream::read_s8()
}
/// Read an unsigned 8-bit character.
-boost::uint8_t
+std::uint8_t
CodeStream::read_u8()
{
char data;
read(&data,1);
- return static_cast<boost::uint8_t> (data);
+ return static_cast<std::uint8_t> (data);
}
/// Same as read_V32(), but doesn't bother with the arithmetic for
diff --git a/libcore/abc/CodeStream.h b/libcore/abc/CodeStream.h
index 8d8b826..17e5b21 100644
--- a/libcore/abc/CodeStream.h
+++ b/libcore/abc/CodeStream.h
@@ -22,7 +22,7 @@
#include <string>
#include <boost/utility.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <istream>
#include <sstream>
@@ -45,10 +45,10 @@ public:
}
/// Read a variable length encoded 32 bit unsigned integer
-boost::uint32_t read_V32();
+std::uint32_t read_V32();
/// Read an opcode for ActionScript 3
-boost::uint8_t read_as3op();
+std::uint8_t read_as3op();
/// Change the current position by a relative value.
void seekBy(int change);
@@ -57,13 +57,13 @@ void seekBy(int change);
void seekTo(unsigned int set);
///Read a signed 24 bit interger.
-boost::int32_t read_S24();
+std::int32_t read_S24();
/// Read a signed 8-bit character.
int8_t read_s8();
/// Read an unsigned 8-bit character.
-boost::uint8_t read_u8();
+std::uint8_t read_u8();
/// Same as read_V32(), but doesn't bother with the arithmetic for
/// calculating the value.
diff --git a/libcore/abc/Method.cpp b/libcore/abc/Method.cpp
index d45e3d0..4d5f6c2 100644
--- a/libcore/abc/Method.cpp
+++ b/libcore/abc/Method.cpp
@@ -60,8 +60,8 @@ Method::print_body()
return;
}
std::stringstream ss("Method Body:");
- for(boost::uint32_t i = 0; i < _bodyLength ; ++i) {
- const boost::uint8_t opcode = _body->read_as3op();
+ for(std::uint32_t i = 0; i < _bodyLength ; ++i) {
+ const std::uint8_t opcode = _body->read_as3op();
ss << "0x" << std::uppercase << std::hex << (opcode |
0x0) << " ";
}
_body->seekTo(0);
@@ -93,7 +93,7 @@ Method::setReturnType(Class* /*type*/)
bool
Method::addValue(string_table::key name, Namespace *ns,
- boost::uint32_t slotId, Class *type, as_value& val, bool isconst)
+ std::uint32_t slotId, Class *type, as_value& val, bool isconst)
{
Global_as* g = VM::get().getGlobal();
if (val.is_object()) {
@@ -160,13 +160,13 @@ Method::addSetter(string_table::key name, Namespace *ns,
Method *method)
bool
Method::addMemberScript(string_table::key name, Namespace *ns,
- boost::uint32_t slotId, Class *type)
+ std::uint32_t slotId, Class *type)
{
return addSlot(name, ns, slotId, type);
}
bool
-Method::addSlot(string_table::key name, Namespace* ns, boost::uint32_t slotId,
+Method::addSlot(string_table::key name, Namespace* ns, std::uint32_t slotId,
Class* /*type*/)
{
string_table::key nsname = ns ? ns->getURI() : string_table::key(0);
@@ -178,7 +178,7 @@ Method::addSlot(string_table::key name, Namespace* ns,
boost::uint32_t slotId,
bool
Method::addSlotFunction(string_table::key name, Namespace *ns,
- boost::uint32_t slotId, Method *method)
+ std::uint32_t slotId, Method *method)
{
Class a;
a.setName(NSV::CLASS_FUNCTION);
diff --git a/libcore/abc/Method.h b/libcore/abc/Method.h
index 0aa6cd2..1dd5a26 100644
--- a/libcore/abc/Method.h
+++ b/libcore/abc/Method.h
@@ -58,47 +58,47 @@ public:
Method();
- boost::uint32_t methodID() const {
+ std::uint32_t methodID() const {
return _methodID;
}
- void setMethodID(boost::uint32_t m) {
+ void setMethodID(std::uint32_t m) {
_methodID = m;
}
void initPrototype(Machine* machine);
- boost::uint32_t getMaxRegisters() { return _maxRegisters;}
+ std::uint32_t getMaxRegisters() { return _maxRegisters;}
- void setMaxRegisters(boost::uint32_t maxRegisters) {
+ void setMaxRegisters(std::uint32_t maxRegisters) {
_maxRegisters = maxRegisters;
}
- boost::uint32_t getBodyLength(){ return _bodyLength;}
+ std::uint32_t getBodyLength(){ return _bodyLength;}
- void setBodyLength(boost::uint32_t length){ _bodyLength = length;}
+ void setBodyLength(std::uint32_t length){ _bodyLength = length;}
- void setMaxStack(boost::uint32_t max) {
+ void setMaxStack(std::uint32_t max) {
_maxStack = max;
}
- boost::uint32_t maxStack() const {
+ std::uint32_t maxStack() const {
return _maxStack;
}
- void setMaxScope(boost::uint32_t max) {
+ void setMaxScope(std::uint32_t max) {
_maxScope = max;
}
- boost::uint32_t maxScope() const {
+ std::uint32_t maxScope() const {
return _maxScope;
}
- void setScopeDepth(boost::uint32_t depth) {
+ void setScopeDepth(std::uint32_t depth) {
_scopeDepth = depth;
}
- boost::uint32_t scopeDepth() const {
+ std::uint32_t scopeDepth() const {
return _scopeDepth;
}
@@ -137,10 +137,10 @@ public:
void setBody(CodeStream *b) { _body = b; }
bool addValue(string_table::key name, Namespace *ns,
- boost::uint32_t slotID, Class *type, as_value& val, bool isconst);
+ std::uint32_t slotID, Class *type, as_value& val, bool isconst);
bool addSlot(string_table::key name, Namespace *ns,
- boost::uint32_t slotID, Class *type);
+ std::uint32_t slotID, Class *type);
bool addMethod(string_table::key name, Namespace *ns, Method *method);
@@ -149,10 +149,10 @@ public:
bool addSetter(string_table::key name, Namespace *ns, Method *method);
bool addMemberScript(string_table::key name, Namespace *ns,
- boost::uint32_t slotID, Class *type);
+ std::uint32_t slotID, Class *type);
bool addSlotFunction(string_table::key name, Namespace *ns,
- boost::uint32_t slotID, Method *method);
+ std::uint32_t slotID, Method *method);
/// \brief
/// Set the owner of this method.
@@ -275,23 +275,23 @@ private:
std::vector<Trait> _traits;
- boost::uint32_t _methodID;
+ std::uint32_t _methodID;
abc_function* _prototype;
int _minArguments;
int _maxArguments;
- boost::uint32_t _bodyLength;
+ std::uint32_t _bodyLength;
bool _isNative;
ArgumentList _arguments;
std::list<as_value> _optionalArguments;
as_function* _implementation;
unsigned char _flags;
CodeStream* _body;
- boost::uint32_t _maxRegisters;
+ std::uint32_t _maxRegisters;
- boost::uint32_t _scopeDepth;
- boost::uint32_t _maxScope;
- boost::uint32_t _maxStack;
+ std::uint32_t _scopeDepth;
+ std::uint32_t _maxScope;
+ std::uint32_t _maxStack;
bool _needsActivation;
diff --git a/libcore/abc/MultiName.h b/libcore/abc/MultiName.h
index e9b3696..d02481a 100644
--- a/libcore/abc/MultiName.h
+++ b/libcore/abc/MultiName.h
@@ -79,7 +79,7 @@ public:
_flags = kind;
}
- boost::uint8_t flags() const {
+ std::uint8_t flags() const {
return _flags;
}
@@ -126,7 +126,7 @@ private:
FLAG_NSSET = 0x10
};
- boost::uint8_t _flags;
+ std::uint8_t _flags;
std::vector<Namespace*>* _namespaceSet;
diff --git a/libcore/abc/abc_function.h b/libcore/abc/abc_function.h
index fd3b2b3..b3358bf 100644
--- a/libcore/abc/abc_function.h
+++ b/libcore/abc/abc_function.h
@@ -49,7 +49,7 @@ public:
return _methodInfo->getBody();
}
- boost::uint32_t getMaxRegisters() const {
+ std::uint32_t getMaxRegisters() const {
return _methodInfo->getMaxRegisters();
}
diff --git a/libcore/abc/asException.h b/libcore/abc/asException.h
index 73e381d..6baa4ac 100644
--- a/libcore/abc/asException.h
+++ b/libcore/abc/asException.h
@@ -31,18 +31,18 @@ namespace gnash {
class asException
{
public:
- void setStart(boost::uint32_t i) { _start = i; }
- void setEnd(boost::uint32_t i) { mEnd = i; }
- void setCatch(boost::uint32_t i) { mCatch = i; }
+ void setStart(std::uint32_t i) { _start = i; }
+ void setEnd(std::uint32_t i) { mEnd = i; }
+ void setCatch(std::uint32_t i) { mCatch = i; }
void catchAny() { mCatchAny = true; }
void setCatchType(abc::Class* p) { mCatchType = p; }
void setNamespace(abc::Namespace* n) { _namespace = n; }
void setName(string_table::key name) { _name = name; }
private:
- boost::uint32_t _start;
- boost::uint32_t mEnd;
- boost::uint32_t mCatch;
+ std::uint32_t _start;
+ std::uint32_t mEnd;
+ std::uint32_t mCatch;
bool mCatchAny;
abc::Class *mCatchType;
abc::Namespace *_namespace;
diff --git a/libcore/as_value.cpp b/libcore/as_value.cpp
index c64f79e..dbb673f 100644
--- a/libcore/as_value.cpp
+++ b/libcore/as_value.cpp
@@ -87,12 +87,12 @@ enum Base
/// @param base The base (8 or 16) to use.
/// @param s The string to parse.
/// @return The converted number.
-boost::int32_t
+std::int32_t
parsePositiveInt(const std::string& s, Base base, bool whole = true)
{
std::istringstream is(s);
- boost::uint32_t target;
+ std::uint32_t target;
switch (base)
{
diff --git a/libcore/as_value.h b/libcore/as_value.h
index be7a0f1..e6acc6c 100644
--- a/libcore/as_value.h
+++ b/libcore/as_value.h
@@ -24,7 +24,7 @@
#include <boost/variant.hpp>
#include <iosfwd> // for inlined output operator
#include <type_traits>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "utility.h" // for UNUSED
#include "dsodefs.h" // for DSOTEXPORT
diff --git a/libcore/asobj/ASConversions.cpp b/libcore/asobj/ASConversions.cpp
index caba969..08c019a 100644
--- a/libcore/asobj/ASConversions.cpp
+++ b/libcore/asobj/ASConversions.cpp
@@ -20,7 +20,7 @@
#include "ASConversions.h"
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <cmath>
#include <limits>
@@ -38,7 +38,7 @@ namespace gnash {
namespace {
// Handle overflows from AS ColorTransform double.
- inline boost::int16_t truncateDouble(double d);
+ inline std::int16_t truncateDouble(double d);
}
SWFMatrix
@@ -64,18 +64,18 @@ toSWFMatrix(as_object& m)
}
// Convert input matrix to SWFMatrix.
- const boost::int32_t a = truncateWithFactor<65536>(
+ const std::int32_t a = truncateWithFactor<65536>(
toNumber(getMember(m, NSV::PROP_A), vm));
- const boost::int32_t b = truncateWithFactor<65536>(
+ const std::int32_t b = truncateWithFactor<65536>(
toNumber(getMember(m, NSV::PROP_B), vm));
- const boost::int32_t c = truncateWithFactor<65536>(
+ const std::int32_t c = truncateWithFactor<65536>(
toNumber(getMember(m, NSV::PROP_C), vm));
- const boost::int32_t d = truncateWithFactor<65536>(
+ const std::int32_t d = truncateWithFactor<65536>(
toNumber(getMember(m, NSV::PROP_D), vm));
- const boost::int32_t tx = pixelsToTwips(
+ const std::int32_t tx = pixelsToTwips(
toNumber(getMember(m, NSV::PROP_TX), vm));
- const boost::int32_t ty = pixelsToTwips(
+ const std::int32_t ty = pixelsToTwips(
toNumber(getMember(m, NSV::PROP_TY), vm));
return SWFMatrix(a, b, c, d, tx, ty);
@@ -99,16 +99,16 @@ toCxForm(const ColorTransform_as& tr)
namespace {
-inline boost::int16_t
+inline std::int16_t
truncateDouble(double d)
{
- if (d > std::numeric_limits<boost::int16_t>::max() ||
- d < std::numeric_limits<boost::int16_t>::min())
+ if (d > std::numeric_limits<std::int16_t>::max() ||
+ d < std::numeric_limits<std::int16_t>::min())
{
- return std::numeric_limits<boost::int16_t>::min();
+ return std::numeric_limits<std::int16_t>::min();
}
- return static_cast<boost::int16_t>(d);
+ return static_cast<std::int16_t>(d);
}
}
diff --git a/libcore/asobj/Array_as.cpp b/libcore/asobj/Array_as.cpp
index 7519427..ec9c78a 100644
--- a/libcore/asobj/Array_as.cpp
+++ b/libcore/asobj/Array_as.cpp
@@ -584,7 +584,7 @@ struct as_value_num_nocase_eq : public as_value_lt
// Note:
// SORT_UNIQUE and SORT_RETURN_INDEX must first be stripped from the flag
as_cmp_fn
-get_basic_cmp(boost::uint8_t flags, const fn_call& fn)
+get_basic_cmp(std::uint8_t flags, const fn_call& fn)
{
as_cmp_fn f;
@@ -641,7 +641,7 @@ get_basic_cmp(boost::uint8_t flags, const fn_call& fn)
// Note:
// SORT_UNIQUE and SORT_RETURN_INDEX must first be stripped from the flag
as_cmp_fn
-get_basic_eq(boost::uint8_t flags, const fn_call& fn)
+get_basic_eq(std::uint8_t flags, const fn_call& fn)
{
as_cmp_fn f;
flags &= ~(SORT_DESCENDING);
@@ -826,8 +826,8 @@ private:
// Convenience function to strip SORT_UNIQUE and SORT_RETURN_INDEX from sort
// flag. Presence of flags recorded in douniq and doindex.
-inline boost::uint8_t
-flag_preprocess(boost::uint8_t flgs, bool* douniq, bool* doindex)
+inline std::uint8_t
+flag_preprocess(std::uint8_t flgs, bool* douniq, bool* doindex)
{
*douniq = (flgs & SORT_UNIQUE);
*doindex = (flgs & SORT_RETURN_INDEX);
@@ -868,7 +868,7 @@ private:
class GetMultiFlags
{
public:
- GetMultiFlags(std::vector<boost::uint8_t>& v, const fn_call& fn)
+ GetMultiFlags(std::vector<std::uint8_t>& v, const fn_call& fn)
:
_v(v),
_i(0),
@@ -879,15 +879,15 @@ public:
void operator()(const as_value& val) {
// extract SORT_UNIQUE and SORT_RETURN_INDEX from first flag
if (!_i) {
- boost::uint8_t flag =
- static_cast<boost::uint8_t>(toNumber(val, getVM(_fn)));
+ std::uint8_t flag =
+ static_cast<std::uint8_t>(toNumber(val, getVM(_fn)));
flag = flag_preprocess(flag, &_uniq, &_index);
_v.push_back(flag);
++_i;
return;
}
- boost::uint8_t flag =
- static_cast<boost::uint8_t>(toNumber(val, getVM(_fn)));
+ std::uint8_t flag =
+ static_cast<std::uint8_t>(toNumber(val, getVM(_fn)));
flag &= ~(SORT_RETURN_INDEX);
flag &= ~(SORT_UNIQUE);
_v.push_back(flag);
@@ -897,7 +897,7 @@ public:
bool index() const { return _index; }
private:
- std::vector<boost::uint8_t>& _v;
+ std::vector<std::uint8_t>& _v;
size_t _i;
bool _uniq;
bool _index;
@@ -1120,10 +1120,10 @@ array_sort(const fn_call& fn)
if (fn.arg(0).is_undefined()) return as_value();
- boost::uint8_t flags = 0;
+ std::uint8_t flags = 0;
if (fn.nargs == 1 && fn.arg(0).is_number()) {
- flags = static_cast<boost::uint8_t>(toNumber(fn.arg(0), getVM(fn)));
+ flags = static_cast<std::uint8_t>(toNumber(fn.arg(0), getVM(fn)));
}
else if (fn.arg(0).is_function()) {
// Get comparison function
@@ -1134,7 +1134,7 @@ array_sort(const fn_call& fn)
bool (*icmp)(int);
if (fn.nargs == 2 && fn.arg(1).is_number()) {
- flags=static_cast<boost::uint8_t>(toNumber(fn.arg(1), getVM(fn)));
+ flags=static_cast<std::uint8_t>(toNumber(fn.arg(1), getVM(fn)));
}
if (flags & SORT_DESCENDING) icmp = &int_lt_or_eq;
@@ -1182,7 +1182,7 @@ array_sortOn(const fn_call& fn)
as_object* array = ensure<ValidThis>(fn);
bool do_unique = false, do_index = false;
- boost::uint8_t flags = 0;
+ std::uint8_t flags = 0;
const int version = getSWFVersion(fn);
VM& vm = getVM(fn);
@@ -1196,7 +1196,7 @@ array_sortOn(const fn_call& fn)
getURI(vm, fn.arg(0).to_string(version));
if (fn.nargs > 1 && fn.arg(1).is_number()) {
- flags = static_cast<boost::uint8_t>(toNumber(fn.arg(1),
getVM(fn)));
+ flags = static_cast<std::uint8_t>(toNumber(fn.arg(1), getVM(fn)));
flags = flag_preprocess(flags, &do_unique, &do_index);
}
@@ -1249,13 +1249,13 @@ array_sortOn(const fn_call& fn)
// Only an array will do for this case.
if (farray->array() && arrayLength(*farray) == optnum) {
- std::vector<boost::uint8_t> flgs;
+ std::vector<std::uint8_t> flgs;
GetMultiFlags mf(flgs, fn);
foreachArray(*farray, mf);
do_unique = mf.unique();
do_index = mf.index();
- std::vector<boost::uint8_t>::const_iterator it =
+ std::vector<std::uint8_t>::const_iterator it =
flgs.begin();
while (it != flgs.end()) {
@@ -1275,8 +1275,8 @@ array_sortOn(const fn_call& fn)
}
// case: sortOn(["prop1", "prop2"], Array.FLAG)
else {
- boost::uint8_t flags =
- static_cast<boost::uint8_t>(toInt(fn.arg(1), getVM(fn)));
+ std::uint8_t flags =
+ static_cast<std::uint8_t>(toInt(fn.arg(1), getVM(fn)));
flags = flag_preprocess(flags, &do_unique, &do_index);
as_cmp_fn c = get_basic_cmp(flags, fn);
diff --git a/libcore/asobj/Color_as.cpp b/libcore/asobj/Color_as.cpp
index 7cb526f..b60ec9e 100644
--- a/libcore/asobj/Color_as.cpp
+++ b/libcore/asobj/Color_as.cpp
@@ -44,7 +44,7 @@ namespace {
void attachColorInterface(as_object& o);
inline void parseColorTransProp(as_object& obj, const ObjectURI& key,
- boost::int16_t& target, bool scale);
+ std::int16_t& target, bool scale);
inline MovieClip* getTarget(as_object* obj, const fn_call& fn);
}
@@ -110,7 +110,7 @@ color_getrgb(const fn_call& fn)
const int g = trans.gb;
const int b = trans.bb;
- const boost::int32_t rgb = (r<<16) | (g<<8) | b;
+ const std::int32_t rgb = (r<<16) | (g<<8) | b;
return as_value(rgb);
}
@@ -158,16 +158,16 @@ color_setrgb(const fn_call& fn)
MovieClip* sp = getTarget(obj, fn);
if (!sp) return as_value();
- boost::int32_t color = toInt(fn.arg(0), getVM(fn));
+ std::int32_t color = toInt(fn.arg(0), getVM(fn));
const int r = (color & 0xff0000) >> 16;
const int g = (color & 0x00ff00) >> 8;
const int b = (color & 0x0000ff);
SWFCxForm newTrans = getCxForm(*sp);
- newTrans.rb = static_cast<boost::int16_t>(r);
- newTrans.gb = static_cast<boost::int16_t>(g);
- newTrans.bb = static_cast<boost::int16_t>(b);
+ newTrans.rb = static_cast<std::int16_t>(r);
+ newTrans.gb = static_cast<std::int16_t>(g);
+ newTrans.bb = static_cast<std::int16_t>(b);
newTrans.ra = 0;
newTrans.ga = 0;
newTrans.ba = 0;
@@ -250,7 +250,7 @@ color_ctor(const fn_call& fn)
}
inline void
-parseColorTransProp(as_object& obj, const ObjectURI& key, boost::int16_t&
+parseColorTransProp(as_object& obj, const ObjectURI& key, std::int16_t&
target, bool scale)
{
as_value tmp;
@@ -258,10 +258,10 @@ parseColorTransProp(as_object& obj, const ObjectURI& key,
boost::int16_t&
const double d = toNumber(tmp, getVM(obj));
if (scale) {
- target = static_cast<boost::int16_t>(d * 2.56);
+ target = static_cast<std::int16_t>(d * 2.56);
}
else {
- target = static_cast<boost::int16_t>(d);
+ target = static_cast<std::int16_t>(d);
}
}
diff --git a/libcore/asobj/Date_as.cpp b/libcore/asobj/Date_as.cpp
index b7a2f14..e518c86 100644
--- a/libcore/asobj/Date_as.cpp
+++ b/libcore/asobj/Date_as.cpp
@@ -89,15 +89,15 @@ namespace {
// A time struct to contain the broken-down time.
struct GnashTime
{
- boost::int32_t millisecond;
- boost::int32_t second;
- boost::int32_t minute;
- boost::int32_t hour;
- boost::int32_t monthday;
- boost::int32_t weekday;
- boost::int32_t month;
- boost::int32_t year;
- boost::int32_t timeZoneOffset;
+ std::int32_t millisecond;
+ std::int32_t second;
+ std::int32_t minute;
+ std::int32_t hour;
+ std::int32_t monthday;
+ std::int32_t weekday;
+ std::int32_t month;
+ std::int32_t year;
+ std::int32_t timeZoneOffset;
};
static const int daysInMonth[2][12] = {
@@ -281,15 +281,15 @@ namespace {
// Helpers for calendar algorithms
inline bool
-isLeapYear(boost::int32_t year)
+isLeapYear(std::int32_t year)
{
return !((year + 1900) % 400) ||
( !((year + 1900) % 4) && ((year + 1900) % 100));
}
-inline boost::int32_t
-countLeapYears(boost::int32_t year)
+inline std::int32_t
+countLeapYears(std::int32_t year)
{
return year / 4 - year / 100 + year / 400;
}
@@ -517,7 +517,7 @@ bool invalidDate(double timeValue)
/// @param timeValue The time value to break into elements.
/// @param adjustment Adjust the result by this amount (used for full year).
template<typename T>
-inline as_value timeElement(T dateFunc, boost::int32_t GnashTime::* element,
+inline as_value timeElement(T dateFunc, std::int32_t GnashTime::* element,
double timeValue, int adjustment = 0)
{
if (invalidDate(timeValue)) return as_value();
@@ -1269,7 +1269,7 @@ date_UTC(const fn_call& fn) {
case 2: // these last two are always performed
gt.month = toInt(fn.arg(1), getVM(fn));
{
- boost::int32_t year = 0;
+ std::int32_t year = 0;
truncateDouble(year, toNumber(fn.arg(0), getVM(fn)));
if (year < 100) gt.year = year;
else gt.year = year - 1900;
@@ -1369,13 +1369,13 @@ makeTimeValue(GnashTime& t)
// Now work out the years from 1970 in days.
// Use a temporary 1970-based year for clarity.
- const boost::int32_t ouryear = t.year - 70;
+ const std::int32_t ouryear = t.year - 70;
// Count the leap years between 1970-1-1 and the beginning of our year.
// 1970 - 1972: no leap years
// 1970 - 1968: one leap year
// Adding one less than the required year gives this behaviour.
- boost::int32_t day = countLeapYears(ouryear + 1969) - countLeapYears(1970);
+ std::int32_t day = countLeapYears(ouryear + 1969) - countLeapYears(1970);
day += ouryear * 365;
/// The year 0 was a leap year, but countLeapYears won't calculate it.
@@ -1404,10 +1404,10 @@ makeTimeValue(GnashTime& t)
// The brute force way of converting days into years since the epoch.
// This also reduces the number of days accurately. Its disadvantage is,
// of course, that it iterates; its advantage that it's always correct.
-boost::int32_t
-getYearBruteForce(boost::int32_t& days)
+std::int32_t
+getYearBruteForce(std::int32_t& days)
{
- boost::int32_t year = 1970;
+ std::int32_t year = 1970;
// Handle 400-year blocks - which always have the same
// number of days (14097) - to cut down on iterations.
@@ -1451,11 +1451,11 @@ fillGnashTime(double t, GnashTime& gt)
// Get the sub-day part of the time, if any and reduce time
// to number of complete days.
// This is a safe cast.
- boost::int32_t remainder =
- static_cast<boost::int32_t>(std::fmod(time, 86400.0));
+ std::int32_t remainder =
+ static_cast<std::int32_t>(std::fmod(time, 86400.0));
// This could overflow.
- boost::int32_t days;
+ std::int32_t days;
truncateDouble(days, time / 86400.0); // complete days
gt.second = remainder % 60;
diff --git a/libcore/asobj/Global_as.cpp b/libcore/asobj/Global_as.cpp
index ef2da04..a60bd17 100644
--- a/libcore/asobj/Global_as.cpp
+++ b/libcore/asobj/Global_as.cpp
@@ -757,7 +757,7 @@ global_assetnative(const fn_call& fn)
const std::string& props = fn.arg(2).to_string();
const int minor =
- fn.nargs > 3 ? std::max<boost::int32_t>(toInt(fn.arg(3), getVM(fn)),
0) : 0;
+ fn.nargs > 3 ? std::max<std::int32_t>(toInt(fn.arg(3), getVM(fn)), 0)
: 0;
std::string::const_iterator pos = props.begin();
@@ -826,7 +826,7 @@ global_assetnativeaccessor(const fn_call& fn)
const std::string& props = fn.arg(2).to_string();
const int minor =
- fn.nargs > 3 ? std::max<boost::int32_t>(toInt(fn.arg(3), getVM(fn)),
0) : 0;
+ fn.nargs > 3 ? std::max<std::int32_t>(toInt(fn.arg(3), getVM(fn)), 0)
: 0;
std::string::const_iterator pos = props.begin();
@@ -1090,7 +1090,7 @@ global_clearInterval(const fn_call& fn)
return as_value();
}
- const boost::uint32_t id = toInt(fn.arg(0), getVM(fn));
+ const std::uint32_t id = toInt(fn.arg(0), getVM(fn));
movie_root& root = getRoot(fn);
return as_value(root.clearIntervalTimer(id));
diff --git a/libcore/asobj/LocalConnection_as.cpp
b/libcore/asobj/LocalConnection_as.cpp
index a315c91..ebfd9e0 100644
--- a/libcore/asobj/LocalConnection_as.cpp
+++ b/libcore/asobj/LocalConnection_as.cpp
@@ -21,7 +21,7 @@
#include <cerrno>
#include <cstring>
-#include <boost/cstdint.hpp> // for boost::?int??_t
+#include <cstdint> // for boost::?int??_t
#include <boost/assign/list_of.hpp>
#include <functional>
@@ -140,7 +140,7 @@ namespace {
bool findListener(const std::string& name, SharedMem& mem);
void getMarker(SharedMem::iterator& i, SharedMem::iterator end);
void markRead(SharedMem& m);
- inline boost::uint32_t getTimestamp(const VM& vm);
+ inline std::uint32_t getTimestamp(const VM& vm);
/// Read the AMF data and invoke the function.
void executeAMFFunction(as_object& owner, amf::Reader& rd);
@@ -148,14 +148,14 @@ namespace {
struct ConnectionData
{
std::string name;
- boost::uint32_t ts;
+ std::uint32_t ts;
SimpleBuffer data;
};
}
void
-writeLong(boost::uint8_t*& ptr, boost::uint32_t i)
+writeLong(std::uint8_t*& ptr, std::uint32_t i)
{
*ptr = i & 0xff;
++ptr;
@@ -167,9 +167,9 @@ writeLong(boost::uint8_t*& ptr, boost::uint32_t i)
++ptr;
}
-inline boost::uint32_t
-readLong(const boost::uint8_t* buf) {
- boost::uint32_t s = buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24;
+inline std::uint32_t
+readLong(const std::uint8_t* buf) {
+ std::uint32_t s = buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24;
return s;
}
@@ -252,7 +252,7 @@ private:
std::deque<std::shared_ptr<ConnectionData> > _queue;
// The timestamp of our last write to the shared memory.
- boost::uint32_t _lastTime;
+ std::uint32_t _lastTime;
};
@@ -302,8 +302,8 @@ LocalConnection_as::update()
// These are not network byte order by default, but not sure about
// host byte order.
- const boost::uint32_t timestamp = readLong(ptr + 8);
- const boost::uint32_t size = readLong(ptr + 12);
+ const std::uint32_t timestamp = readLong(ptr + 8);
+ const std::uint32_t size = readLong(ptr + 12);
// As long as there is a timestamp in the shared memory, we mustn't
// write anything.
@@ -317,10 +317,10 @@ LocalConnection_as::update()
if (timestamp) {
// Start after 16-byte header.
- const boost::uint8_t* b = ptr + 16;
+ const std::uint8_t* b = ptr + 16;
// End at reported size of AMF sequence.
- const boost::uint8_t* end = b + size;
+ const std::uint8_t* end = b + size;
amf::Reader rd(b, end, getGlobal(owner()));
as_value a;
@@ -340,7 +340,7 @@ LocalConnection_as::update()
const size_t timeout = 4 * 1000;
VM& vm = getVM(owner());
- const boost::uint32_t timeNow = getTimestamp(vm);
+ const std::uint32_t timeNow = getTimestamp(vm);
if (timeNow - timestamp > timeout) {
log_debug("Data %s expired at %s. Removing its target "
@@ -915,7 +915,7 @@ markRead(SharedMem& m)
/// Version 10 fails if it recieves a value outside the signed 32-bit int
/// range, so we surmise that there is an undocumented conversion to signed
/// in that player. We make sure the value never exceeds 0x7fffffff.
-inline boost::uint32_t
+inline std::uint32_t
getTimestamp(const VM& vm)
{
return vm.getTime() & 0x7fffffff;
diff --git a/libcore/asobj/Microphone_as.cpp b/libcore/asobj/Microphone_as.cpp
index 11e8a4f..0128ba2 100644
--- a/libcore/asobj/Microphone_as.cpp
+++ b/libcore/asobj/Microphone_as.cpp
@@ -284,7 +284,7 @@ microphone_setgain(const fn_call& fn)
return as_value();
}
- const boost::int32_t gain = clamp<boost::int32_t>(toInt(fn.arg(0),
getVM(fn)), 0, 100);
+ const std::int32_t gain = clamp<std::int32_t>(toInt(fn.arg(0), getVM(fn)),
0, 100);
ptr->setGain(gain);
return as_value();
}
@@ -441,7 +441,7 @@ microphone_setsilencelevel(const fn_call& fn)
if (numargs > 1) {
// If it's less than 0, it's set to 0.
- const int timeout = std::max<boost::int32_t>(toInt(fn.arg(1),
getVM(fn)), 0);
+ const int timeout = std::max<std::int32_t>(toInt(fn.arg(1),
getVM(fn)), 0);
ptr->setSilenceTimeout(timeout);
}
return as_value();
diff --git a/libcore/asobj/MovieClip_as.cpp b/libcore/asobj/MovieClip_as.cpp
index 3b8c0f4..4492964 100644
--- a/libcore/asobj/MovieClip_as.cpp
+++ b/libcore/asobj/MovieClip_as.cpp
@@ -476,7 +476,7 @@ movieclip_attachMovie(const fn_call& fn)
const double depth = toNumber(fn.arg(2), getVM(fn));
// This also checks for overflow, as both numbers are expressible as
- // boost::int32_t.
+ // std::int32_t.
if (depth < DisplayObject::lowerAccessibleBound ||
depth > DisplayObject::upperAccessibleBound)
{
@@ -487,7 +487,7 @@ movieclip_attachMovie(const fn_call& fn)
return as_value();
}
- boost::int32_t depthValue = static_cast<boost::int32_t>(depth);
+ std::int32_t depthValue = static_cast<std::int32_t>(depth);
Global_as& gl = getGlobal(fn);
DisplayObject* newch = exported_movie->createDisplayObject(gl, movieclip);
@@ -724,7 +724,7 @@ movieclip_duplicateMovieClip(const fn_call& fn)
const double depth = toNumber(fn.arg(1), getVM(fn));
// This also checks for overflow, as both numbers are expressible as
- // boost::int32_t.
+ // std::int32_t.
if (depth < DisplayObject::lowerAccessibleBound ||
depth > DisplayObject::upperAccessibleBound)
{
@@ -735,7 +735,7 @@ movieclip_duplicateMovieClip(const fn_call& fn)
return as_value();
}
- boost::int32_t depthValue = static_cast<boost::int32_t>(depth);
+ std::int32_t depthValue = static_cast<std::int32_t>(depth);
MovieClip* ch;
@@ -1013,17 +1013,17 @@ movieclip_hitTest(const fn_call& fn)
case 2: // x, y
{
- boost::int32_t x = pixelsToTwips(toNumber(fn.arg(0), getVM(fn)));
- boost::int32_t y = pixelsToTwips(toNumber(fn.arg(1), getVM(fn)));
+ std::int32_t x = pixelsToTwips(toNumber(fn.arg(0), getVM(fn)));
+ std::int32_t y = pixelsToTwips(toNumber(fn.arg(1), getVM(fn)));
return movieclip->pointInBounds(x, y);
}
case 3: // x, y, shapeFlag
{
- const boost::int32_t x = pixelsToTwips(toNumber(fn.arg(0),
+ const std::int32_t x = pixelsToTwips(toNumber(fn.arg(0),
getVM(fn)));
- const boost::int32_t y = pixelsToTwips(toNumber(fn.arg(1),
+ const std::int32_t y = pixelsToTwips(toNumber(fn.arg(1),
getVM(fn)));
const bool shapeFlag = toBool(fn.arg(2), getVM(fn));
@@ -1287,8 +1287,8 @@ movieclip_globalToLocal(const fn_call& fn)
}
as_value tmp;
- boost::int32_t x = 0;
- boost::int32_t y = 0;
+ std::int32_t x = 0;
+ std::int32_t y = 0;
if ( ! obj->get_member(NSV::PROP_X, &tmp) )
{
@@ -1348,8 +1348,8 @@ movieclip_localToGlobal(const fn_call& fn)
}
as_value tmp;
- boost::int32_t x = 0;
- boost::int32_t y = 0;
+ std::int32_t x = 0;
+ std::int32_t y = 0;
if (!obj->get_member(NSV::PROP_X, &tmp)) {
IF_VERBOSE_ASCODING_ERRORS(
@@ -1499,11 +1499,11 @@ movieclip_lineStyle(const fn_call& fn)
return as_value();
}
- boost::uint8_t r = 0;
- boost::uint8_t g = 0;
- boost::uint8_t b = 0;
- boost::uint8_t a = 255;
- boost::uint16_t thickness = 0;
+ std::uint8_t r = 0;
+ std::uint8_t g = 0;
+ std::uint8_t b = 0;
+ std::uint8_t a = 255;
+ std::uint16_t thickness = 0;
bool scaleThicknessVertically = true;
bool scaleThicknessHorizontally = true;
bool pixelHinting = false;
@@ -1594,20 +1594,20 @@ movieclip_lineStyle(const fn_call& fn)
{
const float alphaval = clamp<float>(toNumber(fn.arg(2), getVM(fn)),
0, 100);
- a = boost::uint8_t(255 * (alphaval / 100));
+ a = std::uint8_t(255 * (alphaval / 100));
}
case 2:
{
// See pollock.swf for eventual regressions.
// It sets color to a random number from
// 0 to 160000000 (about 10 times more then the max).
- boost::uint32_t rgbval = toInt(fn.arg(1), getVM(fn));
- r = boost::uint8_t((rgbval & 0xFF0000) >> 16);
- g = boost::uint8_t((rgbval & 0x00FF00) >> 8);
- b = boost::uint8_t((rgbval & 0x0000FF) );
+ std::uint32_t rgbval = toInt(fn.arg(1), getVM(fn));
+ r = std::uint8_t((rgbval & 0xFF0000) >> 16);
+ g = std::uint8_t((rgbval & 0x00FF00) >> 8);
+ b = std::uint8_t((rgbval & 0x0000FF) );
}
case 1:
- thickness = boost::uint16_t(pixelsToTwips(clamp<float>(
+ thickness = std::uint16_t(pixelsToTwips(clamp<float>(
toNumber(fn.arg(0), getVM(fn)), 0, 255)));
break;
}
@@ -1675,13 +1675,13 @@ movieclip_beginFill(const fn_call& fn)
}
// 2^24 is the max here
- const boost::uint32_t rgbval =
+ const std::uint32_t rgbval =
clamp<float>(toNumber(fn.arg(0), getVM(fn)), 0, 16777216);
- const boost::uint8_t r = (rgbval & 0xFF0000) >> 16;
- const boost::uint8_t g = (rgbval & 0x00FF00) >> 8;
- const boost::uint8_t b = rgbval & 0x0000FF;
- boost::uint8_t a = 255;
+ const std::uint8_t r = (rgbval & 0xFF0000) >> 16;
+ const std::uint8_t g = (rgbval & 0x00FF00) >> 8;
+ const std::uint8_t b = rgbval & 0x0000FF;
+ std::uint8_t a = 255;
if (fn.nargs > 1) {
a = 255 * clamp<int>(toInt(fn.arg(1), getVM(fn)), 0, 100) / 100;
@@ -1807,13 +1807,13 @@ movieclip_beginGradientFill(const fn_call& fn)
const ObjectURI& key = getURI(vm, boost::lexical_cast<std::string>(i));
as_value colVal = getMember(*colors, key);
- boost::uint32_t col = colVal.is_number() ? toInt(colVal, getVM(fn)) :
0;
+ std::uint32_t col = colVal.is_number() ? toInt(colVal, getVM(fn)) : 0;
/// Alpha is the range 0..100.
as_value alpVal = getMember(*alphas, key);
const double a = alpVal.is_number() ?
clamp<double>(toNumber(alpVal, getVM(fn)), 0, 100) : 0;
- const boost::uint8_t alp = 0xff * (a / 100);
+ const std::uint8_t alp = 0xff * (a / 100);
// Ratio is the range 0..255, but a ratio may never be smaller than
// the previous value. The pp adjusts it to be greater than the
@@ -1824,12 +1824,12 @@ movieclip_beginGradientFill(const fn_call& fn)
// steps of 1 appear to be adjusted.
const int step = 2;
const as_value& ratVal = getMember(*ratios, key);
- const boost::uint32_t minRatio =
+ const std::uint32_t minRatio =
gradients.empty() ? 0 :
- std::min<boost::uint32_t>(gradients[i - 1].ratio + step, 0xff);
+ std::min<std::uint32_t>(gradients[i - 1].ratio + step, 0xff);
- boost::uint8_t rat = ratVal.is_number() ?
- clamp<boost::uint32_t>(toInt(ratVal, getVM(fn)), minRatio, 0xff)
+ std::uint8_t rat = ratVal.is_number() ?
+ clamp<std::uint32_t>(toInt(ratVal, getVM(fn)), minRatio, 0xff)
: minRatio;
// The renderer may expect successively larger ratios; failure to
diff --git a/libcore/asobj/NetConnection_as.cpp
b/libcore/asobj/NetConnection_as.cpp
index 51e3149..96a7b9d 100644
--- a/libcore/asobj/NetConnection_as.cpp
+++ b/libcore/asobj/NetConnection_as.cpp
@@ -70,8 +70,8 @@ namespace {
getStatusCodeInfo(NetConnection_as::StatusCode code);
/// Parse and send any invoke messages from an HTTP connection.
- void handleAMFInvoke(amf::Reader& rd, const boost::uint8_t*& b,
- const boost::uint8_t* end, as_object& owner);
+ void handleAMFInvoke(amf::Reader& rd, const std::uint8_t*& b,
+ const std::uint8_t* end, as_object& owner);
void replyBWCheck(rtmp::RTMP& r, double txn);
@@ -201,8 +201,8 @@ private:
/// Handle replies to server functions we invoked with a callback.
//
/// This needs access to the stored callbacks.
- void handleAMFReplies(amf::Reader& rd, const boost::uint8_t*& b,
- const boost::uint8_t* end);
+ void handleAMFReplies(amf::Reader& rd, const std::uint8_t*& b,
+ const std::uint8_t* end);
Connection& _handler;
@@ -397,7 +397,7 @@ public:
private:
- void handleInvoke(const boost::uint8_t* payload, const boost::uint8_t*
end);
+ void handleInvoke(const std::uint8_t* payload, const std::uint8_t* end);
rtmp::RTMP _rtmp;
bool _connectionComplete;
@@ -928,11 +928,11 @@ getStatusCodeInfo(NetConnection_as::StatusCode code)
}
void
-handleAMFInvoke(amf::Reader& rd, const boost::uint8_t*& b,
- const boost::uint8_t* end, as_object& owner)
+handleAMFInvoke(amf::Reader& rd, const std::uint8_t*& b,
+ const std::uint8_t* end, as_object& owner)
{
- const boost::uint16_t invokecount = amf::readNetworkShort(b);
+ const std::uint16_t invokecount = amf::readNetworkShort(b);
b += 2;
if (!invokecount) return;
@@ -941,7 +941,7 @@ handleAMFInvoke(amf::Reader& rd, const boost::uint8_t*& b,
if (b + 2 > end) {
throw amf::AMFException("Invoke buffer too short");
}
- const boost::uint16_t namelength = amf::readNetworkShort(b);
+ const std::uint16_t namelength = amf::readNetworkShort(b);
b += 2;
if (b + namelength > end) {
throw amf::AMFException("Invoke buffer too short");
@@ -977,10 +977,10 @@ handleAMFInvoke(amf::Reader& rd, const boost::uint8_t*& b,
//
/// Note that fatal errors will throw an amf::AMFException.
void
-HTTPRequest::handleAMFReplies(amf::Reader& rd, const boost::uint8_t*& b,
- const boost::uint8_t* end)
+HTTPRequest::handleAMFReplies(amf::Reader& rd, const std::uint8_t*& b,
+ const std::uint8_t* end)
{
- const boost::uint16_t numreplies = amf::readNetworkShort(b);
+ const std::uint16_t numreplies = amf::readNetworkShort(b);
b += 2; // number of replies
// TODO: test if this value is relevant at all.
@@ -996,7 +996,7 @@ HTTPRequest::handleAMFReplies(amf::Reader& rd, const
boost::uint8_t*& b,
if (b + 2 > end) return;
- const boost::uint16_t replylength = amf::readNetworkShort(b);
+ const std::uint16_t replylength = amf::readNetworkShort(b);
b += 2;
if (replylength < 4 || b + replylength > end) {
@@ -1027,7 +1027,7 @@ HTTPRequest::handleAMFReplies(amf::Reader& rd, const
boost::uint8_t*& b,
// parse past unused string in header
if (b + 2 > end) return;
- const boost::uint16_t unusedlength = amf::readNetworkShort(b);
+ const std::uint16_t unusedlength = amf::readNetworkShort(b);
b += 2;
if (b + unusedlength > end) return;
@@ -1112,7 +1112,7 @@ HTTPRequest::send(const URL& url, NetConnection_as& nc)
log_debug("creating connection");
// Fill in header
- (reinterpret_cast<boost::uint16_t*>(_data.data() + 4))[0] = htons(_calls);
+ (reinterpret_cast<std::uint16_t*>(_data.data() + 4))[0] = htons(_calls);
std::string postdata(reinterpret_cast<char*>(_data.data()), _data.size());
#ifdef GNASH_DEBUG_REMOTING
@@ -1199,8 +1199,8 @@ HTTPRequest::process(NetConnection_as& nc)
#ifdef GNASH_DEBUG_REMOTING
log_debug("hit eof");
#endif
- const boost::uint8_t *b = _reply.data();
- const boost::uint8_t *end = _reply.data() + _reply.size();
+ const std::uint8_t *b = _reply.data();
+ const std::uint8_t *end = _reply.data() + _reply.size();
amf::Reader rd(b, end, getGlobal(nc.owner()));
@@ -1282,8 +1282,8 @@ HTTPConnection::call(as_object* asCallback, const
std::string& methodName,
}
void
-RTMPConnection::handleInvoke(const boost::uint8_t* payload,
- const boost::uint8_t* end)
+RTMPConnection::handleInvoke(const std::uint8_t* payload,
+ const std::uint8_t* end)
{
// TODO: clean up the logic in this function to reduce duplication.
diff --git a/libcore/asobj/NetStream_as.cpp b/libcore/asobj/NetStream_as.cpp
index 1a39a94..4c878ec 100644
--- a/libcore/asobj/NetStream_as.cpp
+++ b/libcore/asobj/NetStream_as.cpp
@@ -26,7 +26,7 @@
#include <functional>
#include <algorithm>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/thread/mutex.hpp>
#include "RunResources.h"
@@ -185,7 +185,7 @@ NetStream_as::setStatus(StatusCode status)
}
void
-NetStream_as::setBufferTime(boost::uint32_t time)
+NetStream_as::setBufferTime(std::uint32_t time)
{
// The argument is in milliseconds,
_bufferTime = time;
@@ -549,7 +549,7 @@ NetStream_as::startPlayback()
std::unique_ptr<image::GnashImage>
-NetStream_as::getDecodedVideoFrame(boost::uint32_t ts)
+NetStream_as::getDecodedVideoFrame(std::uint32_t ts)
{
assert(_videoDecoder.get());
@@ -562,7 +562,7 @@ NetStream_as::getDecodedVideoFrame(boost::uint32_t ts)
return video;
}
- boost::uint64_t nextTimestamp;
+ std::uint64_t nextTimestamp;
bool parsingComplete = _parser->parsingCompleted();
if (!_parser->nextVideoFrameTimestamp(nextTimestamp)) {
@@ -699,8 +699,8 @@ NetStream_as::decodeNextAudioFrame()
// NOTE: adjust_volume assumes samples
// are 16 bits in size, and signed.
// Size is still given in bytes..
- boost::int16_t* const start =
- reinterpret_cast<boost::int16_t*>(raw->m_data);
+ std::int16_t* const start =
+ reinterpret_cast<std::int16_t*>(raw->m_data);
sound::adjustVolume(start, start + raw->m_size / 2, vol /
100.0);
}
}
@@ -721,7 +721,7 @@ NetStream_as::decodeNextAudioFrame()
}
void
-NetStream_as::seek(boost::uint32_t posSeconds)
+NetStream_as::seek(std::uint32_t posSeconds)
{
GNASH_REPORT_FUNCTION;
@@ -733,7 +733,7 @@ NetStream_as::seek(boost::uint32_t posSeconds)
}
// Don't ask me why, but NetStream_as::seek() takes seconds...
- boost::uint32_t pos = posSeconds*1000;
+ std::uint32_t pos = posSeconds*1000;
// We'll pause the clock source and mark decoders as buffering.
// In this way, next advance won't find the source time to
@@ -744,7 +744,7 @@ NetStream_as::seek(boost::uint32_t posSeconds)
_playbackClock->pause();
// Seek to new position
- boost::uint32_t newpos = pos;
+ std::uint32_t newpos = pos;
if ( ! _parser->seek(newpos) )
{
#ifdef GNASH_DEBUG_STATUS
@@ -792,9 +792,9 @@ NetStream_as::refreshAudioBuffer()
#ifdef GNASH_DEBUG_DECODING
// bufferLength() would lock the mutex (which we already hold),
// so this is to avoid that.
- boost::uint32_t parserTime = _parser->getBufferLength();
- boost::uint32_t playHeadTime = time();
- boost::uint32_t bufferLen =
+ std::uint32_t parserTime = _parser->getBufferLength();
+ std::uint32_t playHeadTime = time();
+ std::uint32_t bufferLen =
parserTime > playHeadTime ? parserTime-playHeadTime : 0;
#endif
@@ -818,7 +818,7 @@ NetStream_as::refreshAudioBuffer()
}
// Calculate the current time
- boost::uint64_t curPos = _playHead.getPosition();
+ std::uint64_t curPos = _playHead.getPosition();
#ifdef GNASH_DEBUG_DECODING
log_debug(_("%p.refreshAudioBuffer: currentPosition=%d, playHeadState=%d,
bufferLength=%d, bufferTime=%d"),
@@ -833,7 +833,7 @@ NetStream_as::refreshAudioBuffer()
}
void
-NetStream_as::pushDecodedAudioFrames(boost::uint32_t ts)
+NetStream_as::pushDecodedAudioFrames(std::uint32_t ts)
{
assert(_parser.get());
@@ -884,7 +884,7 @@ NetStream_as::pushDecodedAudioFrames(boost::uint32_t ts)
bool consumed = false;
- boost::uint64_t nextTimestamp;
+ std::uint64_t nextTimestamp;
while (1) {
// FIXME: use services of BufferedAudioStreamer for this
@@ -1107,7 +1107,7 @@ NetStream_as::refreshVideoFrame(bool alsoIfPaused)
}
#ifdef GNASH_DEBUG_DECODING
- boost::uint32_t bufferLen = bufferLength();
+ std::uint32_t bufferLen = bufferLength();
#endif
if ( ! alsoIfPaused && _playHead.getState() == PlayHead::PLAY_PAUSED )
@@ -1132,7 +1132,7 @@ NetStream_as::refreshVideoFrame(bool alsoIfPaused)
}
// Calculate the current time
- boost::uint64_t curPos = _playHead.getPosition();
+ std::uint64_t curPos = _playHead.getPosition();
#ifdef GNASH_DEBUG_DECODING
log_debug(_("%p.refreshVideoFrame: currentPosition=%d, playHeadState=%d, "
@@ -1293,10 +1293,10 @@ NetStream_as::update()
// If playhead position needs to be updated
// is set to Set playhead to first available frame, if any
// TODO: use another flag to signify 'initialization-needed'
- boost::uint64_t curPosition = _playHead.getPosition();
+ std::uint64_t curPosition = _playHead.getPosition();
if ( curPosition == 0 )
{
- boost::uint64_t firstFrameTimestamp;
+ std::uint64_t firstFrameTimestamp;
if ( _parser->nextFrameTimestamp(firstFrameTimestamp) )
{
_playHead.seekTo(firstFrameTimestamp);
@@ -1345,7 +1345,7 @@ NetStream_as::update()
if ( emptyAudioQueue )
{
- boost::uint64_t nextTimestamp;
+ std::uint64_t nextTimestamp;
if ( _parser->nextAudioFrameTimestamp(nextTimestamp) )
{
log_debug(_("Moving NetStream playhead "
@@ -1372,7 +1372,7 @@ NetStream_as::update()
#endif // USE_MEDIA
}
-boost::int32_t
+std::int32_t
NetStream_as::time()
{
return _playHead.getPosition();
@@ -1481,7 +1481,7 @@ BufferedAudioStreamer::detachAuxStreamer()
// audio callback, possibly running in a separate thread
unsigned int
-BufferedAudioStreamer::fetchWrapper(void *owner, boost::int16_t* samples,
+BufferedAudioStreamer::fetchWrapper(void *owner, std::int16_t* samples,
unsigned int nSamples, bool& eof)
{
BufferedAudioStreamer* streamer =
@@ -1500,11 +1500,11 @@
BufferedAudioStreamer::BufferedAudioStreamer(sound::sound_handler* handler)
}
unsigned int
-BufferedAudioStreamer::fetch(boost::int16_t* samples, unsigned int nSamples,
bool& eof)
+BufferedAudioStreamer::fetch(std::int16_t* samples, unsigned int nSamples,
bool& eof)
{
//GNASH_REPORT_FUNCTION;
- boost::uint8_t* stream = reinterpret_cast<boost::uint8_t*>(samples);
+ std::uint8_t* stream = reinterpret_cast<std::uint8_t*>(samples);
int len = nSamples*2;
boost::mutex::scoped_lock lock(_audioQueueMutex);
@@ -1667,9 +1667,9 @@ as_value
netstream_seek(const fn_call& fn)
{
NetStream_as* ns = ensure<ThisIsNative<NetStream_as> >(fn);
- boost::uint32_t time = 0;
+ std::uint32_t time = 0;
if (fn.nargs > 0) {
- time = static_cast<boost::uint32_t>(toNumber(fn.arg(0), getVM(fn)));
+ time = static_cast<std::uint32_t>(toNumber(fn.arg(0), getVM(fn)));
}
ns->seek(time);
@@ -1690,7 +1690,7 @@ netstream_setbuffertime(const fn_call& fn)
// TODO: don't allow a limit < 100
- ns->setBufferTime(boost::uint32_t(time * 1000));
+ ns->setBufferTime(std::uint32_t(time * 1000));
return as_value();
}
@@ -1888,8 +1888,8 @@ attachPrototypeProperties(as_object& o)
void
executeTag(const SimpleBuffer& _buffer, as_object& thisPtr)
{
- const boost::uint8_t* ptr = _buffer.data();
- const boost::uint8_t* endptr = ptr + _buffer.size();
+ const std::uint8_t* ptr = _buffer.data();
+ const std::uint8_t* endptr = ptr + _buffer.size();
std::string funcName;
diff --git a/libcore/asobj/NetStream_as.h b/libcore/asobj/NetStream_as.h
index c136fbd..e61dd2a 100644
--- a/libcore/asobj/NetStream_as.h
+++ b/libcore/asobj/NetStream_as.h
@@ -103,16 +103,16 @@ public:
}
/// Number of samples left in buffer starting from cursor
- boost::uint32_t m_size;
+ std::uint32_t m_size;
/// Actual data
//
/// The data must be allocated with new []
/// as will be delete []'d by the dtor
- boost::uint8_t* m_data;
+ std::uint8_t* m_data;
/// Cursor into the data
- boost::uint8_t* m_ptr;
+ std::uint8_t* m_ptr;
};
typedef boost::ptr_deque<CursoredBuffer> AudioQueue;
@@ -151,11 +151,11 @@ public:
void detachAuxStreamer();
/// Fetch samples from the audio queue
- unsigned int fetch(boost::int16_t* samples, unsigned int nSamples,
+ unsigned int fetch(std::int16_t* samples, unsigned int nSamples,
bool& eof);
/// Fetch samples from the audio queue
- static unsigned int fetchWrapper(void* owner, boost::int16_t* samples,
+ static unsigned int fetchWrapper(void* owner, std::int16_t* samples,
unsigned int nSamples, bool& eof);
/// Push a buffer to the audio queue
@@ -235,13 +235,13 @@ public:
/// Defines in seconds where to seek to
/// @todo take milliseconds !!
///
- void seek(boost::uint32_t pos);
+ void seek(std::uint32_t pos);
/// Tells where the playhead currently is
//
/// @return The time in milliseconds of the current playhead position
///
- boost::int32_t time();
+ std::int32_t time();
/// Called at the heart-beat frequency. Used to process queued status
messages
/// and (re)start after a buffering pause. In NetStreamFfmpeg it is also
@@ -270,14 +270,14 @@ public:
/// @param time
/// The time in milliseconds that should be buffered.
///
- void setBufferTime(boost::uint32_t time);
+ void setBufferTime(std::uint32_t time);
/// Returns what the buffer time has been set to. (100 milliseconds
/// is default)
//
/// @return The size of the buffer in milliseconds.
///
- boost::uint32_t bufferTime() { return _bufferTime; }
+ std::uint32_t bufferTime() { return _bufferTime; }
/// Returns the number of bytes of the media file that have been buffered.
long bytesLoaded();
@@ -318,7 +318,7 @@ public:
/// It might be invoked by a separate thread (neither main,
/// nor decoder thread).
///
- static unsigned int audio_streamer(void *udata, boost::int16_t* samples,
+ static unsigned int audio_streamer(void *udata, std::int16_t* samples,
unsigned int nSamples, bool& eof);
private:
@@ -442,7 +442,7 @@ private:
/// \brief
/// Decode input audio frames with timestamp <= ts
/// and push them to the output audio queue
- void pushDecodedAudioFrames(boost::uint32_t ts);
+ void pushDecodedAudioFrames(std::uint32_t ts);
/// Decode input frames up to the one with timestamp <= ts.
//
@@ -454,7 +454,7 @@ private:
/// 3. next element in cursor has timestamp > tx
/// 4. there was an error decoding
///
- std::unique_ptr<image::GnashImage> getDecodedVideoFrame(boost::uint32_t
ts);
+ std::unique_ptr<image::GnashImage> getDecodedVideoFrame(std::uint32_t ts);
DecodingState decodingStatus(DecodingState newstate = DEC_NONE);
@@ -506,7 +506,7 @@ private:
std::unique_ptr<CharacterProxy> _audioController;
// The size of the buffer in milliseconds
- boost::uint32_t _bufferTime;
+ std::uint32_t _bufferTime;
// Mutex to insure we don't corrupt the image
boost::mutex image_mutex;
diff --git a/libcore/asobj/Object.cpp b/libcore/asobj/Object.cpp
index 1193f89..3b9caa8 100644
--- a/libcore/asobj/Object.cpp
+++ b/libcore/asobj/Object.cpp
@@ -305,7 +305,7 @@ object_registerClass(const fn_call& fn)
const movie_definition* def = relRoot->definition();
// We only care about definitions, not other exportable resources.
- const boost::uint16_t id = def->exportID(symbolid);
+ const std::uint16_t id = def->exportID(symbolid);
SWF::DefinitionTag* d = def->getDefinitionTag(id);
if (!d) {
diff --git a/libcore/asobj/PlayHead.cpp b/libcore/asobj/PlayHead.cpp
index ab783ab..de7e857 100644
--- a/libcore/asobj/PlayHead.cpp
+++ b/libcore/asobj/PlayHead.cpp
@@ -54,7 +54,7 @@ PlayHead::setState(PlaybackStatus newState)
// if we go from PAUSED to PLAYING, reset
// _clockOffset to yank current position
// when querying clock source *now*
- boost::uint64_t now = _clockSource->elapsed();
+ std::uint64_t now = _clockSource->elapsed();
_clockOffset = ( now - _position );
// check if we did the right thing
@@ -101,7 +101,7 @@ PlayHead::advanceIfConsumed()
}
// Advance position
- boost::uint64_t now = _clockSource->elapsed();
+ std::uint64_t now = _clockSource->elapsed();
_position = now-_clockOffset;
// Reset consumers state
@@ -109,9 +109,9 @@ PlayHead::advanceIfConsumed()
}
void
-PlayHead::seekTo(boost::uint64_t position)
+PlayHead::seekTo(std::uint64_t position)
{
- boost::uint64_t now = _clockSource->elapsed();
+ std::uint64_t now = _clockSource->elapsed();
_position = position;
_clockOffset = ( now - _position );
diff --git a/libcore/asobj/PlayHead.h b/libcore/asobj/PlayHead.h
index e5348ac..5e70e52 100644
--- a/libcore/asobj/PlayHead.h
+++ b/libcore/asobj/PlayHead.h
@@ -21,7 +21,7 @@
#ifndef GNASH_PLAYHEAD_H
#define GNASH_PLAYHEAD_H
-#include <boost/cstdint.hpp> // For C99 int types
+#include <cstdint> // For C99 int types
// Forward declarations
namespace gnash {
@@ -74,7 +74,7 @@ public:
}
/// Get current playhead position (milliseconds)
- boost::uint64_t getPosition() const { return _position; }
+ std::uint64_t getPosition() const { return _position; }
/// Get current playback state
PlaybackStatus getState() const { return _state; }
@@ -121,7 +121,7 @@ public:
/// - isAudioConsumed() == false
/// - getPosition() == position
///
- void seekTo(boost::uint64_t position);
+ void seekTo(std::uint64_t position);
/// Advance position if all available consumers consumed the current one
//
@@ -146,7 +146,7 @@ private:
};
/// Current playhead position
- boost::uint64_t _position;
+ std::uint64_t _position;
/// Current playback state
PlaybackStatus _state;
@@ -166,7 +166,7 @@ private:
/// to get current position
//
/// The offset will be
- boost::uint64_t _clockOffset;
+ std::uint64_t _clockOffset;
};
diff --git a/libcore/asobj/SharedObject_as.cpp
b/libcore/asobj/SharedObject_as.cpp
index 9ba3dd4..a67ff1e 100644
--- a/libcore/asobj/SharedObject_as.cpp
+++ b/libcore/asobj/SharedObject_as.cpp
@@ -167,7 +167,7 @@ public:
}
// This is SOL specific.
- boost::uint8_t end(0);
+ std::uint8_t end(0);
_writer.writeData(&end, 1);
++_count;
return true;
@@ -899,9 +899,9 @@ readSOL(VM& vm, const std::string& filespec)
return data;
}
- std::unique_ptr<boost::uint8_t[]> sbuf(new boost::uint8_t[size]);
- const boost::uint8_t *buf = sbuf.get();
- const boost::uint8_t *end = buf + size;
+ std::unique_ptr<std::uint8_t[]> sbuf(new std::uint8_t[size]);
+ const std::uint8_t *buf = sbuf.get();
+ const std::uint8_t *end = buf + size;
try {
std::ifstream ifs(filespec.c_str(), std::ios::binary);
@@ -912,7 +912,7 @@ readSOL(VM& vm, const std::string& filespec)
buf += 16; // skip const-length headers
// skip past name TODO add sanity check
- buf += ntohs(*(reinterpret_cast<const boost::uint16_t*>(buf)));
+ buf += ntohs(*(reinterpret_cast<const std::uint16_t*>(buf)));
buf += 2;
buf += 4; // skip past padding
@@ -936,8 +936,8 @@ readSOL(VM& vm, const std::string& filespec)
break;
}
- const boost::uint16_t len =
- ntohs(*(reinterpret_cast<const boost::uint16_t*>(buf)));
+ const std::uint16_t len =
+ ntohs(*(reinterpret_cast<const std::uint16_t*>(buf)));
buf += 2;
if (!len) {
@@ -1012,7 +1012,7 @@ createSharedObject(Global_as& gl)
void
encodeHeader(const size_t size, SimpleBuffer& buf)
{
- const boost::uint8_t header[] = { 0x00, 0xbf };
+ const std::uint8_t header[] = { 0x00, 0xbf };
// Initial header byters
buf.append(header, arraySize(header));
@@ -1026,19 +1026,19 @@ bool
encodeData(const std::string& name, as_object& data, SimpleBuffer& buf)
{
// Write the remaining header-like information.
- const boost::uint8_t magic[] = { 'T', 'C', 'S', 'O',
+ const std::uint8_t magic[] = { 'T', 'C', 'S', 'O',
0x00, 0x04, 0x00, 0x00, 0x00, 0x00 };
// Magic SharedObject bytes.
buf.append(magic, arraySize(magic));
// SharedObject name
- const boost::uint16_t len = name.length();
+ const std::uint16_t len = name.length();
buf.appendNetworkShort(len);
buf.append(name.c_str(), len);
// Padding
- const boost::uint8_t padding[] = { 0, 0, 0, 0 };
+ const std::uint8_t padding[] = { 0, 0, 0, 0 };
buf.append(padding, arraySize(padding));
// see http://osflash.org/documentation/amf/envelopes/sharedobject
diff --git a/libcore/asobj/Sound_as.cpp b/libcore/asobj/Sound_as.cpp
index ff7cdde..3783ca5 100644
--- a/libcore/asobj/Sound_as.cpp
+++ b/libcore/asobj/Sound_as.cpp
@@ -25,7 +25,7 @@
#include <string>
#include <boost/thread/mutex.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/optional.hpp>
#include "RunResources.h"
@@ -197,17 +197,17 @@ private:
/// Number of milliseconds into the sound to start it
//
/// This is set by start()
- boost::uint64_t _startTime;
+ std::uint64_t _startTime;
- std::unique_ptr<boost::uint8_t[]> _leftOverData;
- boost::uint8_t* _leftOverPtr;
- boost::uint32_t _leftOverSize;
+ std::unique_ptr<std::uint8_t[]> _leftOverData;
+ std::uint8_t* _leftOverPtr;
+ std::uint32_t _leftOverSize;
/// This is a sound_handler::aux_streamer_ptr type.
- static unsigned int getAudioWrapper(void *owner, boost::int16_t* samples,
+ static unsigned int getAudioWrapper(void *owner, std::int16_t* samples,
unsigned int nSamples, bool& etEOF);
- unsigned int getAudio(boost::int16_t* samples, unsigned int nSamples,
+ unsigned int getAudio(std::int16_t* samples, unsigned int nSamples,
bool& atEOF);
/// The aux streamer for sound handler
@@ -612,7 +612,7 @@ Sound_as::loadSound(const std::string& file, bool streaming)
} else {
// If this is an event sound, we must not limit buffering (parsing),
// because onLoad will not be called until we have finished doing so.
-
_mediaParser->setBufferTime(std::numeric_limits<boost::uint64_t>::max());
+ _mediaParser->setBufferTime(std::numeric_limits<std::uint64_t>::max());
}
startProbeTimer();
@@ -710,7 +710,7 @@ Sound_as::start(double secOff, int loops)
// Always seek as we might be called during or after some playing...
{
_startTime = secOff * 1000;
- boost::uint32_t seekms = boost::uint32_t(secOff * 1000);
+ std::uint32_t seekms = std::uint32_t(secOff * 1000);
// TODO: boost::mutex::scoped_lock parserLock(_parserMutex);
bool seeked = _mediaParser->seek(seekms); // well, we try...
log_debug("Seeked MediaParser to %d, returned: %d", seekms,
seeked);
@@ -816,7 +816,7 @@ Sound_as::getPosition() const
}
if (_mediaParser) {
- boost::uint64_t ts;
+ std::uint64_t ts;
if ( _mediaParser->nextAudioFrameTimestamp(ts) ) {
return ts;
}
@@ -828,9 +828,9 @@ Sound_as::getPosition() const
unsigned int
-Sound_as::getAudio(boost::int16_t* samples, unsigned int nSamples, bool& atEOF)
+Sound_as::getAudio(std::int16_t* samples, unsigned int nSamples, bool& atEOF)
{
- boost::uint8_t* stream = reinterpret_cast<boost::uint8_t*>(samples);
+ std::uint8_t* stream = reinterpret_cast<std::uint8_t*>(samples);
int len = nSamples*2;
#ifdef USE_SOUND
@@ -910,7 +910,7 @@ Sound_as::getAudio(boost::int16_t* samples, unsigned int
nSamples, bool& atEOF)
// audio callback is running in sound handler thread
unsigned int
-Sound_as::getAudioWrapper(void* owner, boost::int16_t* samples,
+Sound_as::getAudioWrapper(void* owner, std::int16_t* samples,
unsigned int nSamples, bool& atEOF)
{
Sound_as* so = static_cast<Sound_as*>(owner);
@@ -1041,7 +1041,7 @@ sound_stop(const fn_call& fn)
const movie_definition* def = fn.callerDef;
assert(def);
- const boost::uint16_t id = def->exportID(name);
+ const std::uint16_t id = def->exportID(name);
if (!id) {
IF_VERBOSE_MALFORMED_SWF(
log_swferror(_("No such export '%s'"),
@@ -1096,7 +1096,7 @@ sound_attachsound(const fn_call& fn)
assert(def);
- const boost::uint16_t id = def->exportID(name);
+ const std::uint16_t id = def->exportID(name);
if (!id) {
IF_VERBOSE_MALFORMED_SWF(
log_swferror(_("No such export '%s'"),
diff --git a/libcore/asobj/String_as.cpp b/libcore/asobj/String_as.cpp
index 5a5231c..0a114ee 100644
--- a/libcore/asobj/String_as.cpp
+++ b/libcore/asobj/String_as.cpp
@@ -524,8 +524,8 @@ string_fromCharCode(const fn_call& fn)
for (unsigned int i = 0; i < fn.nargs; i++)
{
// Maximum 65535, as with all DisplayObject codes.
- const boost::uint16_t c =
- static_cast<boost::uint16_t>(toInt(fn.arg(i), getVM(fn)));
+ const std::uint16_t c =
+ static_cast<std::uint16_t>(toInt(fn.arg(i), getVM(fn)));
// If more than 255, push 'overflow' byte.
if (c > 255) {
@@ -544,8 +544,8 @@ string_fromCharCode(const fn_call& fn)
for (unsigned int i = 0; i < fn.nargs; i++)
{
- const boost::uint16_t c =
- static_cast<boost::uint16_t>(toInt(fn.arg(i), getVM(fn)));
+ const std::uint16_t c =
+ static_cast<std::uint16_t>(toInt(fn.arg(i), getVM(fn)));
if (c == 0) break;
wstr.push_back(c);
}
@@ -607,7 +607,7 @@ string_charAt(const fn_call& fn)
std::string::const_iterator it = str.begin(), e = str.end();
- while (boost::uint32_t code = utf8::decodeNextUnicodeCharacter(it, e))
+ while (std::uint32_t code = utf8::decodeNextUnicodeCharacter(it, e))
{
if (currentIndex == index)
{
diff --git a/libcore/asobj/TextField_as.cpp b/libcore/asobj/TextField_as.cpp
index 36d5275..ec316ff 100644
--- a/libcore/asobj/TextField_as.cpp
+++ b/libcore/asobj/TextField_as.cpp
@@ -315,7 +315,7 @@ textfield_backgroundColor(const fn_call& fn)
}
else {
rgba newColor;
- newColor.parseRGB(static_cast<boost::uint32_t>(toInt(fn.arg(0),
getVM(fn))));
+ newColor.parseRGB(static_cast<std::uint32_t>(toInt(fn.arg(0),
getVM(fn))));
ptr->setBackgroundColor(newColor);
}
@@ -332,7 +332,7 @@ textfield_borderColor(const fn_call& fn)
}
else {
rgba newColor;
- newColor.parseRGB(static_cast<boost::uint32_t>(toNumber(fn.arg(0),
getVM(fn))));
+ newColor.parseRGB(static_cast<std::uint32_t>(toNumber(fn.arg(0),
getVM(fn))));
ptr->setBorderColor(newColor);
}
@@ -352,7 +352,7 @@ textfield_textColor(const fn_call& fn)
// Setter
rgba newColor;
- newColor.parseRGB(static_cast<boost::uint32_t>(toNumber(fn.arg(0),
getVM(fn))));
+ newColor.parseRGB(static_cast<std::uint32_t>(toNumber(fn.arg(0),
getVM(fn))));
ptr->setTextColor(newColor);
return as_value();
@@ -833,7 +833,7 @@ textfield_maxChars(const fn_call& fn)
if (!fn.nargs)
{
- boost::int32_t maxChars = text->maxChars();
+ std::int32_t maxChars = text->maxChars();
if (maxChars == 0)
{
as_value null;
diff --git a/libcore/asobj/TextFormat_as.cpp b/libcore/asobj/TextFormat_as.cpp
index a662a75..ece49af 100644
--- a/libcore/asobj/TextFormat_as.cpp
+++ b/libcore/asobj/TextFormat_as.cpp
@@ -72,7 +72,7 @@ struct
PixelsToTwips : SetBase
{
PixelsToTwips(const fn_call& fn) : SetBase(fn) {}
- boost::int32_t operator()(const as_value& val) const {
+ std::int32_t operator()(const as_value& val) const {
return pixelsToTwips(toNumber(val, getVM(fn())));
}
};
@@ -256,11 +256,11 @@ registerTextFormatNative(as_object& o)
110, 2);
vm.registerNative(
- Get<const TextFormat_as, boost::uint16_t,
+ Get<const TextFormat_as, std::uint16_t,
&TextFormat_as::size, TwipsToPixels>::get,
110, 3);
vm.registerNative(
- Set<TextFormat_as, boost::uint16_t, &TextFormat_as::sizeSet,
+ Set<TextFormat_as, std::uint16_t, &TextFormat_as::sizeSet,
PixelsToTwips>::set,
110, 4);
@@ -311,47 +311,47 @@ registerTextFormatNative(as_object& o)
vm.registerNative(textformat_align, 110, 18);
vm.registerNative(
- Get<const TextFormat_as, boost::uint16_t,
+ Get<const TextFormat_as, std::uint16_t,
&TextFormat_as::leftMargin, TwipsToPixels>::get,
110, 19);
vm.registerNative(
- Set<TextFormat_as, boost::uint16_t, &TextFormat_as::leftMarginSet,
+ Set<TextFormat_as, std::uint16_t, &TextFormat_as::leftMarginSet,
PositiveTwips>::set,
110, 20);
vm.registerNative(
- Get<const TextFormat_as, boost::uint16_t,
+ Get<const TextFormat_as, std::uint16_t,
&TextFormat_as::rightMargin, TwipsToPixels>::get,
110, 21);
vm.registerNative(
- Set<TextFormat_as, boost::uint16_t, &TextFormat_as::rightMarginSet,
+ Set<TextFormat_as, std::uint16_t, &TextFormat_as::rightMarginSet,
PositiveTwips>::set,
110, 22);
vm.registerNative(
- Get<const TextFormat_as, boost::uint16_t,
+ Get<const TextFormat_as, std::uint16_t,
&TextFormat_as::indent,
TwipsToPixels>::get, 110, 23);
vm.registerNative(
- Set<TextFormat_as, boost::uint16_t, &TextFormat_as::indentSet,
+ Set<TextFormat_as, std::uint16_t, &TextFormat_as::indentSet,
PositiveTwips>::set,
110, 24);
vm.registerNative(
- Get<const TextFormat_as, boost::uint16_t,
+ Get<const TextFormat_as, std::uint16_t,
&TextFormat_as::leading,
TwipsToPixels>::get, 110, 25);
vm.registerNative(
- Set<TextFormat_as, boost::uint16_t, &TextFormat_as::leadingSet,
+ Set<TextFormat_as, std::uint16_t, &TextFormat_as::leadingSet,
PositiveTwips>::set,
110, 26);
vm.registerNative(
- Get<const TextFormat_as, boost::uint32_t,
+ Get<const TextFormat_as, std::uint32_t,
&TextFormat_as::blockIndent,
TwipsToPixels>::get, 110, 27);
vm.registerNative(
- Set<TextFormat_as, boost::uint32_t, &TextFormat_as::blockIndentSet,
+ Set<TextFormat_as, std::uint32_t, &TextFormat_as::blockIndentSet,
PositiveTwips>::set,
110, 28);
@@ -590,7 +590,7 @@ textformat_getTextExtent(const fn_call& fn)
const movie_definition* md = getRoot(fn).getRootMovie().definition();
// Option 1. Name refers to an imported font ('asset') symbol.
- boost::uint16_t fontId = md->exportID(name);
+ std::uint16_t fontId = md->exportID(name);
if (fontId != 0) {
f = md->get_font(fontId);
}
diff --git a/libcore/asobj/TextFormat_as.h b/libcore/asobj/TextFormat_as.h
index 9acbd5d..df27293 100644
--- a/libcore/asobj/TextFormat_as.h
+++ b/libcore/asobj/TextFormat_as.h
@@ -23,7 +23,7 @@
#define GNASH_TEXTFORMAT_H
#include <vector>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <string>
#include <boost/optional.hpp>
@@ -76,7 +76,7 @@ public:
}
/// Indentation from left margin to the first character in the paragraph
- const boost::optional<boost::uint16_t>& indent() const { return _indent; }
+ const boost::optional<std::uint16_t>& indent() const { return _indent; }
/// Paragraph alignment
const boost::optional<TextField::TextAlignment>& align() const { return
_align; }
@@ -91,24 +91,24 @@ public:
const boost::optional<std::string>& url() const { return _url; }
/// The block indent.
- const boost::optional<boost::uint32_t>& blockIndent() const {
+ const boost::optional<std::uint32_t>& blockIndent() const {
return _blockIndent;
}
/// Return a number that indicates the amount of leading vertical
/// space between lines.
- const boost::optional<boost::uint16_t>& leading() const { return _leading;
}
+ const boost::optional<std::uint16_t>& leading() const { return _leading; }
/// Indicates the left margin of the paragraph, in points.
- const boost::optional<boost::uint16_t>& leftMargin() const { return
_leftMargin; }
+ const boost::optional<std::uint16_t>& leftMargin() const { return
_leftMargin; }
/// Indicates the right margin of the paragraph in twips
- const boost::optional<boost::uint16_t>& rightMargin() const {
+ const boost::optional<std::uint16_t>& rightMargin() const {
return _rightMargin;
}
/// Return a float that indicates the point size in twips.
- const boost::optional<boost::uint16_t>& size() const { return _pointSize; }
+ const boost::optional<std::uint16_t>& size() const { return _pointSize; }
/// Setters
@@ -126,7 +126,7 @@ public:
void colorSet(const boost::optional<rgba>& x) { _color = x; }
- void indentSet(const boost::optional<boost::uint16_t>& x) { _indent = x; }
+ void indentSet(const boost::optional<std::uint16_t>& x) { _indent = x; }
void fontSet(const boost::optional<std::string>& font) { _font=font; }
@@ -134,19 +134,19 @@ public:
void alignSet(const std::string& align);
- void blockIndentSet(const boost::optional<boost::uint32_t>& x) {
+ void blockIndentSet(const boost::optional<std::uint32_t>& x) {
_blockIndent = x;
}
- void leadingSet(const boost::optional<boost::uint16_t>& x) { _leading = x;
}
+ void leadingSet(const boost::optional<std::uint16_t>& x) { _leading = x; }
- void leftMarginSet(const boost::optional<boost::uint16_t>& x) {
_leftMargin = x; }
+ void leftMarginSet(const boost::optional<std::uint16_t>& x) { _leftMargin
= x; }
- void rightMarginSet(const boost::optional<boost::uint16_t>& x) {
+ void rightMarginSet(const boost::optional<std::uint16_t>& x) {
_rightMargin = x;
}
- void sizeSet(const boost::optional<boost::uint16_t>& x) { _pointSize = x; }
+ void sizeSet(const boost::optional<std::uint16_t>& x) { _pointSize = x; }
void tabStopsSet(const std::vector<int>& tabStops) { _tabStops = tabStops;
}
@@ -178,7 +178,7 @@ private:
boost::optional<TextField::TextAlignment> _align;
//
- boost::optional<boost::uint32_t> _blockIndent;
+ boost::optional<std::uint32_t> _blockIndent;
/// The color of text using this text format.
//
@@ -195,20 +195,20 @@ private:
/// An integer that indicates the indentation from the left
/// margin to the first DisplayObject in the paragraph (twips)
- boost::optional<boost::uint16_t> _indent;
+ boost::optional<std::uint16_t> _indent;
/// A number that indicates the amount of leading vertical
/// space between lines (twips)
- boost::optional<boost::uint16_t> _leading;
+ boost::optional<std::uint16_t> _leading;
/// Indicates the left margin of the paragraph, in points (twips)
- boost::optional<boost::uint16_t> _leftMargin;
+ boost::optional<std::uint16_t> _leftMargin;
/// Indicates the right margin of the paragraph, in points (twips).
- boost::optional<boost::uint16_t> _rightMargin;
+ boost::optional<std::uint16_t> _rightMargin;
/// Point size in twips.
- boost::optional<boost::uint16_t> _pointSize;
+ boost::optional<std::uint16_t> _pointSize;
///
boost::optional<std::vector<int> > _tabStops;
diff --git a/libcore/asobj/TextSnapshot_as.cpp
b/libcore/asobj/TextSnapshot_as.cpp
index e2f83ad..9afaf3e 100644
--- a/libcore/asobj/TextSnapshot_as.cpp
+++ b/libcore/asobj/TextSnapshot_as.cpp
@@ -59,10 +59,10 @@ public:
/// AS return values.
TextSnapshot_as(const MovieClip* mc);
- std::string getText(boost::int32_t start, boost::int32_t end,
+ std::string getText(std::int32_t start, std::int32_t end,
bool nl) const;
- boost::int32_t findText(boost::int32_t start, const std::string& text,
+ std::int32_t findText(std::int32_t start, const std::string& text,
bool ignoreCase) const;
bool valid() const { return _valid; }
@@ -356,13 +356,13 @@ TextSnapshot_as::makeString(std::string& to, bool
newline, bool selectedOnly,
}
std::string
-TextSnapshot_as::getText(boost::int32_t start, boost::int32_t end, bool nl)
+TextSnapshot_as::getText(std::int32_t start, std::int32_t end, bool nl)
const
{
// Start is always moved to between 0 and len - 1.
- start = std::max<boost::int32_t>(start, 0);
- start = std::min<boost::int32_t>(start, _count - 1);
+ start = std::max<std::int32_t>(start, 0);
+ start = std::min<std::int32_t>(start, _count - 1);
// End is always moved to between start and end. We don't really care
// about the end of the string.
@@ -384,8 +384,8 @@ TextSnapshot_as::getSelectedText(bool newline) const
return sel;
}
-boost::int32_t
-TextSnapshot_as::findText(boost::int32_t start, const std::string& text,
+std::int32_t
+TextSnapshot_as::findText(std::int32_t start, const std::string& text,
bool ignoreCase) const
{
@@ -496,9 +496,9 @@ textsnapshot_getTextRunInfo(const fn_call& fn)
return as_value();
}
- const size_t start = std::max<boost::int32_t>(0,
+ const size_t start = std::max<std::int32_t>(0,
toInt(fn.arg(0), getVM(fn)));
- const size_t end = std::max<boost::int32_t>(start + 1,
+ const size_t end = std::max<std::int32_t>(start + 1,
toInt(fn.arg(1), getVM(fn)));
Global_as& gl = getGlobal(fn);
@@ -523,7 +523,7 @@ textsnapshot_findText(const fn_call& fn)
return as_value();
}
- boost::int32_t start = toInt(fn.arg(0), getVM(fn));
+ std::int32_t start = toInt(fn.arg(0), getVM(fn));
const std::string& text = fn.arg(1).to_string();
/// Yes, the pp is case-insensitive by default. We don't write
@@ -562,9 +562,9 @@ textsnapshot_getSelected(const fn_call& fn)
return as_value();
}
- const size_t start = std::max<boost::int32_t>(0,
+ const size_t start = std::max<std::int32_t>(0,
toInt(fn.arg(0), getVM(fn)));
- const size_t end = std::max<boost::int32_t>(start + 1,
+ const size_t end = std::max<std::int32_t>(start + 1,
toInt(fn.arg(1), getVM(fn)));
return as_value(ts->getSelected(start, end));
@@ -603,8 +603,8 @@ textsnapshot_getText(const fn_call& fn)
return as_value();
}
- const boost::int32_t start = toInt(fn.arg(0), getVM(fn));
- const boost::int32_t end = toInt(fn.arg(1), getVM(fn));
+ const std::int32_t start = toInt(fn.arg(0), getVM(fn));
+ const std::int32_t end = toInt(fn.arg(1), getVM(fn));
const bool newline = (fn.nargs > 2) ? toBool(fn.arg(2), getVM(fn)) : false;
@@ -648,9 +648,9 @@ textsnapshot_setSelected(const fn_call& fn)
return as_value();
}
- const size_t start = std::max<boost::int32_t>(0,
+ const size_t start = std::max<std::int32_t>(0,
toInt(fn.arg(0), getVM(fn)));
- const size_t end = std::max<boost::int32_t>(start,
+ const size_t end = std::max<std::int32_t>(start,
toInt(fn.arg(1), getVM(fn)));
const bool selected = (fn.nargs > 2) ? toBool(fn.arg(2), getVM(fn)) : true;
diff --git a/libcore/asobj/XMLSocket_as.cpp b/libcore/asobj/XMLSocket_as.cpp
index 0aee240..cd506de 100644
--- a/libcore/asobj/XMLSocket_as.cpp
+++ b/libcore/asobj/XMLSocket_as.cpp
@@ -78,7 +78,7 @@ public:
/// @return false if the connection is not allowed, otherwise true.
/// Note that a return of true does not mean a successful
/// connection.
- bool connect(const std::string& host, boost::uint16_t port);
+ bool connect(const std::string& host, std::uint16_t port);
/// Send a string with a null-terminator to the socket.
//
@@ -160,7 +160,7 @@ XMLSocket_as::update()
bool
-XMLSocket_as::connect(const std::string& host, boost::uint16_t port)
+XMLSocket_as::connect(const std::string& host, std::uint16_t port)
{
if (!URLAccessManager::allowXMLSocket(host, port)) {
@@ -330,7 +330,7 @@ xmlsocket_connect(const fn_call& fn)
// TODO: find out.
// Other ports and hosts are checked against security policy before
// acceptance or rejection.
- if (port > std::numeric_limits<boost::uint16_t>::max()) {
+ if (port > std::numeric_limits<std::uint16_t>::max()) {
return as_value(false);
}
diff --git a/libcore/asobj/XML_as.cpp b/libcore/asobj/XML_as.cpp
index 8ae2d36..b13e867 100644
--- a/libcore/asobj/XML_as.cpp
+++ b/libcore/asobj/XML_as.cpp
@@ -658,11 +658,11 @@ xml_status(const fn_call& fn)
const double status = toNumber(fn.arg(0), getVM(fn));
if (isNaN(status) ||
- status > std::numeric_limits<boost::int32_t>::max() ||
- status < std::numeric_limits<boost::int32_t>::min()) {
+ status > std::numeric_limits<std::int32_t>::max() ||
+ status < std::numeric_limits<std::int32_t>::min()) {
ptr->setStatus(static_cast<XML_as::ParseStatus>(
- std::numeric_limits<boost::int32_t>::min()));
+ std::numeric_limits<std::int32_t>::min()));
}
else ptr->setStatus(static_cast<XML_as::ParseStatus>(int(status)));
return as_value();
diff --git a/libcore/asobj/flash/display/BitmapData_as.cpp
b/libcore/asobj/flash/display/BitmapData_as.cpp
index 1c2e493..a031b6e 100644
--- a/libcore/asobj/flash/display/BitmapData_as.cpp
+++ b/libcore/asobj/flash/display/BitmapData_as.cpp
@@ -102,7 +102,7 @@ namespace {
//
/// Note: calls pixelAt(), so do not use this more than necessary!
void setPixel32(const BitmapData_as& bd, size_t x, size_t y,
- boost::uint32_t color);
+ std::uint32_t color);
/// Set the RGB values at (x, y) to the RGB components of a colour.
//
@@ -110,9 +110,9 @@ namespace {
//
/// Note: calls pixelAt(), so do not use this more than necessary!
void setPixel(const BitmapData_as& bd, size_t x, size_t y,
- boost::uint32_t color);
+ std::uint32_t color);
- boost::uint32_t getPixel(const BitmapData_as& bd, size_t x, size_t y);
+ std::uint32_t getPixel(const BitmapData_as& bd, size_t x, size_t y);
/// Get the overlapping part of a rectangle and a Bitmap
//
@@ -126,13 +126,13 @@ namespace {
/// @param h The height of the rectangle.
void adjustRect(int& x, int& y, int& w, int& h, const BitmapData_as& b);
- boost::uint32_t setChannel(boost::uint32_t targ, boost::uint8_t bitmask,
- boost::uint8_t value);
+ std::uint32_t setChannel(std::uint32_t targ, std::uint8_t bitmask,
+ std::uint8_t value);
- boost::uint8_t getChannel(boost::uint32_t src, boost::uint8_t bitmask);
+ std::uint8_t getChannel(std::uint32_t src, std::uint8_t bitmask);
void floodFill(const BitmapData_as& bd, size_t startx, size_t starty,
- boost::uint32_t old, boost::uint32_t fill);
+ std::uint32_t old, std::uint32_t fill);
/// Fill a rectangle of the BitmapData_as
//
@@ -145,9 +145,9 @@ namespace {
/// @param h The height of the rectangle.
/// @param color The ARGB colour to fill with.
void fillRect(const BitmapData_as& bd, int x, int y, int w, int h,
- boost::uint32_t color);
+ std::uint32_t color);
- inline bool oneBitSet(boost::uint8_t mask) {
+ inline bool oneBitSet(std::uint8_t mask) {
return mask == (mask & -mask);
}
}
@@ -202,7 +202,7 @@ private:
template<typename NoiseGenerator>
struct NoiseAdapter
{
- NoiseAdapter(NoiseGenerator& n, boost::uint8_t bitmask, bool grey)
+ NoiseAdapter(NoiseGenerator& n, std::uint8_t bitmask, bool grey)
:
_gen(n),
_bitmask(bitmask),
@@ -210,14 +210,14 @@ struct NoiseAdapter
{}
/// Generate a 32-bit ARGB noise value.
- boost::uint32_t operator()() {
+ std::uint32_t operator()() {
if (_greyscale) {
- boost::uint8_t val = _gen();
+ std::uint8_t val = _gen();
return 0xff000000 | val | val << 8 | val << 16;
}
- boost::uint32_t ret = 0xff000000;
+ std::uint32_t ret = 0xff000000;
if (_bitmask & BitmapData_as::CHANNEL_RED) {
ret |= (_gen() << 16);
@@ -230,7 +230,7 @@ struct NoiseAdapter
}
if (_bitmask & BitmapData_as::CHANNEL_ALPHA) {
// Alpha is 0xff by default.
- const boost::uint8_t rd = _gen();
+ const std::uint8_t rd = _gen();
ret &= (~rd) << 24;
}
return ret;
@@ -238,7 +238,7 @@ struct NoiseAdapter
private:
NoiseGenerator& _gen;
- const boost::uint8_t _bitmask;
+ const std::uint8_t _bitmask;
const bool _greyscale;
};
@@ -252,26 +252,26 @@ struct CopyChannel
typedef boost::tuple<Iterator, Iterator> iterator_tuple;
typedef boost::zip_iterator<iterator_tuple> iterator_type;
- CopyChannel(bool multiple, boost::uint8_t srcchans,
- boost::uint8_t destchans)
+ CopyChannel(bool multiple, std::uint8_t srcchans,
+ std::uint8_t destchans)
:
_multiple(multiple),
_srcchans(srcchans),
_destchans(destchans)
{}
- boost::uint32_t operator()(typename iterator_type::value_type p) const {
+ std::uint32_t operator()(typename iterator_type::value_type p) const {
// If multiple source channels, we set the destination channel
// to black. Else to the value of the requested channel.
- const boost::uint8_t val = _multiple ?
+ const std::uint8_t val = _multiple ?
0 : getChannel(boost::get<0>(p), _srcchans);
return setChannel(boost::get<1>(p), _destchans, val);
}
private:
const bool _multiple;
- const boost::uint8_t _srcchans;
- const boost::uint8_t _destchans;
+ const std::uint8_t _srcchans;
+ const std::uint8_t _destchans;
};
@@ -295,8 +295,8 @@ void normalize(T& a, T& b)
/// @tparam B The size of the permutation table.
/// @tparam Offset An offset for generating non-identical patterns with the
/// same Perlin noise generator.
-template<typename T, boost::uint32_t Size = 0x100,
- boost::uint32_t Offset = 1327>
+template<typename T, std::uint32_t Size = 0x100,
+ std::uint32_t Offset = 1327>
struct PerlinNoise
{
typedef T value_type;
@@ -310,7 +310,7 @@ struct PerlinNoise
init(seed);
}
- boost::uint32_t size() const {
+ std::uint32_t size() const {
return Size;
}
@@ -430,9 +430,9 @@ private:
/// Store offsets.
struct Vector
{
- Vector(boost::int32_t x, boost::int32_t y) : x(x), y(y) {}
- boost::int32_t x;
- boost::int32_t y;
+ Vector(std::int32_t x, std::int32_t y) : x(x), y(y) {}
+ std::int32_t x;
+ std::int32_t y;
};
/// Transform negative offsets into positive ones
@@ -802,11 +802,11 @@ bitmapdata_copyChannel(const fn_call& fn)
// is negative (currently it is truncated and made positive.
// The source channel mask
- const boost::uint8_t srcchans =
+ const std::uint8_t srcchans =
std::abs(toInt(fn.arg(3), getVM(fn))) & 15;
// The destination channel mask
- const boost::uint8_t destchans =
+ const std::uint8_t destchans =
std::abs(toInt(fn.arg(4), getVM(fn))) & 15;
// If more than one destination channel is specified,
@@ -1142,7 +1142,7 @@ bitmapdata_fillRect(const fn_call& fn)
obj->get_member(NSV::PROP_WIDTH, &w);
obj->get_member(NSV::PROP_HEIGHT, &h);
- const boost::uint32_t color = toInt(fn.arg(1), getVM(fn));
+ const std::uint32_t color = toInt(fn.arg(1), getVM(fn));
fillRect(*ptr, toInt(x, getVM(fn)), toInt(y, getVM(fn)),
toInt(w, getVM(fn)), toInt(h, getVM(fn)), color);
@@ -1175,8 +1175,8 @@ bitmapdata_floodFill(const fn_call& fn)
return as_value();
}
- const boost::uint32_t fill = toInt(fn.arg(2), getVM(fn));
- const boost::uint32_t old = *pixelAt(*ptr, x, y);
+ const std::uint32_t fill = toInt(fn.arg(2), getVM(fn));
+ const std::uint32_t old = *pixelAt(*ptr, x, y);
// This checks whether the colours are the same.
floodFill(*ptr, x, y, old, fill);
@@ -1223,7 +1223,7 @@ bitmapdata_getPixel(const fn_call& fn)
// Note: x and y are converted to size_t, so negative values becomre
// very large and are also outside the image. This is perfectly legal!
- return static_cast<boost::int32_t>(getPixel(*ptr, x, y) & 0xffffff);
+ return static_cast<std::int32_t>(getPixel(*ptr, x, y) & 0xffffff);
}
as_value
@@ -1247,7 +1247,7 @@ bitmapdata_getPixel32(const fn_call& fn)
// Note: x and y are converted to size_t, so negative values becomre
// very large and are also outside the image. This is perfectly legal!
- return static_cast<boost::int32_t>(getPixel(*ptr, x, y));
+ return static_cast<std::int32_t>(getPixel(*ptr, x, y));
}
@@ -1281,13 +1281,13 @@ bitmapdata_noise(const fn_call& fn)
}
const int seed = toInt(fn.arg(0), getVM(fn));
- const boost::uint8_t low = fn.nargs > 1 ?
+ const std::uint8_t low = fn.nargs > 1 ?
clamp(toInt(fn.arg(1), getVM(fn)), 0, 255) : 0;
- const boost::uint8_t high = fn.nargs > 2 ?
+ const std::uint8_t high = fn.nargs > 2 ?
clamp<int>(toInt(fn.arg(2), getVM(fn)), low, 255) : 255;
- const boost::uint8_t chans = fn.nargs > 3 ?
+ const std::uint8_t chans = fn.nargs > 3 ?
std::abs(toInt(fn.arg(3), getVM(fn))) & 15 :
BitmapData_as::CHANNEL_RED |
BitmapData_as::CHANNEL_GREEN |
@@ -1343,7 +1343,7 @@ bitmapdata_perlinNoise(const fn_call& fn)
toBool(fn.arg(5), getVM(fn)) : false;
// Which channels to use.
- const boost::uint8_t channels = fn.nargs > 6 ?
+ const std::uint8_t channels = fn.nargs > 6 ?
clamp<int>(toInt(fn.arg(6), getVM(fn)), 0, 255) :
BitmapData_as::CHANNEL_RED |
BitmapData_as::CHANNEL_GREEN |
@@ -1391,7 +1391,7 @@ bitmapdata_perlinNoise(const fn_call& fn)
const size_t x = pixel % width;
const size_t y = pixel / width;
- boost::uint8_t rv = 0;
+ std::uint8_t rv = 0;
if (greyscale || channels & BitmapData_as::CHANNEL_RED) {
// Create one noise channel.
@@ -1399,7 +1399,7 @@ bitmapdata_perlinNoise(const fn_call& fn)
rv = clamp(r, 0.0, 255.0);
}
- boost::uint8_t av = 0xff;
+ std::uint8_t av = 0xff;
// It's just a waste of time if the BitmapData has no alpha.
if (transparent && channels & BitmapData_as::CHANNEL_ALPHA) {
@@ -1418,8 +1418,8 @@ bitmapdata_perlinNoise(const fn_call& fn)
// Otherwise create data for the other channels too by using the
// PerlinNoise object's pattern offset (this is cheaper than using a
// separate generator)
- boost::uint8_t gv = 0;
- boost::uint8_t bv = 0;
+ std::uint8_t gv = 0;
+ std::uint8_t bv = 0;
if (channels & BitmapData_as::CHANNEL_GREEN) {
const double g = pa(x, y, 1);
@@ -1472,7 +1472,7 @@ bitmapdata_setPixel(const fn_call& fn)
}
// Ignore any transparency here.
- const boost::uint32_t color = toInt(fn.arg(2), getVM(fn));
+ const std::uint32_t color = toInt(fn.arg(2), getVM(fn));
setPixel(*ptr, x, y, color);
@@ -1496,7 +1496,7 @@ bitmapdata_setPixel32(const fn_call& fn)
}
// TODO: multiply.
- const boost::uint32_t color = toInt(fn.arg(2), getVM(fn));
+ const std::uint32_t color = toInt(fn.arg(2), getVM(fn));
setPixel32(*ptr, x, y, color);
@@ -1604,7 +1604,7 @@ bitmapdata_loadBitmap(const fn_call& fn)
const movie_definition* def = root->definition();
- const boost::uint16_t id = def->exportID(linkage);
+ const std::uint16_t id = def->exportID(linkage);
CachedBitmap* bit = def->getBitmap(id);
if (!bit) return as_value();
@@ -1664,7 +1664,7 @@ bitmapdata_ctor(const fn_call& fn)
const size_t width = toInt(fn.arg(0), getVM(fn));
const size_t height = toInt(fn.arg(1), getVM(fn));
const bool transparent = fn.nargs > 2 ? toBool(fn.arg(2), getVM(fn)) :
true;
- boost::uint32_t fillColor =
+ std::uint32_t fillColor =
fn.nargs > 3 ? toInt(fn.arg(3), getVM(fn)) : 0xffffffff;
if (width > 2880 || height > 2880 || width < 1 || height < 1) {
@@ -1753,7 +1753,7 @@ pixelAt(const BitmapData_as& bd, size_t x, size_t y)
return (bd.begin() + y * width + x);
}
-boost::uint32_t
+std::uint32_t
getPixel(const BitmapData_as& bd, size_t x, size_t y)
{
if (x >= bd.width() || y >= bd.height()) return 0;
@@ -1761,18 +1761,18 @@ getPixel(const BitmapData_as& bd, size_t x, size_t y)
}
void
-setPixel(const BitmapData_as& bd, size_t x, size_t y, boost::uint32_t color)
+setPixel(const BitmapData_as& bd, size_t x, size_t y, std::uint32_t color)
{
if (bd.disposed()) return;
if (x >= bd.width() || y >= bd.height()) return;
BitmapData_as::iterator it = pixelAt(bd, x, y);
- const boost::uint32_t val = *it;
+ const std::uint32_t val = *it;
*it = (color & 0xffffff) | (val & 0xff000000);
}
void
-setPixel32(const BitmapData_as& bd, size_t x, size_t y, boost::uint32_t color)
+setPixel32(const BitmapData_as& bd, size_t x, size_t y, std::uint32_t color)
{
if (bd.disposed()) return;
if (x >= bd.width() || y >= bd.height()) return;
@@ -1783,7 +1783,7 @@ setPixel32(const BitmapData_as& bd, size_t x, size_t y,
boost::uint32_t color)
void
fillRect(const BitmapData_as& bd, int x, int y, int w, int h,
- boost::uint32_t color)
+ std::uint32_t color)
{
adjustRect(x, y, w, h, bd);
@@ -1809,7 +1809,7 @@ fillRect(const BitmapData_as& bd, int x, int y, int w,
int h,
void
floodFill(const BitmapData_as& bd, size_t startx, size_t starty,
- boost::uint32_t old, boost::uint32_t fill)
+ std::uint32_t old, std::uint32_t fill)
{
const size_t width = bd.width();
const size_t height = bd.height();
@@ -1924,8 +1924,8 @@ adjustRect(int& x, int& y, int& w, int& h, const
BitmapData_as& b)
}
-boost::uint8_t
-getChannel(boost::uint32_t src, boost::uint8_t bitmask)
+std::uint8_t
+getChannel(std::uint32_t src, std::uint8_t bitmask)
{
if (bitmask & BitmapData_as::CHANNEL_RED) {
// Red
@@ -1946,11 +1946,11 @@ getChannel(boost::uint32_t src, boost::uint8_t bitmask)
return 0;
}
-boost::uint32_t
-setChannel(boost::uint32_t targ, boost::uint8_t bitmask, boost::uint8_t value)
+std::uint32_t
+setChannel(std::uint32_t targ, std::uint8_t bitmask, std::uint8_t value)
{
- boost::uint32_t bytemask = 0;
- boost::uint32_t valmask = 0;
+ std::uint32_t bytemask = 0;
+ std::uint32_t valmask = 0;
if (bitmask & BitmapData_as::CHANNEL_RED) {
// Red
bytemask = 0xff0000;
diff --git a/libcore/asobj/flash/display/BitmapData_as.h
b/libcore/asobj/flash/display/BitmapData_as.h
index 9733c1f..a028ffa 100644
--- a/libcore/asobj/flash/display/BitmapData_as.h
+++ b/libcore/asobj/flash/display/BitmapData_as.h
@@ -22,7 +22,7 @@
#define GNASH_ASOBJ_BITMAPDATA_H
#include <list>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <memory>
#include <cassert>
#include <boost/intrusive_ptr.hpp>
diff --git a/libcore/asobj/flash/filters/BevelFilter_as.cpp
b/libcore/asobj/flash/filters/BevelFilter_as.cpp
index c28c859..28bc2c8 100644
--- a/libcore/asobj/flash/filters/BevelFilter_as.cpp
+++ b/libcore/asobj/flash/filters/BevelFilter_as.cpp
@@ -125,7 +125,7 @@ bevelfilter_highlightColor(const fn_call& fn)
if (fn.nargs == 0) {
return as_value(ptr->m_highlightColor );
}
- boost::uint32_t sp_highlightColor = toNumber(fn.arg(0), getVM(fn));
+ std::uint32_t sp_highlightColor = toNumber(fn.arg(0), getVM(fn));
ptr->m_highlightColor = sp_highlightColor;
return as_value();
}
@@ -137,7 +137,7 @@ bevelfilter_highlightAlpha(const fn_call& fn)
if (fn.nargs == 0) {
return as_value(ptr->m_highlightAlpha );
}
- boost::uint8_t sp_highlightAlpha = toNumber(fn.arg(0), getVM(fn));
+ std::uint8_t sp_highlightAlpha = toNumber(fn.arg(0), getVM(fn));
ptr->m_highlightAlpha = sp_highlightAlpha;
return as_value();
}
@@ -149,7 +149,7 @@ bevelfilter_shadowColor(const fn_call& fn)
if (fn.nargs == 0) {
return as_value(ptr->m_shadowColor );
}
- boost::uint32_t sp_shadowColor = toNumber(fn.arg(0), getVM(fn));
+ std::uint32_t sp_shadowColor = toNumber(fn.arg(0), getVM(fn));
ptr->m_shadowColor = sp_shadowColor;
return as_value();
}
@@ -161,7 +161,7 @@ bevelfilter_shadowAlpha(const fn_call& fn)
if (fn.nargs == 0) {
return as_value(ptr->m_shadowAlpha );
}
- boost::uint8_t sp_shadowAlpha = toNumber(fn.arg(0), getVM(fn));
+ std::uint8_t sp_shadowAlpha = toNumber(fn.arg(0), getVM(fn));
ptr->m_shadowAlpha = sp_shadowAlpha;
return as_value();
}
@@ -209,7 +209,7 @@ bevelfilter_quality(const fn_call& fn)
if (fn.nargs == 0) {
return as_value(ptr->m_quality );
}
- boost::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
+ std::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
ptr->m_quality = sp_quality;
return as_value();
}
diff --git a/libcore/asobj/flash/filters/BlurFilter_as.cpp
b/libcore/asobj/flash/filters/BlurFilter_as.cpp
index 6c709f4..6da489f 100644
--- a/libcore/asobj/flash/filters/BlurFilter_as.cpp
+++ b/libcore/asobj/flash/filters/BlurFilter_as.cpp
@@ -92,7 +92,7 @@ blurfilter_quality(const fn_call& fn)
if (fn.nargs == 0) {
return as_value(ptr->m_quality );
}
- boost::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
+ std::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
ptr->m_quality = sp_quality;
return as_value();
}
diff --git a/libcore/asobj/flash/filters/DropShadowFilter_as.cpp
b/libcore/asobj/flash/filters/DropShadowFilter_as.cpp
index 20ae315..7060223 100644
--- a/libcore/asobj/flash/filters/DropShadowFilter_as.cpp
+++ b/libcore/asobj/flash/filters/DropShadowFilter_as.cpp
@@ -184,7 +184,7 @@ dropshadowfilter_quality(const fn_call& fn)
if (fn.nargs == 0) {
return as_value(ptr->m_quality );
}
- boost::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
+ std::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
ptr->m_quality = sp_quality;
return as_value();
}
diff --git a/libcore/asobj/flash/filters/GlowFilter_as.cpp
b/libcore/asobj/flash/filters/GlowFilter_as.cpp
index 1a85c2e..77ccc51 100644
--- a/libcore/asobj/flash/filters/GlowFilter_as.cpp
+++ b/libcore/asobj/flash/filters/GlowFilter_as.cpp
@@ -90,7 +90,7 @@ glowfilter_inner(const fn_call& fn)
if (fn.nargs == 0) {
return as_value(ptr->m_inner );
}
- boost::uint32_t sp_inner = toNumber(fn.arg(0), getVM(fn));
+ std::uint32_t sp_inner = toNumber(fn.arg(0), getVM(fn));
ptr->m_inner = sp_inner;
return as_value();
}
@@ -162,7 +162,7 @@ glowfilter_quality(const fn_call& fn)
if (fn.nargs == 0) {
return as_value(ptr->m_quality );
}
- boost::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
+ std::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
ptr->m_quality = sp_quality;
return as_value();
}
diff --git a/libcore/asobj/flash/filters/GradientBevelFilter_as.cpp
b/libcore/asobj/flash/filters/GradientBevelFilter_as.cpp
index 14c414d..f58659a 100644
--- a/libcore/asobj/flash/filters/GradientBevelFilter_as.cpp
+++ b/libcore/asobj/flash/filters/GradientBevelFilter_as.cpp
@@ -184,7 +184,7 @@ gradientbevelfilter_quality(const fn_call& fn)
if (fn.nargs == 0) {
return as_value(ptr->m_quality );
}
- boost::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
+ std::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
ptr->m_quality = sp_quality;
return as_value();
}
diff --git a/libcore/asobj/flash/filters/GradientGlowFilter_as.cpp
b/libcore/asobj/flash/filters/GradientGlowFilter_as.cpp
index 9f7ba4a..f580c19 100644
--- a/libcore/asobj/flash/filters/GradientGlowFilter_as.cpp
+++ b/libcore/asobj/flash/filters/GradientGlowFilter_as.cpp
@@ -185,7 +185,7 @@ gradientglowfilter_quality(const fn_call& fn)
if (fn.nargs == 0) {
return as_value(ptr->m_quality );
}
- boost::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
+ std::uint8_t sp_quality = toNumber(fn.arg(0), getVM(fn));
ptr->m_quality = sp_quality;
return as_value();
}
diff --git a/libcore/asobj/flash/geom/ColorTransform_as.cpp
b/libcore/asobj/flash/geom/ColorTransform_as.cpp
index 25c4643..bd0fb17 100644
--- a/libcore/asobj/flash/geom/ColorTransform_as.cpp
+++ b/libcore/asobj/flash/geom/ColorTransform_as.cpp
@@ -322,20 +322,20 @@ colortransform_rgb(const fn_call& fn)
if (!fn.nargs)
{
// Getter
- boost::uint32_t r = static_cast<boost::uint32_t>(
+ std::uint32_t r = static_cast<std::uint32_t>(
std::fmod(relay->getRedOffset(), 4294967296.0));
- boost::uint32_t g = static_cast<boost::uint32_t>(
+ std::uint32_t g = static_cast<std::uint32_t>(
std::fmod(relay->getGreenOffset(), 4294967296.0));
- boost::uint32_t b = static_cast<boost::uint32_t>(
+ std::uint32_t b = static_cast<std::uint32_t>(
std::fmod(relay->getBlueOffset(), 4294967296.0));
- boost::uint32_t rgb = (r << 16) + (g << 8) + b;
+ std::uint32_t rgb = (r << 16) + (g << 8) + b;
return as_value(rgb);
}
// Setter
- boost::uint32_t rgb = toInt(fn.arg(0), getVM(fn));
+ std::uint32_t rgb = toInt(fn.arg(0), getVM(fn));
relay->setRedOffset((rgb & 0xFF0000) >> 16);
relay->setGreenOffset((rgb & 0x00FF00) >> 8);
relay->setBlueOffset(rgb & 0x0000FF);
diff --git a/libcore/builtin_function.h b/libcore/builtin_function.h
index 1508282..c9d0045 100644
--- a/libcore/builtin_function.h
+++ b/libcore/builtin_function.h
@@ -58,7 +58,7 @@ public:
/// Return the number of registers required for function execution
//
/// Gnash's C++ implementations of AS functions don't need any registers!
- virtual boost::uint8_t registers() const {
+ virtual std::uint8_t registers() const {
return 0;
}
diff --git a/libcore/event_id.h b/libcore/event_id.h
index 6890be5..14d2bde 100644
--- a/libcore/event_id.h
+++ b/libcore/event_id.h
@@ -110,7 +110,7 @@ public:
//
/// @param SWFKey The SWF code matched to the event. This
/// must be converted to a unique gnash::key::code.
- void setKeyCode(boost::uint8_t SWFkey)
+ void setKeyCode(std::uint8_t SWFkey)
{
// Lookup the SWFcode in the gnash::key::code table.
// Some are not unique (keypad numbers are the
diff --git a/libcore/movie_root.cpp b/libcore/movie_root.cpp
index 7689bb6..77071fb 100644
--- a/libcore/movie_root.cpp
+++ b/libcore/movie_root.cpp
@@ -579,7 +579,7 @@ movie_root::setDimensions(size_t w, size_t h)
}
bool
-movie_root::mouseMoved(boost::int32_t x, boost::int32_t y)
+movie_root::mouseMoved(std::int32_t x, std::int32_t y)
{
assert(testInvariant());
@@ -664,8 +664,8 @@ movie_root::mouseWheel(int delta)
getBuiltinObject(*this, getURI(_vm, NSV::CLASS_MOUSE));
if (!mouseObj) return false;
- const boost::int32_t x = pixelsToTwips(_mouseX);
- const boost::int32_t y = pixelsToTwips(_mouseY);
+ const std::int32_t x = pixelsToTwips(_mouseX);
+ const std::int32_t y = pixelsToTwips(_mouseY);
DisplayObject* i = getTopmostMouseEntity(x, y);
@@ -695,8 +695,8 @@ movie_root::fire_mouse_event()
{
assert(testInvariant());
- boost::int32_t x = pixelsToTwips(_mouseX);
- boost::int32_t y = pixelsToTwips(_mouseY);
+ std::int32_t x = pixelsToTwips(_mouseX);
+ std::int32_t y = pixelsToTwips(_mouseY);
// Generate a mouse event
_mouseButtonState.topmostEntity = getTopmostMouseEntity(x, y);
@@ -734,7 +734,7 @@ movie_root::fire_mouse_event()
return need_redraw;
}
-std::pair<boost::int32_t, boost::int32_t>
+std::pair<std::int32_t, std::int32_t>
movie_root::mousePosition() const
{
assert(testInvariant());
@@ -758,8 +758,8 @@ movie_root::setDragState(const DragState& st)
// Get current mouse coordinates
const point world_mouse(pixelsToTwips(_mouseX),
pixelsToTwips(_mouseY));
- boost::int32_t xoffset = world_mouse.x - world_origin.x;
- boost::int32_t yoffset = world_mouse.y - world_origin.y;
+ std::int32_t xoffset = world_mouse.x - world_origin.x;
+ std::int32_t yoffset = world_mouse.y - world_origin.y;
_dragState->setOffset(xoffset, yoffset);
}
@@ -811,7 +811,7 @@ movie_root::doMouseDrag()
dragChar->setMatrix(local);
}
-boost::uint32_t
+std::uint32_t
movie_root::addIntervalTimer(std::unique_ptr<Timer> timer)
{
assert(timer.get());
@@ -829,7 +829,7 @@ movie_root::addIntervalTimer(std::unique_ptr<Timer> timer)
}
bool
-movie_root::clearIntervalTimer(boost::uint32_t x)
+movie_root::clearIntervalTimer(std::uint32_t x)
{
TimerMap::iterator it = _intervalTimers.find(x);
if (it == _intervalTimers.end()) {
@@ -1160,8 +1160,8 @@ movie_root::getDraggingCharacter() const
const DisplayObject*
movie_root::getEntityUnderPointer() const
{
- const boost::int32_t x = pixelsToTwips(_mouseX);
- const boost::int32_t y = pixelsToTwips(_mouseY);
+ const std::int32_t x = pixelsToTwips(_mouseX);
+ const std::int32_t y = pixelsToTwips(_mouseY);
return findDropTarget(x, y, getDraggingCharacter());
}
@@ -1805,7 +1805,7 @@ movie_root::markReachableResources() const
}
InteractiveObject*
-movie_root::getTopmostMouseEntity(boost::int32_t x, boost::int32_t y) const
+movie_root::getTopmostMouseEntity(std::int32_t x, std::int32_t y) const
{
for (Levels::const_reverse_iterator i=_movies.rbegin(), e=_movies.rend();
i != e; ++i)
@@ -1818,7 +1818,7 @@ movie_root::getTopmostMouseEntity(boost::int32_t x,
boost::int32_t y) const
}
const DisplayObject *
-movie_root::findDropTarget(boost::int32_t x, boost::int32_t y,
+movie_root::findDropTarget(std::int32_t x, std::int32_t y,
DisplayObject* dragging) const
{
for (Levels::const_reverse_iterator i=_movies.rbegin(), e=_movies.rend();
@@ -2094,7 +2094,7 @@ movie_root::set_background_color(const rgba& color)
void
movie_root::set_background_alpha(float alpha)
{
- const boost::uint8_t newAlpha = clamp<int>(frnd(alpha * 255.0f), 0, 255);
+ const std::uint8_t newAlpha = clamp<int>(frnd(alpha * 255.0f), 0, 255);
if (m_background_color.m_a != newAlpha) {
setInvalidated();
@@ -2246,7 +2246,7 @@ movie_root::getURL(const std::string& urlstr, const
std::string& target,
}
void
-movie_root::setScriptLimits(boost::uint16_t recursion, boost::uint16_t timeout)
+movie_root::setScriptLimits(std::uint16_t recursion, std::uint16_t timeout)
{
if ( recursion == _recursionLimit && _timeoutLimit == timeout ) {
// avoid the debug log...
@@ -2408,7 +2408,7 @@ movie_root::LoadCallback::processLoad()
}
const size_t chunksize = 65535;
- boost::uint8_t chunk[chunksize];
+ std::uint8_t chunk[chunksize];
size_t actuallyRead = _stream->readNonBlocking(chunk, chunksize);
diff --git a/libcore/movie_root.h b/libcore/movie_root.h
index 7ac424d..af3db25 100644
--- a/libcore/movie_root.h
+++ b/libcore/movie_root.h
@@ -268,7 +268,7 @@ public:
///
/// TODO: take twips (or float pixels), or we won't be able to
/// support sub-pixel accuracy in collision detection.
- DSOEXPORT bool mouseMoved(boost::int32_t x, boost::int32_t y);
+ DSOEXPORT bool mouseMoved(std::int32_t x, std::int32_t y);
/// Inform the Stage that a mouse click has occurred.
//
@@ -294,7 +294,7 @@ public:
/// Use this to retrieve the last state of the mouse.
//
/// Coordinates are in PIXELS, NOT TWIPS.
- std::pair<boost::int32_t, boost::int32_t> mousePosition() const;
+ std::pair<std::int32_t, std::int32_t> mousePosition() const;
void setDragState(const DragState& st);
@@ -320,7 +320,7 @@ public:
/// @return An integer indentifying the timer
/// for subsequent call to clear_interval_timer.
/// It will NEVER be zero.
- boost::uint32_t addIntervalTimer(std::unique_ptr<Timer> timer);
+ std::uint32_t addIntervalTimer(std::unique_ptr<Timer> timer);
/// Register an object for loading data to.
//
@@ -347,7 +347,7 @@ public:
/// Remove timer identified by given integer
//
/// @return true on success, false on error (no such timer)
- bool clearIntervalTimer(boost::uint32_t x);
+ bool clearIntervalTimer(std::uint32_t x);
void set_background_color(const rgba& color);
@@ -763,17 +763,17 @@ public:
/// The default value for this (i.e. when no
/// ScriptLimits tag is present) is documented to be
/// 15 to 20 seconds, depending on platform.
- void setScriptLimits(boost::uint16_t recursion, boost::uint16_t timeout);
+ void setScriptLimits(std::uint16_t recursion, std::uint16_t timeout);
/// Get the current global recursion limit for this movie: it can
/// be changed by loaded movies.
- boost::uint16_t getRecursionLimit() const {
+ std::uint16_t getRecursionLimit() const {
return _recursionLimit;
}
/// Get the current global script timeout limit for this movie: it
/// can be changed by loaded movies.
- boost::uint16_t getTimeoutLimit() const
+ std::uint16_t getTimeoutLimit() const
{
return _timeoutLimit;
}
@@ -898,8 +898,8 @@ private:
/// @param y
/// Y ordinate of the pointer, in world coordiante space (twips).
///
- InteractiveObject* getTopmostMouseEntity(boost::int32_t x,
- boost::int32_t y) const;
+ InteractiveObject* getTopmostMouseEntity(std::int32_t x,
+ std::int32_t y) const;
/// Delete DisplayObjects removed from the stage
/// from the display lists
@@ -944,7 +944,7 @@ private:
return (_processingActionLevel < PRIORITY_SIZE);
}
- const DisplayObject* findDropTarget(boost::int32_t x, boost::int32_t y,
+ const DisplayObject* findDropTarget(std::int32_t x, std::int32_t y,
DisplayObject* dragging) const;
void handleActionLimitHit(const std::string& ref);
@@ -989,8 +989,8 @@ private:
rgba m_background_color;
bool m_background_color_set;
- boost::int32_t _mouseX;
- boost::int32_t _mouseY;
+ std::int32_t _mouseX;
+ std::int32_t _mouseY;
MouseButtonState _mouseButtonState;
@@ -1000,7 +1000,7 @@ private:
LoadCallbacks _loadCallbacks;
- typedef std::map<boost::uint32_t, std::shared_ptr<Timer> > TimerMap;
+ typedef std::map<std::uint32_t, std::shared_ptr<Timer> > TimerMap;
TimerMap _intervalTimers;
@@ -1069,10 +1069,10 @@ private:
DisplayState _displayState;
// Maximum number of recursions set in the ScriptLimits tag.
- boost::uint16_t _recursionLimit;
+ std::uint16_t _recursionLimit;
// Timeout in seconds for script execution, set in the ScriptLimits tag.
- boost::uint16_t _timeoutLimit;
+ std::uint16_t _timeoutLimit;
// delay between movie advancement, in milliseconds
size_t _movieAdvancementDelay;
diff --git a/libcore/parser/SWFMovieDefinition.cpp
b/libcore/parser/SWFMovieDefinition.cpp
index cf6add3..d935e19 100644
--- a/libcore/parser/SWFMovieDefinition.cpp
+++ b/libcore/parser/SWFMovieDefinition.cpp
@@ -173,7 +173,7 @@ SWFMovieDefinition::~SWFMovieDefinition()
}
void
-SWFMovieDefinition::addDisplayObject(boost::uint16_t id, SWF::DefinitionTag* c)
+SWFMovieDefinition::addDisplayObject(std::uint16_t id, SWF::DefinitionTag* c)
{
assert(c);
boost::mutex::scoped_lock lock(_dictionaryMutex);
@@ -182,7 +182,7 @@ SWFMovieDefinition::addDisplayObject(boost::uint16_t id,
SWF::DefinitionTag* c)
}
SWF::DefinitionTag*
-SWFMovieDefinition::getDefinitionTag(boost::uint16_t id) const
+SWFMovieDefinition::getDefinitionTag(std::uint16_t id) const
{
boost::mutex::scoped_lock lock(_dictionaryMutex);
boost::intrusive_ptr<SWF::DefinitionTag> ch =
@@ -272,8 +272,8 @@ SWFMovieDefinition::readHeader(std::unique_ptr<IOChannel>
in,
_url = url.empty() ? "<anonymous>" : url;
- boost::uint32_t file_start_pos = _in->tell();
- boost::uint32_t header = _in->read_le32();
+ std::uint32_t file_start_pos = _in->tell();
+ std::uint32_t header = _in->read_le32();
m_file_length = _in->read_le32();
_swf_end_pos = file_start_pos + m_file_length;
@@ -324,7 +324,7 @@ SWFMovieDefinition::readHeader(std::unique_ptr<IOChannel>
in,
_str->ensureBytes(2 + 2); // frame rate, frame count.
m_frame_rate = _str->read_u16() / 256.0f;
if (!m_frame_rate) {
- m_frame_rate = std::numeric_limits<boost::uint16_t>::max();
+ m_frame_rate = std::numeric_limits<std::uint16_t>::max();
}
m_frame_count = _str->read_u16();
@@ -560,7 +560,7 @@ SWFMovieDefinition::incrementLoadedFrames()
void
SWFMovieDefinition::registerExport(const std::string& symbol,
- boost::uint16_t id)
+ std::uint16_t id)
{
assert(id);
@@ -609,7 +609,7 @@
SWFMovieDefinition::set_jpeg_loader(std::unique_ptr<image::JpegInput> j_in)
m_jpeg_in = std::move(j_in);
}
-boost::uint16_t
+std::uint16_t
SWFMovieDefinition::exportID(const std::string& symbol) const
{
boost::mutex::scoped_lock lock(_exportedResourcesMutex);
@@ -648,7 +648,7 @@ SWFMovieDefinition::importResources(
log_debug("%s importing %s from %s", get_url(), symbolName,
source->get_url());
#endif
- boost::uint16_t targetID;
+ std::uint16_t targetID;
while(!(targetID = source->exportID(symbolName))) {
diff --git a/libcore/parser/SWFMovieDefinition.h
b/libcore/parser/SWFMovieDefinition.h
index 8afe346..6125a7c 100644
--- a/libcore/parser/SWFMovieDefinition.h
+++ b/libcore/parser/SWFMovieDefinition.h
@@ -240,10 +240,10 @@ public:
DSOTEXPORT virtual void
importResources(boost::intrusive_ptr<movie_definition> source,
const Imports& imports);
- virtual void addDisplayObject(boost::uint16_t id, SWF::DefinitionTag* c);
+ virtual void addDisplayObject(std::uint16_t id, SWF::DefinitionTag* c);
/// Return a DisplayObject from the dictionary
- DSOTEXPORT SWF::DefinitionTag* getDefinitionTag(boost::uint16_t id) const;
+ DSOTEXPORT SWF::DefinitionTag* getDefinitionTag(std::uint16_t id) const;
// See dox in movie_definition
//
@@ -372,7 +372,7 @@ public:
/// @return The id corresponding to the passed symbol. 0 is not a
/// valid id and signifies that the symbol was not (yet)
/// exported.
- boost::uint16_t exportID(const std::string& symbol) const;
+ std::uint16_t exportID(const std::string& symbol) const;
/// Register a symbol to refer to a character id
//
@@ -381,7 +381,7 @@ public:
/// @param id The id of the character to map to the symbol. NB: this
/// must never be 0!
/// @param symbol The symbol to map to the id.
- void registerExport(const std::string& symbol, boost::uint16_t id);
+ void registerExport(const std::string& symbol, std::uint16_t id);
#ifdef USE_SWFTREE
@@ -433,7 +433,7 @@ private:
mutable boost::mutex _namedFramesMutex;
/// Allow mapping symbol to id case insensitively.
- typedef std::map<std::string, boost::uint16_t,
+ typedef std::map<std::string, std::uint16_t,
StringNoCaseLessThan> Exports;
/// A map of symbol to character id.
@@ -483,7 +483,7 @@ private:
int m_loading_sound_stream;
- boost::uint32_t m_file_length;
+ std::uint32_t m_file_length;
std::unique_ptr<image::JpegInput> m_jpeg_in;
diff --git a/libcore/parser/TypesParser.cpp b/libcore/parser/TypesParser.cpp
index 0d8e52f..0e14efc 100644
--- a/libcore/parser/TypesParser.cpp
+++ b/libcore/parser/TypesParser.cpp
@@ -53,11 +53,11 @@ readSWFMatrix(SWFStream& in)
in.ensureBits(1);
const bool has_scale = in.read_bit();
- boost::int32_t sx = 65536;
- boost::int32_t sy = 65536;
+ std::int32_t sx = 65536;
+ std::int32_t sy = 65536;
if (has_scale) {
in.ensureBits(5);
- const boost::uint8_t scale_nbits = in.read_uint(5);
+ const std::uint8_t scale_nbits = in.read_uint(5);
if (scale_nbits) {
in.ensureBits(scale_nbits * 2);
sx = in.read_sint(scale_nbits);
@@ -67,8 +67,8 @@ readSWFMatrix(SWFStream& in)
in.ensureBits(1);
const bool has_rotate = in.read_bit();
- boost::int32_t shx = 0;
- boost::int32_t shy = 0;
+ std::int32_t shx = 0;
+ std::int32_t shy = 0;
if (has_rotate) {
in.ensureBits(5);
unsigned int rotate_nbits = in.read_uint(5);
@@ -80,9 +80,9 @@ readSWFMatrix(SWFStream& in)
}
in.ensureBits(5);
- const boost::uint8_t translate_nbits = in.read_uint(5);
- boost::int32_t tx = 0;
- boost::int32_t ty = 0;
+ const std::uint8_t translate_nbits = in.read_uint(5);
+ std::int32_t tx = 0;
+ std::int32_t ty = 0;
if (translate_nbits) {
in.ensureBits(translate_nbits * 2);
tx = in.read_sint(translate_nbits);
@@ -95,10 +95,10 @@ rgba
readRGBA(SWFStream& in)
{
in.ensureBytes(4);
- const boost::uint8_t r = in.read_u8();
- const boost::uint8_t g = in.read_u8();
- const boost::uint8_t b = in.read_u8();
- const boost::uint8_t a = in.read_u8();
+ const std::uint8_t r = in.read_u8();
+ const std::uint8_t g = in.read_u8();
+ const std::uint8_t b = in.read_u8();
+ const std::uint8_t a = in.read_u8();
return rgba(r, g, b, a);
}
@@ -106,10 +106,10 @@ rgba
readRGB(SWFStream& in)
{
in.ensureBytes(3);
- const boost::uint8_t r = in.read_u8();
- const boost::uint8_t g = in.read_u8();
- const boost::uint8_t b = in.read_u8();
- const boost::uint8_t a = 0xff;
+ const std::uint8_t r = in.read_u8();
+ const std::uint8_t g = in.read_u8();
+ const std::uint8_t b = in.read_u8();
+ const std::uint8_t a = 0xff;
return rgba(r, g, b, a);
}
@@ -207,9 +207,9 @@ readFills(SWFStream& in, SWF::TagType t, movie_definition&
md, bool readMorph)
}
in.ensureBytes(1);
- const boost::uint8_t grad_props = in.read_u8();
+ const std::uint8_t grad_props = in.read_u8();
- const boost::uint8_t num_gradients = grad_props & 0xF;
+ const std::uint8_t num_gradients = grad_props & 0xF;
IF_VERBOSE_PARSE(
log_parse(_(" gradients count: %d"), +num_gradients);
);
@@ -324,10 +324,10 @@ readCxFormRGB(SWFStream& in)
in.align();
in.ensureBits(6);
- const boost::uint8_t field = in.read_uint(6);
+ const std::uint8_t field = in.read_uint(6);
const bool has_add = field & (1 << 5);
const bool has_mult = field & (1 << 4);
- const boost::uint8_t nbits = field & 0x0f;
+ const std::uint8_t nbits = field & 0x0f;
const size_t reads = has_mult + has_add; // 0, 1 or 2
SWFCxForm ret;
@@ -356,10 +356,10 @@ readCxFormRGBA(SWFStream& in)
in.align();
in.ensureBits(6);
- const boost::uint8_t field = in.read_uint(6);
+ const std::uint8_t field = in.read_uint(6);
const bool has_add = field & (1 << 5);
const bool has_mult = field & (1 << 4);
- const boost::uint8_t nbits = field & 0x0f;
+ const std::uint8_t nbits = field & 0x0f;
const size_t reads = has_mult + has_add; // 0, 1 or 2
SWFCxForm ret;
@@ -423,7 +423,7 @@ readBitmapFill(SWFStream& in, SWF::FillType type,
movie_definition& md,
{
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
SWFMatrix m = readSWFMatrix(in).invert();
@@ -442,7 +442,7 @@ GradientRecord
readGradientRecord(SWFStream& in, SWF::TagType tag)
{
in.ensureBytes(1);
- const boost::uint8_t ratio = in.read_u8();
+ const std::uint8_t ratio = in.read_u8();
switch (tag) {
case SWF::DEFINESHAPE:
diff --git a/libcore/parser/action_buffer.cpp b/libcore/parser/action_buffer.cpp
index 928dd7d..021f41e 100644
--- a/libcore/parser/action_buffer.cpp
+++ b/libcore/parser/action_buffer.cpp
@@ -111,8 +111,8 @@ action_buffer::readConstantPool(size_t start_pc, size_t
stop_pc) const
ConstantPool& pool = _pools[start_pc];
size_t i = start_pc;
- const boost::uint16_t length = read_uint16(i + 1);
- const boost::uint16_t count = read_uint16(i + 3);
+ const std::uint16_t length = read_uint16(i + 1);
+ const std::uint16_t count = read_uint16(i + 3);
i += 2;
assert(start_pc + 3 + length == stop_pc);
@@ -300,8 +300,8 @@ disasm_instruction(const unsigned char* instruction_data,
case 7:
{
- // boost::int32_t
- boost::int32_t val = instruction_data[3 + i]
+ // std::int32_t
+ std::int32_t val = instruction_data[3 + i]
| (instruction_data[3 + i + 1] << 8)
| (instruction_data[3 + i + 2] << 16)
| (instruction_data[3 + i + 3] << 24);
@@ -372,17 +372,17 @@ disasm_instruction(const unsigned char* instruction_data,
if (i + 6 > length) break;
++i;
- boost::uint16_t argCount = instruction_data[3 + i] |
(instruction_data[3 + i + 1] << 8);
+ std::uint16_t argCount = instruction_data[3 + i] |
(instruction_data[3 + i + 1] << 8);
i += 2;
- boost::uint8_t registerCount = instruction_data[3 + i];
+ std::uint8_t registerCount = instruction_data[3 + i];
i++;
ss << "\tname = '" << functionName << "'"
<< " arg count = " << argCount
<< " register count = " <<
static_cast<int>(registerCount);
- const boost::uint16_t flags =
+ const std::uint16_t flags =
(instruction_data[3 + i]) |
(instruction_data[3 + i + 1] << 8);
@@ -504,16 +504,16 @@ convert_float_little(const void *p)
// Hairy union for endian detection and munging
union {
float f;
- boost::uint32_t i;
+ std::uint32_t i;
struct { // for endian detection
- boost::uint16_t s0;
- boost::uint16_t s1;
+ std::uint16_t s0;
+ std::uint16_t s1;
} s;
struct { // for byte-swapping
- boost::uint8_t c0;
- boost::uint8_t c1;
- boost::uint8_t c2;
- boost::uint8_t c3;
+ std::uint8_t c0;
+ std::uint8_t c1;
+ std::uint8_t c2;
+ std::uint8_t c3;
} c;
} u;
@@ -525,7 +525,7 @@ convert_float_little(const void *p)
break;
case 0x3f80: // big-endian host
{
- const boost::uint8_t *cp = static_cast<const boost::uint8_t*>(p);
+ const std::uint8_t *cp = static_cast<const std::uint8_t*>(p);
u.c.c0 = cp[3];
u.c.c1 = cp[2];
u.c.c2 = cp[1];
@@ -547,29 +547,29 @@ convert_float_little(const void *p)
double
convert_double_wacky(const void *p)
{
- const boost::uint8_t *cp = static_cast<const boost::uint8_t*>(p);
+ const std::uint8_t *cp = static_cast<const std::uint8_t*>(p);
union {
double d;
- boost::uint64_t i;
+ std::uint64_t i;
struct {
- boost::uint32_t l0;
- boost::uint32_t l1;
+ std::uint32_t l0;
+ std::uint32_t l1;
} l;
struct {
- boost::uint16_t s0;
- boost::uint16_t s1;
- boost::uint16_t s2;
- boost::uint16_t s3;
+ std::uint16_t s0;
+ std::uint16_t s1;
+ std::uint16_t s2;
+ std::uint16_t s3;
} s;
struct {
- boost::uint8_t c0;
- boost::uint8_t c1;
- boost::uint8_t c2;
- boost::uint8_t c3;
- boost::uint8_t c4;
- boost::uint8_t c5;
- boost::uint8_t c6;
- boost::uint8_t c7;
+ std::uint8_t c0;
+ std::uint8_t c1;
+ std::uint8_t c2;
+ std::uint8_t c3;
+ std::uint8_t c4;
+ std::uint8_t c5;
+ std::uint8_t c6;
+ std::uint8_t c7;
} c;
} u;
diff --git a/libcore/parser/action_buffer.h b/libcore/parser/action_buffer.h
index 4cdd729..46270b6 100644
--- a/libcore/parser/action_buffer.h
+++ b/libcore/parser/action_buffer.h
@@ -23,7 +23,7 @@
#include <vector>
#include <map>
#include <boost/noncopyable.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "GnashException.h"
#include "ConstantPool.h"
@@ -64,7 +64,7 @@ public:
size_t size() const { return m_buffer.size(); }
- boost::uint8_t operator[] (size_t off) const
+ std::uint8_t operator[] (size_t off) const
{
if (off >= m_buffer.size()) {
throw ActionParserException (_("Attempt to read outside "
@@ -102,33 +102,33 @@ public:
//
/// Useful to hide complexity of underlying buffer access.
///
- boost::int16_t read_int16(size_t pc) const
+ std::int16_t read_int16(size_t pc) const
{
if (pc + 1 >= m_buffer.size()) {
throw ActionParserException(_("Attempt to read outside action
buffer limits"));
}
- boost::int16_t ret = (m_buffer[pc] | (m_buffer[pc + 1] << 8));
+ std::int16_t ret = (m_buffer[pc] | (m_buffer[pc + 1] << 8));
return ret;
}
/// Get an unsigned short integer value from given offset
/// read_int16 should check buffer boundaries.
- boost::uint16_t read_uint16(size_t pc) const
+ std::uint16_t read_uint16(size_t pc) const
{
- return static_cast<boost::uint16_t>(read_int16(pc));
+ return static_cast<std::uint16_t>(read_int16(pc));
}
/// Read a 32-bit integer starting at given offset.
//
/// Useful to hide complexity of underlying buffer access.
///
- boost::int32_t read_int32(size_t pc) const
+ std::int32_t read_int32(size_t pc) const
{
if (pc + 3 >= m_buffer.size()) {
throw ActionParserException(_("Attempt to read outside action
buffer limits"));
}
- boost::int32_t val = m_buffer[pc]
+ std::int32_t val = m_buffer[pc]
| (m_buffer[pc + 1] << 8)
| (m_buffer[pc + 2] << 16)
| (m_buffer[pc + 3] << 24);
@@ -189,7 +189,7 @@ public:
private:
/// the code itself, as read from the SWF
- std::vector<boost::uint8_t> m_buffer;
+ std::vector<std::uint8_t> m_buffer;
/// The set of ConstantPools found in this action_buffer
typedef std::map<size_t, ConstantPool> PoolsMap;
diff --git a/libcore/parser/filter_factory.cpp
b/libcore/parser/filter_factory.cpp
index acb4eb8..50f9eb5 100644
--- a/libcore/parser/filter_factory.cpp
+++ b/libcore/parser/filter_factory.cpp
@@ -145,7 +145,7 @@ bool BlurFilter::read(SWFStream& in)
m_blurX = in.read_ufixed();
m_blurY = in.read_ufixed();
- m_quality = static_cast<boost::uint8_t> (in.read_uint(5));
+ m_quality = static_cast<std::uint8_t> (in.read_uint(5));
static_cast<void> (in.read_uint(3)); // Throw these away.
@@ -225,7 +225,7 @@ bool GradientGlowFilter::read(SWFStream& in)
{
in.ensureBytes(1);
- boost::uint8_t count = in.read_u8(); // How many colorings.
+ std::uint8_t count = in.read_u8(); // How many colorings.
m_colors.reserve(count);
m_alphas.reserve(count);
@@ -259,7 +259,7 @@ bool GradientGlowFilter::read(SWFStream& in)
m_type = outer ? (inner ? FULL_GLOW : OUTER_GLOW) : INNER_GLOW;
- m_quality = static_cast<boost::uint8_t> (in.read_uint(4));
+ m_quality = static_cast<std::uint8_t> (in.read_uint(4));
IF_VERBOSE_PARSE(
log_parse(_(" GradientGlowFilter "));
@@ -336,7 +336,7 @@ bool ColorMatrixFilter::read(SWFStream& in)
bool GradientBevelFilter::read(SWFStream& in)
{
in.ensureBytes(1);
- boost::uint8_t count = in.read_u8(); // How many colorings.
+ std::uint8_t count = in.read_u8(); // How many colorings.
in.ensureBytes(count*5 + 8 + 8 + 2 + 1);
@@ -369,7 +369,7 @@ bool GradientBevelFilter::read(SWFStream& in)
m_type = outer ? (inner ? FULL_BEVEL : OUTER_BEVEL) : INNER_BEVEL;
- m_quality = static_cast<boost::uint8_t> (in.read_uint(4));
+ m_quality = static_cast<std::uint8_t> (in.read_uint(4));
IF_VERBOSE_PARSE(
log_parse(_(" GradientBevelFilter "));
diff --git a/libcore/parser/movie_definition.h
b/libcore/parser/movie_definition.h
index 27b640a..3e47fd0 100644
--- a/libcore/parser/movie_definition.h
+++ b/libcore/parser/movie_definition.h
@@ -56,7 +56,7 @@
#include <memory> // for unique_ptr
#include <vector> // for PlayList typedef
#include <boost/intrusive_ptr.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "DefinitionTag.h"
#include "log.h"
@@ -193,7 +193,7 @@ public:
///
/// @return NULL if no DisplayObject with the given ID is found
/// (this is the default)
- virtual DefinitionTag* getDefinitionTag(boost::uint16_t /*id*/) const
+ virtual DefinitionTag* getDefinitionTag(std::uint16_t /*id*/) const
{
return NULL;
}
@@ -230,7 +230,7 @@ public:
//
/// This method is here to be called by DEFINE tags loaders.
/// The default implementation does nothing.
- virtual void addDisplayObject(boost::uint16_t /*id*/, DefinitionTag*
/*c*/)
+ virtual void addDisplayObject(std::uint16_t /*id*/, DefinitionTag*
/*c*/)
{
}
@@ -387,13 +387,13 @@ public:
/// Register a symbol to refer to a character id
//
/// The default implementation does nothing.
- virtual void registerExport(const std::string&, boost::uint16_t) {}
+ virtual void registerExport(const std::string&, std::uint16_t) {}
/// Get the id that corresponds to a symbol.
//
/// @return The id corresponding to the passed symbol. The default
/// implementation returns 0, as it has no export table.
- virtual boost::uint16_t exportID(const std::string& /*symbol*/) const {
+ virtual std::uint16_t exportID(const std::string& /*symbol*/) const {
return 0;
}
@@ -458,7 +458,7 @@ public:
#endif
protected:
- movie_definition(boost::uint16_t id = 0)
+ movie_definition(std::uint16_t id = 0)
:
DefinitionTag(id)
{}
diff --git a/libcore/parser/sprite_definition.cpp
b/libcore/parser/sprite_definition.cpp
index 13ff968..75796fe 100644
--- a/libcore/parser/sprite_definition.cpp
+++ b/libcore/parser/sprite_definition.cpp
@@ -108,7 +108,7 @@ sprite_definition::get_labeled_frame(const std::string&
label,
}
sprite_definition::sprite_definition(movie_definition& m, SWFStream& in,
- const RunResources& runResources, boost::uint16_t id)
+ const RunResources& runResources, std::uint16_t id)
:
movie_definition(id),
m_movie_def(m),
diff --git a/libcore/parser/sprite_definition.h
b/libcore/parser/sprite_definition.h
index 80a2dce..21f2f05 100644
--- a/libcore/parser/sprite_definition.h
+++ b/libcore/parser/sprite_definition.h
@@ -22,7 +22,7 @@
#define GNASH_SPRITE_DEFINITION_H
#include <boost/intrusive_ptr.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <string>
#include <map>
#include "movie_definition.h" // for inheritance
@@ -65,7 +65,7 @@ public:
/// to be already positioned right before the frame count
///
sprite_definition(movie_definition& m, SWFStream& in,
- const RunResources& runResources, boost::uint16_t id);
+ const RunResources& runResources, std::uint16_t id);
/// Destructor, releases playlist data
~sprite_definition();
@@ -176,11 +176,11 @@ public:
return _loadingSoundStream;
}
- virtual boost::uint16_t exportID(const std::string& symbol) const {
+ virtual std::uint16_t exportID(const std::string& symbol) const {
return m_movie_def.exportID(symbol);
}
- virtual void registerExport(const std::string& s, boost::uint16_t id) {
+ virtual void registerExport(const std::string& s, std::uint16_t id) {
m_movie_def.registerExport(s, id);
}
@@ -188,13 +188,13 @@ public:
/// Get a SWF::DefinitionTag from this Sprite's root movie
/// CharacterDictionary.
///
- virtual SWF::DefinitionTag* getDefinitionTag(boost::uint16_t id)
const
+ virtual SWF::DefinitionTag* getDefinitionTag(std::uint16_t id) const
{
return m_movie_def.getDefinitionTag(id);
}
/// Delegate call to associated root movie
- virtual void addDisplayObject(boost::uint16_t id, SWF::DefinitionTag* c)
+ virtual void addDisplayObject(std::uint16_t id, SWF::DefinitionTag* c)
{
m_movie_def.addDisplayObject(id, c);
}
diff --git a/libcore/swf/CSMTextSettingsTag.cpp
b/libcore/swf/CSMTextSettingsTag.cpp
index 0627fba..993fb06 100644
--- a/libcore/swf/CSMTextSettingsTag.cpp
+++ b/libcore/swf/CSMTextSettingsTag.cpp
@@ -20,7 +20,7 @@
#include "CSMTextSettingsTag.h"
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "utility.h"
#include "RunResources.h"
@@ -52,7 +52,7 @@ CSMTextSettingsTag::loader(SWFStream& in, TagType tag,
movie_definition& /*m*/,
in.ensureBytes(2 + 1 + 4 + 4 + 1);
- boost::uint16_t textID = in.read_u16();
+ std::uint16_t textID = in.read_u16();
// Should be either 1 or 0. TODO: what if it's something else?
bool flashType = in.read_uint(2);
@@ -60,10 +60,10 @@ CSMTextSettingsTag::loader(SWFStream& in, TagType tag,
movie_definition& /*m*/,
// 0: no grid fitting.
// 1: Pixel grid fit (only for left-aligned dynamic text)
// 2: Sub-pixel grid fit.
- boost::uint8_t gridFit = in.read_uint(3);
+ std::uint8_t gridFit = in.read_uint(3);
// Should be 0:
- boost::uint8_t reserved = in.read_uint(3);
+ std::uint8_t reserved = in.read_uint(3);
UNUSED(reserved);
float thickness = in.read_long_float();
diff --git a/libcore/swf/DefineBitsTag.cpp b/libcore/swf/DefineBitsTag.cpp
index 3222c72..aa222c0 100644
--- a/libcore/swf/DefineBitsTag.cpp
+++ b/libcore/swf/DefineBitsTag.cpp
@@ -197,7 +197,7 @@ DefineBitsTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
const RunResources& r)
{
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
if (m.getBitmap(id)) {
IF_VERBOSE_MALFORMED_SWF(
@@ -337,7 +337,7 @@ std::unique_ptr<image::GnashImage>
readDefineBitsJpeg3(SWFStream& in, TagType tag)
{
in.ensureBytes(4);
- const boost::uint32_t jpeg_size = in.read_u32();
+ const std::uint32_t jpeg_size = in.read_u32();
if (tag == DEFINEBITSJPEG4) {
in.ensureBytes(2);
@@ -360,7 +360,7 @@ readDefineBitsJpeg3(SWFStream& in, TagType tag)
}
// We assume it's a JPEG with alpha data.
- const boost::uint32_t alpha_position = in.tell() + jpeg_size;
+ const std::uint32_t alpha_position = in.tell() + jpeg_size;
#ifndef HAVE_ZLIB_H
log_error(_("gnash is not linked to zlib -- can't load jpeg3 image data"));
@@ -382,7 +382,7 @@ readDefineBitsJpeg3(SWFStream& in, TagType tag)
const size_t imHeight = im->height();
const size_t bufferLength = imWidth * imHeight;
- std::unique_ptr<boost::uint8_t[]> buffer(new boost::uint8_t[bufferLength]);
+ std::unique_ptr<std::uint8_t[]> buffer(new std::uint8_t[bufferLength]);
inflateWrapper(in, buffer.get(), bufferLength);
@@ -403,9 +403,9 @@ readLossless(SWFStream& in, TagType tag)
in.ensureBytes(2 + 2 + 1); // the initial header
// 3 == 8 bit, 4 == 16 bit, 5 == 32 bit
- const boost::uint8_t bitmap_format = in.read_u8();
- const boost::uint16_t width = in.read_u16();
- const boost::uint16_t height = in.read_u16();
+ const std::uint8_t bitmap_format = in.read_u8();
+ const std::uint16_t width = in.read_u16();
+ const std::uint16_t height = in.read_u16();
IF_VERBOSE_PARSE(
log_parse(_(" defbitslossless2: tag = %d, fmt = %d, "
@@ -478,7 +478,7 @@ readLossless(SWFStream& in, TagType tag)
const size_t pitch = (width * bytes_per_pixel + 3) &~ 3;
const size_t bufSize = colorTableSize * channels + pitch * height;
- std::unique_ptr<boost::uint8_t[]> buffer(new boost::uint8_t[bufSize]);
+ std::unique_ptr<std::uint8_t[]> buffer(new std::uint8_t[bufSize]);
inflateWrapper(in, buffer.get(), bufSize);
assert(in.tell() <= in.get_tag_end_position());
@@ -488,15 +488,15 @@ readLossless(SWFStream& in, TagType tag)
case 3:
{
// 8-bit data, preceded by a palette.
- boost::uint8_t* colorTable = buffer.get();
+ std::uint8_t* colorTable = buffer.get();
for (size_t j = 0; j < height; ++j) {
- boost::uint8_t* inRow = buffer.get() +
+ std::uint8_t* inRow = buffer.get() +
colorTableSize * channels + j * pitch;
- boost::uint8_t* outRow = scanline(*image, j);
+ std::uint8_t* outRow = scanline(*image, j);
for (size_t i = 0; i < width; ++i) {
- boost::uint8_t pixel = inRow[i * bytes_per_pixel];
+ std::uint8_t pixel = inRow[i * bytes_per_pixel];
outRow[i * channels + 0] = colorTable[pixel * channels +
0];
outRow[i * channels + 1] = colorTable[pixel * channels +
1];
outRow[i * channels + 2] = colorTable[pixel * channels +
2];
@@ -514,10 +514,10 @@ readLossless(SWFStream& in, TagType tag)
for (size_t j = 0; j < height; ++j) {
- boost::uint8_t* inRow = buffer.get() + j * pitch;
- boost::uint8_t* outRow = scanline(*image, j);
+ std::uint8_t* inRow = buffer.get() + j * pitch;
+ std::uint8_t* outRow = scanline(*image, j);
for (size_t i = 0; i < width; ++i) {
- const boost::uint16_t pix = ( inRow[i * 2] << 8 )
+ const std::uint16_t pix = ( inRow[i * 2] << 8 )
| ( inRow[i * 2 + 1] ) ;
const double g = 255.0/31.0; // gamma correction
@@ -538,8 +538,8 @@ readLossless(SWFStream& in, TagType tag)
case 5:
// Need to re-arrange ARGB into RGB or RGBA.
for (size_t j = 0; j < height; ++j) {
- boost::uint8_t* inRow = buffer.get() + j * pitch;
- boost::uint8_t* outRow = scanline(*image, j);
+ std::uint8_t* inRow = buffer.get() + j * pitch;
+ std::uint8_t* outRow = scanline(*image, j);
const int inChannels = 4;
for (size_t i = 0; i < width; ++i) {
@@ -594,7 +594,7 @@ inflateWrapper(SWFStream& in, void* buffer, size_t
buffer_bytes)
const size_t CHUNKSIZE = 256;
- boost::uint8_t buf[CHUNKSIZE];
+ std::uint8_t buf[CHUNKSIZE];
unsigned long endTagPos = in.get_tag_end_position();
for (;;) {
@@ -614,7 +614,7 @@ inflateWrapper(SWFStream& in, void* buffer, size_t
buffer_bytes)
chunkSize = availableBytes;
}
- static_assert(sizeof(char) == sizeof(boost::uint8_t),
+ static_assert(sizeof(char) == sizeof(std::uint8_t),
"char must be 1 byte");
// Fill the buffer
diff --git a/libcore/swf/DefineButtonCxformTag.cpp
b/libcore/swf/DefineButtonCxformTag.cpp
index 74b2fef..c4be3df 100644
--- a/libcore/swf/DefineButtonCxformTag.cpp
+++ b/libcore/swf/DefineButtonCxformTag.cpp
@@ -36,7 +36,7 @@ DefineButtonCxformTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
assert(tag == SWF::DEFINEBUTTONCXFORM);
in.ensureBytes(2);
- const boost::uint16_t buttonID = in.read_u16();
+ const std::uint16_t buttonID = in.read_u16();
IF_VERBOSE_PARSE (
log_parse("DefineButtonCxformTag: ButtonId=%d", buttonID);
diff --git a/libcore/swf/DefineButtonSoundTag.h
b/libcore/swf/DefineButtonSoundTag.h
index 0359e21..ffba85a 100644
--- a/libcore/swf/DefineButtonSoundTag.h
+++ b/libcore/swf/DefineButtonSoundTag.h
@@ -43,7 +43,7 @@ public:
struct ButtonSound
{
- boost::uint16_t soundID;
+ std::uint16_t soundID;
sound_sample* sample;
SoundInfoRecord soundInfo;
diff --git a/libcore/swf/DefineButtonTag.cpp b/libcore/swf/DefineButtonTag.cpp
index aa216cd..d895a96 100644
--- a/libcore/swf/DefineButtonTag.cpp
+++ b/libcore/swf/DefineButtonTag.cpp
@@ -48,7 +48,7 @@ namespace {
}
DefineButtonTag::DefineButtonTag(SWFStream& in, movie_definition& m,
- TagType tag, boost::uint16_t id)
+ TagType tag, std::uint16_t id)
:
DefinitionTag(id),
_trackAsMenu(false),
@@ -78,7 +78,7 @@ DefineButtonTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
{
assert(tag == DEFINEBUTTON);
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
IF_VERBOSE_PARSE(
log_parse(_(" DefineButton loader: character id = %d"), id);
@@ -95,7 +95,7 @@ DefineButton2Tag::loader(SWFStream& in, TagType tag,
movie_definition& m,
{
assert(tag == DEFINEBUTTON2);
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
IF_VERBOSE_PARSE(
log_parse(_(" DefineButton2 loader: chararacter id = %d"), id);
@@ -151,7 +151,7 @@ DefineButtonTag::readDefineButton2Tag(SWFStream& in,
movie_definition& m)
// Read the menu flag
// (this is a single bit, the first 7 bits are reserved)
- const boost::uint8_t flags = in.read_u8();
+ const std::uint8_t flags = in.read_u8();
_trackAsMenu = flags & (1 << 0);
if (_trackAsMenu) {
LOG_ONCE(log_unimpl("DefineButton2: trackAsMenu"));
@@ -362,7 +362,7 @@ ButtonRecord::read(SWFStream& in, TagType t,
}
in.ensureBytes(1);
- boost::uint8_t flags = in.read_u8();
+ std::uint8_t flags = in.read_u8();
if (!flags) return false;
// Upper 4 bits are:
@@ -382,7 +382,7 @@ ButtonRecord::read(SWFStream& in, TagType t,
return false;
}
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
// Get DisplayObject definition now (safer)
_definitionTag = m.getDefinitionTag(id);
diff --git a/libcore/swf/DefineButtonTag.h b/libcore/swf/DefineButtonTag.h
index 002f7b0..68a2a81 100644
--- a/libcore/swf/DefineButtonTag.h
+++ b/libcore/swf/DefineButtonTag.h
@@ -23,7 +23,7 @@
#include <vector>
#include <boost/ptr_container/ptr_vector.hpp>
#include <memory>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <memory>
#include "DefinitionTag.h"
@@ -119,7 +119,7 @@ private:
/// associated with button records.
//
/// Currently unused by Gnash.
- boost::uint8_t _blendMode;
+ std::uint8_t _blendMode;
bool _hitTest;
bool _down;
@@ -186,7 +186,7 @@ private:
KEYPRESS = 0xFE00 // highest 7 bits
};
- boost::uint16_t _conditions;
+ std::uint16_t _conditions;
};
@@ -277,7 +277,7 @@ private:
//
/// This can only be constructed using a loader() function.
DefineButtonTag(SWFStream& in, movie_definition& m, TagType tag,
- boost::uint16_t id);
+ std::uint16_t id);
/// Read a DEFINEBUTTON tag
void readDefineButtonTag(SWFStream& in, movie_definition& m);
diff --git a/libcore/swf/DefineEditTextTag.cpp
b/libcore/swf/DefineEditTextTag.cpp
index ca096c7..18f4258 100644
--- a/libcore/swf/DefineEditTextTag.cpp
+++ b/libcore/swf/DefineEditTextTag.cpp
@@ -37,7 +37,7 @@ DefineEditTextTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
assert(tag == SWF::DEFINEEDITTEXT); // 37
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
std::unique_ptr<DefineEditTextTag> editText(new DefineEditTextTag(in, m,
id));
@@ -176,7 +176,7 @@ DefineEditTextTag::read(SWFStream& in, movie_definition& m)
}
DefineEditTextTag::DefineEditTextTag(SWFStream& in, movie_definition& m,
- boost::uint16_t id)
+ std::uint16_t id)
:
DefinitionTag(id),
_hasText(true),
diff --git a/libcore/swf/DefineEditTextTag.h b/libcore/swf/DefineEditTextTag.h
index 677c52b..9c92889 100644
--- a/libcore/swf/DefineEditTextTag.h
+++ b/libcore/swf/DefineEditTextTag.h
@@ -27,7 +27,7 @@
#include <boost/intrusive_ptr.hpp>
#include <string>
-#include <boost/cstdint.hpp> // for boost::uint16_t and friends
+#include <cstdint> // for std::uint16_t and friends
// Forward declarations
@@ -93,23 +93,23 @@ public:
}
/// Get right margin in twips
- boost::uint16_t rightMargin() const {
+ std::uint16_t rightMargin() const {
return _rightMargin;
}
/// Get left margin in twips
- boost::uint16_t leftMargin() const {
+ std::uint16_t leftMargin() const {
return _leftMargin;
}
/// Get indentation in twips
- boost::uint16_t indent() const {
+ std::uint16_t indent() const {
return _indent;
}
/// Get height of font in twips.
// @@ what if has_font is false ??
- boost::uint16_t textHeight() const {
+ std::uint16_t textHeight() const {
return _textHeight;
}
@@ -122,7 +122,7 @@ public:
/// Get extra space between lines (in twips).
//
/// This is in addition to default font line spacing.
- boost::uint16_t leading() const {
+ std::uint16_t leading() const {
return _leading;
}
@@ -190,7 +190,7 @@ private:
/// Construct a DefineEditTextTag.
//
/// This should only be used from the loader() function.
- DefineEditTextTag(SWFStream& in, movie_definition& m, boost::uint16_t
id);
+ DefineEditTextTag(SWFStream& in, movie_definition& m, std::uint16_t id);
/// Read a tag from the SWFStream.
void read(SWFStream& in, movie_definition& m);
@@ -261,7 +261,7 @@ private:
// TODO: initialize to a meaningful value (see MovieClip::add_textfield)
// and make sure get_font_height is not called for rendering purposes
// (instead call a method of TextField) (?)
- boost::uint16_t _textHeight;
+ std::uint16_t _textHeight;
/// Text color
rgba _color;
@@ -275,18 +275,18 @@ private:
TextField::TextAlignment _alignment;
/// extra space between box's left border and text (in twips)
- boost::uint16_t _leftMargin;
+ std::uint16_t _leftMargin;
/// extra space between box's right border and text (in twips)
- boost::uint16_t _rightMargin;
+ std::uint16_t _rightMargin;
/// how much to indent the first line of multiline text (in twips)
- boost::uint16_t _indent;
+ std::uint16_t _indent;
/// \brief
/// Extra space between lines
/// (in addition to default font line spacing)
- boost::uint16_t _leading;
+ std::uint16_t _leading;
/// The default text to be displayed
std::string _defaultText;
diff --git a/libcore/swf/DefineFontAlignZonesTag.cpp
b/libcore/swf/DefineFontAlignZonesTag.cpp
index 5c27fbd..620828e 100644
--- a/libcore/swf/DefineFontAlignZonesTag.cpp
+++ b/libcore/swf/DefineFontAlignZonesTag.cpp
@@ -20,7 +20,7 @@
#include "DefineFontAlignZonesTag.h"
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "RunResources.h"
#include "Font.h"
@@ -45,7 +45,7 @@ DefineFontAlignZonesTag::loader(SWFStream& in, TagType tag,
in.ensureBytes(2);
// must reference a valid DEFINEFONT3 tag
- const boost::uint16_t ref = in.read_u16();
+ const std::uint16_t ref = in.read_u16();
Font* referencedFont = m.get_font(ref);
if (!referencedFont) {
IF_VERBOSE_MALFORMED_SWF(
@@ -58,10 +58,10 @@ DefineFontAlignZonesTag::loader(SWFStream& in, TagType tag,
in.ensureBytes(1);
// 2bits are cms table, 6bits are reserved
- const boost::uint8_t flags = in.read_u8();
+ const std::uint8_t flags = in.read_u8();
// What is this?
- const boost::uint16_t csm_table_int = flags >> 6;
+ const std::uint16_t csm_table_int = flags >> 6;
// TODO:
// The first thing to to is test what this does. According to some
@@ -84,8 +84,8 @@ DefineFontAlignZonesTag::loader(SWFStream& in, TagType tag,
for (size_t j = 0; j != 2; ++j) {
in.ensureBytes(4);
- const boost::uint16_t zone_position = in.read_u16();
- const boost::uint16_t zone_size = in.read_u16();
+ const std::uint16_t zone_position = in.read_u16();
+ const std::uint16_t zone_size = in.read_u16();
IF_VERBOSE_PARSE(
log_parse("Zone position: %s, size: %s", zone_position,
@@ -95,7 +95,7 @@ DefineFontAlignZonesTag::loader(SWFStream& in, TagType tag,
in.ensureBytes(1);
// What is this?
- const boost::uint8_t u = in.read_u8();
+ const std::uint8_t u = in.read_u8();
const bool zone_x = u & 0x01;
const bool zone_y = (u >> 1) & 0x01;
diff --git a/libcore/swf/DefineFontNameTag.h b/libcore/swf/DefineFontNameTag.h
index ea52720..849240b 100644
--- a/libcore/swf/DefineFontNameTag.h
+++ b/libcore/swf/DefineFontNameTag.h
@@ -45,7 +45,7 @@ public:
assert(tag == SWF::DEFINEFONTNAME);
in.ensureBytes(2);
- boost::uint16_t fontID = in.read_u16();
+ std::uint16_t fontID = in.read_u16();
Font* f = m.get_font(fontID);
if (!f)
diff --git a/libcore/swf/DefineFontTag.cpp b/libcore/swf/DefineFontTag.cpp
index 405bbce..94988e5 100644
--- a/libcore/swf/DefineFontTag.cpp
+++ b/libcore/swf/DefineFontTag.cpp
@@ -44,7 +44,7 @@ DefineFontTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
assert(tag == DEFINEFONT || tag == DEFINEFONT2 || tag == DEFINEFONT3);
in.ensureBytes(2);
- const boost::uint16_t fontID = in.read_u16();
+ const std::uint16_t fontID = in.read_u16();
std::unique_ptr<DefineFontTag> ft(new DefineFontTag(in, m, tag, r));
boost::intrusive_ptr<Font> f(new Font(std::move(ft)));
@@ -66,9 +66,9 @@ DefineFontTag::readCodeTable(SWFStream& in, Font::CodeTable&
table,
if (wideCodes) {
in.ensureBytes(2 * glyphCount);
- // Code table is made of boost::uint16_t's.
+ // Code table is made of std::uint16_t's.
for (size_t i=0; i < glyphCount; ++i) {
- const boost::uint16_t code = in.read_u16();
+ const std::uint16_t code = in.read_u16();
table.insert(std::make_pair(code, i));
}
}
@@ -76,7 +76,7 @@ DefineFontTag::readCodeTable(SWFStream& in, Font::CodeTable&
table,
// Code table is made of bytes.
in.ensureBytes(1 * glyphCount);
for (size_t i = 0; i < glyphCount; ++i) {
- const boost::uint8_t code = in.read_u8();
+ const std::uint8_t code = in.read_u8();
table.insert(std::make_pair(code, i));
}
}
@@ -192,7 +192,7 @@ DefineFontTag::readDefineFont2Or3(SWFStream& in,
movie_definition& m,
in.read_string_with_length(_name);
in.ensureBytes(2);
- const boost::uint16_t glyph_count = in.read_u16();
+ const std::uint16_t glyph_count = in.read_u16();
IF_VERBOSE_PARSE (
log_parse(" has_layout = %d", has_layout);
@@ -212,14 +212,14 @@ DefineFontTag::readDefineFont2Or3(SWFStream& in,
movie_definition& m,
// Read the glyph offsets. Offsets
// are measured from the start of the
// offset table. Make sure wide offsets fit into elements
- std::vector<boost::uint32_t> offsets;
+ std::vector<std::uint32_t> offsets;
int font_code_offset;
if (wide_offsets) {
// 32-bit offsets.
in.ensureBytes(4*glyph_count + 4);
for (size_t i = 0; i < glyph_count; ++i) {
- const boost::uint32_t off = in.read_u32();
+ const std::uint32_t off = in.read_u32();
IF_VERBOSE_PARSE (
log_parse(_("Glyph %d at offset %u"), i, off);
);
@@ -231,7 +231,7 @@ DefineFontTag::readDefineFont2Or3(SWFStream& in,
movie_definition& m,
// 16-bit offsets.
in.ensureBytes(2*glyph_count + 2);
for (size_t i = 0; i < glyph_count; ++i) {
- const boost::uint16_t off = in.read_u16();
+ const std::uint16_t off = in.read_u16();
IF_VERBOSE_PARSE(
log_parse(_("Glyph %d at offset %u"), i, off);
);
@@ -297,12 +297,12 @@ DefineFontTag::readDefineFont2Or3(SWFStream& in,
movie_definition& m,
// Kerning pairs.
in.ensureBytes(2);
- const boost::uint16_t kerning_count = in.read_u16();
+ const std::uint16_t kerning_count = in.read_u16();
in.ensureBytes(kerning_count * (wideCodes ? 6 : 4));
for (int i = 0; i < kerning_count; ++i) {
- boost::uint16_t char0, char1;
+ std::uint16_t char0, char1;
if (wideCodes) {
char0 = in.read_u16();
char1 = in.read_u16();
@@ -311,7 +311,7 @@ DefineFontTag::readDefineFont2Or3(SWFStream& in,
movie_definition& m,
char0 = in.read_u8();
char1 = in.read_u8();
}
- const boost::int16_t adjustment = in.read_s16();
+ const std::int16_t adjustment = in.read_s16();
kerning_pair k;
k.m_char0 = char0;
@@ -335,7 +335,7 @@ DefineFontInfoTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
assert(tag == DEFINEFONTINFO || tag == DEFINEFONTINFO2);
in.ensureBytes(2);
- const boost::uint16_t fontID = in.read_u16();
+ const std::uint16_t fontID = in.read_u16();
Font* f = m.get_font(fontID);
if (!f) {
@@ -355,7 +355,7 @@ DefineFontInfoTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
in.read_string_with_length(name);
in.ensureBytes(1);
- const boost::uint8_t flags = in.read_u8();
+ const std::uint8_t flags = in.read_u8();
const bool wideCodes = flags & (1 << 0);
diff --git a/libcore/swf/DefineFontTag.h b/libcore/swf/DefineFontTag.h
index b562e13..e009be3 100644
--- a/libcore/swf/DefineFontTag.h
+++ b/libcore/swf/DefineFontTag.h
@@ -34,7 +34,7 @@
#include "Font.h"
#include <map>
#include <string>
-#include <boost/cstdint.hpp>
+#include <cstdint>
// Forward declarations
namespace gnash {
@@ -93,21 +93,21 @@ public:
/// The font leading value
//
/// This is documented to be int16_t, but may be uint16_t like advance.
- boost::int16_t leading() const {
+ std::int16_t leading() const {
return _leading;
}
/// The font ascent value
//
/// This is documented to be int16_t, but may be uint16_t like advance.
- boost::int16_t ascent() const {
+ std::int16_t ascent() const {
return _ascent;
}
/// The font descent value
//
/// This is documented to be int16_t, but may be uint16_t like advance.
- boost::int16_t descent() const {
+ std::int16_t descent() const {
return _descent;
}
@@ -141,11 +141,11 @@ private:
bool _italic;
bool _bold;
- boost::int16_t _ascent;
- boost::int16_t _descent;
- boost::int16_t _leading;
+ std::int16_t _ascent;
+ std::int16_t _descent;
+ std::int16_t _leading;
- typedef std::map<kerning_pair, boost::int16_t> KerningTable;
+ typedef std::map<kerning_pair, std::int16_t> KerningTable;
KerningTable _kerningPairs;
std::shared_ptr<const Font::CodeTable> _codeTable;
diff --git a/libcore/swf/DefineMorphShapeTag.cpp
b/libcore/swf/DefineMorphShapeTag.cpp
index 13927f8..107b26e 100644
--- a/libcore/swf/DefineMorphShapeTag.cpp
+++ b/libcore/swf/DefineMorphShapeTag.cpp
@@ -25,7 +25,7 @@
#include "DefineMorphShapeTag.h"
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "TypesParser.h"
#include "MorphShape.h"
@@ -47,7 +47,7 @@ DefineMorphShapeTag::loader(SWFStream& in, TagType tag,
movie_definition& md,
const RunResources& r)
{
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
IF_VERBOSE_PARSE(
log_parse("DefineMorphShapeTag: id = %d", id);
@@ -58,7 +58,7 @@ DefineMorphShapeTag::loader(SWFStream& in, TagType tag,
movie_definition& md,
}
DefineMorphShapeTag::DefineMorphShapeTag(SWFStream& in, TagType tag,
- movie_definition& md, const RunResources& r, boost::uint16_t id)
+ movie_definition& md, const RunResources& r, std::uint16_t id)
:
DefinitionTag(id)
{
@@ -110,7 +110,7 @@ DefineMorphShapeTag::read(SWFStream& in, TagType tag,
movie_definition& md,
static_cast<void>(in.read_u32());
// Next line will throw ParserException on malformed SWF
- const boost::uint16_t fillCount = in.read_variable_count();
+ const std::uint16_t fillCount = in.read_variable_count();
SWF::Subshape subshape1;
SWF::Subshape subshape2;
@@ -121,7 +121,7 @@ DefineMorphShapeTag::read(SWFStream& in, TagType tag,
movie_definition& md,
subshape2.addFillStyle(*fp.second);
}
- const boost::uint16_t lineCount = in.read_variable_count();
+ const std::uint16_t lineCount = in.read_variable_count();
LineStyle ls1, ls2;
for (size_t i = 0; i < lineCount; ++i) {
ls1.read_morph(in, tag, md, r, &ls2);
diff --git a/libcore/swf/DefineMorphShapeTag.h
b/libcore/swf/DefineMorphShapeTag.h
index 54add1b..e2c5810 100644
--- a/libcore/swf/DefineMorphShapeTag.h
+++ b/libcore/swf/DefineMorphShapeTag.h
@@ -68,7 +68,7 @@ public:
private:
DefineMorphShapeTag(SWFStream& in, SWF::TagType tag, movie_definition& md,
- const RunResources& r, boost::uint16_t id);
+ const RunResources& r, std::uint16_t id);
/// Read a DefineMorphShape tag from stream
//
diff --git a/libcore/swf/DefineScalingGridTag.cpp
b/libcore/swf/DefineScalingGridTag.cpp
index 892b919..4954409 100644
--- a/libcore/swf/DefineScalingGridTag.cpp
+++ b/libcore/swf/DefineScalingGridTag.cpp
@@ -36,7 +36,7 @@ DefineScalingGridTag::loader(SWFStream& in, TagType /*tag*/,
movie_definition& /*md*/, const RunResources& /*r*/)
{
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
IF_VERBOSE_PARSE(
log_parse("DefineScalingGridTag: id = %d", id);
diff --git a/libcore/swf/DefineSceneAndFrameLabelDataTag.h
b/libcore/swf/DefineSceneAndFrameLabelDataTag.h
index 5f29288..456d5d6 100644
--- a/libcore/swf/DefineSceneAndFrameLabelDataTag.h
+++ b/libcore/swf/DefineSceneAndFrameLabelDataTag.h
@@ -77,22 +77,22 @@ private:
void read(SWFStream& in) {
- boost::uint32_t scenes = in.read_V32();
+ std::uint32_t scenes = in.read_V32();
IF_VERBOSE_PARSE(log_parse("Scene count: %d", scenes));
for (size_t i = 0; i < scenes; ++i) {
- boost::uint32_t offset = in.read_V32();
+ std::uint32_t offset = in.read_V32();
std::string name;
in.read_string(name);
IF_VERBOSE_PARSE(log_parse("Offset %d name: %s", offset, name));
_scenes[offset] = name;
}
- boost::uint32_t labels = in.read_V32();
+ std::uint32_t labels = in.read_V32();
for (size_t i = 0; i < labels; ++i) {
- boost::uint32_t num = in.read_V32();
+ std::uint32_t num = in.read_V32();
std::string label;
in.read_string(label);
IF_VERBOSE_PARSE(log_parse("Frame %d label: %s", num, label));
@@ -101,8 +101,8 @@ private:
}
- std::map<boost::uint32_t, std::string> _scenes;
- std::map<boost::uint32_t, std::string> _frames;
+ std::map<std::uint32_t, std::string> _scenes;
+ std::map<std::uint32_t, std::string> _frames;
};
diff --git a/libcore/swf/DefineShapeTag.cpp b/libcore/swf/DefineShapeTag.cpp
index faa279a..ddda58e 100644
--- a/libcore/swf/DefineShapeTag.cpp
+++ b/libcore/swf/DefineShapeTag.cpp
@@ -52,7 +52,7 @@ DefineShapeTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
tag == DEFINESHAPE4_);
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
IF_VERBOSE_PARSE(
log_parse(_("DefineShapeTag(%s): id = %d"), tag, id);
@@ -70,7 +70,7 @@ DefineShapeTag::createDisplayObject(Global_as& gl,
DisplayObject* parent) const
}
bool
-DefineShapeTag::pointTestLocal(boost::int32_t x, boost::int32_t y,
+DefineShapeTag::pointTestLocal(std::int32_t x, std::int32_t y,
const SWFMatrix& wm) const
{
return _shape.pointTest(x, y, wm);
@@ -78,7 +78,7 @@ DefineShapeTag::pointTestLocal(boost::int32_t x,
boost::int32_t y,
DefineShapeTag::DefineShapeTag(SWFStream& in, TagType tag,
- movie_definition& m, const RunResources& r, boost::uint16_t id)
+ movie_definition& m, const RunResources& r, std::uint16_t id)
:
DefinitionTag(id),
_shape(in, tag, m, r)
diff --git a/libcore/swf/DefineShapeTag.h b/libcore/swf/DefineShapeTag.h
index 2291606..093783c 100644
--- a/libcore/swf/DefineShapeTag.h
+++ b/libcore/swf/DefineShapeTag.h
@@ -53,13 +53,13 @@ public:
/// a matrix is given to allow computing proper line
/// thickness based on display scale.
///
- bool pointTestLocal(boost::int32_t x, boost::int32_t y,
+ bool pointTestLocal(std::int32_t x, std::int32_t y,
const SWFMatrix& wm) const;
private:
DefineShapeTag(SWFStream& in, TagType tag, movie_definition& m,
- const RunResources& r, boost::uint16_t id);
+ const RunResources& r, std::uint16_t id);
/// The actual shape data is stored in this record.
const ShapeRecord _shape;
diff --git a/libcore/swf/DefineTextTag.cpp b/libcore/swf/DefineTextTag.cpp
index e04654f..b3bd856 100644
--- a/libcore/swf/DefineTextTag.cpp
+++ b/libcore/swf/DefineTextTag.cpp
@@ -45,7 +45,7 @@ DefineTextTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
assert(tag == DEFINETEXT);
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
std::unique_ptr<DefineTextTag> t(new DefineTextTag(in, m, tag, id));
IF_VERBOSE_PARSE(
@@ -86,7 +86,7 @@ DefineText2Tag::loader(SWFStream& in, TagType tag,
movie_definition& m,
assert(tag == DEFINETEXT2);
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
std::unique_ptr<DefineTextTag> t(new DefineTextTag(in, m, tag, id));
IF_VERBOSE_PARSE(
diff --git a/libcore/swf/DefineTextTag.h b/libcore/swf/DefineTextTag.h
index afcd437..7dcf068 100644
--- a/libcore/swf/DefineTextTag.h
+++ b/libcore/swf/DefineTextTag.h
@@ -76,7 +76,7 @@ private:
//
/// This should only be constructed using the loader() functions.
DefineTextTag(SWFStream& in, movie_definition& m, TagType tag,
- boost::uint16_t id)
+ std::uint16_t id)
:
DefinitionTag(id)
{
diff --git a/libcore/swf/DefineVideoStreamTag.cpp
b/libcore/swf/DefineVideoStreamTag.cpp
index 610848c..7da4eea 100644
--- a/libcore/swf/DefineVideoStreamTag.cpp
+++ b/libcore/swf/DefineVideoStreamTag.cpp
@@ -36,7 +36,7 @@
namespace gnash {
namespace SWF {
-DefineVideoStreamTag::DefineVideoStreamTag(SWFStream& in, boost::uint16_t id)
+DefineVideoStreamTag::DefineVideoStreamTag(SWFStream& in, std::uint16_t id)
:
DefinitionTag(id),
_width(0),
@@ -57,7 +57,7 @@ DefineVideoStreamTag::loader(SWFStream& in, SWF::TagType tag,
assert(tag == SWF::DEFINEVIDEOSTREAM); // 60
in.ensureBytes(2);
- boost::uint16_t id = in.read_u16();
+ std::uint16_t id = in.read_u16();
std::unique_ptr<DefineVideoStreamTag> vs(new DefineVideoStreamTag(in, id));
diff --git a/libcore/swf/DefineVideoStreamTag.h
b/libcore/swf/DefineVideoStreamTag.h
index 389fe3f..9f20a86 100644
--- a/libcore/swf/DefineVideoStreamTag.h
+++ b/libcore/swf/DefineVideoStreamTag.h
@@ -114,7 +114,7 @@ public:
/// @tparam t A visitor that should accept a const
/// media::EncodedVideoFrame.
template<typename T>
- size_t visitSlice(const T& t, boost::uint32_t from, boost::uint32_t to)
const {
+ size_t visitSlice(const T& t, std::uint32_t from, std::uint32_t to) const {
boost::mutex::scoped_lock lock(_video_mutex);
@@ -140,26 +140,26 @@ private:
/// constructor, as that's the one which will eventually get passed
/// the id.
/// NOTE: What dynamically created definitions?
- DefineVideoStreamTag(SWFStream& in, boost::uint16_t id);
+ DefineVideoStreamTag(SWFStream& in, std::uint16_t id);
void read(SWFStream& in);
/// Reserved flags read from DEFINEVIDEOSTREAM tag
- boost::uint8_t m_reserved_flags;
+ std::uint8_t m_reserved_flags;
/// Flags read from DEFINEVIDEOSTREAM tag
- boost::uint8_t m_deblocking_flags;
+ std::uint8_t m_deblocking_flags;
/// Smoothing flag, as read from DEFINEVIDEOSTREAM tag
bool m_smoothing_flags;
/// Frame in which the DEFINEVIDEOSTREAM was found
- //boost::uint16_t m_start_frame;
+ //std::uint16_t m_start_frame;
/// Number of frames in the embedded video, as reported
/// by the DEFINEVIDEOSTREAM tag
///
- boost::uint16_t m_num_frames;
+ std::uint16_t m_num_frames;
/// Codec ID as read from DEFINEVIDEOSTREAM tag
//
@@ -180,10 +180,10 @@ private:
EmbeddedFrames _video_frames;
/// Width of the video
- boost::uint32_t _width;
+ std::uint32_t _width;
/// Height of the video
- boost::uint32_t _height;
+ std::uint32_t _height;
/// Info about embedded video
//
diff --git a/libcore/swf/DefinitionTag.h b/libcore/swf/DefinitionTag.h
index 7d3db70..6ab5300 100644
--- a/libcore/swf/DefinitionTag.h
+++ b/libcore/swf/DefinitionTag.h
@@ -21,7 +21,7 @@
#include <boost/noncopyable.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "ControlTag.h"
#include "dsodefs.h" // for DSOTEXPORT
@@ -74,17 +74,17 @@ public:
/// The immutable id of the DefinitionTag.
//
/// @return the id of the DefinitionTag as parsed from a SWF.
- boost::uint16_t id() const {
+ std::uint16_t id() const {
return _id;
}
protected:
- DefinitionTag(boost::uint16_t id) : _id(id) {}
+ DefinitionTag(std::uint16_t id) : _id(id) {}
private:
- const boost::uint16_t _id;
+ const std::uint16_t _id;
};
diff --git a/libcore/swf/DoInitActionTag.h b/libcore/swf/DoInitActionTag.h
index d4fe198..ca90153 100644
--- a/libcore/swf/DoInitActionTag.h
+++ b/libcore/swf/DoInitActionTag.h
@@ -72,7 +72,7 @@ public:
}
in.ensureBytes(2);
- const boost::uint16_t cid = in.read_u16();
+ const std::uint16_t cid = in.read_u16();
IF_VERBOSE_PARSE(
log_parse(_(" tag %d: do_init_action_loader"), tag);
diff --git a/libcore/swf/ExportAssetsTag.h b/libcore/swf/ExportAssetsTag.h
index 5e0a92f..9c55657 100644
--- a/libcore/swf/ExportAssetsTag.h
+++ b/libcore/swf/ExportAssetsTag.h
@@ -55,7 +55,7 @@ public:
Movie* mov = m->get_root();
for (Exports::const_iterator it = _exports.begin(), e = _exports.end();
it != e; ++it) {
- const boost::uint16_t id = mov->definition()->exportID(*it);
+ const std::uint16_t id = mov->definition()->exportID(*it);
// We exported it, so we assume it is known.
assert(id);
@@ -73,7 +73,7 @@ private:
void read(SWFStream& in, movie_definition& m) {
in.ensureBytes(2);
- const boost::uint16_t count = in.read_u16();
+ const std::uint16_t count = in.read_u16();
IF_VERBOSE_PARSE(
log_parse(_(" export: count = %d"), count);
@@ -82,7 +82,7 @@ private:
// Read the exports.
for (size_t i = 0; i < count; ++i) {
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
if (!id) continue;
diff --git a/libcore/swf/ImportAssetsTag.h b/libcore/swf/ImportAssetsTag.h
index ca2ff0f..bd9973f 100644
--- a/libcore/swf/ImportAssetsTag.h
+++ b/libcore/swf/ImportAssetsTag.h
@@ -87,12 +87,12 @@ private:
if (t == SWF::IMPORTASSETS2) {
in.ensureBytes(2);
import_version = in.read_uint(8);
- boost::uint8_t reserved = in.read_uint(8);
+ std::uint8_t reserved = in.read_uint(8);
UNUSED(reserved);
}
in.ensureBytes(2);
- const boost::uint16_t count = in.read_u16();
+ const std::uint16_t count = in.read_u16();
IF_VERBOSE_PARSE(
log_parse(_(" import: version = %u, source_url = %s (%s), "
@@ -130,7 +130,7 @@ private:
for (size_t i = 0; i < count; ++i)
{
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
// We don't consider 0 valid.
if (!id) continue;
diff --git a/libcore/swf/PlaceObject2Tag.cpp b/libcore/swf/PlaceObject2Tag.cpp
index ea50878..5e10e44 100644
--- a/libcore/swf/PlaceObject2Tag.cpp
+++ b/libcore/swf/PlaceObject2Tag.cpp
@@ -99,7 +99,7 @@ PlaceObject2Tag::readPlaceActions(SWFStream& in)
const int movie_version = _movie_def.get_version();
in.ensureBytes(2);
- boost::uint16_t reserved = in.read_u16();
+ std::uint16_t reserved = in.read_u16();
IF_VERBOSE_MALFORMED_SWF(
if (reserved != 0) {
log_swferror(_("Reserved field in PlaceObject actions == "
@@ -107,7 +107,7 @@ PlaceObject2Tag::readPlaceActions(SWFStream& in)
}
);
- boost::uint32_t all_event_flags;
+ std::uint32_t all_event_flags;
// The logical 'or' of all the following handlers.
if (movie_version >= 6) {
@@ -136,7 +136,7 @@ PlaceObject2Tag::readPlaceActions(SWFStream& in)
// Read event.
in.align();
- boost::uint32_t flags;
+ std::uint32_t flags;
if (movie_version >= 6) {
in.ensureBytes(4);
flags = in.read_u32();
@@ -152,7 +152,7 @@ PlaceObject2Tag::readPlaceActions(SWFStream& in)
}
in.ensureBytes(4);
- boost::uint32_t event_length = in.read_u32();
+ std::uint32_t event_length = in.read_u32();
if (in.get_tag_end_position() - in.tell() < event_length) {
IF_VERBOSE_MALFORMED_SWF(
log_swferror(_("swf_event::read(), "
@@ -398,7 +398,7 @@ PlaceObject2Tag::readPlaceObject3(SWFStream& in)
LOG_ONCE(log_unimpl("Blend mode in PlaceObject tag"));
}
- boost::uint8_t bitmask = 0;
+ std::uint8_t bitmask = 0;
if (hasBitmapCaching()) {
// cacheAsBitmap is a boolean value, so the flag itself ought to be
// enough. Alexis' SWF reference is unsure about this, but suggests
diff --git a/libcore/swf/PlaceObject2Tag.h b/libcore/swf/PlaceObject2Tag.h
index cf43f68..d41dc34 100644
--- a/libcore/swf/PlaceObject2Tag.h
+++ b/libcore/swf/PlaceObject2Tag.h
@@ -106,9 +106,9 @@ public:
return m_has_flags2 & (HAS_CHARACTER_MASK | MOVE_MASK);
}
- boost::uint16_t getRatio() const { return _ratio; }
+ std::uint16_t getRatio() const { return _ratio; }
int getClipDepth() const { return m_clip_depth; }
- boost::uint16_t getID() const { return _id; }
+ std::uint16_t getID() const { return _id; }
const std::string& getName() const { return m_name; }
const SWFMatrix& getMatrix() const { return m_matrix; }
const SWFCxForm& getCxform() const { return m_color_transform; }
@@ -144,7 +144,7 @@ public:
//
/// This is stored as a uint8_t to allow for future expansion of
/// blend modes.
- boost::uint8_t getBlendMode() const {
+ std::uint8_t getBlendMode() const {
return _blendMode;
}
@@ -162,16 +162,16 @@ private:
// read SWF::PLACEOBJECT3
void readPlaceObject3(SWFStream& in);
- boost::uint8_t m_has_flags2;
- boost::uint8_t m_has_flags3;
- boost::uint16_t _id;
+ std::uint8_t m_has_flags2;
+ std::uint8_t m_has_flags3;
+ std::uint16_t _id;
SWFCxForm m_color_transform;
SWFMatrix m_matrix;
- boost::uint16_t _ratio;
+ std::uint16_t _ratio;
std::string m_name;
int m_clip_depth;
- boost::uint8_t _blendMode;
+ std::uint8_t _blendMode;
/// NOTE: getPlaceType() is dependent on the enum values.
enum PlaceType
diff --git a/libcore/swf/ScriptLimitsTag.h b/libcore/swf/ScriptLimitsTag.h
index f51e535..3953757 100644
--- a/libcore/swf/ScriptLimitsTag.h
+++ b/libcore/swf/ScriptLimitsTag.h
@@ -74,8 +74,8 @@ private:
}
- boost::uint16_t _recursionLimit;
- boost::uint16_t _timeoutLimit;
+ std::uint16_t _recursionLimit;
+ std::uint16_t _timeoutLimit;
};
} // namespace gnash::SWF
diff --git a/libcore/swf/SetTabIndexTag.cpp b/libcore/swf/SetTabIndexTag.cpp
index 9cfa7c8..fda4f34 100644
--- a/libcore/swf/SetTabIndexTag.cpp
+++ b/libcore/swf/SetTabIndexTag.cpp
@@ -33,14 +33,14 @@ SetTabIndexTag::loader(SWFStream& in, TagType /*tag*/,
movie_definition& /*md*/,
const RunResources& /*r*/)
{
in.ensureBytes(2);
- boost::uint16_t depth = in.read_u16();
+ std::uint16_t depth = in.read_u16();
IF_VERBOSE_PARSE(
log_parse("SetTabIndexTag: depth = %d", depth);
);
in.ensureBytes(2);
- boost::uint16_t tab_index = in.read_u16();
+ std::uint16_t tab_index = in.read_u16();
UNUSED(tab_index);
LOG_ONCE( log_unimpl("SetTabIndexTag") );
diff --git a/libcore/swf/ShapeRecord.cpp b/libcore/swf/ShapeRecord.cpp
index 9c72cd4..d8eb24c 100644
--- a/libcore/swf/ShapeRecord.cpp
+++ b/libcore/swf/ShapeRecord.cpp
@@ -334,7 +334,7 @@ ShapeRecord::read(SWFStream& in, SWF::TagType tag,
movie_definition& m,
// Use read_u8 to force alignment.
in.ensureBytes(1);
- boost::uint8_t num_bits = in.read_u8();
+ std::uint8_t num_bits = in.read_u8();
int num_fill_bits = (num_bits & 0xF0) >> 4;
int num_line_bits = (num_bits & 0x0F);
@@ -608,7 +608,7 @@ readFillStyles(ShapeRecord::FillStyles& styles, SWFStream&
in,
SWF::TagType tag, movie_definition& m, const RunResources& /*r*/)
{
in.ensureBytes(1);
- boost::uint16_t fillcount = in.read_u8();
+ std::uint16_t fillcount = in.read_u8();
if (tag != SWF::DEFINESHAPE) {
if (fillcount == 0xff) {
in.ensureBytes(2);
@@ -622,7 +622,7 @@ readFillStyles(ShapeRecord::FillStyles& styles, SWFStream&
in,
// Read the styles.
styles.reserve(styles.size() + fillcount);
- for (boost::uint16_t i = 0; i < fillcount; ++i) {
+ for (std::uint16_t i = 0; i < fillcount; ++i) {
OptionalFillPair fp = readFills(in, tag, m, false);
styles.push_back(fp.first);
IF_VERBOSE_PARSE(
diff --git a/libcore/swf/ShapeRecord.h b/libcore/swf/ShapeRecord.h
index 2f73612..4401610 100644
--- a/libcore/swf/ShapeRecord.h
+++ b/libcore/swf/ShapeRecord.h
@@ -180,7 +180,7 @@ public:
_bounds = bounds;
}
- bool pointTest(boost::int32_t x, boost::int32_t y,
+ bool pointTest(std::int32_t x, std::int32_t y,
const SWFMatrix& wm) const {
for (SWF::ShapeRecord::Subshapes::const_iterator it =
_subshapes.begin(),
end = _subshapes.end(); it != end; ++it) {
diff --git a/libcore/swf/SoundStreamHeadTag.cpp
b/libcore/swf/SoundStreamHeadTag.cpp
index 516393f..3b20909 100644
--- a/libcore/swf/SoundStreamHeadTag.cpp
+++ b/libcore/swf/SoundStreamHeadTag.cpp
@@ -18,7 +18,7 @@
#include "SoundStreamHeadTag.h"
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <memory>
#include "SWF.h"
@@ -54,9 +54,9 @@ SoundStreamHeadTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
// These are all unused by current implementation
int reserved = in.read_uint(4); UNUSED(reserved);
- const boost::uint32_t samplerates[] = { 5512, 11025, 22050, 44100 };
+ const std::uint32_t samplerates[] = { 5512, 11025, 22050, 44100 };
- boost::uint8_t pbSoundRate = in.read_uint(2);
+ std::uint8_t pbSoundRate = in.read_uint(2);
if (pbSoundRate >= arraySize(samplerates)) {
IF_VERBOSE_MALFORMED_SWF(
log_swferror("SOUNDSTREAMHEAD: playback sound rate %d (expected "
@@ -64,14 +64,14 @@ SoundStreamHeadTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
);
pbSoundRate = 0;
}
- const boost::uint32_t playbackSoundRate = samplerates[pbSoundRate];
+ const std::uint32_t playbackSoundRate = samplerates[pbSoundRate];
const bool playbackSound16bit = in.read_bit();
const bool playbackSoundStereo = in.read_bit();
// These are the used ones
media::audioCodecType format =
static_cast<media::audioCodecType>(in.read_uint(4)); // TODO: check
input !
- boost::uint8_t stSoundRate = in.read_uint(2);
+ std::uint8_t stSoundRate = in.read_uint(2);
if (stSoundRate >= arraySize(samplerates)) {
IF_VERBOSE_MALFORMED_SWF(
@@ -80,7 +80,7 @@ SoundStreamHeadTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
);
stSoundRate=0;
}
- const boost::uint32_t streamSoundRate = samplerates[stSoundRate];
+ const std::uint32_t streamSoundRate = samplerates[stSoundRate];
const bool streamSound16bit = in.read_bit();
const bool streamSoundStereo = in.read_bit();
@@ -112,7 +112,7 @@ SoundStreamHeadTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
}
// 2 bytes here
- const boost::uint16_t sampleCount = in.read_u16();
+ const std::uint16_t sampleCount = in.read_u16();
if (!sampleCount) {
// this seems common too, we'd need to reproduce with a custom
@@ -123,7 +123,7 @@ SoundStreamHeadTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
);
}
- boost::int16_t latency = 0;
+ std::int16_t latency = 0;
if (format == media::AUDIO_CODEC_MP3) {
try {
in.ensureBytes(2);
diff --git a/libcore/swf/SoundStreamHeadTag.h b/libcore/swf/SoundStreamHeadTag.h
index 318e111..0a2ce78 100644
--- a/libcore/swf/SoundStreamHeadTag.h
+++ b/libcore/swf/SoundStreamHeadTag.h
@@ -20,7 +20,7 @@
#define GNASH_SWF_SOUNDSTREAMHEAD_TAG_H
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "SWF.h"
diff --git a/libcore/swf/StartSoundTag.h b/libcore/swf/StartSoundTag.h
index 6d6dd63..6a24543 100644
--- a/libcore/swf/StartSoundTag.h
+++ b/libcore/swf/StartSoundTag.h
@@ -23,7 +23,7 @@
#include "SWF.h" // for TagType definition
#include "SoundInfoRecord.h"
-#include <boost/cstdint.hpp> // for boost::uint16_t and friends
+#include <cstdint> // for std::uint16_t and friends
// Forward declarations
@@ -51,7 +51,7 @@ class StartSoundTag : public ControlTag
/// This one is the latter, probably so with the intention of avoiding
/// a lookup at every execution...
///
- boost::uint16_t m_handler_id;
+ std::uint16_t m_handler_id;
/// Create a StartSoundTag for starting the given sound sample
//
diff --git a/libcore/swf/StreamSoundBlockTag.cpp
b/libcore/swf/StreamSoundBlockTag.cpp
index 3dee0a4..1a9dbcc 100644
--- a/libcore/swf/StreamSoundBlockTag.cpp
+++ b/libcore/swf/StreamSoundBlockTag.cpp
@@ -20,7 +20,7 @@
#include "StreamSoundBlockTag.h"
#include <boost/intrusive_ptr.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "utility.h"
#include "sound_handler.h"
@@ -82,8 +82,8 @@ StreamSoundBlockTag::loader(SWFStream& in, TagType tag,
movie_definition& m,
media::audioCodecType format = sinfo->getFormat();
- boost::uint16_t sampleCount;
- boost::int16_t seekSamples = 0;
+ std::uint16_t sampleCount;
+ std::int16_t seekSamples = 0;
// MP3 format blocks have additional info
if (format == media::AUDIO_CODEC_MP3) {
diff --git a/libcore/swf/StreamSoundBlockTag.h
b/libcore/swf/StreamSoundBlockTag.h
index 3f60414..03905db 100644
--- a/libcore/swf/StreamSoundBlockTag.h
+++ b/libcore/swf/StreamSoundBlockTag.h
@@ -19,7 +19,7 @@
#ifndef GNASH_SWF_STREAMSOUNDBLOCK_TAG_H
#define GNASH_SWF_STREAMSOUNDBLOCK_TAG_H
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "ControlTag.h" // for inheritance
#include "SWF.h" // for TagType definition
@@ -66,7 +66,7 @@ private:
/// @param blockId identifier of the stream block to play.
///
/// This should only be constructed using the loader() function.
- StreamSoundBlockTag(boost::uint16_t streamId,
+ StreamSoundBlockTag(std::uint16_t streamId,
sound::sound_handler::StreamBlockId blockId)
:
_handler_id(streamId),
@@ -74,7 +74,7 @@ private:
{}
/// Id of the stream this tag should play
- const boost::uint16_t _handler_id;
+ const std::uint16_t _handler_id;
/// Offset in the stream buffer to play
const sound::sound_handler::StreamBlockId _blockId;
diff --git a/libcore/swf/SymbolClassTag.h b/libcore/swf/SymbolClassTag.h
index 6576998..53b384d 100644
--- a/libcore/swf/SymbolClassTag.h
+++ b/libcore/swf/SymbolClassTag.h
@@ -65,11 +65,11 @@ public:
}
in.ensureBytes(2);
- boost::uint16_t num_symbols = in.read_u16();
+ std::uint16_t num_symbols = in.read_u16();
log_debug("There are %u symbols.", num_symbols);
for (unsigned int i = 0; i < num_symbols; ++i) {
in.ensureBytes(2);
- boost::uint16_t id = in.read_u16();
+ std::uint16_t id = in.read_u16();
std::string name;
in.read_string(name);
IF_VERBOSE_PARSE(
diff --git a/libcore/swf/TextRecord.cpp b/libcore/swf/TextRecord.cpp
index 879c907..cf67b01 100644
--- a/libcore/swf/TextRecord.cpp
+++ b/libcore/swf/TextRecord.cpp
@@ -43,7 +43,7 @@ TextRecord::read(SWFStream& in, movie_definition& m, int
glyphBits,
_glyphs.clear();
in.ensureBytes(1);
- boost::uint8_t flags = in.read_u8();
+ std::uint8_t flags = in.read_u8();
if (!flags)
{
@@ -62,7 +62,7 @@ TextRecord::read(SWFStream& in, movie_definition& m, int
glyphBits,
if (hasFont)
{
in.ensureBytes(2);
- boost::uint16_t fontID = in.read_u16();
+ std::uint16_t fontID = in.read_u16();
_font = m.get_font(fontID);
if (!_font)
@@ -119,7 +119,7 @@ TextRecord::read(SWFStream& in, movie_definition& m, int
glyphBits,
}
in.ensureBytes(1);
- boost::uint8_t glyphCount = in.read_u8();
+ std::uint8_t glyphCount = in.read_u8();
if (!glyphCount) return false;
IF_VERBOSE_PARSE(
@@ -208,7 +208,7 @@ TextRecord::displayRecords(Renderer& renderer, const
Transform& xform,
if (rec.hasYOffset()) y = rec.yOffset();
// Save for the underline, if any
- const boost::int16_t startX = x;
+ const std::int16_t startX = x;
rgba textColor = cx.transform(rec.color());
@@ -276,13 +276,13 @@ TextRecord::displayRecords(Renderer& renderer, const
Transform& xform,
// This will only be known if a glyph was actually found,
// or would be the size of the empty box (arbitrary size)
//
- boost::int16_t endX = static_cast<boost::int16_t>(x);
+ std::int16_t endX = static_cast<std::int16_t>(x);
// The underline is made to be some pixels below the baseline (0)
// and scaled so it's further as font size increases.
//
// 1/4 the EM square offset far from baseline
- boost::int16_t posY = int(y+int((unitsPerEM/4)*scale));
+ std::int16_t posY = int(y+int((unitsPerEM/4)*scale));
const std::vector<point> underline = boost::assign::list_of
(point(startX, posY))
diff --git a/libcore/swf/TextRecord.h b/libcore/swf/TextRecord.h
index c2c7a67..50d2bfb 100644
--- a/libcore/swf/TextRecord.h
+++ b/libcore/swf/TextRecord.h
@@ -134,7 +134,7 @@ public:
return _font.get();
}
- void setTextHeight(boost::uint16_t height) {
+ void setTextHeight(std::uint16_t height) {
_textHeight = height;
}
@@ -147,7 +147,7 @@ public:
return width;
}
- boost::uint16_t textHeight() const {
+ std::uint16_t textHeight() const {
return _textHeight;
}
@@ -201,7 +201,7 @@ private:
rgba _color;
/// The height of the text in TWIPS.
- boost::uint16_t _textHeight;
+ std::uint16_t _textHeight;
/// Whether the TextRecord has an x offset.
bool _hasXOffset;
diff --git a/libcore/swf/VideoFrameTag.cpp b/libcore/swf/VideoFrameTag.cpp
index ba94a61..b975fe5 100644
--- a/libcore/swf/VideoFrameTag.cpp
+++ b/libcore/swf/VideoFrameTag.cpp
@@ -38,7 +38,7 @@ VideoFrameTag::loader(SWFStream& in, SWF::TagType tag,
movie_definition& m,
assert(tag == SWF::VIDEOFRAME);
in.ensureBytes(2);
- boost::uint16_t id = in.read_u16();
+ std::uint16_t id = in.read_u16();
DefinitionTag* chdef = m.getDefinitionTag(id);
if (!chdef)
@@ -80,7 +80,7 @@ VideoFrameTag::loader(SWFStream& in, SWF::TagType tag,
movie_definition& m,
const unsigned int dataLength = in.get_tag_end_position() - in.tell();
// FIXME: catch bad_alloc
- boost::uint8_t* buffer = new boost::uint8_t[dataLength + padding];
+ std::uint8_t* buffer = new std::uint8_t[dataLength + padding];
const size_t bytesRead = in.read(reinterpret_cast<char*>(buffer),
dataLength);
diff --git a/libcore/swf/tag_loaders.cpp b/libcore/swf/tag_loaders.cpp
index 469d64e..0979d31 100644
--- a/libcore/swf/tag_loaders.cpp
+++ b/libcore/swf/tag_loaders.cpp
@@ -48,7 +48,7 @@ namespace SWF {
// Anonymous namespace
namespace {
-const boost::uint32_t samplerates[] = { 5512, 11025, 22050, 44100 };
+const std::uint32_t samplerates[] = { 5512, 11025, 22050, 44100 };
}
@@ -101,7 +101,7 @@ sprite_loader(SWFStream& in, TagType tag, movie_definition&
m,
assert(tag == SWF::DEFINESPRITE); // 39 - DefineSprite
in.ensureBytes(2);
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
IF_VERBOSE_PARSE(
log_parse(_(" sprite: char id = %d"), id);
@@ -156,13 +156,13 @@ define_sound_loader(SWFStream& in, TagType tag,
movie_definition& m,
in.ensureBytes(2+4+1+4); // DisplayObject id + flags + sample count
- const boost::uint16_t id = in.read_u16();
+ const std::uint16_t id = in.read_u16();
#ifdef USE_SOUND
media::audioCodecType format = static_cast<media::audioCodecType>(
in.read_uint(4));
- boost::uint8_t sample_rate_in = in.read_uint(2);
+ std::uint8_t sample_rate_in = in.read_uint(2);
if (sample_rate_in >= arraySize(samplerates)) {
IF_VERBOSE_MALFORMED_SWF(
@@ -171,14 +171,14 @@ define_sound_loader(SWFStream& in, TagType tag,
movie_definition& m,
);
sample_rate_in = 0;
}
- const boost::uint32_t sample_rate = samplerates[sample_rate_in];
+ const std::uint32_t sample_rate = samplerates[sample_rate_in];
const bool sample_16bit = in.read_bit();
const bool stereo = in.read_bit();
- const boost::uint32_t sample_count = in.read_u32();
+ const std::uint32_t sample_count = in.read_u32();
- boost::int16_t delaySeek = 0;
+ std::int16_t delaySeek = 0;
if (format == media::AUDIO_CODEC_MP3) {
in.ensureBytes(2);
@@ -346,21 +346,21 @@ serialnumber_loader(SWFStream& in, TagType tag,
movie_definition& /*m*/,
in.ensureBytes(26);
- const boost::uint32_t id = in.read_u32();
- const boost::uint32_t edition = in.read_u32();
- const boost::uint8_t major = in.read_u8();
- const boost::uint8_t minor = in.read_u8();
+ const std::uint32_t id = in.read_u32();
+ const std::uint32_t edition = in.read_u32();
+ const std::uint8_t major = in.read_u8();
+ const std::uint8_t minor = in.read_u8();
- const boost::uint32_t buildL = in.read_u32();
- const boost::uint32_t buildH = in.read_u32();
- const boost::uint64_t build =
- (static_cast<boost::uint64_t>(buildH) << 32) + buildL;
+ const std::uint32_t buildL = in.read_u32();
+ const std::uint32_t buildH = in.read_u32();
+ const std::uint64_t build =
+ (static_cast<std::uint64_t>(buildH) << 32) + buildL;
- const boost::uint32_t timestampL = in.read_u32();
- const boost::uint32_t timestampH = in.read_u32();
+ const std::uint32_t timestampL = in.read_u32();
+ const std::uint32_t timestampH = in.read_u32();
// This timestamp is number of milliseconds since 1 Jan 1970 (epoch)
- boost::uint64_t timestamp =
- (static_cast<boost::uint64_t>(timestampH) << 32) + timestampL;
+ std::uint64_t timestamp =
+ (static_cast<std::uint64_t>(timestampH) << 32) + timestampL;
std::stringstream ss;
ss << "SERIALNUMBER: Version " << id << "." << edition
@@ -380,9 +380,9 @@ reflex_loader(SWFStream& in, TagType tag, movie_definition&
/*m*/,
assert(tag == SWF::REFLEX); // 777
in.ensureBytes(3);
- const boost::uint8_t first = in.read_u8();
- const boost::uint8_t second = in.read_u8();
- const boost::uint8_t third = in.read_u8();
+ const std::uint8_t first = in.read_u8();
+ const std::uint8_t second = in.read_u8();
+ const std::uint8_t third = in.read_u8();
IF_VERBOSE_PARSE(
log_parse(_(" reflex = \"%c%c%c\""), first, second, third);
diff --git a/libcore/vm/ASHandlers.cpp b/libcore/vm/ASHandlers.cpp
index b06a29a..e62b086 100644
--- a/libcore/vm/ASHandlers.cpp
+++ b/libcore/vm/ASHandlers.cpp
@@ -84,7 +84,7 @@ namespace {
/// @param target the target window or _level1 to _level10
/// @param method 0:NONE, 1:GET, 2:POST
void commonGetURL(as_environment& env, as_value target,
- const std::string& url, boost::uint8_t method);
+ const std::string& url, std::uint8_t method);
/// Common code for SetTarget and SetTargetExpression
///
@@ -621,7 +621,7 @@ ActionWaitForFrame(ActionExec& thread)
// skip the specified number of actions.
//
unsigned int framenum = code.read_int16(thread.getCurrentPC()+3);
- boost::uint8_t skip = code[thread.getCurrentPC()+5];
+ std::uint8_t skip = code[thread.getCurrentPC()+5];
DisplayObject* target = env.target();
MovieClip* target_sprite = target ? target->to_movie() : 0;
@@ -1102,7 +1102,7 @@ ActionDuplicateClip(ActionExec& thread)
DisplayObject::staticDepthOffset;
// This also checks for overflow, as both numbers are expressible as
- // boost::int32_t.
+ // std::int32_t.
if (depth < DisplayObject::lowerAccessibleBound ||
depth > DisplayObject::upperAccessibleBound) {
@@ -1114,7 +1114,7 @@ ActionDuplicateClip(ActionExec& thread)
return;
}
- boost::int32_t depthValue = static_cast<boost::int32_t>(depth);
+ std::int32_t depthValue = static_cast<std::int32_t>(depth);
const std::string& newname = env.top(1).to_string();
const std::string& path = env.top(2).to_string();
@@ -1214,10 +1214,10 @@ ActionStartDragMovie(ActionExec& thread)
// it should actually convert to false!
if (toNumber(env.top(2), getVM(env))) {
- boost::int32_t y1 = pixelsToTwips(toNumber(env.top(3), getVM(env)));
- boost::int32_t x1 = pixelsToTwips(toNumber(env.top(4), getVM(env)));
- boost::int32_t y0 = pixelsToTwips(toNumber(env.top(5), getVM(env)));
- boost::int32_t x0 = pixelsToTwips(toNumber(env.top(6), getVM(env)));
+ std::int32_t y1 = pixelsToTwips(toNumber(env.top(3), getVM(env)));
+ std::int32_t x1 = pixelsToTwips(toNumber(env.top(4), getVM(env)));
+ std::int32_t y0 = pixelsToTwips(toNumber(env.top(5), getVM(env)));
+ std::int32_t x0 = pixelsToTwips(toNumber(env.top(6), getVM(env)));
// check for swapped values
if (y1 < y0) {
@@ -1504,7 +1504,7 @@ ActionChr(ActionExec& thread)
as_environment& env = thread.env;
// This is UB:
- const boost::uint16_t c = toInt(env.top(0), getVM(env));
+ const std::uint16_t c = toInt(env.top(0), getVM(env));
// If the argument to chr() is '0', we return
// nothing, not NULL
@@ -1628,7 +1628,7 @@ ActionMbOrd(ActionExec& thread)
std::string::const_iterator it = s.begin(), e = s.end();
- boost::uint32_t out = utf8::decodeNextUnicodeCharacter(it, e);
+ std::uint32_t out = utf8::decodeNextUnicodeCharacter(it, e);
/// Always valid, or can it be undefined?
env.top(0).set_double(out);
@@ -1650,7 +1650,7 @@ ActionMbChr(ActionExec& thread)
}
// This is UB
- const boost::uint16_t i = toInt(env.top(0), getVM(env));
+ const std::uint16_t i = toInt(env.top(0), getVM(env));
std::string out = utf8::encodeUnicodeCharacter(i);
@@ -1683,7 +1683,7 @@ ActionWaitForFrameExpression(ActionExec& thread)
const action_buffer& code = thread.code;
// how many actions to skip if frame has not been loaded
- const boost::uint8_t skip = code[thread.getCurrentPC() + 3];
+ const std::uint8_t skip = code[thread.getCurrentPC() + 3];
// env.top(0) contains frame specification,
// evaluated as for ActionGotoExpression
@@ -1775,14 +1775,14 @@ ActionPushData(ActionExec& thread)
const action_buffer& code = thread.code;
const size_t pc = thread.getCurrentPC();
- const boost::uint16_t length = code.read_uint16(pc + 1);
+ const std::uint16_t length = code.read_uint16(pc + 1);
//---------------
size_t i = pc;
size_t count = 0;
while (i - pc < length) {
- const boost::uint8_t type = code[3 + i];
+ const std::uint8_t type = code[3 + i];
++i;
switch (type)
@@ -1859,7 +1859,7 @@ ActionPushData(ActionExec& thread)
case pushInt32: // 7
{
- const boost::int32_t val = code.read_int32(i + 3);
+ const std::int32_t val = code.read_int32(i + 3);
i += 4;
env.push(val);
break;
@@ -1867,7 +1867,7 @@ ActionPushData(ActionExec& thread)
case pushDict8: // 8
{
- const boost::uint8_t id = code[3 + i];
+ const std::uint8_t id = code[3 + i];
++i;
pushConstant(thread, id);
break;
@@ -1875,7 +1875,7 @@ ActionPushData(ActionExec& thread)
case pushDict16: // 9
{
- const boost::uint16_t id = code.read_int16(i + 3);
+ const std::uint16_t id = code.read_int16(i + 3);
i += 2;
pushConstant(thread, id);
break;
@@ -1894,7 +1894,7 @@ ActionPushData(ActionExec& thread)
void
ActionBranchAlways(ActionExec& thread)
{
- boost::int16_t offset = thread.code.read_int16(thread.getCurrentPC()+3);
+ std::int16_t offset = thread.code.read_int16(thread.getCurrentPC()+3);
thread.adjustNextPC(offset);
// @@ TODO range checks
}
@@ -1910,7 +1910,7 @@ ActionGetUrl2(ActionExec& thread)
assert(thread.atActionTag(SWF::ACTION_GETURL2));
#endif
- const boost::uint8_t method = code[thread.getCurrentPC() + 3];
+ const std::uint8_t method = code[thread.getCurrentPC() + 3];
as_value url_val = env.top(1);
if (url_val.is_undefined()) {
@@ -1937,7 +1937,7 @@ ActionBranchIfTrue(ActionExec& thread)
assert(thread.atActionTag(SWF::ACTION_BRANCHIFTRUE));
#endif
- boost::int16_t offset = code.read_int16(pc+3);
+ std::int16_t offset = code.read_int16(pc+3);
const bool test = toBool(env.pop(), getVM(env));
if (test) {
@@ -2994,13 +2994,13 @@ ActionBitwiseXor(ActionExec& thread)
env.drop(1);
}
-inline boost::uint32_t
-saneShiftParam(boost::int32_t value)
+inline std::uint32_t
+saneShiftParam(std::int32_t value)
{
// NOTE: ISO-IEC 14882:2003 5.8.1: "The behavior is undefined if the right
// operand is negative, or greater than or equal to the length in bits of
// the promoted left operand."
- boost::uint32_t rv = value;
+ std::uint32_t rv = value;
return rv % 32;
}
@@ -3009,8 +3009,8 @@ ActionShiftLeft(ActionExec& thread)
{
as_environment& env = thread.env;
- boost::uint32_t amount = saneShiftParam(toInt(env.top(0), getVM(env)));
- boost::int32_t value = toInt(env.top(1), getVM(env));
+ std::uint32_t amount = saneShiftParam(toInt(env.top(0), getVM(env)));
+ std::int32_t value = toInt(env.top(1), getVM(env));
value = value << amount;
@@ -3023,8 +3023,8 @@ ActionShiftRight(ActionExec& thread)
{
as_environment& env = thread.env;
- boost::uint32_t amount = saneShiftParam(toInt(env.top(0), getVM(env)));
- boost::int32_t value = toInt(env.top(1), getVM(env));
+ std::uint32_t amount = saneShiftParam(toInt(env.top(0), getVM(env)));
+ std::int32_t value = toInt(env.top(1), getVM(env));
value = value >> amount;
@@ -3037,10 +3037,10 @@ ActionShiftRight2(ActionExec& thread)
{
as_environment& env = thread.env;
- boost::uint32_t amount = saneShiftParam(toInt(env.top(0), getVM(env)));
- boost::int32_t value = toInt(env.top(1), getVM(env));
+ std::uint32_t amount = saneShiftParam(toInt(env.top(0), getVM(env)));
+ std::int32_t value = toInt(env.top(1), getVM(env));
- value = static_cast<boost::uint32_t>(value) >> amount;
+ value = static_cast<std::uint32_t>(value) >> amount;
env.top(1) = value;
env.drop(1);
@@ -3157,24 +3157,24 @@ ActionDefineFunction2(ActionExec& thread)
i += name.length() + 1; // add NULL-termination
// Get number of arguments.
- const boost::uint16_t nargs = code.read_uint16(i);
+ const std::uint16_t nargs = code.read_uint16(i);
i += 2;
// Get the count of local registers used by this function.
- const boost::uint8_t register_count = code[i];
+ const std::uint8_t register_count = code[i];
++i;
func->setRegisterCount(register_count);
// Flags, for controlling register assignment of implicit args.
- const boost::uint16_t flags = code.read_uint16(i);
+ const std::uint16_t flags = code.read_uint16(i);
i += 2;
func->setFlags(flags);
// Get the register assignments and names of the arguments.
for (size_t n = 0; n < nargs; ++n) {
- boost::uint8_t arg_register = code[i];
+ std::uint8_t arg_register = code[i];
++i;
// @@ security: watch out for possible missing terminator here!
@@ -3185,7 +3185,7 @@ ActionDefineFunction2(ActionExec& thread)
}
// Get the length of the actual function code.
- boost::uint16_t code_size = code.read_int16(i);
+ std::uint16_t code_size = code.read_int16(i);
// Check code_size value consistency
const size_t actionbuf_size = thread.code.size();
@@ -3241,20 +3241,20 @@ ActionTry(ActionExec& thread)
size_t i = thread.getCurrentPC() + 3; // skip tag id and length
- boost::uint8_t flags = code[i];
+ std::uint8_t flags = code[i];
++i;
bool doCatch = flags & 1;
bool doFinally = flags & (1<<1);
bool catchInRegister = flags&(1<<2);
- boost::uint8_t reserved = flags&0xE0;
+ std::uint8_t reserved = flags&0xE0;
- boost::uint16_t trySize = code.read_uint16(i); i += 2;
- boost::uint16_t catchSize = code.read_uint16(i); i += 2;
- boost::uint16_t finallySize = code.read_uint16(i); i += 2;
+ std::uint16_t trySize = code.read_uint16(i); i += 2;
+ std::uint16_t catchSize = code.read_uint16(i); i += 2;
+ std::uint16_t finallySize = code.read_uint16(i); i += 2;
const char* catchName = NULL;
- boost::uint8_t catchRegister = 0;
+ std::uint8_t catchRegister = 0;
if (!doFinally) finallySize = 0;
if (!doCatch) catchSize = 0;
@@ -3351,7 +3351,7 @@ ActionDefineFunction(ActionExec& thread)
#ifndef NDEBUG
// TODO: check effects of the following 'length'
- boost::int16_t length = code.read_int16(thread.getCurrentPC()+1);
+ std::int16_t length = code.read_int16(thread.getCurrentPC()+1);
assert( length >= 0 );
#endif
@@ -3396,7 +3396,7 @@ ActionDefineFunction(ActionExec& thread)
}
// Get the length of the actual function code.
- const boost::uint16_t code_size = code.read_uint16(i);
+ const std::uint16_t code_size = code.read_uint16(i);
func->setLength(code_size);
@@ -3497,7 +3497,7 @@ construct_object(as_function* ctor_as_func,
as_environment& env,
/// @param target the target window, or _level1..10
void
commonGetURL(as_environment& env, as_value target,
- const std::string& url, boost::uint8_t method)
+ const std::string& url, std::uint8_t method)
{
if (url.empty()) {
log_error(_("Bogus empty GetUrl URL in SWF file, skipping"));
diff --git a/libcore/vm/ActionExec.cpp b/libcore/vm/ActionExec.cpp
index 4b2ac0c..e6f4b23 100644
--- a/libcore/vm/ActionExec.cpp
+++ b/libcore/vm/ActionExec.cpp
@@ -216,7 +216,7 @@ ActionExec::operator()()
}
// Get the opcode.
- boost::uint8_t action_id = code[pc];
+ std::uint8_t action_id = code[pc];
IF_VERBOSE_ACTION (
log_action(_("PC:%d - EX: %s"), pc, code.disasm(pc));
@@ -231,7 +231,7 @@ ActionExec::operator()()
else {
// action with extra data
// Note this converts from int to uint!
- boost::uint16_t length(code.read_int16(pc + 1));
+ std::uint16_t length(code.read_int16(pc + 1));
next_pc = pc + length + 3;
if (next_pc > stop_pc) {
@@ -571,7 +571,7 @@ ActionExec::skip_actions(size_t offset)
}
// Get the opcode.
- const boost::uint8_t action_id = code[next_pc];
+ const std::uint8_t action_id = code[next_pc];
// Set default next_pc offset, control flow action handlers
// will be able to reset it.
@@ -581,7 +581,7 @@ ActionExec::skip_actions(size_t offset)
}
else {
// action with extra data
- const boost::int16_t length = code.read_int16(next_pc + 1);
+ const std::int16_t length = code.read_int16(next_pc + 1);
assert(length >= 0);
next_pc += length + 3;
}
@@ -684,7 +684,7 @@ ActionExec::dumpActions(size_t from, size_t to,
std::ostream& os)
size_t lpc = from;
while (lpc < to) {
// Get the opcode.
- const boost::uint8_t action_id = code[lpc];
+ const std::uint8_t action_id = code[lpc];
os << " PC:" << lpc << " - EX: " << code.disasm(lpc) << std::endl;
@@ -696,7 +696,7 @@ ActionExec::dumpActions(size_t from, size_t to,
std::ostream& os)
}
else {
// action with extra data
- const boost::int16_t length = code.read_int16(lpc + 1);
+ const std::int16_t length = code.read_int16(lpc + 1);
assert(length >= 0);
lpc += length + 3;
}
diff --git a/libcore/vm/ActionExec.h b/libcore/vm/ActionExec.h
index 274eea8..7a57f75 100644
--- a/libcore/vm/ActionExec.h
+++ b/libcore/vm/ActionExec.h
@@ -65,7 +65,7 @@ public:
{}
TryBlock(size_t cur_off, size_t try_size, size_t catch_size,
- size_t finally_size, boost::uint8_t register_index)
+ size_t finally_size, std::uint8_t register_index)
:
_catchOffset(cur_off + try_size),
_finallyOffset(cur_off + try_size + catch_size),
diff --git a/libcore/vm/Machine.cpp b/libcore/vm/Machine.cpp
index 1cd2d35..94c9941 100644
--- a/libcore/vm/Machine.cpp
+++ b/libcore/vm/Machine.cpp
@@ -68,7 +68,7 @@ public:
namespace {
inline const std::string&
-pool_string(boost::uint32_t index, AbcBlock *pool)
+pool_string(std::uint32_t index, AbcBlock *pool)
{
if (!pool) throw ASException();
try {
@@ -80,7 +80,7 @@ pool_string(boost::uint32_t index, AbcBlock *pool)
}
inline int
-pool_int(boost::uint32_t index, AbcBlock *pool)
+pool_int(std::uint32_t index, AbcBlock *pool)
{
if (!pool) throw ASException();
try {
@@ -92,7 +92,7 @@ pool_int(boost::uint32_t index, AbcBlock *pool)
}
inline unsigned int
-pool_uint(boost::uint32_t index, AbcBlock *pool)
+pool_uint(std::uint32_t index, AbcBlock *pool)
{
if (!pool) throw ASException();
try {
@@ -104,7 +104,7 @@ pool_uint(boost::uint32_t index, AbcBlock *pool)
}
inline double
-pool_double(boost::uint32_t index, AbcBlock *pool)
+pool_double(std::uint32_t index, AbcBlock *pool)
{
if (!pool) throw ASException();
try {
@@ -116,7 +116,7 @@ pool_double(boost::uint32_t index, AbcBlock *pool)
}
inline Namespace*
-pool_namespace(boost::uint32_t index, AbcBlock *pool)
+pool_namespace(std::uint32_t index, AbcBlock *pool)
{
if (!pool) throw ASException();
try {
@@ -129,7 +129,7 @@ pool_namespace(boost::uint32_t index, AbcBlock *pool)
}
inline Method*
-pool_method(boost::uint32_t index, AbcBlock* pool)
+pool_method(std::uint32_t index, AbcBlock* pool)
{
if (!pool) throw ASException();
try {
@@ -141,7 +141,7 @@ pool_method(boost::uint32_t index, AbcBlock* pool)
}
inline Class*
-pool_script(boost::uint32_t index, AbcBlock* pool)
+pool_script(std::uint32_t index, AbcBlock* pool)
{
if (!pool) throw ASException();
try {
@@ -154,7 +154,7 @@ pool_script(boost::uint32_t index, AbcBlock* pool)
// Don't make this a reference or you'll taint the pool.
inline MultiName
-pool_name(boost::uint32_t index, AbcBlock* pool)
+pool_name(std::uint32_t index, AbcBlock* pool)
{
if (!pool) throw ASException();
try {
@@ -291,7 +291,7 @@ inline bool abstractEquality(const as_value& a, const
as_value& b,
#define JUMPIF(jtruth)
\
{
\
- boost::int32_t jumpOffset = mStream->read_S24();
\
+ std::int32_t jumpOffset = mStream->read_S24();
\
if (jtruth)
\
mStream->seekBy(jumpOffset);
\
break;
\
@@ -506,7 +506,7 @@ Machine::execute()
/// this the default XML namespace.
case SWF::ABC_ACTION_DXNS:
{
- boost::uint32_t soffset = mStream->read_V32();
+ std::uint32_t soffset = mStream->read_V32();
const std::string& uri = pool_string(soffset, mPoolObject);
ClassHierarchy& ch = _global->classHierarchy();
@@ -539,7 +539,7 @@ Machine::execute()
/// Equivalent: ACTION_DELETE
case SWF::ABC_ACTION_KILL:
{
- boost::uint32_t regNum = mStream->read_V32();
+ std::uint32_t regNum = mStream->read_V32();
setRegister(regNum, as_value());
break;
}
@@ -632,7 +632,7 @@ Machine::execute()
/// Equivalent: ACTION_BRANCHALWAYS
case SWF::ABC_ACTION_JUMP:
{
- const boost::int32_t bytes = mStream->read_S24();
+ const std::int32_t bytes = mStream->read_S24();
log_abc("ABC_ACTION_JUMP: Jumping %d bytes.",bytes);
mStream->seekBy(bytes);
break;
@@ -649,7 +649,7 @@ Machine::execute()
/// Equivalent: ACTION_BRANCHIFTRUE
case SWF::ABC_ACTION_IFTRUE:
{
- const boost::int32_t bytes = mStream->read_S24();
+ const std::int32_t bytes = mStream->read_S24();
if (pop_stack().to_bool()) {
log_abc("ABC_ACTION_IFTRUE: Jumping %d bytes.",bytes);
mStream->seekBy(bytes);
@@ -671,7 +671,7 @@ Machine::execute()
/// ABC_ACTION_JUMP does.
case SWF::ABC_ACTION_IFFALSE:
{
- const boost::int32_t bytes = mStream->read_S24();
+ const std::int32_t bytes = mStream->read_S24();
const bool truth = pop_stack().to_bool();
if (!truth) {
log_abc("ABC_ACTION_IFFALSE: Jumping %d bytes.",
bytes);
@@ -691,7 +691,7 @@ Machine::execute()
/// ABC_ACTION_JUMP does.
case SWF::ABC_ACTION_IFEQ:
{
- const boost::int32_t bytes = mStream->read_S24();
+ const std::int32_t bytes = mStream->read_S24();
const as_value b = pop_stack();
const as_value a = pop_stack();
if (a.equals(b)) {
@@ -717,7 +717,7 @@ Machine::execute()
{
as_value a = pop_stack();
as_value b = pop_stack();
- const boost::int32_t bytes = mStream->read_S24();
+ const std::int32_t bytes = mStream->read_S24();
if (!a.equals(b)) {
log_abc("Jumping... %d bytes.", bytes);
mStream->seekBy(bytes);
@@ -741,7 +741,7 @@ Machine::execute()
{
as_value b = pop_stack();
as_value a = pop_stack();
- const boost::int32_t bytes = mStream->read_S24();
+ const std::int32_t bytes = mStream->read_S24();
const bool jump = newLessThan(a, b, _vm).to_bool();
if (jump) {
log_abc("Jumping... %d bytes.", bytes);
@@ -781,7 +781,7 @@ Machine::execute()
/// Do: If a > b move by jump in stream, as ABC_ACTION_JUMP
does.
case SWF::ABC_ACTION_IFGT:
{
- boost::int32_t bytes = mStream->read_S24();
+ std::int32_t bytes = mStream->read_S24();
bool truth;
// If b < a, then a > b, with undefined as false
ABSTRACT_COMPARE(truth, _stack.top(0), _stack.top(1),
false);
@@ -865,12 +865,12 @@ Machine::execute()
std::size_t npos = mStream->tellg();
if (!_stack.top(0).is_number()) throw ASException();
- boost::uint32_t index =
+ std::uint32_t index =
toNumber(_stack.top(0), getVM(fn));
_stack.drop(1);
mStream->seekBy(3); // Skip the intial offset.
- boost::uint32_t cases = mStream->read_V32();
+ std::uint32_t cases = mStream->read_V32();
// Read from our original position and use it to skip
// if the case is out of range.
if (index > cases) {
@@ -879,7 +879,7 @@ Machine::execute()
}
else {
mStream->seekTo(npos + 3 * (index + 1));
- boost::uint32_t newpos = mStream->read_S24();
+ std::uint32_t newpos = mStream->read_S24();
mStream->seekTo(npos - 1 + newpos);
}
break;
@@ -954,7 +954,7 @@ Machine::execute()
ENSURE_NUMBER(_stack.top(0));
ENSURE_OBJECT(_stack.top(1));
as_object *obj = _stack.top(1).to_object(*_global);
- const boost::uint32_t index =
+ const std::uint32_t index =
toNumber(_stack.top(0), getVM(fn));
if (!obj) {
@@ -986,7 +986,7 @@ Machine::execute()
ENSURE_NUMBER(_stack.top(0));
ENSURE_OBJECT(_stack.top(1));
as_object *obj = _stack.top(1).to_object(*_global);
- boost::uint32_t index =
+ std::uint32_t index =
toNumber(_stack.top(0), getVM(fn));
_stack.drop(1);
assert(obj);
@@ -1026,7 +1026,7 @@ Machine::execute()
ENSURE_NUMBER(_stack.top(0));
ENSURE_OBJECT(_stack.top(1));
as_object *obj = _stack.top(1).to_object(*_global);
- const boost::uint32_t index =
+ const std::uint32_t index =
toNumber(_stack.top(0), getVM(fn));
const Property *b = obj->getByIndex(index);
_stack.drop(1);
@@ -1044,7 +1044,7 @@ Machine::execute()
/// byte -- as a raw byte
case SWF::ABC_ACTION_PUSHBYTE:
{
- const boost::int8_t b = mStream->read_s8();
+ const std::int8_t b = mStream->read_s8();
push_stack(b);
break;
}
@@ -1055,8 +1055,8 @@ Machine::execute()
/// value -- as a raw integer
case SWF::ABC_ACTION_PUSHSHORT:
{
- const boost::int16_t s =
- static_cast<boost::int16_t>(mStream->read_V32());
+ const std::int16_t s =
+ static_cast<std::int16_t>(mStream->read_V32());
push_stack(s);
break;
}
@@ -1190,8 +1190,8 @@ Machine::execute()
/// first logical property.
case SWF::ABC_ACTION_HASNEXT2:
{
- const boost::int32_t oindex = mStream->read_V32();
- const boost::int32_t iindex = mStream->read_V32();
+ const std::int32_t oindex = mStream->read_V32();
+ const std::int32_t iindex = mStream->read_V32();
const as_value& objv = getRegister(oindex);
const as_value& indexv = getRegister(iindex);
@@ -1209,7 +1209,7 @@ Machine::execute()
break;
}
- boost::uint32_t index = toInt(indexv);
+ std::uint32_t index = toInt(indexv);
as_object *owner = 0;
int next = obj->nextIndex(index, &owner);
@@ -1243,7 +1243,7 @@ Machine::execute()
/// the function from this information and bind the current
scope.
case SWF::ABC_ACTION_NEWFUNCTION:
{
- boost::int32_t method_index = mStream->read_V32();
+ std::int32_t method_index = mStream->read_V32();
log_abc("Creating new abc_function: method
index=%u",method_index);
Method *m = pool_method(method_index, mPoolObject);
abc_function* new_function = m->getPrototype();
@@ -1262,7 +1262,7 @@ Machine::execute()
/// value -- the value returned by obj->func(arg1, ...., argN)
case SWF::ABC_ACTION_CALL:
{
- boost::uint32_t argc = mStream->read_V32();
+ std::uint32_t argc = mStream->read_V32();
ENSURE_OBJECT(_stack.top(argc + 1)); // The func
ENSURE_OBJECT(_stack.top(argc)); // The 'this'
as_function *f = _stack.top(argc + 1).to_function();
@@ -1289,7 +1289,7 @@ Machine::execute()
/// obj(arg1, ..., argN)
case SWF::ABC_ACTION_CONSTRUCT:
{
- boost::uint32_t argc = mStream->read_V32();
+ std::uint32_t argc = mStream->read_V32();
as_function *f = _stack.top(argc).to_function();
if (!f) {
log_abc("CONSTRUCT: No function on stack!");
@@ -1310,8 +1310,8 @@ Machine::execute()
/// ..., argN)
case SWF::ABC_ACTION_CALLMETHOD:
{
- boost::uint32_t dispatch_id = mStream->read_V32() - 1;
- boost::uint32_t argc = mStream->read_V32();
+ std::uint32_t dispatch_id = mStream->read_V32() - 1;
+ std::uint32_t argc = mStream->read_V32();
ENSURE_OBJECT(_stack.top(argc));
as_object *obj = _stack.top(argc).to_object(*_global);
const Property *f = obj->getByIndex(dispatch_id);
@@ -1346,7 +1346,7 @@ Machine::execute()
case SWF::ABC_ACTION_CALLSTATIC:
{
Method *m = pool_method(mStream->read_V32(), mPoolObject);
- boost::uint32_t argc = mStream->read_V32();
+ std::uint32_t argc = mStream->read_V32();
as_function *func = m->getPrototype();
ENSURE_OBJECT(_stack.top(argc));
as_object *obj = _stack.top(argc).to_object(*_global);
@@ -1368,7 +1368,7 @@ Machine::execute()
case SWF::ABC_ACTION_CALLSUPERVOID:
{
MultiName a = pool_name(mStream->read_V32(), mPoolObject);
- boost::uint32_t argc = mStream->read_V32();
+ std::uint32_t argc = mStream->read_V32();
int dropsize = completeName(a);
ENSURE_OBJECT(_stack.top(argc + dropsize));
_stack.drop(dropsize);
@@ -1419,7 +1419,7 @@ Machine::execute()
{
as_value result;
MultiName a = pool_name(mStream->read_V32(), mPoolObject);
- boost::uint32_t argc = mStream->read_V32();
+ std::uint32_t argc = mStream->read_V32();
fn_call::Args args;
get_args(argc, args);
@@ -1537,7 +1537,7 @@ Machine::execute()
/// .
case SWF::ABC_ACTION_CONSTRUCTSUPER:
{
- boost::uint32_t argc = mStream->read_V32();
+ std::uint32_t argc = mStream->read_V32();
fn_call::Args args;
get_args(argc, args);
@@ -1575,7 +1575,7 @@ Machine::execute()
as_environment env = as_environment(_vm);
MultiName a = pool_name(mStream->read_V32(), mPoolObject);
- boost::uint32_t argc = mStream->read_V32();
+ std::uint32_t argc = mStream->read_V32();
fn_call::Args args;
get_args(argc, args);
@@ -1652,7 +1652,7 @@ Machine::execute()
case SWF::ABC_ACTION_NEWOBJECT:
{
as_object *obj = _global->createObject();
- boost::uint32_t argc = mStream->read_V32();
+ std::uint32_t argc = mStream->read_V32();
int i = argc;
while (i--)
{
@@ -1675,8 +1675,8 @@ Machine::execute()
/// array -- an array { value_1, value_2, ..., value_n }
case SWF::ABC_ACTION_NEWARRAY:
{
- boost::uint32_t asize = mStream->read_V32();
- boost::uint32_t i = asize;
+ std::uint32_t asize = mStream->read_V32();
+ std::uint32_t i = asize;
as_object* arr = _global->createArray();
while (i--) {
@@ -1718,7 +1718,7 @@ Machine::execute()
/// lifetime(?))
case SWF::ABC_ACTION_NEWCLASS:
{
- boost::uint32_t cid = mStream->read_V32();
+ std::uint32_t cid = mStream->read_V32();
log_abc("Class index: %s", cid);
Class* c = pool_script(cid, mPoolObject);
log_abc("Creating new class id=%u name=%s", c->getName(),
@@ -1911,7 +1911,7 @@ Machine::execute()
/// value
case SWF::ABC_ACTION_GETLOCAL:
{
- boost::uint32_t index = mStream->read_V32();
+ std::uint32_t index = mStream->read_V32();
push_stack(getRegister(index));
break;
}
@@ -1925,7 +1925,7 @@ Machine::execute()
/// .
case SWF::ABC_ACTION_SETLOCAL:
{
- boost::uint32_t index = mStream->read_V32();
+ std::uint32_t index = mStream->read_V32();
log_abc("Register index: %u",index);
setRegister(index, pop_stack());
break;
@@ -1946,7 +1946,7 @@ Machine::execute()
/// scope -- The scope object at depth
case SWF::ABC_ACTION_GETSCOPEOBJECT:
{
- boost::uint8_t depth = mStream->read_u8();
+ std::uint8_t depth = mStream->read_u8();
push_stack(get_scope_stack(depth));
print_scope_stack();
break;
@@ -2020,7 +2020,7 @@ Machine::execute()
/// from the context.
case SWF::ABC_ACTION_INITPROPERTY:
{
- boost::uint32_t index = mStream->read_V32();
+ std::uint32_t index = mStream->read_V32();
MultiName a = pool_name(index, mPoolObject);
as_value v = pop_stack();
// TODO: If multiname is a runtime mutiname we need to also
@@ -2079,7 +2079,7 @@ Machine::execute()
case SWF::ABC_ACTION_GETSLOT:
{
as_value val;
- boost::uint32_t sindex = mStream->read_V32();
+ std::uint32_t sindex = mStream->read_V32();
as_object* object = pop_stack().to_object(*_global);
if (!object) {
log_abc("GETSLOT: Did not find expected object on "
@@ -2109,7 +2109,7 @@ Machine::execute()
/// equal to the number of slots (so one-based index?).
case SWF::ABC_ACTION_SETSLOT:
{
- boost::uint32_t sindex = mStream->read_V32();
+ std::uint32_t sindex = mStream->read_V32();
as_value value = pop_stack();
as_value object = pop_stack();
log_abc("SETSLOT object: %s, value: %s, index: %s",
@@ -2151,7 +2151,7 @@ Machine::execute()
/// NB: Deprecated
case SWF::ABC_ACTION_GETGLOBALSLOT:
{
- boost::uint32_t sindex = mStream->read_V32();
+ std::uint32_t sindex = mStream->read_V32();
if (!sindex)
throw ASException();
--sindex;
@@ -2170,7 +2170,7 @@ Machine::execute()
/// NB: Deprecated
case SWF::ABC_ACTION_SETGLOBALSLOT:
{
- boost::uint32_t sindex = mStream->read_V32();
+ std::uint32_t sindex = mStream->read_V32();
if (!sindex)
throw ASException();
--sindex;
@@ -2228,7 +2228,7 @@ Machine::execute()
/// int_value -- value as an unsigned integer object
case SWF::ABC_ACTION_CONVERT_U:
case SWF::ABC_ACTION_COERCE_U:
- _stack.top(0) = static_cast<boost::uint32_t>(
+ _stack.top(0) = static_cast<std::uint32_t>(
toNumber(_stack.top(0), getVM(fn)));
break;
@@ -2412,7 +2412,7 @@ Machine::execute()
/// Frame: Load i from frame_addr and increment it.
case SWF::ABC_ACTION_INCLOCAL:
{
- boost::uint32_t foff = mStream->read_V32();
+ std::uint32_t foff = mStream->read_V32();
setRegister(foff, toNumber(getRegister(foff), getVM(fn)) +
1);
break;
}
@@ -2433,7 +2433,7 @@ Machine::execute()
/// Frame: Load i from frame_addr and decrement it.
case SWF::ABC_ACTION_DECLOCAL:
{
- const boost::uint32_t foff = mStream->read_V32();
+ const std::uint32_t foff = mStream->read_V32();
setRegister(foff, toNumber(getRegister(foff), getVM(fn)) -
1);
break;
}
@@ -2561,7 +2561,7 @@ Machine::execute()
case SWF::ABC_ACTION_URSHIFT:
{
_stack.top(1) =
- static_cast<boost::uint32_t>(toNumber(_stack.top(1),
getVM(fn)))
+ static_cast<std::uint32_t>(toNumber(_stack.top(1),
getVM(fn)))
>> toInt(_stack.top(0));
_stack.drop(1);
break;
@@ -2784,7 +2784,7 @@ Machine::execute()
/// not double
case SWF::ABC_ACTION_INCLOCAL_I:
{
- const boost::uint32_t foff = mStream->read_V32();
+ const std::uint32_t foff = mStream->read_V32();
setRegister(foff, toInt(getRegister(foff)) + 1);
break;
}
@@ -2794,7 +2794,7 @@ Machine::execute()
/// not double
case SWF::ABC_ACTION_DECLOCAL_I:
{
- const boost::uint32_t foff = mStream->read_V32();
+ const std::uint32_t foff = mStream->read_V32();
setRegister(foff, toInt(getRegister(foff)) - 1);
break;
}
@@ -3350,7 +3350,7 @@ Machine::get_args(size_t argc, fn_call::Args& args)
}
void
-Machine::clearRegisters(boost::uint32_t maxRegisters)
+Machine::clearRegisters(std::uint32_t maxRegisters)
{
_registers.clear();
_registers.resize(maxRegisters);
diff --git a/libcore/vm/Machine.h b/libcore/vm/Machine.h
index ce6c891..0cd9893 100644
--- a/libcore/vm/Machine.h
+++ b/libcore/vm/Machine.h
@@ -300,11 +300,11 @@ private:
void get_args(size_t argc, FunctionArgs<as_value>& args);
- void load_function(CodeStream* stream, boost::uint32_t maxRegisters);
+ void load_function(CodeStream* stream, std::uint32_t maxRegisters);
void executeCodeblock(CodeStream* stream);
- void clearRegisters(boost::uint32_t maxRegsiters);
+ void clearRegisters(std::uint32_t maxRegsiters);
const as_value& getRegister(int index){
log_abc("Getting value at a register %d ", index);
@@ -340,7 +340,7 @@ private:
return _scopeStack.pop();
}
- as_object* get_scope_stack(boost::uint8_t depth) const {
+ as_object* get_scope_stack(std::uint8_t depth) const {
log_abc("Getting value from scope stack %u from the bottom.",
depth | 0x0);
return _scopeStack.value(depth);
diff --git a/libcore/vm/VM.cpp b/libcore/vm/VM.cpp
index 4214097..b25e4c8 100644
--- a/libcore/vm/VM.cpp
+++ b/libcore/vm/VM.cpp
@@ -241,7 +241,7 @@ VM::pushCallFrame(UserFunction& func)
// TODO: override from gnashrc.
// A stack size of 0 is apparently legitimate.
- const boost::uint16_t recursionLimit = getRoot().getRecursionLimit();
+ const std::uint16_t recursionLimit = getRoot().getRecursionLimit();
// Don't proceed if local call frames would reach the recursion limit.
if (_callStack.size() + 1 >= recursionLimit) {
@@ -459,7 +459,7 @@ toObject(const as_value& v, VM& vm)
return v.to_object(vm);
}
-boost::int32_t
+std::int32_t
toInt(const as_value& v, const VM& vm)
{
const double d = v.to_number(vm.getSWFVersion());
@@ -468,16 +468,16 @@ toInt(const as_value& v, const VM& vm)
return 0;
}
- typedef std::numeric_limits<boost::int32_t> limit;
+ typedef std::numeric_limits<std::int32_t> limit;
if (d >= limit::min() && d <= limit::max()) {
return d;
}
if (d < 0) {
- return - static_cast<boost::uint32_t>(std::fmod(-d, 4294967296.0));
+ return - static_cast<std::uint32_t>(std::fmod(-d, 4294967296.0));
}
- return static_cast<boost::uint32_t>(std::fmod(d, 4294967296.0));
+ return static_cast<std::uint32_t>(std::fmod(d, 4294967296.0));
}
/// Force type to number.
diff --git a/libcore/vm/VM.h b/libcore/vm/VM.h
index 54a26f7..a1258d2 100644
--- a/libcore/vm/VM.h
+++ b/libcore/vm/VM.h
@@ -27,7 +27,7 @@
#include <map>
#include <memory>
#include <boost/array.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/random/mersenne_twister.hpp> // for mt11213b
#include <boost/noncopyable.hpp>
@@ -425,7 +425,7 @@ as_object* toObject(const as_value& v, VM& vm);
/// @param val The value to return as an int.
/// @param vm The VM to use for the conversion.
/// @return The integer value of the passed as_value.
-boost::int32_t toInt(const as_value& val, const VM& vm);
+std::int32_t toInt(const as_value& val, const VM& vm);
/// Force type to number.
//
diff --git a/libdevice/GnashDevice.h b/libdevice/GnashDevice.h
index 24254e0..3e46198 100644
--- a/libdevice/GnashDevice.h
+++ b/libdevice/GnashDevice.h
@@ -24,7 +24,7 @@
#include "gnashconfig.h"
#endif
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "log.h"
/// @note This file is the base class for all low level rendering and display
@@ -113,10 +113,10 @@ struct GnashDevice
// These are only used for the Framebuffer
/// Get the memory from the real framebuffer
- virtual boost::uint8_t *getFBMemory() { return 0; };
+ virtual std::uint8_t *getFBMemory() { return 0; };
/// Get the memory from an offscreen buffer to support Double Buffering
- virtual boost::uint8_t *getOffscreenBuffer() { return 0; };
+ virtual std::uint8_t *getOffscreenBuffer() { return 0; };
virtual size_t getFBMemSize() { return 0; };
diff --git a/libdevice/events/EventDevice.cpp b/libdevice/events/EventDevice.cpp
index aa2e8c8..9307f9a 100644
--- a/libdevice/events/EventDevice.cpp
+++ b/libdevice/events/EventDevice.cpp
@@ -261,7 +261,7 @@ EventDevice::check()
}
// Try to read something from the device
- std::unique_ptr<boost::uint8_t[]> buf = readData(sizeof( struct
input_event));
+ std::unique_ptr<std::uint8_t[]> buf = readData(sizeof( struct
input_event));
// time,type,code,value
if (!buf) {
return false;
diff --git a/libdevice/events/InputDevice.cpp b/libdevice/events/InputDevice.cpp
index efd9443..0cf2e39 100644
--- a/libdevice/events/InputDevice.cpp
+++ b/libdevice/events/InputDevice.cpp
@@ -108,12 +108,12 @@ InputDevice::addData(bool pressed, key::code key, int
modifier, int x, int y)
}
// Read data into the Device input buffer.
-std::unique_ptr<boost::uint8_t[]>
+std::unique_ptr<std::uint8_t[]>
InputDevice::readData(size_t size)
{
// GNASH_REPORT_FUNCTION;
- std::unique_ptr<boost::uint8_t[]> inbuf;
+ std::unique_ptr<std::uint8_t[]> inbuf;
if (_fd < 0) {
return inbuf; // no mouse available
@@ -137,7 +137,7 @@ InputDevice::readData(size_t size)
return inbuf;
}
- inbuf.reset(new boost::uint8_t[size]);
+ inbuf.reset(new std::uint8_t[size]);
ret = ::read(_fd, inbuf.get(), size);
if (ret > 0) {
// log_debug(_("Read %d bytes, %s"), ret, hexify(inbuf.get(), ret,
false));
diff --git a/libdevice/events/InputDevice.h b/libdevice/events/InputDevice.h
index 1924a6c..ee5d903 100644
--- a/libdevice/events/InputDevice.h
+++ b/libdevice/events/InputDevice.h
@@ -23,7 +23,7 @@
#endif
#include <memory>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <vector>
#include <queue>
#include <linux/input.h>
@@ -127,7 +127,7 @@ public:
void setType(InputDevice::devicetype_e x) { _type = x; };
// Read data into the Device input buffer.
- std::unique_ptr<boost::uint8_t[]> readData(size_t size);
+ std::unique_ptr<std::uint8_t[]> readData(size_t size);
std::shared_ptr<input_data_t> popData()
{
std::shared_ptr<InputDevice::input_data_t> input;
@@ -157,7 +157,7 @@ protected:
int _fd;
input_data_t _input_data;
// These hold the data queue
- std::unique_ptr<boost::uint8_t[]> _buffer;
+ std::unique_ptr<std::uint8_t[]> _buffer;
std::queue<std::shared_ptr<input_data_t> > _data;
int _screen_width;
int _screen_height;
diff --git a/libdevice/events/MouseDevice.cpp b/libdevice/events/MouseDevice.cpp
index b14aeba..11e49d9 100644
--- a/libdevice/events/MouseDevice.cpp
+++ b/libdevice/events/MouseDevice.cpp
@@ -238,7 +238,7 @@ MouseDevice::check()
// GNASH_REPORT_FUNCTION;
int xmove, ymove, btn;
- std::unique_ptr<boost::uint8_t[]> buf;
+ std::unique_ptr<std::uint8_t[]> buf;
if (_type == InputDevice::TOUCHMOUSE) {
// The eTurboTouch has a 4 byte packet
buf = readData(4);
diff --git a/libdevice/rawfb/RawFBDevice.cpp b/libdevice/rawfb/RawFBDevice.cpp
index 3385b7c..7c79e6b 100644
--- a/libdevice/rawfb/RawFBDevice.cpp
+++ b/libdevice/rawfb/RawFBDevice.cpp
@@ -217,7 +217,7 @@ RawFBDevice::attachWindow(GnashDevice::native_window_t
window)
// of the opened device. EGL wants the descriptor here too, so
// this way we work in a similar manner.
if (window) {
- _fbmem = reinterpret_cast<boost::uint8_t *>(mmap(0, _fixinfo.smem_len,
+ _fbmem = reinterpret_cast<std::uint8_t *>(mmap(0, _fixinfo.smem_len,
PROT_READ|PROT_WRITE, MAP_SHARED,
window, 0));
}
@@ -230,7 +230,7 @@ RawFBDevice::attachWindow(GnashDevice::native_window_t
window)
if (!isSingleBuffered()) {
// Create an offscreen buffer the same size as the Framebuffer
- _offscreen_buffer.reset(new boost::uint8_t[_fixinfo.smem_len]);
+ _offscreen_buffer.reset(new std::uint8_t[_fixinfo.smem_len]);
memset(_offscreen_buffer.get(), 0, _fixinfo.smem_len);
}
diff --git a/libdevice/rawfb/RawFBDevice.h b/libdevice/rawfb/RawFBDevice.h
index 0b51e64..45dde48 100644
--- a/libdevice/rawfb/RawFBDevice.h
+++ b/libdevice/rawfb/RawFBDevice.h
@@ -107,10 +107,10 @@ class DSOEXPORT RawFBDevice : public GnashDevice
void createWindow(const char *name, int x, int y, int width, int height);
// Get the memory from the real framebuffer
- boost::uint8_t *getFBMemory() { return _fbmem; };
+ std::uint8_t *getFBMemory() { return _fbmem; };
// // Get the memory from an offscreen buffer to support Double Buffering
- boost::uint8_t *getOffscreenBuffer() { return _offscreen_buffer.get(); };
+ std::uint8_t *getOffscreenBuffer() { return _offscreen_buffer.get(); };
size_t getStride() { return _fixinfo.line_length; };
size_t getFBMemSize() { return _fixinfo.smem_len; };
@@ -147,9 +147,9 @@ protected:
std::string _filespec;
struct fb_fix_screeninfo _fixinfo;
struct fb_var_screeninfo _varinfo;
- boost::uint8_t *_fbmem;
+ std::uint8_t *_fbmem;
- std::unique_ptr<boost::uint8_t> _offscreen_buffer;
+ std::unique_ptr<std::uint8_t> _offscreen_buffer;
struct fb_cmap _cmap; // the colormap
};
diff --git a/libdevice/vaapi/VaapiImage.cpp b/libdevice/vaapi/VaapiImage.cpp
index 1d2f0fd..f8c1996 100644
--- a/libdevice/vaapi/VaapiImage.cpp
+++ b/libdevice/vaapi/VaapiImage.cpp
@@ -153,7 +153,7 @@ bool VaapiImage::unmap()
}
// Get pixels for the specified plane
-boost::uint8_t *VaapiImage::getPlane(int plane) const
+std::uint8_t *VaapiImage::getPlane(int plane) const
{
if (!isMapped()) {
throw VaapiException("VaapiImage::getPixels(): unmapped image");
diff --git a/libdevice/vaapi/VaapiImage.h b/libdevice/vaapi/VaapiImage.h
index b68c5e4..a9f27f7 100644
--- a/libdevice/vaapi/VaapiImage.h
+++ b/libdevice/vaapi/VaapiImage.h
@@ -41,7 +41,7 @@ class DSOEXPORT VaapiImage
{
VaapiImageFormat _format;
VAImage _image;
- boost::uint8_t * _image_data;
+ std::uint8_t * _image_data;
/// Create VA image
bool create(unsigned int width, unsigned int height);
@@ -80,7 +80,7 @@ public:
unsigned int getPlaneCount() const { return _image.num_planes; }
/// Get pixels for the specified plane
- boost::uint8_t *getPlane(int plane) const;
+ std::uint8_t *getPlane(int plane) const;
/// Get scanline pitch for the specified plane
unsigned int getPitch(int plane) const;
diff --git a/libdevice/vaapi/VaapiSurface.cpp b/libdevice/vaapi/VaapiSurface.cpp
index 3e16b25..792aeb5 100644
--- a/libdevice/vaapi/VaapiSurface.cpp
+++ b/libdevice/vaapi/VaapiSurface.cpp
@@ -18,7 +18,7 @@
//
#include <algorithm>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "log.h"
#include "VaapiSurface.h"
@@ -111,14 +111,14 @@ void VaapiSurface::clear()
}
// 0x10 is the black level for Y
- boost::uint8_t *Y = background.getPlane(0);
+ std::uint8_t *Y = background.getPlane(0);
unsigned int i, stride = background.getPitch(0);
for (i = 0; i < background.height(); i++, Y += stride) {
memset(Y, 0x10, stride);
}
// 0x80 is the black level for Cb and Cr
- boost::uint8_t *UV = background.getPlane(1);
+ std::uint8_t *UV = background.getPlane(1);
stride = background.getPitch(1);
for (i = 0; i < background.height()/2; i++, UV += stride) {
memset(UV, 0x80, stride);
diff --git a/libdevice/vaapi/vaapi_common.h b/libdevice/vaapi/vaapi_common.h
index 9007999..0870f10 100644
--- a/libdevice/vaapi/vaapi_common.h
+++ b/libdevice/vaapi/vaapi_common.h
@@ -31,7 +31,7 @@
#include <memory>
#include <stdint.h>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "dsodefs.h"
#endif // GNASH_VAAPI_COMMON_H
diff --git a/libdevice/vaapi/vaapi_utils.cpp b/libdevice/vaapi/vaapi_utils.cpp
index 8ddb5ac..98a347c 100644
--- a/libdevice/vaapi/vaapi_utils.cpp
+++ b/libdevice/vaapi/vaapi_utils.cpp
@@ -58,7 +58,7 @@ bool vaapi_check_status(VAStatus status, const char *msg)
}
/// Return a string representation of a FOURCC
-const char *string_of_FOURCC(boost::uint32_t fourcc)
+const char *string_of_FOURCC(std::uint32_t fourcc)
{
static int buf;
static char str[2][5]; // XXX: 2 buffers should be enough for most purposes
diff --git a/libdevice/vaapi/vaapi_utils.h b/libdevice/vaapi/vaapi_utils.h
index a613995..5390b34 100644
--- a/libdevice/vaapi/vaapi_utils.h
+++ b/libdevice/vaapi/vaapi_utils.h
@@ -37,7 +37,7 @@ void DSOEXPORT vaapi_dprintf(const char *format, ...);
bool DSOEXPORT vaapi_check_status(VAStatus status, const char *msg);
/// Return a string representation of a FOURCC
-DSOEXPORT const char* string_of_FOURCC(boost::uint32_t fourcc);
+DSOEXPORT const char* string_of_FOURCC(std::uint32_t fourcc);
/// Return a string representation of a VAProfile
DSOEXPORT const char* string_of_VAProfile(VAProfile profile);
diff --git a/libmedia/AudioDecoder.h b/libmedia/AudioDecoder.h
index ef1c9ce..87949ed 100644
--- a/libmedia/AudioDecoder.h
+++ b/libmedia/AudioDecoder.h
@@ -20,7 +20,7 @@
#ifndef GNASH_AUDIODECODER_H
#define GNASH_AUDIODECODER_H
-#include <boost/cstdint.hpp> // for C99 int types
+#include <cstdint> // for C99 int types
// Forward declarations
namespace gnash {
@@ -62,9 +62,9 @@ public:
///
/// @todo return a SimpleBuffer by unique_ptr
///
- virtual boost::uint8_t* decode(const boost::uint8_t* input,
- boost::uint32_t inputSize, boost::uint32_t& outputSize,
- boost::uint32_t& decodedData);
+ virtual std::uint8_t* decode(const std::uint8_t* input,
+ std::uint32_t inputSize, std::uint32_t& outputSize,
+ std::uint32_t& decodedData);
/// Decodes an EncodedAudioFrame and returns a pointer to the decoded
data
//
@@ -79,20 +79,20 @@ public:
///
/// @todo return a SimpleBuffer by unique_ptr
///
- virtual boost::uint8_t* decode(const EncodedAudioFrame& input,
- boost::uint32_t& outputSize);
+ virtual std::uint8_t* decode(const EncodedAudioFrame& input,
+ std::uint32_t& outputSize);
};
-inline boost::uint8_t*
-AudioDecoder::decode(const boost::uint8_t*, boost::uint32_t, boost::uint32_t&,
- boost::uint32_t&)
+inline std::uint8_t*
+AudioDecoder::decode(const std::uint8_t*, std::uint32_t, std::uint32_t&,
+ std::uint32_t&)
{
return 0;
}
-inline boost::uint8_t*
-AudioDecoder::decode(const EncodedAudioFrame&, boost::uint32_t&)
+inline std::uint8_t*
+AudioDecoder::decode(const EncodedAudioFrame&, std::uint32_t&)
{
return 0;
}
diff --git a/libmedia/AudioDecoderSimple.cpp b/libmedia/AudioDecoderSimple.cpp
index 586606e..74f05d6 100644
--- a/libmedia/AudioDecoderSimple.cpp
+++ b/libmedia/AudioDecoderSimple.cpp
@@ -95,17 +95,17 @@ private:
}
/* Uncompress 4096 mono samples of ADPCM. */
- static boost::uint32_t doMonoBlock(boost::int16_t** out_data, int
n_bits, BitsReader& in, int sample, int stepsize_index)
+ static std::uint32_t doMonoBlock(std::int16_t** out_data, int n_bits,
BitsReader& in, int sample, int stepsize_index)
{
/* First sample doesn't need to be decompressed. */
- boost::uint32_t sample_count = 1;
- *(*out_data)++ = (boost::int16_t) sample;
+ std::uint32_t sample_count = 1;
+ *(*out_data)++ = (std::int16_t) sample;
while (sample_count < 4096 && in.gotBits(n_bits))
{
int raw_code = in.read_uint(n_bits);
doSample(n_bits, sample, stepsize_index, raw_code);
/* sample & stepsize_index are in/out params */
- *(*out_data)++ = (boost::int16_t) sample;
+ *(*out_data)++ = (std::int16_t) sample;
sample_count++;
}
@@ -115,7 +115,7 @@ private:
/* Uncompress 4096 stereo sample pairs of ADPCM. */
static int doStereoBlock(
- boost::int16_t** out_data, // in/out param
+ std::int16_t** out_data, // in/out param
int n_bits,
BitsReader& in,
int left_sample,
@@ -125,20 +125,20 @@ private:
)
{
/* First samples don't need to be decompressed. */
- boost::uint32_t sample_count = 2;
- *(*out_data)++ = (boost::int16_t) left_sample;
- *(*out_data)++ = (boost::int16_t) right_sample;
+ std::uint32_t sample_count = 2;
+ *(*out_data)++ = (std::int16_t) left_sample;
+ *(*out_data)++ = (std::int16_t) right_sample;
unsigned bitsNeeded = n_bits*2;
while (sample_count < 4096 && in.gotBits(bitsNeeded))
{
int left_raw_code = in.read_uint(n_bits);
doSample(n_bits, left_sample, left_stepsize_index,
left_raw_code);
- *(*out_data)++ = (boost::int16_t) left_sample;
+ *(*out_data)++ = (std::int16_t) left_sample;
int right_raw_code = in.read_uint(n_bits);
doSample(n_bits, right_sample, right_stepsize_index,
right_raw_code);
- *(*out_data)++ = (boost::int16_t) right_sample;
+ *(*out_data)++ = (std::int16_t) right_sample;
sample_count++;
}
@@ -149,7 +149,7 @@ public:
// Utility function: uncompress ADPCM data from in BitReader to
// out_data[]. Returns the output samplecount.
- static boost::uint32_t adpcm_expand(
+ static std::uint32_t adpcm_expand(
unsigned char* &data,
BitsReader& in,
unsigned int insize,
@@ -166,10 +166,10 @@ public:
unsigned int n_bits = in.read_uint(2) + 2; // 2 to 5 bits
// The compression ratio is 4:1, so this should be enough...
- boost::int16_t* out_data = new boost::int16_t[insize * 5];
+ std::int16_t* out_data = new std::int16_t[insize * 5];
data = reinterpret_cast<unsigned char *>(out_data);
- boost::uint32_t sample_count = 0;
+ std::uint32_t sample_count = 0;
while ( in.gotBits(22) )
{
@@ -263,15 +263,15 @@ int ADPCMDecoder::s_stepsize[STEPSIZE_CT] = {
static void
u8_expand(unsigned char * &data,
const unsigned char* input,
- boost::uint32_t input_size) // This is also the number of u8bit samples
+ std::uint32_t input_size) // This is also the number of u8bit samples
{
- boost::int16_t *out_data = new boost::int16_t[input_size];
+ std::int16_t *out_data = new std::int16_t[input_size];
// Convert 8-bit to 16
- const boost::uint8_t *inp = input;
- boost::int16_t *outp = out_data;
+ const std::uint8_t *inp = input;
+ std::int16_t *outp = out_data;
for (unsigned int i = input_size; i>0; i--) {
- *outp++ = ((boost::int16_t)(*inp++) - 128) * 256;
+ *outp++ = ((std::int16_t)(*inp++) - 128) * 256;
}
data = (unsigned char *)out_data;
@@ -363,20 +363,20 @@ AudioDecoderSimple::setup(const AudioInfo& info)
}
}
-boost::uint8_t*
-AudioDecoderSimple::decode(const boost::uint8_t* input, boost::uint32_t
inputSize,
- boost::uint32_t& outputSize, boost::uint32_t& decodedBytes)
+std::uint8_t*
+AudioDecoderSimple::decode(const std::uint8_t* input, std::uint32_t inputSize,
+ std::uint32_t& outputSize, std::uint32_t& decodedBytes)
{
unsigned char* decodedData = NULL;
- boost::uint32_t outsize = 0;
+ std::uint32_t outsize = 0;
switch (_codec) {
case AUDIO_CODEC_ADPCM:
{
- //boost::uint32_t sample_count = inputSize * ( _stereo ? 1 : 2
); //(_sampleCount == 0 ? inputSize / ( _stereo ? 4 : 2 ) : _sampleCount);
+ //std::uint32_t sample_count = inputSize * ( _stereo ? 1 : 2 );
//(_sampleCount == 0 ? inputSize / ( _stereo ? 4 : 2 ) : _sampleCount);
BitsReader br(input, inputSize);
- boost::uint32_t sample_count =
ADPCMDecoder::adpcm_expand(decodedData, br, inputSize, _stereo);
+ std::uint32_t sample_count =
ADPCMDecoder::adpcm_expand(decodedData, br, inputSize, _stereo);
outsize = sample_count * (_stereo ? 4 : 2);
}
break;
@@ -415,10 +415,10 @@ AudioDecoderSimple::decode(const boost::uint8_t* input,
boost::uint32_t inputSiz
// nothing and is less of a continual maintenance
headache
// than compile-time detection.
union u {
- boost::uint16_t s;
+ std::uint16_t s;
struct {
- boost::uint8_t c0;
- boost::uint8_t c1;
+ std::uint8_t c0;
+ std::uint8_t c1;
} c;
} u = { 0x0001 };
@@ -438,12 +438,12 @@ AudioDecoderSimple::decode(const boost::uint8_t* input,
boost::uint32_t inputSiz
// Cast the buffers to help the
compiler understand that we
// swapping 16-bit words. This should
produce a single-instruction
// swap for each 16-bit word.
- const boost::uint16_t* input16 =
reinterpret_cast<const boost::uint16_t*>(input);
- boost::uint16_t* decodedData16 =
reinterpret_cast<boost::uint16_t*>(decodedData);
- unsigned inputSize16 = inputSize /
sizeof(boost::uint16_t);
+ const std::uint16_t* input16 =
reinterpret_cast<const std::uint16_t*>(input);
+ std::uint16_t* decodedData16 =
reinterpret_cast<std::uint16_t*>(decodedData);
+ unsigned inputSize16 = inputSize /
sizeof(std::uint16_t);
for ( unsigned i = 0; i < inputSize16;
i++ )
{
- boost::uint16_t sample =
input16[i];
+ std::uint16_t sample =
input16[i];
decodedData16[i] = ((sample <<
8) & 0xFF00) | ((sample >> 8) & 0x00FF);
}
break;
@@ -455,13 +455,13 @@ AudioDecoderSimple::decode(const boost::uint8_t* input,
boost::uint32_t inputSiz
// ???, this should only decode ADPCM, RAW and UNCOMPRESSED
}
- boost::uint8_t* tmp_raw_buffer = decodedData;
- boost::uint32_t tmp_raw_buffer_size = 0;
+ std::uint8_t* tmp_raw_buffer = decodedData;
+ std::uint32_t tmp_raw_buffer_size = 0;
// If we need to convert samplerate or/and from mono to stereo...
if (outsize > 0 && (_sampleRate != 44100 || !_stereo)) {
- boost::int16_t* adjusted_data = 0;
+ std::int16_t* adjusted_data = 0;
int adjusted_size = 0;
int sample_count = outsize / (_stereo ? 4 : 2); // samples are
of size 2
@@ -483,7 +483,7 @@ AudioDecoderSimple::decode(const boost::uint8_t* input,
boost::uint32_t inputSiz
// Move the new data to the sound-struct
delete[] tmp_raw_buffer;
- tmp_raw_buffer =
reinterpret_cast<boost::uint8_t*>(adjusted_data);
+ tmp_raw_buffer = reinterpret_cast<std::uint8_t*>(adjusted_data);
tmp_raw_buffer_size = adjusted_size;
} else {
diff --git a/libmedia/AudioDecoderSimple.h b/libmedia/AudioDecoderSimple.h
index 5f302eb..e000621 100644
--- a/libmedia/AudioDecoderSimple.h
+++ b/libmedia/AudioDecoderSimple.h
@@ -61,7 +61,7 @@ public:
~AudioDecoderSimple();
// See dox in AudioDecoder.h
- boost::uint8_t* decode(const boost::uint8_t* input, boost::uint32_t
inputSize, boost::uint32_t& outputSize, boost::uint32_t& decodedBytes);
+ std::uint8_t* decode(const std::uint8_t* input, std::uint32_t
inputSize, std::uint32_t& outputSize, std::uint32_t& decodedBytes);
private:
@@ -75,10 +75,10 @@ private:
audioCodecType _codec;
// samplerate
- boost::uint16_t _sampleRate;
+ std::uint16_t _sampleRate;
// sampleCount
- boost::uint32_t _sampleCount;
+ std::uint32_t _sampleCount;
// stereo
bool _stereo;
diff --git a/libmedia/AudioDecoderSpeex.cpp b/libmedia/AudioDecoderSpeex.cpp
index 75fcaac..9cb85bf 100644
--- a/libmedia/AudioDecoderSpeex.cpp
+++ b/libmedia/AudioDecoderSpeex.cpp
@@ -23,7 +23,7 @@
#include <functional>
#include <boost/checked_delete.hpp>
-#include <boost/cstdint.hpp> // For C99 int types
+#include <cstdint> // For C99 int types
#ifdef RESAMPLING_SPEEX
# include <boost/rational.hpp>
@@ -58,11 +58,11 @@ AudioDecoderSpeex::AudioDecoderSpeex()
speex_resampler_get_ratio (_resampler, &num, &den);
assert(num && den);
- boost::rational<boost::uint32_t> numsamples(den, num);
+ boost::rational<std::uint32_t> numsamples(den, num);
numsamples *= _speex_framesize * 2 /* convert to stereo */;
- _target_frame_size = boost::rational_cast<boost::uint32_t>(numsamples);
+ _target_frame_size = boost::rational_cast<std::uint32_t>(numsamples);
#endif
}
AudioDecoderSpeex::~AudioDecoderSpeex()
@@ -78,25 +78,25 @@ AudioDecoderSpeex::~AudioDecoderSpeex()
struct DecodedFrame : boost::noncopyable
{
- DecodedFrame(boost::int16_t* newdata, size_t datasize)
+ DecodedFrame(std::int16_t* newdata, size_t datasize)
: data(newdata),
size(datasize)
{}
- std::unique_ptr<boost::int16_t[]> data;
+ std::unique_ptr<std::int16_t[]> data;
size_t size;
};
-boost::uint8_t*
+std::uint8_t*
AudioDecoderSpeex::decode(const EncodedAudioFrame& input,
- boost::uint32_t& outputSize)
+ std::uint32_t& outputSize)
{
speex_bits_read_from(&_speex_bits,
reinterpret_cast<char*>(input.data.get()),
input.dataSize);
std::vector<DecodedFrame*> decoded_frames;
- boost::uint32_t total_size = 0;
+ std::uint32_t total_size = 0;
while (speex_bits_remaining(&_speex_bits)) {
@@ -112,11 +112,11 @@ AudioDecoderSpeex::decode(const EncodedAudioFrame& input,
}
- boost::int16_t* conv_data = 0;
+ std::int16_t* conv_data = 0;
#ifdef RESAMPLING_SPEEX
spx_uint32_t conv_size = 0;
- conv_data = new boost::int16_t[_target_frame_size];
+ conv_data = new std::int16_t[_target_frame_size];
memset(conv_data, 0, _target_frame_size * 2);
spx_uint32_t in_size = _speex_framesize;
@@ -138,19 +138,19 @@ AudioDecoderSpeex::decode(const EncodedAudioFrame& input,
conv_size *= 2;
// Now, duplicate all the samples so we get a stereo sound.
- for (boost::uint32_t i = 0; i < conv_size; i += 2) {
+ for (std::uint32_t i = 0; i < conv_size; i += 2) {
conv_data[i+1] = conv_data[i];
}
// Our interface requires returning the audio size in bytes.
- conv_size *= sizeof(boost::int16_t);
+ conv_size *= sizeof(std::int16_t);
#else
int outsize = 0;
AudioResampler::convert_raw_data(&conv_data, &outsize, output.get(),
_speex_framesize /* sample count*/, 2 /* sample size */,
16000, false /* stereo */, 44100 /* new rate */,
true /* convert to stereo */);
- boost::uint32_t conv_size = outsize;
+ std::uint32_t conv_size = outsize;
#endif
total_size += conv_size;
@@ -161,8 +161,8 @@ AudioDecoderSpeex::decode(const EncodedAudioFrame& input,
// We have to jump through hoops because decode() requires as much
// data to be returned as possible.
- boost::uint8_t* rv = new boost::uint8_t[total_size];
- boost::uint8_t* ptr = rv;
+ std::uint8_t* rv = new std::uint8_t[total_size];
+ std::uint8_t* ptr = rv;
for (std::vector<DecodedFrame*>::iterator it = decoded_frames.begin(),
end = decoded_frames.end(); it != end; ++it) {
diff --git a/libmedia/AudioDecoderSpeex.h b/libmedia/AudioDecoderSpeex.h
index 5e7d85a..ae43ccb 100644
--- a/libmedia/AudioDecoderSpeex.h
+++ b/libmedia/AudioDecoderSpeex.h
@@ -43,8 +43,8 @@ public:
AudioDecoderSpeex();
~AudioDecoderSpeex();
- boost::uint8_t* decode(const EncodedAudioFrame& input,
- boost::uint32_t& outputSize);
+ std::uint8_t* decode(const EncodedAudioFrame& input,
+ std::uint32_t& outputSize);
private:
@@ -55,7 +55,7 @@ private:
#ifdef RESAMPLING_SPEEX
SpeexResamplerState* _resampler;
/// Number of samples in a resampled 44kHz stereo frame.
- boost::uint32_t _target_frame_size;
+ std::uint32_t _target_frame_size;
#endif
};
diff --git a/libmedia/AudioInput.h b/libmedia/AudioInput.h
index dc8cd08..426ba88 100644
--- a/libmedia/AudioInput.h
+++ b/libmedia/AudioInput.h
@@ -20,7 +20,7 @@
#ifndef GNASH_AUDIOINPUT_H
#define GNASH_AUDIOINPUT_H
-#include <boost/cstdint.hpp> // for C99 int types
+#include <cstdint> // for C99 int types
#include <string>
#include "dsodefs.h" //DSOEXPORT
diff --git a/libmedia/AudioResampler.cpp b/libmedia/AudioResampler.cpp
index 5e648ce..81ecc2e 100644
--- a/libmedia/AudioResampler.cpp
+++ b/libmedia/AudioResampler.cpp
@@ -27,7 +27,7 @@ namespace media {
void
AudioResampler::convert_raw_data(
- boost::int16_t** adjusted_data,
+ std::int16_t** adjusted_data,
int* adjusted_size,
void* data,
int sample_count, // A stereo pair counts as one
@@ -68,9 +68,9 @@ AudioResampler::convert_raw_data(
}
int output_sample_count = (sample_count * dup * (stereo ? 2 : 1)) /
inc;
- boost::int16_t* out_data = new boost::int16_t[output_sample_count];
+ std::int16_t* out_data = new std::int16_t[output_sample_count];
*adjusted_data = out_data;
- *adjusted_size = output_sample_count * sizeof(boost::int16_t); // in bytes
+ *adjusted_size = output_sample_count * sizeof(std::int16_t); // in bytes
// Either inc > 1 (decimate the audio)
// or dup > 1 (repeat samples)
@@ -78,12 +78,12 @@ AudioResampler::convert_raw_data(
if (inc == 1 && dup == 1)
{
// No tranformation required
- std::memcpy(out_data, data, output_sample_count *
sizeof(boost::int16_t));
+ std::memcpy(out_data, data, output_sample_count *
sizeof(std::int16_t));
}
else if (inc > 1)
{
// Downsample by skipping samples from the input
- boost::int16_t* in = (boost::int16_t*) data;
+ std::int16_t* in = (std::int16_t*) data;
for (int i = output_sample_count; i > 0; i--)
{
*out_data++ = *in;
@@ -100,7 +100,7 @@ AudioResampler::convert_raw_data(
// then the right sample in both channels alternately.
// So for stereo-stereo transforms we have a stereo routine.
- boost::int16_t* in = (boost::int16_t*) data;
+ std::int16_t* in = (std::int16_t*) data;
if (stereo && m_stereo) {
// Stereo-to-stereo upsampling: Replicate pairs of samples
diff --git a/libmedia/AudioResampler.h b/libmedia/AudioResampler.h
index 22b5e16..0f7f68e 100644
--- a/libmedia/AudioResampler.h
+++ b/libmedia/AudioResampler.h
@@ -21,7 +21,7 @@
#ifndef __GNASH_UTIL_H
#define __GNASH_UTIL_H
-#include <boost/cstdint.hpp> // for boost::int16_t
+#include <cstdint> // for std::int16_t
namespace gnash {
namespace media {
@@ -64,7 +64,7 @@ public:
///
/// @param m_stereo
/// Do we want the output data to be in stereo (output)?
- static void convert_raw_data(boost::int16_t** adjusted_data,
+ static void convert_raw_data(std::int16_t** adjusted_data,
int* adjusted_size, void* data, int sample_count,
int sample_size, int sample_rate, bool stereo,
int m_sample_rate, bool m_stereo);
diff --git a/libmedia/FLVParser.cpp b/libmedia/FLVParser.cpp
index 8e8a3b4..152f72d 100644
--- a/libmedia/FLVParser.cpp
+++ b/libmedia/FLVParser.cpp
@@ -38,7 +38,7 @@ namespace media {
const size_t FLVParser::paddingBytes;
-const boost::uint16_t FLVParser::FLVAudioTag::flv_audio_rates [] =
+const std::uint16_t FLVParser::FLVAudioTag::flv_audio_rates [] =
{ 5500, 11000, 22050, 44100 };
FLVParser::FLVParser(std::unique_ptr<IOChannel> lt)
@@ -66,7 +66,7 @@ FLVParser::~FLVParser()
// would be called by main thread
bool
-FLVParser::seek(boost::uint32_t& time)
+FLVParser::seek(std::uint32_t& time)
{
boost::mutex::scoped_lock streamLock(_streamMutex);
@@ -128,7 +128,7 @@ FLVParser::parseNextChunk()
// would be called by parser thread
void
-FLVParser::indexAudioTag(const FLVTag& tag, boost::uint32_t thisTagPos)
+FLVParser::indexAudioTag(const FLVTag& tag, std::uint32_t thisTagPos)
{
if ( _videoInfo.get()) {
// if we have video we let that drive cue points
@@ -147,7 +147,7 @@ FLVParser::indexAudioTag(const FLVTag& tag, boost::uint32_t
thisTagPos)
}
void
-FLVParser::indexVideoTag(const FLVTag& tag, const FLVVideoTag& videotag,
boost::uint32_t thisTagPos)
+FLVParser::indexVideoTag(const FLVTag& tag, const FLVVideoTag& videotag,
std::uint32_t thisTagPos)
{
if ( videotag.frametype != FLV_VIDEO_KEYFRAME ) {
return;
@@ -160,7 +160,7 @@ FLVParser::indexVideoTag(const FLVTag& tag, const
FLVVideoTag& videotag, boost::
std::unique_ptr<EncodedAudioFrame>
-FLVParser::parseAudioTag(const FLVTag& flvtag, const FLVAudioTag& audiotag,
boost::uint32_t thisTagPos)
+FLVParser::parseAudioTag(const FLVTag& flvtag, const FLVAudioTag& audiotag,
std::uint32_t thisTagPos)
{
std::unique_ptr<EncodedAudioFrame> frame;
@@ -172,10 +172,10 @@ FLVParser::parseAudioTag(const FLVTag& flvtag, const
FLVAudioTag& audiotag, boos
}
bool header = false;
- boost::uint32_t bodyLength = flvtag.body_size;
+ std::uint32_t bodyLength = flvtag.body_size;
if (audiotag.codec == AUDIO_CODEC_AAC) {
- boost::uint8_t packettype = _stream->read_byte();
+ std::uint8_t packettype = _stream->read_byte();
header = (packettype == 0);
--bodyLength;
}
@@ -199,7 +199,7 @@ FLVParser::parseAudioTag(const FLVTag& flvtag, const
FLVAudioTag& audiotag, boos
// never smaller.
const size_t bufSize = frame->dataSize + paddingBytes;
- boost::uint8_t* data = new boost::uint8_t[bufSize];
+ std::uint8_t* data = new std::uint8_t[bufSize];
std::copy(frame->data.get(), frame->data.get() + bufSize, data);
@@ -217,7 +217,7 @@ FLVParser::parseAudioTag(const FLVTag& flvtag, const
FLVAudioTag& audiotag, boos
}
std::unique_ptr<EncodedVideoFrame>
-FLVParser::parseVideoTag(const FLVTag& flvtag, const FLVVideoTag& videotag,
boost::uint32_t thisTagPos)
+FLVParser::parseVideoTag(const FLVTag& flvtag, const FLVVideoTag& videotag,
std::uint32_t thisTagPos)
{
if ( ! _video ) {
log_error(_("Unexpected video tag found at offset %d of FLV
stream "
@@ -227,7 +227,7 @@ FLVParser::parseVideoTag(const FLVTag& flvtag, const
FLVVideoTag& videotag, boos
}
bool header = false;
- boost::uint32_t bodyLength = flvtag.body_size;
+ std::uint32_t bodyLength = flvtag.body_size;
switch(videotag.codec) {
case VIDEO_CODEC_VP6:
@@ -239,14 +239,14 @@ FLVParser::parseVideoTag(const FLVTag& flvtag, const
FLVVideoTag& videotag, boos
}
case VIDEO_CODEC_H264:
{
- boost::uint8_t packettype = _stream->read_byte();
+ std::uint8_t packettype = _stream->read_byte();
IF_VERBOSE_PARSE( log_debug(_("AVC packet type: %d"),
(unsigned)packettype) );
header = (packettype == 0);
// 24-bits value for composition time offset ignored
for now.
- boost::uint8_t tmp[3];
+ std::uint8_t tmp[3];
_stream->read(tmp, 3);
bodyLength -= 4;
@@ -274,7 +274,7 @@ FLVParser::parseVideoTag(const FLVTag& flvtag, const
FLVVideoTag& videotag, boos
// never smaller.
const size_t bufSize = frame->dataSize() + paddingBytes;
- boost::uint8_t* data = new boost::uint8_t[bufSize];
+ std::uint8_t* data = new std::uint8_t[bufSize];
std::copy(frame->data(), frame->data() + bufSize, data);
_videoInfo->extra.reset(
@@ -306,7 +306,7 @@ FLVParser::parseNextTag(bool index_only)
_seekRequest = false;
}
- boost::uint64_t& position = index_only ? _nextPosToIndex :
_lastParsedPosition;
+ std::uint64_t& position = index_only ? _nextPosToIndex :
_lastParsedPosition;
bool& completed = index_only ? _indexingCompleted : _parsingComplete;
//log_debug("parseNextTag: _lastParsedPosition:%d, _nextPosToIndex:%d,
index_only:%d", _lastParsedPosition, _nextPosToIndex, index_only);
@@ -326,7 +326,7 @@ FLVParser::parseNextTag(bool index_only)
//log_debug("FLVParser::parseNextTag seeked to %d", thisTagPos+4);
// Read the tag info
- boost::uint8_t chunk[12];
+ std::uint8_t chunk[12];
int actuallyRead = _stream->read(chunk, 12);
if ( actuallyRead < 12 )
{
@@ -437,7 +437,7 @@ FLVParser::parseNextTag(bool index_only)
}
metaTag->resize(actuallyRead);
- boost::uint32_t terminus = getUInt24(metaTag->data() +
+ std::uint32_t terminus = getUInt24(metaTag->data() +
actuallyRead - 3);
if (terminus != 9) {
@@ -455,7 +455,7 @@ FLVParser::parseNextTag(bool index_only)
}
_stream->read(chunk, 4);
- boost::uint32_t prevtagsize = chunk[0] << 24 | chunk[1] << 16 |
+ std::uint32_t prevtagsize = chunk[0] << 24 | chunk[1] << 16 |
chunk[2] << 8 | chunk[3];
if (prevtagsize != flvtag.body_size + 11) {
log_error(_("Corrupt FLV: previous tag size record (%1%)
unexpected "
@@ -473,7 +473,7 @@ FLVParser::parseHeader()
// We only use 5 bytes of the header, because the last 4 bytes represent
// an integer which is always 1.
- boost::uint8_t header[9];
+ std::uint8_t header[9];
if ( _stream->read(header, 9) != 9 )
{
log_error(_("FLVParser::parseHeader: couldn't read 9 bytes of
header"));
@@ -486,7 +486,7 @@ FLVParser::parseHeader()
return false;
}
- const boost::uint8_t version = header[3];
+ const std::uint8_t version = header[3];
// Parse the audio+video bitmask
_audio = header[4]&(1<<2);
@@ -498,14 +498,14 @@ FLVParser::parseHeader()
return true;
}
-inline boost::uint32_t
-FLVParser::getUInt24(boost::uint8_t* in)
+inline std::uint32_t
+FLVParser::getUInt24(std::uint8_t* in)
{
// The bits are in big endian order
return (in[0] << 16) | (in[1] << 8) | in[2];
}
-boost::uint64_t
+std::uint64_t
FLVParser::getBytesLoaded() const
{
boost::mutex::scoped_lock lock(_bytesLoadedMutex);
@@ -515,14 +515,14 @@ FLVParser::getBytesLoaded() const
// would be called by parser thread
/*private*/
std::unique_ptr<EncodedAudioFrame>
-FLVParser::readAudioFrame(boost::uint32_t dataSize, boost::uint32_t timestamp)
+FLVParser::readAudioFrame(std::uint32_t dataSize, std::uint32_t timestamp)
{
std::unique_ptr<EncodedAudioFrame> frame(new EncodedAudioFrame);
const size_t bufSize = dataSize + paddingBytes;
- boost::uint8_t* data = new boost::uint8_t[bufSize];
+ std::uint8_t* data = new std::uint8_t[bufSize];
const size_t bytesRead = _stream->read(data, dataSize);
std::fill(data + bytesRead, data + bufSize, 0);
@@ -542,13 +542,13 @@ FLVParser::readAudioFrame(boost::uint32_t dataSize,
boost::uint32_t timestamp)
// would be called by parser thread
/*private*/
std::unique_ptr<EncodedVideoFrame>
-FLVParser::readVideoFrame(boost::uint32_t dataSize, boost::uint32_t timestamp)
+FLVParser::readVideoFrame(std::uint32_t dataSize, std::uint32_t timestamp)
{
std::unique_ptr<EncodedVideoFrame> frame;
const size_t bufSize = dataSize + paddingBytes;
- boost::uint8_t* data = new boost::uint8_t[bufSize];
+ std::uint8_t* data = new std::uint8_t[bufSize];
const size_t bytesRead = _stream->read(data, dataSize);
std::fill(data + bytesRead, data + bufSize, 0);
@@ -563,7 +563,7 @@ FLVParser::readVideoFrame(boost::uint32_t dataSize,
boost::uint32_t timestamp)
void
-FLVParser::fetchMetaTags(OrderedMetaTags& tags, boost::uint64_t ts)
+FLVParser::fetchMetaTags(OrderedMetaTags& tags, std::uint64_t ts)
{
boost::mutex::scoped_lock lock(_metaTagsMutex);
if (!_metaTags.empty()) {
diff --git a/libmedia/FLVParser.h b/libmedia/FLVParser.h
index 8356392..ef04dde 100644
--- a/libmedia/FLVParser.h
+++ b/libmedia/FLVParser.h
@@ -53,7 +53,7 @@ public:
///
/// @todo take a SimpleBuffer by unique_ptr
///
- ExtraVideoInfoFlv(boost::uint8_t* extradata, size_t datasize)
+ ExtraVideoInfoFlv(std::uint8_t* extradata, size_t datasize)
:
data(extradata),
size(datasize)
@@ -61,7 +61,7 @@ public:
}
/// Video stream header
- std::unique_ptr<boost::uint8_t[]> data;
+ std::unique_ptr<std::uint8_t[]> data;
/// Video stream header size
size_t size;
@@ -85,7 +85,7 @@ public:
///
/// @todo take a SimpleBuffer by unique_ptr
///
- ExtraAudioInfoFlv(boost::uint8_t* extradata, size_t datasize)
+ ExtraAudioInfoFlv(std::uint8_t* extradata, size_t datasize)
:
data(extradata),
size(datasize)
@@ -93,7 +93,7 @@ public:
}
/// Audio stream header
- std::unique_ptr<boost::uint8_t[]> data;
+ std::unique_ptr<std::uint8_t[]> data;
/// Audio stream header size
size_t size;
@@ -126,13 +126,13 @@ public:
~FLVParser();
// see dox in MediaParser.h
- virtual bool seek(boost::uint32_t&);
+ virtual bool seek(std::uint32_t&);
// see dox in MediaParser.h
virtual bool parseNextChunk();
// see dox in MediaParser.h
- boost::uint64_t getBytesLoaded() const;
+ std::uint64_t getBytesLoaded() const;
// see dox in MediaParser.h
bool indexingCompleted() const
@@ -152,7 +152,7 @@ public:
/// timestamp order. Ownership of the data is shared. It
/// is destroyed automatically along with the last owner.
//
- virtual void fetchMetaTags(OrderedMetaTags& tags, boost::uint64_t ts);
+ virtual void fetchMetaTags(OrderedMetaTags& tags, std::uint64_t ts);
private:
@@ -165,7 +165,7 @@ private:
struct FLVTag : public boost::noncopyable
{
- FLVTag(boost::uint8_t* stream)
+ FLVTag(std::uint8_t* stream)
:
type(stream[0]),
body_size(getUInt24(stream+1)),
@@ -173,14 +173,14 @@ private:
{}
/// Equals tagType
- boost::uint8_t type;
- boost::uint32_t body_size;
- boost::uint32_t timestamp;
+ std::uint8_t type;
+ std::uint32_t body_size;
+ std::uint32_t timestamp;
};
struct FLVAudioTag : public boost::noncopyable
{
- FLVAudioTag(const boost::uint8_t& byte)
+ FLVAudioTag(const std::uint8_t& byte)
:
codec( (byte & 0xf0) >> 4 ),
samplerate( flv_audio_rates[(byte & 0x0C) >> 2] ),
@@ -190,18 +190,18 @@ private:
}
/// Equals audioCodecType
- boost::uint8_t codec;
+ std::uint8_t codec;
- boost::uint16_t samplerate;
+ std::uint16_t samplerate;
/// Size of each sample, in bytes
- boost::uint8_t samplesize;
+ std::uint8_t samplesize;
bool stereo;
private:
- static const boost::uint16_t flv_audio_rates[];
+ static const std::uint16_t flv_audio_rates[];
};
@@ -214,16 +214,16 @@ private:
struct FLVVideoTag : public boost::noncopyable
{
- FLVVideoTag(const boost::uint8_t& byte)
+ FLVVideoTag(const std::uint8_t& byte)
:
frametype( (byte & 0xf0) >> 4 ),
codec( byte & 0x0f )
{}
/// Equals frameType
- boost::uint8_t frametype;
+ std::uint8_t frametype;
/// Equals videoCodecType
- boost::uint8_t codec;
+ std::uint8_t codec;
};
/// Parses next tag from the file
@@ -234,15 +234,15 @@ private:
bool parseNextTag(bool index_only);
std::unique_ptr<EncodedAudioFrame> parseAudioTag(const FLVTag& flvtag,
- const FLVAudioTag& audiotag, boost::uint32_t thisTagPos);
+ const FLVAudioTag& audiotag, std::uint32_t thisTagPos);
std::unique_ptr<EncodedVideoFrame> parseVideoTag(const FLVTag& flvtag,
- const FLVVideoTag& videotag, boost::uint32_t thisTagPos);
+ const FLVVideoTag& videotag, std::uint32_t thisTagPos);
- void indexAudioTag(const FLVTag& tag, boost::uint32_t thisTagPos);
+ void indexAudioTag(const FLVTag& tag, std::uint32_t thisTagPos);
void indexVideoTag(const FLVTag& tag, const FLVVideoTag& videotag,
- boost::uint32_t thisTagPos);
+ std::uint32_t thisTagPos);
/// Parses the header of the file
bool parseHeader();
@@ -250,14 +250,14 @@ private:
/// Reads three bytes in FLV (big endian) byte order.
/// @param in Pointer to read 3 bytes from.
/// @return 24-bit integer.
- static boost::uint32_t getUInt24(boost::uint8_t* in);
+ static std::uint32_t getUInt24(std::uint8_t* in);
/// The position where the parsing should continue from.
/// Will be reset on seek, and will be protected by the _streamMutex
- boost::uint64_t _lastParsedPosition;
+ std::uint64_t _lastParsedPosition;
/// Position of next tag to index
- boost::uint64_t _nextPosToIndex;
+ std::uint64_t _nextPosToIndex;
/// Audio stream is present
bool _audio;
@@ -266,15 +266,15 @@ private:
bool _video;
std::unique_ptr<EncodedAudioFrame>
- readAudioFrame(boost::uint32_t dataSize, boost::uint32_t timestamp);
+ readAudioFrame(std::uint32_t dataSize, std::uint32_t timestamp);
std::unique_ptr<EncodedVideoFrame>
- readVideoFrame(boost::uint32_t dataSize, boost::uint32_t timestamp);
+ readVideoFrame(std::uint32_t dataSize, std::uint32_t timestamp);
/// Position in input stream for each cue point
/// first: timestamp
/// second: position in input stream
- typedef std::map<boost::uint64_t, long> CuePointsMap;
+ typedef std::map<std::uint64_t, long> CuePointsMap;
CuePointsMap _cuePoints;
bool _indexingCompleted;
diff --git a/libmedia/MediaParser.cpp b/libmedia/MediaParser.cpp
index 2d6dd96..5bd454e 100644
--- a/libmedia/MediaParser.cpp
+++ b/libmedia/MediaParser.cpp
@@ -58,7 +58,7 @@ MediaParser::startParserThread()
#endif
}
-boost::uint64_t
+std::uint64_t
MediaParser::getBufferLength() const
{
#ifdef LOAD_MEDIA_IN_A_SEPARATE_THREAD
@@ -84,7 +84,7 @@ MediaParser::getId3Info() const
return boost::optional<Id3Info>();
}
-boost::uint64_t
+std::uint64_t
MediaParser::getBufferLengthNoLock() const
{
bool hasVideo = _videoInfo.get();
@@ -103,7 +103,7 @@ MediaParser::getBufferLengthNoLock() const
return 0;
}
-boost::uint64_t
+std::uint64_t
MediaParser::videoBufferLength() const
{
if (_videoFrames.empty()) return 0;
@@ -115,7 +115,7 @@ MediaParser::videoBufferLength() const
return _videoFrames.back()->timestamp() -
_videoFrames.front()->timestamp();
}
-boost::uint64_t
+std::uint64_t
MediaParser::audioBufferLength() const
{
if (_audioFrames.empty()) return 0;
@@ -145,7 +145,7 @@ MediaParser::peekNextVideoFrame() const
}
bool
-MediaParser::nextFrameTimestamp(boost::uint64_t& ts) const
+MediaParser::nextFrameTimestamp(std::uint64_t& ts) const
{
#ifdef LOAD_MEDIA_IN_A_SEPARATE_THREAD
boost::mutex::scoped_lock lock(_qMutex);
@@ -185,7 +185,7 @@ MediaParser::nextFrameTimestamp(boost::uint64_t& ts) const
}
bool
-MediaParser::nextVideoFrameTimestamp(boost::uint64_t& ts) const
+MediaParser::nextVideoFrameTimestamp(std::uint64_t& ts) const
{
#ifdef LOAD_MEDIA_IN_A_SEPARATE_THREAD
boost::mutex::scoped_lock lock(_qMutex);
@@ -243,7 +243,7 @@ MediaParser::nextAudioFrame()
}
bool
-MediaParser::nextAudioFrameTimestamp(boost::uint64_t& ts) const
+MediaParser::nextAudioFrameTimestamp(std::uint64_t& ts) const
{
#ifdef LOAD_MEDIA_IN_A_SEPARATE_THREAD
boost::mutex::scoped_lock lock(_qMutex);
@@ -424,8 +424,8 @@ bool
MediaParser::bufferFull() const
{
// Callers are expected to hold a lock on _qMutex
- boost::uint64_t bl = getBufferLengthNoLock();
- boost::uint64_t bt = getBufferTime();
+ std::uint64_t bl = getBufferLengthNoLock();
+ std::uint64_t bt = getBufferTime();
#ifdef GNASH_DEBUG_MEDIAPARSER
log_debug("MediaParser::bufferFull: %d/%d", bl, bt);
#endif // GNASH_DEBUG_MEDIAPARSER
@@ -452,7 +452,7 @@ MediaParser::parserLoop()
void
-MediaParser::fetchMetaTags(OrderedMetaTags& /*tags*/, boost::uint64_t /*ts*/)
+MediaParser::fetchMetaTags(OrderedMetaTags& /*tags*/, std::uint64_t /*ts*/)
{
}
diff --git a/libmedia/MediaParser.h b/libmedia/MediaParser.h
index 32d14b8..9e80f27 100644
--- a/libmedia/MediaParser.h
+++ b/libmedia/MediaParser.h
@@ -229,9 +229,9 @@ public:
/// @param typei
/// Changes interpretation of the codeci parameter.
///
- AudioInfo(int codeci, boost::uint16_t sampleRatei,
- boost::uint16_t sampleSizei, bool stereoi,
- boost::uint64_t durationi, codecType typei)
+ AudioInfo(int codeci, std::uint16_t sampleRatei,
+ std::uint16_t sampleSizei, bool stereoi,
+ std::uint64_t durationi, codecType typei)
:
codec(codeci),
sampleRate(sampleRatei),
@@ -250,14 +250,14 @@ public:
///
int codec;
- boost::uint16_t sampleRate;
+ std::uint16_t sampleRate;
/// Size of each sample, in bytes
- boost::uint16_t sampleSize;
+ std::uint16_t sampleSize;
bool stereo;
- boost::uint64_t duration;
+ std::uint64_t duration;
codecType type;
@@ -316,8 +316,8 @@ public:
/// @param typei
/// Changes interpretation of the codeci parameter.
///
- VideoInfo(int codeci, boost::uint16_t widthi, boost::uint16_t heighti,
- boost::uint16_t frameRatei, boost::uint64_t durationi,
+ VideoInfo(int codeci, std::uint16_t widthi, std::uint16_t heighti,
+ std::uint16_t frameRatei, std::uint64_t durationi,
codecType typei)
:
codec(codeci),
@@ -330,10 +330,10 @@ public:
}
int codec;
- boost::uint16_t width;
- boost::uint16_t height;
- boost::uint16_t frameRate;
- boost::uint64_t duration;
+ std::uint16_t width;
+ std::uint16_t height;
+ std::uint16_t frameRate;
+ std::uint64_t duration;
codecType type;
/// Extra info about a video stream
@@ -382,9 +382,9 @@ public:
/// @param timestamp
/// Presentation timestamp, in milliseconds.
///
- EncodedVideoFrame(boost::uint8_t* data, boost::uint32_t size,
+ EncodedVideoFrame(std::uint8_t* data, std::uint32_t size,
unsigned int frameNum,
- boost::uint64_t timestamp=0)
+ std::uint64_t timestamp=0)
:
_size(size),
_data(data),
@@ -393,13 +393,13 @@ public:
{}
/// Return pointer to actual data. Ownership retained by this class.
- const boost::uint8_t* data() const { return _data.get(); }
+ const std::uint8_t* data() const { return _data.get(); }
/// Return size of data buffer.
- boost::uint32_t dataSize() const { return _size; }
+ std::uint32_t dataSize() const { return _size; }
/// Return video frame presentation timestamp
- boost::uint64_t timestamp() const { return _timestamp; }
+ std::uint64_t timestamp() const { return _timestamp; }
/// Return video frame number
unsigned frameNum() const { return _frameNum; }
@@ -408,19 +408,19 @@ public:
std::unique_ptr<EncodedExtraData> extradata;
private:
- boost::uint32_t _size;
- std::unique_ptr<boost::uint8_t[]> _data;
+ std::uint32_t _size;
+ std::unique_ptr<std::uint8_t[]> _data;
unsigned int _frameNum;
- boost::uint64_t _timestamp;
+ std::uint64_t _timestamp;
};
/// An encoded audio frame
class EncodedAudioFrame
{
public:
- boost::uint32_t dataSize;
- std::unique_ptr<boost::uint8_t[]> data;
- boost::uint64_t timestamp;
+ std::uint32_t dataSize;
+ std::unique_ptr<std::uint8_t[]> data;
+ std::uint64_t timestamp;
// FIXME: should have better encapsulation for this sort of stuff.
std::unique_ptr<EncodedExtraData> extradata;
@@ -441,7 +441,7 @@ public:
/// A container for executable MetaTags contained in media streams.
//
/// Presently only known in FLV.
- typedef std::multimap<boost::uint64_t, std::shared_ptr<SimpleBuffer> >
+ typedef std::multimap<std::uint64_t, std::shared_ptr<SimpleBuffer> >
MetaTags;
typedef std::vector<MetaTags::mapped_type> OrderedMetaTags;
@@ -465,7 +465,7 @@ public:
///
/// @return true if the seek was valid, false otherwise.
///
- virtual bool seek(boost::uint32_t& time)=0;
+ virtual bool seek(std::uint32_t& time)=0;
/// Returns mininum length of available buffers in milliseconds
//
@@ -476,7 +476,7 @@ public:
/// frames and let NetSTream::bufferLength() use that with playhead
/// time to find out...
///
- DSOEXPORT boost::uint64_t getBufferLength() const;
+ DSOEXPORT std::uint64_t getBufferLength() const;
/// Return true if both audio and video buffers are empty
//
@@ -484,7 +484,7 @@ public:
DSOEXPORT bool isBufferEmpty() const;
/// Return the time we want the parser thread to maintain in the buffer
- DSOEXPORT boost::uint64_t getBufferTime() const
+ DSOEXPORT std::uint64_t getBufferTime() const
{
boost::mutex::scoped_lock lock(_bufferTimeMutex);
return _bufferTime;
@@ -495,7 +495,7 @@ public:
/// @param t
/// Number of milliseconds to keep in the buffers.
///
- DSOEXPORT void setBufferTime(boost::uint64_t t)
+ DSOEXPORT void setBufferTime(std::uint64_t t)
{
boost::mutex::scoped_lock lock(_bufferTimeMutex);
_bufferTime=t;
@@ -508,7 +508,7 @@ public:
///
/// NOTE: locks _qMutex
///
- DSOEXPORT bool nextFrameTimestamp(boost::uint64_t& ts) const;
+ DSOEXPORT bool nextFrameTimestamp(std::uint64_t& ts) const;
/// Get timestamp of the video frame which would be returned on
nextVideoFrame
//
@@ -517,7 +517,7 @@ public:
///
/// NOTE: locks _qMutex
///
- DSOEXPORT bool nextVideoFrameTimestamp(boost::uint64_t& ts) const;
+ DSOEXPORT bool nextVideoFrameTimestamp(std::uint64_t& ts) const;
/// Returns the next video frame in the parsed buffer, advancing video
cursor.
//
@@ -535,7 +535,7 @@ public:
///
/// NOTE: locks _qMutex
///
- DSOEXPORT bool nextAudioFrameTimestamp(boost::uint64_t& ts) const;
+ DSOEXPORT bool nextAudioFrameTimestamp(std::uint64_t& ts) const;
/// Returns the next audio frame in the parsed buffer, advancing audio
cursor.
//
@@ -580,10 +580,10 @@ public:
virtual bool indexingCompleted() const { return true; }
/// Return number of bytes parsed so far
- virtual boost::uint64_t getBytesLoaded() const { return 0; }
+ virtual std::uint64_t getBytesLoaded() const { return 0; }
/// Return total number of bytes in input
- boost::uint64_t getBytesTotal() const
+ std::uint64_t getBytesTotal() const
{
return _stream->size();
}
@@ -608,7 +608,7 @@ public:
//
/// Metadata is currently only parsed from FLV streams. The default
/// is a no-op.
- virtual void fetchMetaTags(OrderedMetaTags& tags, boost::uint64_t ts);
+ virtual void fetchMetaTags(OrderedMetaTags& tags, std::uint64_t ts);
/// Get ID3 data from the parsed stream if it exists.
//
@@ -629,7 +629,7 @@ protected:
bool _parsingComplete;
/// Number of bytes loaded
- boost::uint64_t _bytesLoaded;
+ std::uint64_t _bytesLoaded;
/// }@
@@ -685,7 +685,7 @@ protected:
return _parserThreadKillRequested;
}
- boost::uint64_t _bufferTime;
+ std::uint64_t _bufferTime;
mutable boost::mutex _bufferTimeMutex;
std::unique_ptr<boost::thread> _parserThread;
@@ -765,13 +765,13 @@ private:
}
/// Return diff between timestamp of last and first audio frame
- boost::uint64_t audioBufferLength() const;
+ std::uint64_t audioBufferLength() const;
/// Return diff between timestamp of last and first video frame
- boost::uint64_t videoBufferLength() const;
+ std::uint64_t videoBufferLength() const;
/// A getBufferLength method not locking the _qMutex (expected to be
locked by caller already).
- boost::uint64_t getBufferLengthNoLock() const;
+ std::uint64_t getBufferLengthNoLock() const;
};
diff --git a/libmedia/SoundInfo.h b/libmedia/SoundInfo.h
index dcfad25..01f9055 100644
--- a/libmedia/SoundInfo.h
+++ b/libmedia/SoundInfo.h
@@ -65,9 +65,9 @@ public:
/// and by 2 (two channels) to find number of output
/// samples to skip or fill.
///
- SoundInfo(audioCodecType format, bool stereo, boost::uint32_t
sampleRate,
- boost::uint32_t sampleCount, bool is16bit,
- boost::int16_t delaySeek=0)
+ SoundInfo(audioCodecType format, bool stereo, std::uint32_t sampleRate,
+ std::uint32_t sampleCount, bool is16bit,
+ std::int16_t delaySeek=0)
:
_format(format),
_stereo(stereo),
@@ -106,7 +106,7 @@ public:
//
/// The number is to be considered in pre-resampling units.
///
- boost::int16_t getDelaySeek() const { return _delaySeek; }
+ std::int16_t getDelaySeek() const { return _delaySeek; }
/// Returns the 16bit status of the sound
//
@@ -121,13 +121,13 @@ private:
bool _stereo;
/// Sample rate, one of 5512, 11025, 22050, 44100
- boost::uint32_t _sampleRate;
+ std::uint32_t _sampleRate;
/// Number of samples
- boost::uint32_t _sampleCount;
+ std::uint32_t _sampleCount;
/// Number of samples to seek forward or delay.
- boost::int16_t _delaySeek;
+ std::int16_t _delaySeek;
/// Is the audio in 16bit format (samplesize == 2)? else it
/// is 8bit (samplesize == 1). Used for streams when decoding adpcm.
diff --git a/libmedia/VideoConverter.h b/libmedia/VideoConverter.h
index cbf923c..5dcee78 100644
--- a/libmedia/VideoConverter.h
+++ b/libmedia/VideoConverter.h
@@ -21,7 +21,7 @@
#define GNASH_VIDEOCONVERTER_H
#include <boost/noncopyable.hpp>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <boost/array.hpp>
#include <memory>
@@ -42,10 +42,10 @@ namespace media {
struct ImgBuf : public boost::noncopyable
{
- typedef boost::uint32_t Type4CC;
+ typedef std::uint32_t Type4CC;
typedef void (*FreeFunc)(void*);
- ImgBuf(Type4CC t, boost::uint8_t* dataptr, size_t datasize, size_t w,
+ ImgBuf(Type4CC t, std::uint8_t* dataptr, size_t datasize, size_t w,
size_t h)
: type(t),
data(dataptr),
@@ -62,7 +62,7 @@ struct ImgBuf : public boost::noncopyable
static void array_delete(void* voidptr)
{
- boost::uint8_t* ptr = static_cast<boost::uint8_t*>(voidptr);
+ std::uint8_t* ptr = static_cast<std::uint8_t*>(voidptr);
delete [] ptr;
}
@@ -71,7 +71,7 @@ struct ImgBuf : public boost::noncopyable
}
Type4CC type;
- boost::uint8_t* data;
+ std::uint8_t* data;
size_t size; // in bytes
size_t width; // in pixels
diff --git a/libmedia/VideoInput.h b/libmedia/VideoInput.h
index 0ae6d16..7d3a581 100644
--- a/libmedia/VideoInput.h
+++ b/libmedia/VideoInput.h
@@ -20,7 +20,7 @@
#ifndef GNASH_VIDEOINPUT_H
#define GNASH_VIDEOINPUT_H
-#include <boost/cstdint.hpp> // for C99 int types
+#include <cstdint> // for C99 int types
#include <string>
#include "dsodefs.h" //DSOEXPORT
diff --git a/libmedia/ffmpeg/AudioDecoderFfmpeg.cpp
b/libmedia/ffmpeg/AudioDecoderFfmpeg.cpp
index 2f98d05..59ebbd2 100644
--- a/libmedia/ffmpeg/AudioDecoderFfmpeg.cpp
+++ b/libmedia/ffmpeg/AudioDecoderFfmpeg.cpp
@@ -334,15 +334,15 @@ void AudioDecoderFfmpeg::setup(const AudioInfo& info)
}
-boost::uint8_t*
-AudioDecoderFfmpeg::decode(const boost::uint8_t* input,
- boost::uint32_t inputSize, boost::uint32_t&
- outputSize, boost::uint32_t& decodedBytes)
+std::uint8_t*
+AudioDecoderFfmpeg::decode(const std::uint8_t* input,
+ std::uint32_t inputSize, std::uint32_t&
+ outputSize, std::uint32_t& decodedBytes)
{
//GNASH_REPORT_FUNCTION;
size_t retCapacity = MAX_AUDIO_FRAME_SIZE;
- boost::uint8_t* retBuf = new boost::uint8_t[retCapacity];
+ std::uint8_t* retBuf = new std::uint8_t[retCapacity];
int retBufSize = 0;
#ifdef GNASH_DEBUG_AUDIO_DECODING
@@ -352,7 +352,7 @@ AudioDecoderFfmpeg::decode(const boost::uint8_t* input,
decodedBytes = 0; // nothing decoded yet
while (decodedBytes < inputSize)
{
- const boost::uint8_t* frame=0; // parsed frame (pointer into input)
+ const std::uint8_t* frame=0; // parsed frame (pointer into input)
int framesize; // parsed frame size
int consumed = parseInput(input+decodedBytes,
@@ -404,8 +404,8 @@ AudioDecoderFfmpeg::decode(const boost::uint8_t* input,
// Now, decode the frame. We use the ::decodeFrame specialized function
// here so resampling is done appropriately
- boost::uint32_t outSize = 0;
- std::unique_ptr<boost::uint8_t[]> outBuf(
+ std::uint32_t outSize = 0;
+ std::unique_ptr<std::uint8_t[]> outBuf(
decodeFrame(frame, framesize, outSize));
if (!outBuf)
@@ -436,7 +436,7 @@ AudioDecoderFfmpeg::decode(const boost::uint8_t* input,
retBufSize+(unsigned)outSize, retCapacity);
#endif
- boost::uint8_t* tmp = retBuf;
+ std::uint8_t* tmp = retBuf;
retCapacity = std::max(retBufSize+static_cast<size_t>(outSize),
retCapacity * 2);
@@ -445,7 +445,7 @@ AudioDecoderFfmpeg::decode(const boost::uint8_t* input,
retCapacity);
#endif // GNASH_DEBUG_AUDIO_DECODING
- retBuf = new boost::uint8_t[retCapacity];
+ retBuf = new std::uint8_t[retCapacity];
if ( retBufSize ) std::copy(tmp, tmp+retBufSize, retBuf);
delete [] tmp;
}
@@ -459,16 +459,16 @@ AudioDecoderFfmpeg::decode(const boost::uint8_t* input,
}
-boost::uint8_t*
+std::uint8_t*
AudioDecoderFfmpeg::decode(const EncodedAudioFrame& ef,
- boost::uint32_t& outputSize)
+ std::uint32_t& outputSize)
{
return decodeFrame(ef.data.get(), ef.dataSize, outputSize);
}
-boost::uint8_t*
-AudioDecoderFfmpeg::decodeFrame(const boost::uint8_t* input,
- boost::uint32_t inputSize, boost::uint32_t& outputSize)
+std::uint8_t*
+AudioDecoderFfmpeg::decodeFrame(const std::uint8_t* input,
+ std::uint32_t inputSize, std::uint32_t& outputSize)
{
//GNASH_REPORT_FUNCTION;
@@ -477,15 +477,15 @@ AudioDecoderFfmpeg::decodeFrame(const boost::uint8_t*
input,
size_t outSize = MAX_AUDIO_FRAME_SIZE;
// TODO: make this a private member, to reuse (see NetStreamFfmpeg in
0.8.3)
- std::unique_ptr<boost::int16_t, decltype(av_free)*> output(
- reinterpret_cast<boost::int16_t*>(av_malloc(outSize)), av_free );
+ std::unique_ptr<std::int16_t, decltype(av_free)*> output(
+ reinterpret_cast<std::int16_t*>(av_malloc(outSize)), av_free );
if (!output.get()) {
log_error(_("failed to allocate audio buffer."));
outputSize = 0;
return NULL;
}
- boost::int16_t* outPtr = output.get();
+ std::int16_t* outPtr = output.get();
#ifdef GNASH_DEBUG_AUDIO_DECODING
@@ -571,7 +571,7 @@ AudioDecoderFfmpeg::decodeFrame(const boost::uint8_t* input,
int resampledFrameSize = expectedMaxOutSamples*2*2;
// Allocate just the required amount of bytes
- boost::uint8_t* resampledOutput = new
boost::uint8_t[resampledFrameSize];
+ std::uint8_t* resampledOutput = new std::uint8_t[resampledFrameSize];
#ifdef GNASH_DEBUG_AUDIO_DECODING
log_debug(" decodeFrame | Calling the resampler, resampleFactor: %d | "
@@ -588,7 +588,7 @@ AudioDecoderFfmpeg::decodeFrame(const boost::uint8_t* input,
&resampledOutput); // output
// make sure to set outPtr *after* we use it as input to the resampler
- outPtr = reinterpret_cast<boost::int16_t*>(resampledOutput);
+ outPtr = reinterpret_cast<std::int16_t*>(resampledOutput);
#ifdef GNASH_DEBUG_AUDIO_DECODING
log_debug("resampler returned %d samples ", outSamples);
@@ -618,9 +618,9 @@ AudioDecoderFfmpeg::decodeFrame(const boost::uint8_t* input,
}
else {
- boost::uint8_t* newOutput = new boost::uint8_t[outSize];
+ std::uint8_t* newOutput = new std::uint8_t[outSize];
std::memcpy(newOutput, outPtr, outSize);
- outPtr = reinterpret_cast<boost::int16_t*>(newOutput);
+ outPtr = reinterpret_cast<std::int16_t*>(newOutput);
}
outputSize = outSize;
@@ -628,9 +628,9 @@ AudioDecoderFfmpeg::decodeFrame(const boost::uint8_t* input,
}
int
-AudioDecoderFfmpeg::parseInput(const boost::uint8_t* input,
- boost::uint32_t inputSize,
- boost::uint8_t const ** outFrame, int* outFrameSize)
+AudioDecoderFfmpeg::parseInput(const std::uint8_t* input,
+ std::uint32_t inputSize,
+ std::uint8_t const ** outFrame, int* outFrameSize)
{
if ( _needsParsing )
{
@@ -641,7 +641,7 @@ AudioDecoderFfmpeg::parseInput(const boost::uint8_t* input,
#endif
// as of 2008-10-28 SVN, ffmpeg doesn't
// accept a pointer to pointer to const..
- const_cast<boost::uint8_t**>(outFrame),
+ const_cast<std::uint8_t**>(outFrame),
outFrameSize,
input, inputSize,
#if LIBAVCODEC_VERSION_MAJOR >= 53
diff --git a/libmedia/ffmpeg/AudioDecoderFfmpeg.h
b/libmedia/ffmpeg/AudioDecoderFfmpeg.h
index 9310830..96578bc 100644
--- a/libmedia/ffmpeg/AudioDecoderFfmpeg.h
+++ b/libmedia/ffmpeg/AudioDecoderFfmpeg.h
@@ -56,20 +56,20 @@ public:
~AudioDecoderFfmpeg();
// See dox in AudioDecoder.h
- boost::uint8_t* decode(const boost::uint8_t* input,
- boost::uint32_t inputSize, boost::uint32_t& outputSize,
- boost::uint32_t& decodedBytes);
+ std::uint8_t* decode(const std::uint8_t* input,
+ std::uint32_t inputSize, std::uint32_t& outputSize,
+ std::uint32_t& decodedBytes);
- boost::uint8_t* decode(const EncodedAudioFrame& af,
- boost::uint32_t& outputSize);
+ std::uint8_t* decode(const EncodedAudioFrame& af,
+ std::uint32_t& outputSize);
private:
void setup(const AudioInfo& info);
void setup(SoundInfo& info);
- boost::uint8_t* decodeFrame(const boost::uint8_t* input,
- boost::uint32_t inputSize, boost::uint32_t& outputSize);
+ std::uint8_t* decodeFrame(const std::uint8_t* input,
+ std::uint32_t inputSize, std::uint32_t& outputSize);
AVCodec* _audioCodec;
AVCodecContext* _audioCodecCtx;
@@ -99,8 +99,8 @@ private:
///
/// @return number of input bytes parsed, or -1 on error
///
- int parseInput(const boost::uint8_t* input, boost::uint32_t inputSize,
- boost::uint8_t const ** outFrame, int* outFrameSize);
+ int parseInput(const std::uint8_t* input, std::uint32_t inputSize,
+ std::uint8_t const ** outFrame, int* outFrameSize);
};
} // gnash.media.ffmpeg namespace
diff --git a/libmedia/ffmpeg/AudioInputFfmpeg.h
b/libmedia/ffmpeg/AudioInputFfmpeg.h
index 5d647cd..32e7292 100644
--- a/libmedia/ffmpeg/AudioInputFfmpeg.h
+++ b/libmedia/ffmpeg/AudioInputFfmpeg.h
@@ -23,7 +23,7 @@
#include "dsodefs.h" //DSOEXPORT
#include "AudioInput.h"
-#include <boost/cstdint.hpp> // for C99 int types
+#include <cstdint> // for C99 int types
#include <string>
namespace gnash {
diff --git a/libmedia/ffmpeg/AudioResamplerFfmpeg.cpp
b/libmedia/ffmpeg/AudioResamplerFfmpeg.cpp
index d4d2e15..ce80d89 100644
--- a/libmedia/ffmpeg/AudioResamplerFfmpeg.cpp
+++ b/libmedia/ffmpeg/AudioResamplerFfmpeg.cpp
@@ -85,8 +85,8 @@ AudioResamplerFfmpeg::init(AVCodecContext* ctx) {
}
int
-AudioResamplerFfmpeg::resample(boost::uint8_t** input, int plane_size,
- int samples, boost::uint8_t** output) {
+AudioResamplerFfmpeg::resample(std::uint8_t** input, int plane_size,
+ int samples, std::uint8_t** output) {
UNUSED( plane_size );
#ifdef HAVE_SWRESAMPLE_H
return swr_convert(_context,
diff --git a/libmedia/ffmpeg/AudioResamplerFfmpeg.h
b/libmedia/ffmpeg/AudioResamplerFfmpeg.h
index 3dc2748..5b21c83 100644
--- a/libmedia/ffmpeg/AudioResamplerFfmpeg.h
+++ b/libmedia/ffmpeg/AudioResamplerFfmpeg.h
@@ -25,7 +25,7 @@
#include "ffmpegHeaders.h"
-#include <boost/cstdint.hpp>
+#include <cstdint>
namespace gnash {
namespace media {
@@ -67,8 +67,8 @@ public:
///
/// @return the number of samples in the output data.
///
- DSOEXPORT int resample(boost::uint8_t** input, int plane_size,
- int samples, boost::uint8_t** output);
+ DSOEXPORT int resample(std::uint8_t** input, int plane_size,
+ int samples, std::uint8_t** output);
private:
// The container of the resample format information.
diff --git a/libmedia/ffmpeg/MediaHandlerFfmpeg.cpp
b/libmedia/ffmpeg/MediaHandlerFfmpeg.cpp
index 2ab83bc..127aaaa 100644
--- a/libmedia/ffmpeg/MediaHandlerFfmpeg.cpp
+++ b/libmedia/ffmpeg/MediaHandlerFfmpeg.cpp
@@ -42,7 +42,7 @@ std::string
MediaHandlerFfmpeg::description() const
{
std::ostringstream ss;
- const boost::uint32_t ver = avcodec_version();
+ const std::uint32_t ver = avcodec_version();
ss << "FFmpeg (avcodec version: " << (ver >> 16) << "."
<< ((ver & 0xff00) >> 8) << "."
<< (ver & 0xff) << ")";
diff --git a/libmedia/ffmpeg/MediaParserFfmpeg.cpp
b/libmedia/ffmpeg/MediaParserFfmpeg.cpp
index d7304ac..842f722 100644
--- a/libmedia/ffmpeg/MediaParserFfmpeg.cpp
+++ b/libmedia/ffmpeg/MediaParserFfmpeg.cpp
@@ -46,15 +46,15 @@ inline double as_double(AVRational time) {
int
-MediaParserFfmpeg::readPacketWrapper(void* opaque, boost::uint8_t* buf,
+MediaParserFfmpeg::readPacketWrapper(void* opaque, std::uint8_t* buf,
int buf_size)
{
MediaParserFfmpeg* p = static_cast<MediaParserFfmpeg*>(opaque);
return p->readPacket(buf, buf_size);
}
-boost::int64_t
-MediaParserFfmpeg::seekMediaWrapper(void *opaque, boost::int64_t offset, int
whence)
+std::int64_t
+MediaParserFfmpeg::seekMediaWrapper(void *opaque, std::int64_t offset, int
whence)
{
MediaParserFfmpeg* p = static_cast<MediaParserFfmpeg*>(opaque);
return p->seekMedia(offset, whence);
@@ -66,7 +66,7 @@ MediaParserFfmpeg::probeStream()
const size_t probeSize = 4096;
const size_t bufSize = probeSize + FF_INPUT_BUFFER_PADDING_SIZE;
- std::unique_ptr<boost::uint8_t[]> buffer(new boost::uint8_t[bufSize]);
+ std::unique_ptr<std::uint8_t[]> buffer(new std::uint8_t[bufSize]);
assert(_stream->tell() == static_cast<std::streampos>(0));
size_t actuallyRead = _stream->read(buffer.get(), probeSize);
@@ -92,7 +92,7 @@ MediaParserFfmpeg::probeStream()
}
bool
-MediaParserFfmpeg::seek(boost::uint32_t& pos)
+MediaParserFfmpeg::seek(std::uint32_t& pos)
{
// lock the stream while reading from it, so actionscript
// won't mess with the parser on seek or on getBytesLoaded
@@ -158,7 +158,7 @@ MediaParserFfmpeg::parseVideoFrame(AVPacket& packet)
// pkt->pts can be AV_NOPTS_VALUE if the video format has B frames,
// so it is better to rely on pkt->dts if you do not decompress the
payload.
//
- boost::uint64_t timestamp = static_cast<boost::uint64_t>(packet.dts *
as_double(_videoStream->time_base) * 1000.0);
+ std::uint64_t timestamp = static_cast<std::uint64_t>(packet.dts *
as_double(_videoStream->time_base) * 1000.0);
#if 0
LOG_ONCE( log_unimpl("%s", __PRETTY_FUNCTION__) );
@@ -172,7 +172,7 @@ MediaParserFfmpeg::parseVideoFrame(AVPacket& packet)
// we might do proper padding or (better) avoid the copy as a
whole by making
// EncodedVideoFrame virtual.
size_t allocSize = packet.size*2;
- boost::uint8_t* data = new boost::uint8_t[allocSize];
+ std::uint8_t* data = new std::uint8_t[allocSize];
std::copy(packet.data, packet.data+packet.size, data);
std::unique_ptr<EncodedVideoFrame> frame(new EncodedVideoFrame(data,
packet.size, 0, timestamp));
@@ -197,8 +197,8 @@ MediaParserFfmpeg::parseAudioFrame(AVPacket& packet)
// so it is better to rely on pkt->dts if you do not decompress the
payload.
//
- boost::uint64_t dts = packet.dts;
- if ( dts == static_cast<boost::uint64_t>(AV_NOPTS_VALUE) ) {
+ std::uint64_t dts = packet.dts;
+ if ( dts == static_cast<std::uint64_t>(AV_NOPTS_VALUE) ) {
// We'll take 'nopts' value as zero.
// Would likely be better to make it use timestamp
// of previous frame, if any.
@@ -212,7 +212,7 @@ MediaParserFfmpeg::parseAudioFrame(AVPacket& packet)
"timestamp has no value, taking as zero")));
dts = 0;
}
- boost::uint64_t timestamp = static_cast<boost::uint64_t>(dts *
as_double(_audioStream->time_base) * 1000.0);
+ std::uint64_t timestamp = static_cast<std::uint64_t>(dts *
as_double(_audioStream->time_base) * 1000.0);
//log_debug("On getting audio frame with timestamp %d, duration is %d",
timestamp, _audioStream->duration);
std::unique_ptr<EncodedAudioFrame> frame ( new EncodedAudioFrame );
@@ -221,7 +221,7 @@ MediaParserFfmpeg::parseAudioFrame(AVPacket& packet)
// we might do proper padding or (better) avoid the copy as a
whole by making
// EncodedVideoFrame virtual.
size_t allocSize = packet.size*2;
- boost::uint8_t* data = new boost::uint8_t[allocSize];
+ std::uint8_t* data = new std::uint8_t[allocSize];
std::copy(packet.data, packet.data+packet.size, data);
frame->data.reset(data);
@@ -260,7 +260,7 @@ MediaParserFfmpeg::parseNextFrame()
int rc = av_read_frame(_formatCtx, &packet);
// Update _lastParsedPosition, even in case of error..
- boost::uint64_t curPos = _stream->tell();
+ std::uint64_t curPos = _stream->tell();
if ( curPos > _lastParsedPosition )
{
_lastParsedPosition = curPos;
@@ -314,7 +314,7 @@ MediaParserFfmpeg::parseNextChunk()
return true;
}
-boost::uint64_t
+std::uint64_t
MediaParserFfmpeg::getBytesLoaded() const
{
return _lastParsedPosition;
@@ -486,16 +486,16 @@ MediaParserFfmpeg::initializeParser()
// Create VideoInfo
if ( _videoStream) {
const int codec = static_cast<int>(_videoStream->codec->codec_id);
- boost::uint16_t width = _videoStream->codec->width;
- boost::uint16_t height = _videoStream->codec->height;
- boost::uint16_t frameRate = static_cast<boost::uint16_t>(
+ std::uint16_t width = _videoStream->codec->width;
+ std::uint16_t height = _videoStream->codec->height;
+ std::uint16_t frameRate = static_cast<std::uint16_t>(
as_double(_videoStream->avg_frame_rate));
#if !defined(HAVE_LIBAVFORMAT_AVFORMAT_H) && !defined(HAVE_FFMPEG_AVCODEC_H)
- boost::uint64_t duration = _videoStream->codec_info_duration;
+ std::uint64_t duration = _videoStream->codec_info_duration;
#else
- boost::uint64_t duration = _videoStream->duration;
+ std::uint64_t duration = _videoStream->duration;
#endif
- if (duration == static_cast<boost::uint64_t>(AV_NOPTS_VALUE)) {
+ if (duration == static_cast<std::uint64_t>(AV_NOPTS_VALUE)) {
log_error(_("Duration of video stream unknown"));
duration=0; // TODO: guess!
} else {
@@ -516,15 +516,15 @@ MediaParserFfmpeg::initializeParser()
if (_audioStream) {
const int codec = static_cast<int>(_audioStream->codec->codec_id);
- boost::uint16_t sampleRate = _audioStream->codec->sample_rate;
- boost::uint16_t sampleSize =
SampleFormatToSampleSize(_audioStream->codec->sample_fmt);
+ std::uint16_t sampleRate = _audioStream->codec->sample_rate;
+ std::uint16_t sampleSize =
SampleFormatToSampleSize(_audioStream->codec->sample_fmt);
bool stereo = (_audioStream->codec->channels == 2);
#if !defined(HAVE_LIBAVFORMAT_AVFORMAT_H) && !defined(HAVE_FFMPEG_AVCODEC_H)
- boost::uint64_t duration = _audioStream->codec_info_duration;
+ std::uint64_t duration = _audioStream->codec_info_duration;
#else
- boost::uint64_t duration = _audioStream->duration;
+ std::uint64_t duration = _audioStream->duration;
#endif
- if (duration == static_cast<boost::uint64_t>(AV_NOPTS_VALUE)) {
+ if (duration == static_cast<std::uint64_t>(AV_NOPTS_VALUE)) {
log_error(_("Duration of audio stream unknown to ffmpeg"));
duration=0; // TODO: guess!
}
@@ -570,7 +570,7 @@ MediaParserFfmpeg::~MediaParserFfmpeg()
// b) Even if we don't crash and burn, the FFMPEG parser is left in an
// undefined state.
int
-MediaParserFfmpeg::readPacket(boost::uint8_t* buf, int buf_size)
+MediaParserFfmpeg::readPacket(std::uint8_t* buf, int buf_size)
{
//GNASH_REPORT_FUNCTION;
//log_debug("readPacket(%d)", buf_size);
@@ -592,8 +592,8 @@ MediaParserFfmpeg::getId3Info() const
// a) The behaviour of C++ exceptions passed into C code is undefined.
// b) Even if we don't crash and burn, the FFMPEG parser is left in an
// undefined state.
-boost::int64_t
-MediaParserFfmpeg::seekMedia(boost::int64_t offset, int whence)
+std::int64_t
+MediaParserFfmpeg::seekMedia(std::int64_t offset, int whence)
{
//GNASH_REPORT_FUNCTION;
//log_debug("::seekMedia(%1%, %2%)", offset, whence);
@@ -640,7 +640,7 @@ MediaParserFfmpeg::seekMedia(boost::int64_t offset, int
whence)
return _stream->tell();
}
-boost::uint16_t
+std::uint16_t
MediaParserFfmpeg::SampleFormatToSampleSize(AVSampleFormat fmt)
{
#if LIBAVUTIL_VERSION_INT > AV_VERSION_INT(51,4,0)
diff --git a/libmedia/ffmpeg/MediaParserFfmpeg.h
b/libmedia/ffmpeg/MediaParserFfmpeg.h
index ff9146e..1b15e38 100644
--- a/libmedia/ffmpeg/MediaParserFfmpeg.h
+++ b/libmedia/ffmpeg/MediaParserFfmpeg.h
@@ -43,13 +43,13 @@ namespace ffmpeg {
class ExtraAudioInfoFfmpeg : public AudioInfo::ExtraInfo
{
public:
- ExtraAudioInfoFfmpeg(boost::uint8_t* nData, size_t nDataSize)
+ ExtraAudioInfoFfmpeg(std::uint8_t* nData, size_t nDataSize)
:
data(nData),
dataSize(nDataSize)
{
}
- boost::uint8_t* data;
+ std::uint8_t* data;
size_t dataSize;
};
@@ -60,13 +60,13 @@ public:
class ExtraVideoInfoFfmpeg : public VideoInfo::ExtraInfo
{
public:
- ExtraVideoInfoFfmpeg(boost::uint8_t* nData, size_t nDataSize)
+ ExtraVideoInfoFfmpeg(std::uint8_t* nData, size_t nDataSize)
:
data(nData),
dataSize(nDataSize)
{
}
- boost::uint8_t* data;
+ std::uint8_t* data;
size_t dataSize;
};
@@ -84,13 +84,13 @@ public:
~MediaParserFfmpeg();
// See dox in MediaParser.h
- virtual bool seek(boost::uint32_t&);
+ virtual bool seek(std::uint32_t&);
// See dox in MediaParser.h
virtual bool parseNextChunk();
// See dox in MediaParser.h
- virtual boost::uint64_t getBytesLoaded() const;
+ virtual std::uint64_t getBytesLoaded() const;
virtual boost::optional<Id3Info> getId3Info() const;
@@ -107,16 +107,16 @@ private:
bool parseNextFrame();
/// Input chunk reader, to be called by ffmpeg parser
- int readPacket(boost::uint8_t* buf, int buf_size);
+ int readPacket(std::uint8_t* buf, int buf_size);
/// ffmpeg callback function
- static int readPacketWrapper(void* opaque, boost::uint8_t* buf, int
buf_size);
+ static int readPacketWrapper(void* opaque, std::uint8_t* buf, int
buf_size);
/// Input stream seeker, to be called by ffmpeg parser
- boost::int64_t seekMedia(boost::int64_t offset, int whence);
+ std::int64_t seekMedia(std::int64_t offset, int whence);
/// ffmpeg callback function
- static boost::int64_t seekMediaWrapper(void *opaque, boost::int64_t
offset, int whence);
+ static std::int64_t seekMediaWrapper(void *opaque, std::int64_t offset,
int whence);
/// Read some of the input to figure an AVInputFormat
AVInputFormat* probeStream();
@@ -157,13 +157,13 @@ private:
std::unique_ptr<unsigned char[]> _byteIOBuffer;
/// The last parsed position, for getBytesLoaded
- boost::uint64_t _lastParsedPosition;
+ std::uint64_t _lastParsedPosition;
/// Return sample size from SampleFormat
//
/// TODO: move somewhere in ffmpeg utils..
///
- boost::uint16_t SampleFormatToSampleSize(AVSampleFormat fmt);
+ std::uint16_t SampleFormatToSampleSize(AVSampleFormat fmt);
/// Make an EncodedVideoFrame from an AVPacket and push to buffer
//
diff --git a/libmedia/ffmpeg/VideoConverterFfmpeg.cpp
b/libmedia/ffmpeg/VideoConverterFfmpeg.cpp
index bdd038f..7a30d95 100644
--- a/libmedia/ffmpeg/VideoConverterFfmpeg.cpp
+++ b/libmedia/ffmpeg/VideoConverterFfmpeg.cpp
@@ -171,7 +171,7 @@ VideoConverterFfmpeg::convert(const ImgBuf& src)
return ret;
}
- boost::uint8_t* dstbuffer = new boost::uint8_t[bufsize];
+ std::uint8_t* dstbuffer = new std::uint8_t[bufsize];
AVPicture dstpicture;
avpicture_fill(&dstpicture, dstbuffer, dst_pixFmt, width, height);
diff --git a/libmedia/ffmpeg/VideoDecoderFfmpeg.cpp
b/libmedia/ffmpeg/VideoDecoderFfmpeg.cpp
index 3178e6e..cbd1920 100644
--- a/libmedia/ffmpeg/VideoDecoderFfmpeg.cpp
+++ b/libmedia/ffmpeg/VideoDecoderFfmpeg.cpp
@@ -146,7 +146,7 @@ VideoDecoderFfmpeg::VideoDecoderFfmpeg(const VideoInfo&
info)
throw MediaException(msg.str());
}
- boost::uint8_t* extradata=0;
+ std::uint8_t* extradata=0;
int extradataSize=0;
if (info.extra.get())
{
@@ -171,7 +171,7 @@ VideoDecoderFfmpeg::VideoDecoderFfmpeg(const VideoInfo&
info)
void
VideoDecoderFfmpeg::init(enum CODECID codecId, int /*width*/, int /*height*/,
- boost::uint8_t* extradata, int extradataSize)
+ std::uint8_t* extradata, int extradataSize)
{
// Init the avdecoder-decoder
#if LIBAVCODEC_VERSION_INT < AV_VERSION_INT(52,6,2)
@@ -358,8 +358,8 @@ VideoDecoderFfmpeg::frameToImage(AVCodecContext* srcCtx,
}
std::unique_ptr<image::GnashImage>
-VideoDecoderFfmpeg::decode(const boost::uint8_t* input,
- boost::uint32_t input_size)
+VideoDecoderFfmpeg::decode(const std::uint8_t* input,
+ std::uint32_t input_size)
{
// This object shouldn't exist if there's no codec, as it can'
// do anything anyway.
diff --git a/libmedia/ffmpeg/VideoDecoderFfmpeg.h
b/libmedia/ffmpeg/VideoDecoderFfmpeg.h
index 4b15f0e..f0ea97e 100644
--- a/libmedia/ffmpeg/VideoDecoderFfmpeg.h
+++ b/libmedia/ffmpeg/VideoDecoderFfmpeg.h
@@ -84,10 +84,10 @@ private:
const AVFrame& srcFrame);
void init(enum CODECID format, int width, int height,
- boost::uint8_t* extradata=0, int extradataSize=0);
+ std::uint8_t* extradata=0, int extradataSize=0);
- std::unique_ptr<image::GnashImage> decode(const boost::uint8_t* input,
- boost::uint32_t input_size);
+ std::unique_ptr<image::GnashImage> decode(const std::uint8_t* input,
+ std::uint32_t input_size);
std::unique_ptr<image::GnashImage> decode(const EncodedVideoFrame* vf)
{
diff --git a/libmedia/ffmpeg/VideoInputFfmpeg.h
b/libmedia/ffmpeg/VideoInputFfmpeg.h
index 84b970a..a1c88fd 100644
--- a/libmedia/ffmpeg/VideoInputFfmpeg.h
+++ b/libmedia/ffmpeg/VideoInputFfmpeg.h
@@ -21,7 +21,7 @@
#define GNASH_VIDEOINPUTFFMPEG_H
#include <vector>
-#include <boost/cstdint.hpp> // for C99 int types
+#include <cstdint> // for C99 int types
#include <vector>
#include "VideoInput.h"
diff --git a/libmedia/gst/AudioDecoderGst.cpp b/libmedia/gst/AudioDecoderGst.cpp
index b930d08..68811f9 100644
--- a/libmedia/gst/AudioDecoderGst.cpp
+++ b/libmedia/gst/AudioDecoderGst.cpp
@@ -208,7 +208,7 @@ void AudioDecoderGst::setup(GstCaps* srccaps)
static void
buf_add(gpointer buf, gpointer data)
{
- boost::uint32_t* total = (boost::uint32_t*) data;
+ std::uint32_t* total = (std::uint32_t*) data;
GstBuffer* buffer = (GstBuffer*) buf;
*total += GST_BUFFER_SIZE(buffer);
@@ -216,8 +216,8 @@ buf_add(gpointer buf, gpointer data)
/* private */
-boost::uint8_t*
-AudioDecoderGst::pullBuffers(boost::uint32_t& outputSize)
+std::uint8_t*
+AudioDecoderGst::pullBuffers(std::uint32_t& outputSize)
{
outputSize = 0;
@@ -228,9 +228,9 @@ AudioDecoderGst::pullBuffers(boost::uint32_t& outputSize)
return 0;
}
- boost::uint8_t* rbuf = new boost::uint8_t[outputSize];
+ std::uint8_t* rbuf = new std::uint8_t[outputSize];
- boost::uint8_t* ptr = rbuf;
+ std::uint8_t* ptr = rbuf;
while (true) {
@@ -248,10 +248,10 @@ AudioDecoderGst::pullBuffers(boost::uint32_t& outputSize)
return rbuf;
}
-boost::uint8_t*
-AudioDecoderGst::decode(const boost::uint8_t* input, boost::uint32_t inputSize,
- boost::uint32_t& outputSize,
- boost::uint32_t& decodedData)
+std::uint8_t*
+AudioDecoderGst::decode(const std::uint8_t* input, std::uint32_t inputSize,
+ std::uint32_t& outputSize,
+ std::uint32_t& decodedData)
{
outputSize = decodedData = 0;
@@ -269,8 +269,8 @@ AudioDecoderGst::decode(const boost::uint8_t* input,
boost::uint32_t inputSize,
return pullBuffers(outputSize);
}
-boost::uint8_t*
-AudioDecoderGst::decode(const EncodedAudioFrame& ef, boost::uint32_t&
outputSize)
+std::uint8_t*
+AudioDecoderGst::decode(const EncodedAudioFrame& ef, std::uint32_t& outputSize)
{
outputSize = 0;
diff --git a/libmedia/gst/AudioDecoderGst.h b/libmedia/gst/AudioDecoderGst.h
index f527611..4ff299c 100644
--- a/libmedia/gst/AudioDecoderGst.h
+++ b/libmedia/gst/AudioDecoderGst.h
@@ -49,13 +49,13 @@ public:
~AudioDecoderGst();
- boost::uint8_t* decode(const boost::uint8_t* input, boost::uint32_t
inputSize,
- boost::uint32_t& outputSize, boost::uint32_t&
decodedData);
- boost::uint8_t* decode(const EncodedAudioFrame& ef, boost::uint32_t&
outputSize);
+ std::uint8_t* decode(const std::uint8_t* input, std::uint32_t inputSize,
+ std::uint32_t& outputSize, std::uint32_t&
decodedData);
+ std::uint8_t* decode(const EncodedAudioFrame& ef, std::uint32_t&
outputSize);
private:
- boost::uint8_t* pullBuffers(boost::uint32_t& outputSize);
+ std::uint8_t* pullBuffers(std::uint32_t& outputSize);
void setup(GstCaps* caps);
diff --git a/libmedia/gst/AudioInputGst.h b/libmedia/gst/AudioInputGst.h
index e7fb608..784fb1c 100644
--- a/libmedia/gst/AudioInputGst.h
+++ b/libmedia/gst/AudioInputGst.h
@@ -23,7 +23,7 @@
#include "gst/gst.h"
#include "AudioInput.h"
#include <string>
-#include <boost/cstdint.hpp> // for C99 int types
+#include <cstdint> // for C99 int types
#include <vector>
#include <cassert>
diff --git a/libmedia/gst/MediaHandlerGst.cpp b/libmedia/gst/MediaHandlerGst.cpp
index 90e0589..d87a2de 100644
--- a/libmedia/gst/MediaHandlerGst.cpp
+++ b/libmedia/gst/MediaHandlerGst.cpp
@@ -97,7 +97,7 @@ MediaHandlerGst::createVideoDecoder(const VideoInfo& info)
int width = info.width;
int height = info.height;
- boost::uint8_t* extradata = 0;
+ std::uint8_t* extradata = 0;
size_t datasize = 0;
ExtraVideoInfoFlv* extrainfo =
dynamic_cast<ExtraVideoInfoFlv*>(info.extra.get());
diff --git a/libmedia/gst/MediaParserGst.cpp b/libmedia/gst/MediaParserGst.cpp
index 3a4e5cc..2cf1a6a 100644
--- a/libmedia/gst/MediaParserGst.cpp
+++ b/libmedia/gst/MediaParserGst.cpp
@@ -105,7 +105,7 @@ MediaParserGst::~MediaParserGst()
}
bool
-MediaParserGst::seek(boost::uint32_t& milliseconds)
+MediaParserGst::seek(std::uint32_t& milliseconds)
{
return gst_element_seek_simple(_bin, GST_FORMAT_TIME,
GstSeekFlags(GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_KEY_UNIT),
@@ -148,7 +148,7 @@ MediaParserGst::parseNextChunk()
}
-boost::uint64_t
+std::uint64_t
MediaParserGst::getBytesLoaded() const
{
boost::mutex::scoped_lock lock(_bytesLoadedMutex);
diff --git a/libmedia/gst/MediaParserGst.h b/libmedia/gst/MediaParserGst.h
index 9fde206..d1aef73 100644
--- a/libmedia/gst/MediaParserGst.h
+++ b/libmedia/gst/MediaParserGst.h
@@ -94,7 +94,7 @@ public:
}
private:
- boost::uint64_t _start_time;
+ std::uint64_t _start_time;
};
@@ -113,13 +113,13 @@ public:
~MediaParserGst();
// See dox in MediaParser.h
- bool seek(boost::uint32_t&);
+ bool seek(std::uint32_t&);
// See dox in MediaParser.h
bool parseNextChunk();
// See dox in MediaParser.h
- virtual boost::uint64_t getBytesLoaded() const;
+ virtual std::uint64_t getBytesLoaded() const;
virtual boost::optional<Id3Info> getId3Info() const;
diff --git a/libmedia/gst/VideoConverterGst.cpp
b/libmedia/gst/VideoConverterGst.cpp
index b2cacc5..26c8916 100644
--- a/libmedia/gst/VideoConverterGst.cpp
+++ b/libmedia/gst/VideoConverterGst.cpp
@@ -133,7 +133,7 @@ VideoConverterGst::convert(const ImgBuf& src)
GstBuffer* buffer = gst_buffer_new();
- GST_BUFFER_DATA(buffer) = const_cast<boost::uint8_t*>(src.data);
+ GST_BUFFER_DATA(buffer) = const_cast<std::uint8_t*>(src.data);
GST_BUFFER_SIZE(buffer) = src.size;
GST_BUFFER_FLAG_SET(buffer, GST_BUFFER_FLAG_READONLY);
diff --git a/libmedia/gst/VideoDecoderGst.cpp b/libmedia/gst/VideoDecoderGst.cpp
index 02b693f..61a50f8 100644
--- a/libmedia/gst/VideoDecoderGst.cpp
+++ b/libmedia/gst/VideoDecoderGst.cpp
@@ -53,7 +53,7 @@ VideoDecoderGst::height() const
// TODO: either use width and height or remove them!
VideoDecoderGst::VideoDecoderGst(videoCodecType codec_type,
int /*width*/, int /*height*/,
- const boost::uint8_t* extradata, size_t extradatasize)
+ const std::uint8_t* extradata, size_t extradatasize)
:
_width(0),
_height(0)
@@ -177,7 +177,7 @@ VideoDecoderGst::push(const EncodedVideoFrame& frame)
} else {
buffer = gst_buffer_new();
- GST_BUFFER_DATA(buffer) = const_cast<boost::uint8_t*>(frame.data());
+ GST_BUFFER_DATA(buffer) = const_cast<std::uint8_t*>(frame.data());
GST_BUFFER_SIZE(buffer) = frame.dataSize();
GST_BUFFER_OFFSET(buffer) = frame.frameNum();
GST_BUFFER_TIMESTAMP(buffer) = GST_CLOCK_TIME_NONE;
diff --git a/libmedia/gst/VideoDecoderGst.h b/libmedia/gst/VideoDecoderGst.h
index f63d6bb..b86e02c 100644
--- a/libmedia/gst/VideoDecoderGst.h
+++ b/libmedia/gst/VideoDecoderGst.h
@@ -74,7 +74,7 @@ class DSOEXPORT VideoDecoderGst : public VideoDecoder
{
public:
VideoDecoderGst(videoCodecType codec_type, int width, int height,
- const boost::uint8_t* extradata, size_t extradatasize);
+ const std::uint8_t* extradata, size_t extradatasize);
VideoDecoderGst(GstCaps* caps);
~VideoDecoderGst();
diff --git a/libmedia/gst/VideoInputGst.h b/libmedia/gst/VideoInputGst.h
index 1025a0a..2e28b67 100644
--- a/libmedia/gst/VideoInputGst.h
+++ b/libmedia/gst/VideoInputGst.h
@@ -21,7 +21,7 @@
#define GNASH_VIDEOINPUTGST_H
#include <vector>
-#include <boost/cstdint.hpp> // for C99 int types
+#include <cstdint> // for C99 int types
#include "VideoInput.h"
#include "gst/gst.h"
diff --git a/libmedia/haiku/AudioDecoderHaiku.cpp
b/libmedia/haiku/AudioDecoderHaiku.cpp
index 4b4185d..d86c2ec 100644
--- a/libmedia/haiku/AudioDecoderHaiku.cpp
+++ b/libmedia/haiku/AudioDecoderHaiku.cpp
@@ -51,20 +51,20 @@ AudioDecoderHaiku::~AudioDecoderHaiku()
QQ(2);
}
-boost::uint8_t*
-AudioDecoderHaiku::decode(const boost::uint8_t* input, boost::uint32_t
inputSize, boost::uint32_t& outputSize, boost::uint32_t& decodedBytes)
+std::uint8_t*
+AudioDecoderHaiku::decode(const std::uint8_t* input, std::uint32_t inputSize,
std::uint32_t& outputSize, std::uint32_t& decodedBytes)
{
(void) input;
(void) parse;
- boost::uint8_t *t;
+ std::uint8_t *t;
outputSize = 2048;
decodedBytes = inputSize;
- t = new boost::uint8_t[outputSize];
+ t = new std::uint8_t[outputSize];
- boost::uint16_t *data =
- reinterpret_cast<boost::uint16_t*>(t);
+ std::uint16_t *data =
+ reinterpret_cast<std::uint16_t*>(t);
- for (size_t i = 0; i < outputSize / sizeof(boost::uint16_t); ++i)
+ for (size_t i = 0; i < outputSize / sizeof(std::uint16_t); ++i)
{
data[i] = 1000 * sin(i/10.);
}
@@ -73,8 +73,8 @@ AudioDecoderHaiku::decode(const boost::uint8_t* input,
boost::uint32_t inputSize
return t;
}
-boost::uint8_t*
-AudioDecoderHaiku::decode(const EncodedAudioFrame& af, boost::uint32_t&
outputSize)
+std::uint8_t*
+AudioDecoderHaiku::decode(const EncodedAudioFrame& af, std::uint32_t&
outputSize)
{
QQ(2);
return NULL;
diff --git a/libmedia/haiku/AudioDecoderHaiku.h
b/libmedia/haiku/AudioDecoderHaiku.h
index 92252a1..46f9e5d 100644
--- a/libmedia/haiku/AudioDecoderHaiku.h
+++ b/libmedia/haiku/AudioDecoderHaiku.h
@@ -54,16 +54,16 @@ public:
~AudioDecoderHaiku();
// See dox in AudioDecoder.h
- boost::uint8_t* decode(const boost::uint8_t* input, boost::uint32_t
inputSize, boost::uint32_t& outputSize, boost::uint32_t& decodedBytes);
+ std::uint8_t* decode(const std::uint8_t* input, std::uint32_t
inputSize, std::uint32_t& outputSize, std::uint32_t& decodedBytes);
- boost::uint8_t* decode(const EncodedAudioFrame& af, boost::uint32_t&
outputSize);
+ std::uint8_t* decode(const EncodedAudioFrame& af, std::uint32_t&
outputSize);
private:
//
// void setup(const AudioInfo& info);
// void setup(SoundInfo& info);
//
-// boost::uint8_t* decodeFrame(const boost::uint8_t* input,
boost::uint32_t inputSize, boost::uint32_t& outputSize);
+// std::uint8_t* decodeFrame(const std::uint8_t* input, std::uint32_t
inputSize, std::uint32_t& outputSize);
//
// AVCodec* _audioCodec;
// AVCodecContext* _audioCodecCtx;
@@ -93,8 +93,8 @@ private:
// ///
// /// @return number of input bytes parsed, or -1 on error
// ///
-// int parseInput(const boost::uint8_t* input, boost::uint32_t inputSize,
-// boost::uint8_t const ** outFrame, int* outFrameSize);
+// int parseInput(const std::uint8_t* input, std::uint32_t inputSize,
+// std::uint8_t const ** outFrame, int* outFrameSize);
};
} // gnash.media.haiku namespace
diff --git a/libmedia/haiku/AudioInputHaiku.h b/libmedia/haiku/AudioInputHaiku.h
index d676914..e567122 100644
--- a/libmedia/haiku/AudioInputHaiku.h
+++ b/libmedia/haiku/AudioInputHaiku.h
@@ -23,7 +23,7 @@
#include "dsodefs.h" //DSOEXPORT
#include "AudioInput.h"
-#include <boost/cstdint.hpp> // for C99 int types
+#include <cstdint> // for C99 int types
#include <string>
namespace gnash {
diff --git a/libmedia/haiku/MediaParserHaiku.cpp
b/libmedia/haiku/MediaParserHaiku.cpp
index ea5e89a..576ce50 100644
--- a/libmedia/haiku/MediaParserHaiku.cpp
+++ b/libmedia/haiku/MediaParserHaiku.cpp
@@ -48,7 +48,7 @@ MediaParserHaiku::~MediaParserHaiku()
}
bool
-MediaParserHaiku::seek(boost::uint32_t&)
+MediaParserHaiku::seek(std::uint32_t&)
{
QQ(2);
}
@@ -59,7 +59,7 @@ MediaParserHaiku::parseNextChunk()
QQ(2);
}
-boost::uint64_t
+std::uint64_t
MediaParserHaiku::getBytesLoaded() const
{
QQ(2);
diff --git a/libmedia/haiku/MediaParserHaiku.h
b/libmedia/haiku/MediaParserHaiku.h
index d58e5fa..b6cac92 100644
--- a/libmedia/haiku/MediaParserHaiku.h
+++ b/libmedia/haiku/MediaParserHaiku.h
@@ -47,13 +47,13 @@ public:
~MediaParserHaiku();
// See dox in MediaParser.h
- virtual bool seek(boost::uint32_t&);
+ virtual bool seek(std::uint32_t&);
// See dox in MediaParser.h
virtual bool parseNextChunk();
// See dox in MediaParser.h
- virtual boost::uint64_t getBytesLoaded() const;
+ virtual std::uint64_t getBytesLoaded() const;
};
diff --git a/libmedia/haiku/VideoDecoderHaiku.cpp
b/libmedia/haiku/VideoDecoderHaiku.cpp
index a49a986..91da37f 100644
--- a/libmedia/haiku/VideoDecoderHaiku.cpp
+++ b/libmedia/haiku/VideoDecoderHaiku.cpp
@@ -64,12 +64,12 @@ VideoDecoderHaiku::pop()
{
std::unique_ptr<GnashImage> ret;
ret.reset(new ImageRGB(100, 100));
- boost::uint8_t *d =
- new boost::uint8_t[100*100*4];
+ std::uint8_t *d =
+ new std::uint8_t[100*100*4];
for (int i = 0; i < 100*100*4; ++i)
{
- d[i] *= 1 - (boost::uint8_t) 2*(rand()%2);
- d[i] += (boost::uint8_t) rand()/64;
+ d[i] *= 1 - (std::uint8_t) 2*(rand()%2);
+ d[i] += (std::uint8_t) rand()/64;
}
ret->update(d);
delete [] d;
diff --git a/libmedia/haiku/VideoDecoderHaiku.h
b/libmedia/haiku/VideoDecoderHaiku.h
index 9462225..aeece62 100644
--- a/libmedia/haiku/VideoDecoderHaiku.h
+++ b/libmedia/haiku/VideoDecoderHaiku.h
@@ -40,7 +40,7 @@ class DSOEXPORT VideoDecoderHaiku : public VideoDecoder
{
public:
//VideoDecoderGst(videoCodecType codec_type, int width, int height,
- // const boost::uint8_t* extradata, size_t extradatasize);
+ // const std::uint8_t* extradata, size_t extradatasize);
//VideoDecoderGst(GstCaps* caps);
VideoDecoderHaiku(const VideoInfo& info);
~VideoDecoderHaiku();
diff --git a/libmedia/haiku/VideoInputHaiku.h b/libmedia/haiku/VideoInputHaiku.h
index 2e079e6..a2a3f1b 100644
--- a/libmedia/haiku/VideoInputHaiku.h
+++ b/libmedia/haiku/VideoInputHaiku.h
@@ -20,7 +20,7 @@
#define GNASH_VIDEOINPUTHAIKU_H
#include <vector>
-#include <boost/cstdint.hpp> // for C99 int types
+#include <cstdint> // for C99 int types
#include "VideoInput.h"
namespace gnash {
diff --git a/librender/GnashTexture.cpp b/librender/GnashTexture.cpp
index bd75262..b4026f8 100644
--- a/librender/GnashTexture.cpp
+++ b/librender/GnashTexture.cpp
@@ -204,7 +204,7 @@ void GnashTexture::release()
}
// Update texture with data
-void GnashTexture::update(const boost::uint8_t *data)
+void GnashTexture::update(const std::uint8_t *data)
{
D(bug("GnashTexture::update(): data %p, size %dx%d\n", data, _width,
_height));
diff --git a/librender/GnashTexture.h b/librender/GnashTexture.h
index 4e3ab8d..6329f40 100644
--- a/librender/GnashTexture.h
+++ b/librender/GnashTexture.h
@@ -109,7 +109,7 @@ public:
/// (or derivative thereof) or unexpected things will happen.
///
/// @param data buffer to copy data from.
- void update(const boost::uint8_t *data);
+ void update(const std::uint8_t *data);
};
} // gnash namespace
diff --git a/librender/agg/Renderer_agg.cpp b/librender/agg/Renderer_agg.cpp
index 6325bfb..83d7305 100644
--- a/librender/agg/Renderer_agg.cpp
+++ b/librender/agg/Renderer_agg.cpp
@@ -337,7 +337,7 @@ public:
_pixf(_rbuf),
_rbase(_pixf),
_amask(_rbuf),
- _buffer(new boost::uint8_t[width * height]())
+ _buffer(new std::uint8_t[width * height]())
{
_rbuf.attach(_buffer.get(), width, height, width);
}
@@ -386,7 +386,7 @@ private:
Mask _amask;
// in-memory buffer
- std::unique_ptr<boost::uint8_t[]> _buffer;
+ std::unique_ptr<std::uint8_t[]> _buffer;
};
@@ -2047,10 +2047,10 @@ private: // private variables
bool is_little_endian_host() {
union {
- boost::uint16_t word;
+ std::uint16_t word;
struct {
- boost::uint8_t b1;
- boost::uint8_t b2;
+ std::uint8_t b1;
+ std::uint8_t b2;
} s;
} u;
diff --git a/librender/agg/Renderer_agg_bitmap.h
b/librender/agg/Renderer_agg_bitmap.h
index 7905766..4bd6e5d 100644
--- a/librender/agg/Renderer_agg_bitmap.h
+++ b/librender/agg/Renderer_agg_bitmap.h
@@ -21,7 +21,7 @@
#include <memory>
#include <memory>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "GnashImage.h"
#include "CachedBitmap.h"
@@ -56,7 +56,7 @@ public:
int get_height() const { return _image->height(); }
int get_bpp() const { return _bpp; }
int get_rowlen() const { return _image->stride(); }
- boost::uint8_t* get_data() const { return _image->begin(); }
+ std::uint8_t* get_data() const { return _image->begin(); }
private:
diff --git a/librender/agg/Renderer_agg_style.h
b/librender/agg/Renderer_agg_style.h
index 64b06d5..9c2d197 100644
--- a/librender/agg/Renderer_agg_style.h
+++ b/librender/agg/Renderer_agg_style.h
@@ -364,7 +364,7 @@ class BitmapStyle : public AggStyle
{
public:
- BitmapStyle(int width, int height, int rowlen, boost::uint8_t* data,
+ BitmapStyle(int width, int height, int rowlen, std::uint8_t* data,
const SWFMatrix& mat, const SWFCxForm& cx)
:
AggStyle(false),
diff --git a/librender/cairo/Renderer_cairo.cpp
b/librender/cairo/Renderer_cairo.cpp
index 2c39e37..ba25e5c 100644
--- a/librender/cairo/Renderer_cairo.cpp
+++ b/librender/cairo/Renderer_cairo.cpp
@@ -66,12 +66,12 @@ namespace {
// Converts from RGB image to 32-bit pixels in CAIRO_FORMAT_RGB24 format
static void
-rgb_to_cairo_rgb24(boost::uint8_t* dst, const image::GnashImage* im)
+rgb_to_cairo_rgb24(std::uint8_t* dst, const image::GnashImage* im)
{
- boost::uint32_t* dst32 = reinterpret_cast<boost::uint32_t*>(dst);
+ std::uint32_t* dst32 = reinterpret_cast<std::uint32_t*>(dst);
for (size_t y = 0; y < im->height(); y++)
{
- const boost::uint8_t* src = scanline(*im, y);
+ const std::uint8_t* src = scanline(*im, y);
for (size_t x = 0; x < im->width(); x++, src += 3) {
*dst32++ = (src[0] << 16) | (src[1] << 8) | src[2];
}
@@ -80,15 +80,15 @@ rgb_to_cairo_rgb24(boost::uint8_t* dst, const
image::GnashImage* im)
// Converts from RGBA image to 32-bit pixels in CAIRO_FORMAT_ARGB32 format
static void
-rgba_to_cairo_argb(boost::uint8_t* dst, const image::GnashImage* im)
+rgba_to_cairo_argb(std::uint8_t* dst, const image::GnashImage* im)
{
- boost::uint32_t* dst32 = reinterpret_cast<boost::uint32_t*>(dst);
+ std::uint32_t* dst32 = reinterpret_cast<std::uint32_t*>(dst);
for (size_t y = 0; y < im->height(); y++)
{
- const boost::uint8_t* src = scanline(*im, y);
+ const std::uint8_t* src = scanline(*im, y);
for (size_t x = 0; x < im->width(); x++, src += 4)
{
- const boost::uint8_t& r = src[0],
+ const std::uint8_t& r = src[0],
g = src[1],
b = src[2],
a = src[3];
@@ -105,7 +105,7 @@ rgba_to_cairo_argb(boost::uint8_t* dst, const
image::GnashImage* im)
class bitmap_info_cairo : public CachedBitmap, boost::noncopyable
{
public:
- bitmap_info_cairo(boost::uint8_t* data, int width, int height,
+ bitmap_info_cairo(std::uint8_t* data, int width, int height,
size_t bpp, cairo_format_t format)
:
_data(data),
@@ -150,8 +150,8 @@ class bitmap_info_cairo : public CachedBitmap,
boost::noncopyable
// We assume that cairo uses machine-endian order, as that's what
// the existing conversion functions do.
- boost::uint32_t* start =
- reinterpret_cast<boost::uint32_t*>(_data.get());
+ std::uint32_t* start =
+ reinterpret_cast<std::uint32_t*>(_data.get());
const size_t sz = _width * _height;
std::copy(start, start + sz, image::begin<image::ARGB>(*_image));
return *_image;
@@ -207,7 +207,7 @@ class bitmap_info_cairo : public CachedBitmap,
boost::noncopyable
private:
mutable std::unique_ptr<image::GnashImage> _image;
- std::unique_ptr<boost::uint8_t[]> _data;
+ std::unique_ptr<std::uint8_t[]> _data;
int _width;
int _height;
size_t _bytes_per_pixel;
@@ -463,7 +463,7 @@ CachedBitmap*
Renderer_cairo::createCachedBitmap(std::unique_ptr<image::GnashImage> im)
{
int buf_size = im->width() * im->height() * 4;
- boost::uint8_t* buffer = new boost::uint8_t[buf_size];
+ std::uint8_t* buffer = new std::uint8_t[buf_size];
switch (im->type())
{
@@ -528,7 +528,7 @@ Renderer_cairo::drawVideoFrame(image::GnashImage*
baseframe, const Transform& xf
size_t buf_size = w * h * 4;
if (_video_bufsize < buf_size) {
- _video_buffer.reset(new boost::uint8_t[buf_size]);
+ _video_buffer.reset(new std::uint8_t[buf_size]);
_video_bufsize = buf_size;
}
@@ -560,7 +560,7 @@ Renderer_cairo::drawVideoFrame(image::GnashImage*
baseframe, const Transform& xf
cairo_save(_cr);
cairo_set_source(_cr, pattern);
- geometry::Range2d<boost::int32_t> range = bounds->getRange();
+ geometry::Range2d<std::int32_t> range = bounds->getRange();
xform.matrix.transform(range);
cairo_rectangle(_cr, range.getMinX(), range.getMinY(), range.width(),
@@ -633,7 +633,7 @@ Renderer_cairo::begin_display(const rgba& bg_color,
for (size_t rno=0; rno < _invalidated_ranges.size(); rno++) {
- const geometry::Range2d<boost::int32_t>& range =
+ const geometry::Range2d<std::int32_t>& range =
_invalidated_ranges.getRange(rno);
if (range.isNull()) {
continue;
diff --git a/librender/cairo/Renderer_cairo.h b/librender/cairo/Renderer_cairo.h
index 1583e9d..27f7674 100644
--- a/librender/cairo/Renderer_cairo.h
+++ b/librender/cairo/Renderer_cairo.h
@@ -126,7 +126,7 @@ public:
private:
/// The cairo context.
cairo_t* _cr;
- std::unique_ptr<boost::uint8_t[]> _video_buffer;
+ std::unique_ptr<std::uint8_t[]> _video_buffer;
std::vector<PathVec> _masks;
size_t _video_bufsize;
bool _drawing_mask;
diff --git a/librender/opengl/Renderer_ogl.cpp
b/librender/opengl/Renderer_ogl.cpp
index 40306a7..7e12fda 100644
--- a/librender/opengl/Renderer_ogl.cpp
+++ b/librender/opengl/Renderer_ogl.cpp
@@ -162,7 +162,7 @@ public:
private:
inline bool ogl_accessible() const;
void setup() const;
- void upload(boost::uint8_t* data, size_t width, size_t height) const;
+ void upload(std::uint8_t* data, size_t width, size_t height) const;
mutable std::unique_ptr<image::GnashImage> _img;
mutable std::unique_ptr<image::GnashImage> _cache;
@@ -223,7 +223,7 @@ public:
OSRenderMesa(size_t width, size_t height)
: _width(width),
_height(height),
- _buffer(new boost::uint8_t[width * height * 3]),
+ _buffer(new std::uint8_t[width * height * 3]),
#if OSMESA_MAJOR_VERSION * 100 + OSMESA_MINOR_VERSION >= 305
_context(OSMesaCreateContextExt(OSMESA_RGB, 0, 2, 0, NULL))
#else
@@ -279,7 +279,7 @@ public:
private:
size_t _width;
size_t _height;
- std::unique_ptr<boost::uint8_t[]> _buffer;
+ std::unique_ptr<std::uint8_t[]> _buffer;
OSMesaContext _context;
};
@@ -357,7 +357,7 @@ class
PointSerializer
{
public:
- PointSerializer(std::vector<boost::int16_t>& dest)
+ PointSerializer(std::vector<std::int16_t>& dest)
:
_dest(dest)
{}
@@ -368,7 +368,7 @@ public:
_dest.push_back(p.y);
}
private:
- std::vector<boost::int16_t>& _dest;
+ std::vector<std::int16_t>& _dest;
};
}
@@ -596,8 +596,8 @@ bitmap_info_ogl::setup() const
while (h < _img->height()) { h <<= 1; }
}
- std::unique_ptr<boost::uint8_t[]> resized_data(
- new boost::uint8_t[w * h * _img->channels()]);
+ std::unique_ptr<std::uint8_t[]> resized_data(
+ new std::uint8_t[w * h * _img->channels()]);
// Q: Would mipmapping these textures aid in performance?
GLint rv = gluScaleImage(_pixel_format, _img->width(),
@@ -615,7 +615,7 @@ bitmap_info_ogl::setup() const
}
void
-bitmap_info_ogl::upload(boost::uint8_t* data, size_t width, size_t height)
const
+bitmap_info_ogl::upload(std::uint8_t* data, size_t width, size_t height) const
{
glTexParameteri(_ogl_img_type, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
@@ -1088,7 +1088,7 @@ public:
glColor3ub(color.m_r, color.m_g, color.m_b);
- std::vector<boost::int16_t> pointList;
+ std::vector<std::int16_t> pointList;
pointList.reserve(numPoints * 2);
std::for_each(coords.begin(), coords.end(), PointSerializer(pointList));
@@ -1099,7 +1099,7 @@ public:
// Draw a dot on the beginning and end coordinates to round lines.
// glVertexPointer: skip all but the first and last coordinates in the
line.
- glVertexPointer(2, GL_SHORT, (sizeof(boost::int16_t) * 2) *
+ glVertexPointer(2, GL_SHORT, (sizeof(std::int16_t) * 2) *
(numPoints - 1), &pointList.front());
glEnable(GL_POINT_SMOOTH); // Draw a round (antialiased) point.
glDrawArrays(GL_POINTS, 0, 2);
@@ -1838,7 +1838,7 @@ private:
std::vector<PathVec> _masks;
bool _drawing_mask;
- std::vector<boost::uint8_t> _render_indices;
+ std::vector<std::uint8_t> _render_indices;
std::vector< std::shared_ptr<GnashTexture> > _render_textures;
std::list< std::shared_ptr<GnashTexture> > _cached_textures;
@@ -1862,7 +1862,7 @@ namespace {
// TODO: this function is rubbish and shouldn't survive a rewritten OGL
// renderer.
rgba
-sampleGradient(const GradientFill& fill, boost::uint8_t ratio)
+sampleGradient(const GradientFill& fill, std::uint8_t ratio)
{
// By specs, first gradient should *always* be 0,
diff --git a/librender/opengles1/Renderer_gles1.h
b/librender/opengles1/Renderer_gles1.h
index 203a1eb..081c3cd 100644
--- a/librender/opengles1/Renderer_gles1.h
+++ b/librender/opengles1/Renderer_gles1.h
@@ -118,7 +118,7 @@ public:
private:
inline bool ogl_accessible() const;
void setup() const;
- void upload(boost::uint8_t* data, size_t width, size_t height) const;
+ void upload(std::uint8_t* data, size_t width, size_t height) const;
mutable std::unique_ptr<GnashImage> _img;
GLenum _pixel_format;
diff --git a/librender/openvg/OpenVGBitmap.h b/librender/openvg/OpenVGBitmap.h
index d2b4b21..cb31955 100644
--- a/librender/openvg/OpenVGBitmap.h
+++ b/librender/openvg/OpenVGBitmap.h
@@ -60,7 +60,7 @@ public:
VGPaint getFillPaint() const { return _vgpaint; }
int getWidth() { return _image->width(); }
int getHeight() { return _image->height(); }
- boost::uint8_t *getData() const { return _image->begin(); }
+ std::uint8_t *getData() const { return _image->begin(); }
OpenVGBitmap *createRadialBitmap(float x0, float y0, float x1, float y1,
float radial, const SWFCxForm& cx,
diff --git a/librender/testr.cpp b/librender/testr.cpp
index 167b419..5fa0ff5 100644
--- a/librender/testr.cpp
+++ b/librender/testr.cpp
@@ -405,9 +405,9 @@ test_renderer(Renderer *renderer, const std::string &type)
/// @vertex_count the number of x-y coordinates (vertices).
/// @color the color to be used to draw the line strip.
/// @mat the SWFMatrix to be used to transform the vertices.
- boost::uint16_t x = 10;
- boost::uint16_t y = 10;
- boost::uint16_t h = 10;
+ std::uint16_t x = 10;
+ std::uint16_t y = 10;
+ std::uint16_t h = 10;
std::vector<point> box = boost::assign::list_of
(point(x, y))
(point(x, y + h));
diff --git a/libsound/AuxStream.h b/libsound/AuxStream.h
index 5f87fea..f81f8e3 100644
--- a/libsound/AuxStream.h
+++ b/libsound/AuxStream.h
@@ -22,14 +22,14 @@
#include "InputStream.h" // for inheritance
-#include <boost/cstdint.hpp> // For C99 int types
+#include <cstdint> // For C99 int types
namespace gnash {
namespace sound {
/// @see sound_handler::attach_aux_streamer
typedef unsigned int (*aux_streamer_ptr)(void *udata,
- boost::int16_t* samples, unsigned int nSamples, bool& eof);
+ std::int16_t* samples, unsigned int nSamples, bool& eof);
class AuxStream : public InputStream {
public:
@@ -42,7 +42,7 @@ public:
{}
// See dox in InputStream.h
- unsigned int fetchSamples(boost::int16_t* to, unsigned int nSamples)
+ unsigned int fetchSamples(std::int16_t* to, unsigned int nSamples)
{
unsigned int wrote = _cb(_cbArg, to, nSamples, _eof);
_samplesFetched += wrote;
diff --git a/libsound/EmbedSound.cpp b/libsound/EmbedSound.cpp
index afd581f..78dab45 100644
--- a/libsound/EmbedSound.cpp
+++ b/libsound/EmbedSound.cpp
@@ -21,7 +21,7 @@
#include "EmbedSound.h"
#include <vector>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "EmbedSoundInst.h"
#include "SoundInfo.h"
diff --git a/libsound/EmbedSound.h b/libsound/EmbedSound.h
index 738aa6a..426d4dc 100644
--- a/libsound/EmbedSound.h
+++ b/libsound/EmbedSound.h
@@ -75,7 +75,7 @@ public:
}
/// Return a pointer to the underlying buffer
- const boost::uint8_t* data() const {
+ const std::uint8_t* data() const {
return _buf->data();
}
@@ -84,7 +84,7 @@ public:
/// @param pos The offset value.
/// An assertion will fail if pos > size()
///
- const boost::uint8_t* data(size_t pos) const {
+ const std::uint8_t* data(size_t pos) const {
assert(pos < _buf->size());
return _buf->data()+pos;
}
diff --git a/libsound/EmbedSoundInst.cpp b/libsound/EmbedSoundInst.cpp
index cecfb52..3f5e2f0 100644
--- a/libsound/EmbedSoundInst.cpp
+++ b/libsound/EmbedSoundInst.cpp
@@ -96,9 +96,9 @@ EmbedSoundInst::decodeNextBlock()
// to decode not to bother further streamlining it
// See https://savannah.gnu.org/bugs/?25456 for a testcase
// showing the benefit of chunked decoding.
- const boost::uint32_t chunkSize = 65535;
+ const std::uint32_t chunkSize = 65535;
- boost::uint32_t inputSize = _soundDef.size() - decodingPosition;
+ std::uint32_t inputSize = _soundDef.size() - decodingPosition;
if ( inputSize > chunkSize ) inputSize = chunkSize;
#ifdef GNASH_DEBUG_SOUNDS_DECODING
@@ -106,11 +106,11 @@ EmbedSoundInst::decodeNextBlock()
#endif
assert(inputSize);
- const boost::uint8_t* input = _soundDef.data(decodingPosition);
+ const std::uint8_t* input = _soundDef.data(decodingPosition);
- boost::uint32_t consumed = 0;
- boost::uint32_t decodedDataSize = 0;
- boost::uint8_t* decodedData = decoder().decode(input, inputSize,
+ std::uint32_t consumed = 0;
+ std::uint32_t decodedDataSize = 0;
+ std::uint8_t* decodedData = decoder().decode(input, inputSize,
decodedDataSize, consumed);
decodingPosition += consumed;
@@ -118,7 +118,7 @@ EmbedSoundInst::decodeNextBlock()
assert(!(decodedDataSize%2));
// @todo I hope there are no alignment issues in this cast from int8_t* to
int16_t* !
- boost::int16_t* samples = reinterpret_cast<boost::int16_t*>(decodedData);
+ std::int16_t* samples = reinterpret_cast<std::int16_t*>(decodedData);
unsigned int nSamples = decodedDataSize/2;
#ifdef GNASH_DEBUG_MIXING
@@ -148,7 +148,7 @@ EmbedSoundInst::decodeNextBlock()
}
void
-EmbedSoundInst::applyEnvelopes(boost::int16_t* samples, unsigned int nSamples,
+EmbedSoundInst::applyEnvelopes(std::int16_t* samples, unsigned int nSamples,
unsigned int firstSampleOffset, const SoundEnvelopes& env)
{
@@ -168,7 +168,7 @@ EmbedSoundInst::applyEnvelopes(boost::int16_t* samples,
unsigned int nSamples,
assert(env[current_env].m_mark44 < firstSampleOffset+nSamples);
// Get next envelope position (absolute samples offset)
- boost::uint32_t next_env_pos = 0;
+ std::uint32_t next_env_pos = 0;
if (current_env == (env.size() - 1)) {
// If there is no "next envelope" then set the next envelope
// start point to be unreachable
diff --git a/libsound/EmbedSoundInst.h b/libsound/EmbedSoundInst.h
index 27ff8cf..de88ada 100644
--- a/libsound/EmbedSoundInst.h
+++ b/libsound/EmbedSoundInst.h
@@ -21,7 +21,7 @@
#define SOUND_EMBEDSOUNDINST_H
#include <cassert>
-#include <boost/cstdint.hpp> // For C99 int types
+#include <cstdint> // For C99 int types
#include <limits>
#include "EmbedSound.h"
@@ -104,7 +104,7 @@ private:
///
/// @param env
/// SoundEnvelopes to apply.
- void applyEnvelopes(boost::int16_t* samples, unsigned int nSamples,
+ void applyEnvelopes(std::int16_t* samples, unsigned int nSamples,
unsigned int firstSampleNum, const SoundEnvelopes& env);
bool reachedCustomEnd() const;
@@ -135,7 +135,7 @@ private:
const SoundEnvelopes* envelopes;
/// Index of current envelope.
- boost::uint32_t current_env;
+ std::uint32_t current_env;
/// The encoded data
//
diff --git a/libsound/InputStream.h b/libsound/InputStream.h
index e11a451..41e7bed 100644
--- a/libsound/InputStream.h
+++ b/libsound/InputStream.h
@@ -21,7 +21,7 @@
#ifndef SOUND_INPUTSTREAM_H
#define SOUND_INPUTSTREAM_H
-#include <boost/cstdint.hpp> // For C99 int types
+#include <cstdint> // For C99 int types
namespace gnash {
namespace sound {
@@ -68,7 +68,7 @@ public:
/// if unable to process this and further requests due to internal
/// errors (not if it just happens to complete its source)
///
- virtual unsigned int fetchSamples(boost::int16_t* to, unsigned int
nSamples)=0;
+ virtual unsigned int fetchSamples(std::int16_t* to, unsigned int
nSamples)=0;
/// Return number of samples fetched from this stream
//
diff --git a/libsound/LiveSound.cpp b/libsound/LiveSound.cpp
index a13385e..843d719 100644
--- a/libsound/LiveSound.cpp
+++ b/libsound/LiveSound.cpp
@@ -51,7 +51,7 @@ LiveSound::createDecoder(media::MediaHandler& mh, const
media::SoundInfo& si)
}
unsigned int
-LiveSound::fetchSamples(boost::int16_t* to, unsigned int nSamples)
+LiveSound::fetchSamples(std::int16_t* to, unsigned int nSamples)
{
unsigned int fetchedSamples = 0;
@@ -59,7 +59,7 @@ LiveSound::fetchSamples(boost::int16_t* to, unsigned int
nSamples)
unsigned int availableSamples = decodedSamplesAhead();
if (availableSamples) {
- const boost::int16_t* data = getDecodedData(_playbackPosition);
+ const std::int16_t* data = getDecodedData(_playbackPosition);
if (availableSamples >= nSamples) {
std::copy(data, data + nSamples, to);
diff --git a/libsound/LiveSound.h b/libsound/LiveSound.h
index 08187e8..82df6a5 100644
--- a/libsound/LiveSound.h
+++ b/libsound/LiveSound.h
@@ -22,7 +22,7 @@
#include <memory>
#include <cassert>
-#include <boost/cstdint.hpp> // For C99 int types
+#include <cstdint> // For C99 int types
#include "InputStream.h"
#include "AudioDecoder.h"
@@ -58,9 +58,9 @@ protected:
size_t inPoint);
// Pointer handling and checking functions
- const boost::int16_t* getDecodedData(unsigned long int pos) const {
+ const std::int16_t* getDecodedData(unsigned long int pos) const {
assert(pos < _decodedData.size());
- return reinterpret_cast<const boost::int16_t*>(
+ return reinterpret_cast<const std::int16_t*>(
_decodedData.data() + pos);
}
@@ -96,7 +96,7 @@ protected:
return *_decoder;
}
- void appendDecodedData(boost::uint8_t* data, unsigned int size) {
+ void appendDecodedData(std::uint8_t* data, unsigned int size) {
_decodedData.append(data, size);
delete [] data;
}
@@ -128,7 +128,7 @@ private:
}
// See dox in sound_handler.h (InputStream)
- unsigned int fetchSamples(boost::int16_t* to, unsigned int nSamples);
+ unsigned int fetchSamples(std::int16_t* to, unsigned int nSamples);
void createDecoder(media::MediaHandler& mediaHandler,
const media::SoundInfo& info);
diff --git a/libsound/NullSoundHandler.h b/libsound/NullSoundHandler.h
index 40f2343..518c6cc 100644
--- a/libsound/NullSoundHandler.h
+++ b/libsound/NullSoundHandler.h
@@ -46,7 +46,7 @@ public:
{}
// If a _mixer was given, let it do the mixing!
- void mix(boost::int16_t* outSamples, boost::int16_t* inSamples,
+ void mix(std::int16_t* outSamples, std::int16_t* inSamples,
unsigned int nSamples, float volume)
{
if ( _mixer ) _mixer->mix(outSamples, inSamples, nSamples, volume);
diff --git a/libsound/SoundEnvelope.h b/libsound/SoundEnvelope.h
index 610df06..8897179 100644
--- a/libsound/SoundEnvelope.h
+++ b/libsound/SoundEnvelope.h
@@ -20,7 +20,7 @@
#ifndef SOUND_SOUNDENVELOPE_H
#define SOUND_SOUNDENVELOPE_H
-#include <boost/cstdint.hpp> // For C99 int types
+#include <cstdint> // For C99 int types
#include <vector> // for SoundEnvelopes typedef
@@ -47,13 +47,13 @@ public:
/// with a sample rate of 5.5K is given as position 8 in
/// the envelope.
///
- boost::uint32_t m_mark44;
+ std::uint32_t m_mark44;
/// Volume for the left channel (0..32768)
- boost::uint16_t m_level0;
+ std::uint16_t m_level0;
/// Volume for the right channel (0..32768)
- boost::uint16_t m_level1;
+ std::uint16_t m_level1;
};
/// A vector of SoundEnvelope objects
diff --git a/libsound/SoundUtils.h b/libsound/SoundUtils.h
index 462caa1..d2c0aff 100644
--- a/libsound/SoundUtils.h
+++ b/libsound/SoundUtils.h
@@ -22,7 +22,7 @@
#include <algorithm>
#include <functional>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "SoundInfo.h"
diff --git a/libsound/StreamingSound.cpp b/libsound/StreamingSound.cpp
index a85d898..1284ac5 100644
--- a/libsound/StreamingSound.cpp
+++ b/libsound/StreamingSound.cpp
@@ -77,21 +77,21 @@ StreamingSound::decodeNextBlock()
// If we didn't decode all of a block, do so now. Not sure if this
// can happen.
- const boost::uint32_t inputSize = block.size() - _positionInBlock;
+ const std::uint32_t inputSize = block.size() - _positionInBlock;
- boost::uint32_t consumed = 0;
+ std::uint32_t consumed = 0;
// Empty blocks serve to synchronize, so don't decode but carry on.
if (inputSize) {
- boost::uint32_t decodedDataSize = 0;
- const boost::uint8_t* input = block.data() + _positionInBlock;
- boost::uint8_t* decodedData = decoder().decode(input, inputSize,
+ std::uint32_t decodedDataSize = 0;
+ const std::uint8_t* input = block.data() + _positionInBlock;
+ std::uint8_t* decodedData = decoder().decode(input, inputSize,
decodedDataSize, consumed);
assert(!(decodedDataSize % 2));
- boost::int16_t* samples =
- reinterpret_cast<boost::int16_t*>(decodedData);
+ std::int16_t* samples =
+ reinterpret_cast<std::int16_t*>(decodedData);
unsigned int nSamples = decodedDataSize / 2;
if (_soundDef.volume != 100) {
diff --git a/libsound/StreamingSound.h b/libsound/StreamingSound.h
index bce7227..6b5276d 100644
--- a/libsound/StreamingSound.h
+++ b/libsound/StreamingSound.h
@@ -22,7 +22,7 @@
#include <memory>
#include <cassert>
-#include <boost/cstdint.hpp> // For C99 int types
+#include <cstdint> // For C99 int types
#include "LiveSound.h"
#include "StreamingSoundData.h"
diff --git a/libsound/StreamingSoundData.cpp b/libsound/StreamingSoundData.cpp
index b7b429f..8fa8d20 100644
--- a/libsound/StreamingSoundData.cpp
+++ b/libsound/StreamingSoundData.cpp
@@ -21,7 +21,7 @@
#include "StreamingSoundData.h"
#include <vector>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "SoundInfo.h"
#include "MediaHandler.h"
diff --git a/libsound/WAVWriter.cpp b/libsound/WAVWriter.cpp
index 53c667a..52ac98c 100644
--- a/libsound/WAVWriter.cpp
+++ b/libsound/WAVWriter.cpp
@@ -19,7 +19,7 @@
#include "WAVWriter.h"
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <fstream> // for composition (file_stream)
#include <iostream>
@@ -35,23 +35,23 @@ namespace { // anonymous
// http://ftp.iptel.org/pub/sems/doc/full/current/wav__hdr_8c-source.html
struct WAV_HDR {
char rID[4]; // 'RIFF'
- boost::uint32_t rLen;
+ std::uint32_t rLen;
char wID[4]; // 'WAVE'
char fId[4]; // 'fmt '
- boost::uint32_t pcm_header_len; // varies...
- boost::int16_t wFormatTag;
- boost::int16_t nChannels; // 1,2 for stereo data is (l,r) pairs
- boost::uint32_t nSamplesPerSec;
- boost::uint32_t nAvgBytesPerSec;
- boost::int16_t nBlockAlign;
- boost::int16_t nBitsPerSample;
+ std::uint32_t pcm_header_len; // varies...
+ std::int16_t wFormatTag;
+ std::int16_t nChannels; // 1,2 for stereo data is (l,r) pairs
+ std::uint32_t nSamplesPerSec;
+ std::uint32_t nAvgBytesPerSec;
+ std::int16_t nBlockAlign;
+ std::int16_t nBitsPerSample;
};
// Chunk of wave file
// http://ftp.iptel.org/pub/sems/doc/full/current/wav__hdr_8c-source.html
struct CHUNK_HDR{
char dId[4]; // 'data' or 'fact'
- boost::uint32_t dLen;
+ std::uint32_t dLen;
};
} // end of anonymous namespace
@@ -80,10 +80,10 @@ WAVWriter::~WAVWriter()
/* public */
void
-WAVWriter::pushSamples(boost::int16_t* from, unsigned int nSamples)
+WAVWriter::pushSamples(std::int16_t* from, unsigned int nSamples)
{
// NOTE: if muted, the samples will be silent already
- boost::uint8_t* stream = reinterpret_cast<boost::uint8_t*>(from);
+ std::uint8_t* stream = reinterpret_cast<std::uint8_t*>(from);
unsigned int len = nSamples*2;
file_stream.write((char*) stream, len);
diff --git a/libsound/WAVWriter.h b/libsound/WAVWriter.h
index 88a694c..80a52a1 100644
--- a/libsound/WAVWriter.h
+++ b/libsound/WAVWriter.h
@@ -21,7 +21,7 @@
#define GNASH_SOUND_WAVWRITER_H
#include <fstream> // for composition (file_stream)
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include "dsodefs.h"
@@ -54,7 +54,7 @@ public:
/// to give interpretation of what comes back (how many
/// bytes per channel, which format).
///
- void pushSamples(boost::int16_t* from, unsigned int nSamples);
+ void pushSamples(std::int16_t* from, unsigned int nSamples);
private:
diff --git a/libsound/aos4/sound_handler_ahi.cpp
b/libsound/aos4/sound_handler_ahi.cpp
index 0297d75..93444eb 100644
--- a/libsound/aos4/sound_handler_ahi.cpp
+++ b/libsound/aos4/sound_handler_ahi.cpp
@@ -268,7 +268,7 @@ create_sound_handler_aos4(media::MediaHandler* m)
}
void
-AOS4_sound_handler::fetchSamples(boost::int16_t* to, unsigned int nSamples)
+AOS4_sound_handler::fetchSamples(std::int16_t* to, unsigned int nSamples)
{
if (!_closing)
{
@@ -329,9 +329,9 @@ AOS4_sound_handler::fetchSamples(boost::int16_t* to,
unsigned int nSamples)
}
void
-AOS4_sound_handler::MixAudio (boost::uint8_t *dst, const boost::uint8_t *src,
boost::uint32_t len, int volume)
+AOS4_sound_handler::MixAudio (std::uint8_t *dst, const std::uint8_t *src,
std::uint32_t len, int volume)
{
- boost::uint16_t format;
+ std::uint16_t format;
if ( volume == 0 )
{
@@ -345,7 +345,7 @@ AOS4_sound_handler::MixAudio (boost::uint8_t *dst, const
boost::uint8_t *src, bo
{
case AHIST_S16S:
{
- boost::int16_t src1, src2;
+ std::int16_t src1, src2;
int dst_sample;
const int max_audioval = ((1<<(16-1))-1);
const int min_audioval = -(1<<(16-1));
@@ -379,14 +379,14 @@ AOS4_sound_handler::MixAudio (boost::uint8_t *dst, const
boost::uint8_t *src, bo
}
void
-AOS4_sound_handler::mix(boost::int16_t* outSamples, boost::int16_t* inSamples,
unsigned int nSamples, float volume)
+AOS4_sound_handler::mix(std::int16_t* outSamples, std::int16_t* inSamples,
unsigned int nSamples, float volume)
{
if (!_closing)
{
unsigned int nBytes = nSamples*2;
- boost::uint8_t *out = reinterpret_cast<boost::uint8_t*>(outSamples);
- boost::uint8_t* in = reinterpret_cast<boost::uint8_t*>(inSamples);
+ std::uint8_t *out = reinterpret_cast<std::uint8_t*>(outSamples);
+ std::uint8_t* in = reinterpret_cast<std::uint8_t*>(inSamples);
MixAudio(out, in, nBytes, static_cast<int>(MIX_MAXVOLUME*volume));
}
@@ -528,7 +528,7 @@ AOS4_sound_handler::audioTask()
unsigned long clockAdvance = 40;
unsigned int nSamples = (441*clockAdvance) / 10;
unsigned int toFetch = nSamples*2;
- boost::int16_t samples[AHI_BUF_SIZE];
+ std::int16_t samples[AHI_BUF_SIZE];
_closing = false;
@@ -628,7 +628,7 @@ AOS4_sound_handler::audioTask()
while (toFetch && !_closing)
{
unsigned int n = std::min(toFetch,
AHI_BUF_SIZE);
- if (!_closing)
fetchSamples((boost::int16_t*)&samples, n);
+ if (!_closing)
fetchSamples((std::int16_t*)&samples, n);
toFetch -= n;
}
toFetch = nSamples*2;
diff --git a/libsound/aos4/sound_handler_ahi.h
b/libsound/aos4/sound_handler_ahi.h
index 5a84176..aa06fc9 100644
--- a/libsound/aos4/sound_handler_ahi.h
+++ b/libsound/aos4/sound_handler_ahi.h
@@ -92,10 +92,10 @@ private:
mutable boost::mutex _mutedMutex;
// See dox in sound_handler.h
- void mix(boost::int16_t* outSamples, boost::int16_t* inSamples,
+ void mix(std::int16_t* outSamples, std::int16_t* inSamples,
unsigned int nSamples, float volume);
- void MixAudio (boost::uint8_t *dst, const boost::uint8_t *src,
boost::uint32_t len, int volume);
+ void MixAudio (std::uint8_t *dst, const std::uint8_t *src,
std::uint32_t len, int volume);
public:
@@ -165,7 +165,7 @@ public:
void plugInputStream(std::unique_ptr<InputStream> in);
// See dox in sound_handler.h
- void fetchSamples(boost::int16_t* to, unsigned int nSamples);
+ void fetchSamples(std::int16_t* to, unsigned int nSamples);
int audioTask();
};
diff --git a/libsound/mkit/sound_handler_mkit.cpp
b/libsound/mkit/sound_handler_mkit.cpp
index cc53cdf..63e149c 100644
--- a/libsound/mkit/sound_handler_mkit.cpp
+++ b/libsound/mkit/sound_handler_mkit.cpp
@@ -107,7 +107,7 @@ Mkit_sound_handler::FillNextBuffer(void *cookie, void
*buffer, size_t size,
size_t numSamples =
size / sizeof(uint16);
- boost::int16_t *data = (boost::int16_t*) buffer;
+ std::int16_t *data = (std::int16_t*) buffer;
Mkit_sound_handler *that =
reinterpret_cast<Mkit_sound_handler*>(cookie);
@@ -116,7 +116,7 @@ Mkit_sound_handler::FillNextBuffer(void *cookie, void
*buffer, size_t size,
}
void
-Mkit_sound_handler::fetchSamples(boost::int16_t* to, unsigned int nSamples)
+Mkit_sound_handler::fetchSamples(std::int16_t* to, unsigned int nSamples)
{
boost::mutex::scoped_lock lock(_mutex);
sound_handler::fetchSamples(to, nSamples);
@@ -125,7 +125,7 @@ Mkit_sound_handler::fetchSamples(boost::int16_t* to,
unsigned int nSamples)
if (file_stream)
{
// NOTE: if muted, the samples will be silent already
- boost::uint8_t* stream = reinterpret_cast<boost::uint8_t*>(to);
+ std::uint8_t* stream = reinterpret_cast<std::uint8_t*>(to);
unsigned int len = nSamples*2;
file_stream.write((char*) stream, len);
@@ -229,9 +229,9 @@ Mkit_sound_handler::tell(int soundHandle)
}
void
-Mkit_sound_handler::MixAudio (boost::uint8_t *dst, const boost::uint8_t *src,
boost::uint32_t len, int volume)
+Mkit_sound_handler::MixAudio (std::uint8_t *dst, const std::uint8_t *src,
std::uint32_t len, int volume)
{
- //boost::uint16_t format;
+ //std::uint16_t format;
if ( volume == 0 )
{
@@ -245,7 +245,7 @@ Mkit_sound_handler::MixAudio (boost::uint8_t *dst, const
boost::uint8_t *src, bo
{
//case AHIST_S16S:
{
- boost::int16_t src1, src2;
+ std::int16_t src1, src2;
int dst_sample;
const int max_audioval = ((1<<(16-1))-1);
const int min_audioval = -(1<<(16-1));
@@ -279,14 +279,14 @@ Mkit_sound_handler::MixAudio (boost::uint8_t *dst, const
boost::uint8_t *src, bo
}
void
-Mkit_sound_handler::mix(boost::int16_t* outSamples, boost::int16_t* inSamples,
unsigned int nSamples, float volume)
+Mkit_sound_handler::mix(std::int16_t* outSamples, std::int16_t* inSamples,
unsigned int nSamples, float volume)
{
//if (!_closing)
{
unsigned int nBytes = nSamples*2;
- boost::uint8_t *out = reinterpret_cast<boost::uint8_t*>(outSamples);
- boost::uint8_t* in = reinterpret_cast<boost::uint8_t*>(inSamples);
+ std::uint8_t *out = reinterpret_cast<std::uint8_t*>(outSamples);
+ std::uint8_t* in = reinterpret_cast<std::uint8_t*>(inSamples);
MixAudio(out, in, nBytes, MIX_MAXVOLUME*volume);
}
diff --git a/libsound/mkit/sound_handler_mkit.h
b/libsound/mkit/sound_handler_mkit.h
index 2dead4f..16f4ca9 100644
--- a/libsound/mkit/sound_handler_mkit.h
+++ b/libsound/mkit/sound_handler_mkit.h
@@ -61,10 +61,10 @@ class Mkit_sound_handler : public sound_handler
mutable boost::mutex _mutedMutex;
// See dox in sound_handler.h
- void mix(boost::int16_t* outSamples, boost::int16_t* inSamples,
+ void mix(std::int16_t* outSamples, std::int16_t* inSamples,
unsigned int nSamples, float volume);
- void MixAudio (boost::uint8_t *dst, const boost::uint8_t *src,
boost::uint32_t len, int volume);
+ void MixAudio (std::uint8_t *dst, const std::uint8_t *src, std::uint32_t
len, int volume);
public:
Mkit_sound_handler(media::MediaHandler* m);
@@ -133,7 +133,7 @@ public:
void plugInputStream(std::unique_ptr<InputStream> in);
// See dox in sound_handler.h
- void fetchSamples(boost::int16_t* to, unsigned int nSamples);
+ void fetchSamples(std::int16_t* to, unsigned int nSamples);
};
} // gnash.sound namespace
diff --git a/libsound/sdl/sound_handler_sdl.cpp
b/libsound/sdl/sound_handler_sdl.cpp
index 486fcde..e379e1a 100644
--- a/libsound/sdl/sound_handler_sdl.cpp
+++ b/libsound/sdl/sound_handler_sdl.cpp
@@ -237,7 +237,7 @@ create_sound_handler_sdl(media::MediaHandler* m)
}
void
-SDL_sound_handler::fetchSamples(boost::int16_t* to, unsigned int nSamples)
+SDL_sound_handler::fetchSamples(std::int16_t* to, unsigned int nSamples)
{
boost::mutex::scoped_lock lock(_mutex);
sound_handler::fetchSamples(to, nSamples);
@@ -268,7 +268,7 @@ SDL_sound_handler::sdl_audio_callback(void *udata, Uint8
*buf, int bufLenIn)
}
unsigned int bufLen = static_cast<unsigned int>(bufLenIn);
- boost::int16_t* samples = reinterpret_cast<boost::int16_t*>(buf);
+ std::int16_t* samples = reinterpret_cast<std::int16_t*>(buf);
// 16 bit per sample, 2 channels == 4 bytes per fetch ?
assert(!(bufLen%4));
@@ -283,7 +283,7 @@ SDL_sound_handler::sdl_audio_callback(void *udata, Uint8
*buf, int bufLenIn)
}
void
-SDL_sound_handler::mix(boost::int16_t* outSamples, boost::int16_t* inSamples,
+SDL_sound_handler::mix(std::int16_t* outSamples, std::int16_t* inSamples,
unsigned int nSamples, float volume)
{
Uint8* out = reinterpret_cast<Uint8*>(outSamples);
diff --git a/libsound/sdl/sound_handler_sdl.h b/libsound/sdl/sound_handler_sdl.h
index c940ae1..725ffb4 100644
--- a/libsound/sdl/sound_handler_sdl.h
+++ b/libsound/sdl/sound_handler_sdl.h
@@ -63,7 +63,7 @@ private:
mutable boost::mutex _mutedMutex;
// See dox in sound_handler.h
- void mix(boost::int16_t* outSamples, boost::int16_t* inSamples,
+ void mix(std::int16_t* outSamples, std::int16_t* inSamples,
unsigned int nSamples, float volume);
@@ -162,7 +162,7 @@ public:
void unplugInputStream(InputStream* id);
// See dox in sound_handler.h
- void fetchSamples(boost::int16_t* to, unsigned int nSamples);
+ void fetchSamples(std::int16_t* to, unsigned int nSamples);
};
} // gnash.sound namespace
diff --git a/libsound/sound_handler.cpp b/libsound/sound_handler.cpp
index 1b0ed2f..6c6fe48 100644
--- a/libsound/sound_handler.cpp
+++ b/libsound/sound_handler.cpp
@@ -19,7 +19,7 @@
#include "sound_handler.h"
-#include <boost/cstdint.hpp> // For C99 int types
+#include <cstdint> // For C99 int types
#include <vector>
#include <cmath>
@@ -44,7 +44,7 @@ namespace sound {
namespace {
unsigned int
-silentStream(void*, boost::int16_t* stream, unsigned int len, bool& atEOF)
+silentStream(void*, std::int16_t* stream, unsigned int len, bool& atEOF)
{
std::fill(stream, stream + len, 0);
atEOF=false;
@@ -371,8 +371,8 @@ sound_handler::get_duration(int handle) const
const EmbedSound* sounddata = _sounds[handle];
- const boost::uint32_t sampleCount = sounddata->soundinfo.getSampleCount();
- const boost::uint32_t sampleRate = sounddata->soundinfo.getSampleRate();
+ const std::uint32_t sampleCount = sounddata->soundinfo.getSampleCount();
+ const std::uint32_t sampleRate = sounddata->soundinfo.getSampleRate();
// Return the sound duration in milliseconds
if (sampleCount > 0 && sampleRate > 0) {
@@ -583,7 +583,7 @@ sound_handler::unplugAllInputStreams()
}
void
-sound_handler::fetchSamples(boost::int16_t* to, unsigned int nSamples)
+sound_handler::fetchSamples(std::int16_t* to, unsigned int nSamples)
{
if (isPaused()) return; // should we write wav file anyway ?
@@ -595,7 +595,7 @@ sound_handler::fetchSamples(boost::int16_t* to, unsigned
int nSamples)
if (!_inputStreams.empty()) {
// A buffer to fetch InputStream samples into
- std::unique_ptr<boost::int16_t[]> buf(new boost::int16_t[nSamples]);
+ std::unique_ptr<std::int16_t[]> buf(new std::int16_t[nSamples]);
#ifdef GNASH_DEBUG_SAMPLES_FETCHING
log_debug("Fetching %d samples from each of %d input streams",
nSamples, _inputStreams.size());
diff --git a/libsound/sound_handler.h b/libsound/sound_handler.h
index f4cb1eb..004034d 100644
--- a/libsound/sound_handler.h
+++ b/libsound/sound_handler.h
@@ -412,7 +412,7 @@ public:
/// to give interpretation of what comes back (how many
/// bytes per channel, which format).
///
- virtual void fetchSamples(boost::int16_t* to, unsigned int nSamples);
+ virtual void fetchSamples(std::int16_t* to, unsigned int nSamples);
/// Mix nSamples from inSamples to outSamples, with given volume
//
@@ -439,7 +439,7 @@ public:
/// Maybe, a Mixer instance should be created, initialized
/// with number of channels, at each fetching.
///
- virtual void mix(boost::int16_t* outSamples, boost::int16_t* inSamples,
+ virtual void mix(std::int16_t* outSamples, std::int16_t* inSamples,
unsigned int nSamples, float volume) = 0;
/// Request to dump audio to the given filename
diff --git a/plugin/aos4/plugin.cpp b/plugin/aos4/plugin.cpp
index 5088877..aa1d80f 100644
--- a/plugin/aos4/plugin.cpp
+++ b/plugin/aos4/plugin.cpp
@@ -66,7 +66,7 @@
Compatible Shockwave Flash "FLASH_VERSION
#include <cstdarg>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <fstream>
#include "plugin.h"
@@ -344,7 +344,7 @@ nsPluginInstance::shut(void)
NPError
nsPluginInstance::NewStream(NPMIMEType type, NPStream *stream,
- NPBool seekable, boost::uint16_t *stype)
+ NPBool seekable, std::uint16_t *stype)
{
DBG("nsPluginInstance::NewStream\n");
DBG("stream->url: %s\n", stream->url);
diff --git a/plugin/win32/plugin.cpp b/plugin/win32/plugin.cpp
index b14d138..6bfaed1 100644
--- a/plugin/win32/plugin.cpp
+++ b/plugin/win32/plugin.cpp
@@ -68,7 +68,7 @@
#include <wingdi.h>
#include <cstdarg>
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <fstream>
#include "plugin.h"
@@ -341,7 +341,7 @@ nsPluginInstance::shut(void)
NPError
nsPluginInstance::NewStream(NPMIMEType type, NPStream *stream,
- NPBool seekable, boost::uint16_t *stype)
+ NPBool seekable, std::uint16_t *stype)
{
DBG("nsPluginInstance::NewStream\n");
DBG("stream->url: %s\n", stream->url);
diff --git a/testsuite/DummyCharacter.h b/testsuite/DummyCharacter.h
index 8b9126e..d7ace95 100644
--- a/testsuite/DummyCharacter.h
+++ b/testsuite/DummyCharacter.h
@@ -59,7 +59,7 @@ public:
virtual void mouseEvent(const event_id&) {}
- InteractiveObject* topmostMouseEntity(boost::int32_t, boost::int32_t)
+ InteractiveObject* topmostMouseEntity(std::int32_t, std::int32_t)
{
return 0;
}
diff --git a/testsuite/FuzzyPixel.h b/testsuite/FuzzyPixel.h
index d5f1b68..d5dfe32 100644
--- a/testsuite/FuzzyPixel.h
+++ b/testsuite/FuzzyPixel.h
@@ -97,7 +97,7 @@ public:
/// @param a
/// The alpha value.
///
- FuzzyPixel(boost::uint8_t r, boost::uint8_t g, boost::uint8_t b,
boost::uint8_t a)
+ FuzzyPixel(std::uint8_t r, std::uint8_t g, std::uint8_t b, std::uint8_t
a)
:
_col(r, g, b, a),
_tol(0)
diff --git a/testsuite/MovieTester.cpp b/testsuite/MovieTester.cpp
index 3693c0c..15b85f4 100644
--- a/testsuite/MovieTester.cpp
+++ b/testsuite/MovieTester.cpp
@@ -281,10 +281,10 @@ MovieTester::advanceClock(unsigned long ms_current)
log_debug("advanceClock(%d) needs to fetch %d samples", ms, toFetch);
- boost::int16_t samples[1024];
+ std::int16_t samples[1024];
while (toFetch) {
unsigned int n = std::min(toFetch, 1024u);
- _sound_handler->fetchSamples((boost::int16_t*)&samples, n);
+ _sound_handler->fetchSamples((std::int16_t*)&samples, n);
toFetch -= n;
}
}
diff --git a/testsuite/libbase.all/IntTypesTest.cpp
b/testsuite/libbase.all/IntTypesTest.cpp
index 54536fa..7669fea 100644
--- a/testsuite/libbase.all/IntTypesTest.cpp
+++ b/testsuite/libbase.all/IntTypesTest.cpp
@@ -25,7 +25,7 @@
#include <iostream>
#include <sstream>
#include <cassert>
-#include <boost/cstdint.hpp>
+#include <cstdint>
using namespace std;
@@ -34,14 +34,14 @@ main(int /*argc*/, char** /*argv*/)
{
// Check typedef sizes.
- check_equals (sizeof(boost::uint8_t), 1);
- check_equals (sizeof(boost::uint16_t), 2);
- check_equals (sizeof(boost::uint32_t), 4);
- check_equals (sizeof(boost::uint64_t), 8);
- check_equals (sizeof(boost::int8_t), 1);
- check_equals (sizeof(boost::int16_t), 2);
- check_equals (sizeof(boost::int32_t), 4);
- check_equals (sizeof(boost::int64_t), 8);
+ check_equals (sizeof(std::uint8_t), 1);
+ check_equals (sizeof(std::uint16_t), 2);
+ check_equals (sizeof(std::uint32_t), 4);
+ check_equals (sizeof(std::uint64_t), 8);
+ check_equals (sizeof(std::int8_t), 1);
+ check_equals (sizeof(std::int16_t), 2);
+ check_equals (sizeof(std::int32_t), 4);
+ check_equals (sizeof(std::int64_t), 8);
return 0;
}
diff --git a/testsuite/libbase.all/Point2dTest.cpp
b/testsuite/libbase.all/Point2dTest.cpp
index 5308e2d..8260539 100644
--- a/testsuite/libbase.all/Point2dTest.cpp
+++ b/testsuite/libbase.all/Point2dTest.cpp
@@ -49,7 +49,7 @@ main(int /*argc*/, char** /*argv*/)
check_equals(p.x, 999999);
check_equals(p.y, 1000000);
- boost::int64_t square_dist = 0;
+ std::int64_t square_dist = 0;
square_dist = Point2d::squareDistance(p1, p2);
check_equals(square_dist, 10 * 10);
@@ -64,7 +64,7 @@ main(int /*argc*/, char** /*argv*/)
square_dist = p1.squareDistance(p2);
check_equals(square_dist, 1.0 * 0x8000000 * 0x8000000);
- boost::int32_t dist = 0;
+ std::int32_t dist = 0;
dist = p1.distance(p2);
check_equals(dist, 0x8000000);
return 0;
diff --git a/testsuite/libcore.all/BitsReaderTest.cpp
b/testsuite/libcore.all/BitsReaderTest.cpp
index 43e0a38..162e178 100644
--- a/testsuite/libcore.all/BitsReaderTest.cpp
+++ b/testsuite/libcore.all/BitsReaderTest.cpp
@@ -245,10 +245,10 @@ trymain(int /*argc*/, char** /*argv*/)
/// bits: 10011001 10011001 (0x999999)
- boost::int16_t s16 = s.read_s16(); check_equals(s16,
(boost::int16_t)0x9999);
- boost::uint16_t u16 = s.read_u16(); check_equals(u16,
(boost::uint16_t)0x9999);
- boost::int32_t s32 = s.read_s32(); check_equals(s32,
(boost::int32_t)0x99999999);
- boost::uint32_t u32 = s.read_u32(); check_equals(u32,
(boost::uint32_t)0x99999999);
+ std::int16_t s16 = s.read_s16(); check_equals(s16,
(std::int16_t)0x9999);
+ std::uint16_t u16 = s.read_u16(); check_equals(u16,
(std::uint16_t)0x9999);
+ std::int32_t s32 = s.read_s32(); check_equals(s32,
(std::int32_t)0x99999999);
+ std::uint32_t u32 = s.read_u32(); check_equals(u32,
(std::uint32_t)0x99999999);
/// bits: 10011001 10011001 10011001 10011001 (0x99999999)
/// -
diff --git a/testsuite/libcore.all/CodeStreamTest.cpp
b/testsuite/libcore.all/CodeStreamTest.cpp
index ac09052..485d616 100644
--- a/testsuite/libcore.all/CodeStreamTest.cpp
+++ b/testsuite/libcore.all/CodeStreamTest.cpp
@@ -45,7 +45,7 @@ main(int /*argc*/, char** /*argv*/)
CodeStream* stream = new CodeStream(std::string(data,10));
//Test read_as30p()
- boost::uint8_t opcode;
+ std::uint8_t opcode;
int i = 0;
while(opcode = stream->read_as3op()){
check_equals(opcode,data[i]);
@@ -80,11 +80,11 @@ main(int /*argc*/, char** /*argv*/)
char newData[6] = {0x5,0xC5,0x0,0x0,0x1,0x2};
CodeStream* streamA = new CodeStream(std::string(newData,6));
- boost::uint8_t byteA = streamA->read_u8();
+ std::uint8_t byteA = streamA->read_u8();
check_equals(byteA,newData[0]);
//Test read_S24.
- boost::int32_t byteB = streamA->read_S24();
+ std::int32_t byteB = streamA->read_S24();
check_equals(byteB,197);
diff --git a/testsuite/libcore.all/CxFormTest.cpp
b/testsuite/libcore.all/CxFormTest.cpp
index 941390e..4c71fbf 100644
--- a/testsuite/libcore.all/CxFormTest.cpp
+++ b/testsuite/libcore.all/CxFormTest.cpp
@@ -46,10 +46,10 @@ int main()
check_equals(c.gb, 0);
check_equals(c.ab, 0);
- boost::uint8_t r = 0;
- boost::uint8_t b = 0;
- boost::uint8_t g = 0;
- boost::uint8_t a = 0;
+ std::uint8_t r = 0;
+ std::uint8_t b = 0;
+ std::uint8_t g = 0;
+ std::uint8_t a = 0;
c.transform(r, b, g, a);
check_equals(r, 0);
diff --git a/testsuite/libcore.all/MatrixTest.cpp
b/testsuite/libcore.all/MatrixTest.cpp
index af534d2..9b6a5a3 100644
--- a/testsuite/libcore.all/MatrixTest.cpp
+++ b/testsuite/libcore.all/MatrixTest.cpp
@@ -64,14 +64,14 @@ main(int /*argc*/, char** /*argv*/)
// Note: If any of the following tests fails, your boost library
// is bogus or hasn't been installed properly.
//
- check_equals(sizeof(boost::int8_t), 1);
- check_equals(sizeof(boost::uint8_t), 1);
- check_equals(sizeof(boost::int16_t), 2);
- check_equals(sizeof(boost::uint16_t), 2);
- check_equals(sizeof(boost::int32_t), 4);
- check_equals(sizeof(boost::uint32_t), 4);
- check_equals(sizeof(boost::int64_t), 8);
- check_equals(sizeof(boost::uint64_t), 8);
+ check_equals(sizeof(std::int8_t), 1);
+ check_equals(sizeof(std::uint8_t), 1);
+ check_equals(sizeof(std::int16_t), 2);
+ check_equals(sizeof(std::uint16_t), 2);
+ check_equals(sizeof(std::int32_t), 4);
+ check_equals(sizeof(std::uint32_t), 4);
+ check_equals(sizeof(std::int64_t), 8);
+ check_equals(sizeof(std::uint64_t), 8);
//
// Test identity SWFMatrix.
diff --git a/testsuite/libcore.all/StreamTest.cpp
b/testsuite/libcore.all/StreamTest.cpp
index fb9cbed..28a1ee8 100644
--- a/testsuite/libcore.all/StreamTest.cpp
+++ b/testsuite/libcore.all/StreamTest.cpp
@@ -387,13 +387,13 @@ trymain(int /*argc*/, char** /*argv*/)
/// bits: 10011001 10011001 (0x999999)
- boost::int16_t s16 = s.read_s16(); check_equals(s16,
(boost::int16_t)0x9999);
+ std::int16_t s16 = s.read_s16(); check_equals(s16,
(std::int16_t)0x9999);
check_equals(s.tell(), 30);
- boost::uint16_t u16 = s.read_u16(); check_equals(u16,
(boost::uint16_t)0x9999);
+ std::uint16_t u16 = s.read_u16(); check_equals(u16,
(std::uint16_t)0x9999);
check_equals(s.tell(), 32);
- boost::int32_t s32 = s.read_s32(); check_equals(s32,
(boost::int32_t)0x99999999);
+ std::int32_t s32 = s.read_s32(); check_equals(s32,
(std::int32_t)0x99999999);
check_equals(s.tell(), 36);
- boost::uint32_t u32 = s.read_u32(); check_equals(u32,
(boost::uint32_t)0x99999999);
+ std::uint32_t u32 = s.read_u32(); check_equals(u32,
(std::uint32_t)0x99999999);
check_equals(s.tell(), 40);
/// bits: 10011001 10011001 10011001 10011001 (0x99999999)
diff --git a/testsuite/libdevice.all/test_rawfb.cpp
b/testsuite/libdevice.all/test_rawfb.cpp
index aa3766b..cfff6e4 100644
--- a/testsuite/libdevice.all/test_rawfb.cpp
+++ b/testsuite/libdevice.all/test_rawfb.cpp
@@ -163,7 +163,7 @@ main(int argc, char *argv[])
long location = 0;
int line_length = rfb.getStride();
- boost::uint8_t *fbp = 0;
+ std::uint8_t *fbp = 0;
fbp = rfb.getFBMemory();
if (fbp > 0) {
diff --git a/utilities/flvdumper.cpp b/utilities/flvdumper.cpp
index f14b95b..e941b43 100644
--- a/utilities/flvdumper.cpp
+++ b/utilities/flvdumper.cpp
@@ -212,7 +212,7 @@ main(int argc, char *argv[])
}
cout << "FLV Version: " << int(head->version) << " (should always
be 1)" << endl;
- boost::uint32_t headsize = flv.convert24(head->head_size);
+ std::uint32_t headsize = flv.convert24(head->head_size);
if (all) {
cout << "FLV Header size: " << headsize << " (should always be
9)" << endl;
}
diff --git a/utilities/processor.cpp b/utilities/processor.cpp
index e9f922c..47b3dc5 100644
--- a/utilities/processor.cpp
+++ b/utilities/processor.cpp
@@ -419,7 +419,7 @@ struct SamplesFetcher {
//log_debug("SamplesFetcher::fetch(%d) fetching %d samples", ms,
toFetch);
- boost::int16_t samples[1024];
+ std::int16_t samples[1024];
while (toFetch) {
unsigned int n = std::min(toFetch, 1024u);
_sh.fetchSamples(samples, n);
diff --git a/utilities/rtmpget.cpp b/utilities/rtmpget.cpp
index 7f7a7e4..08b8845 100644
--- a/utilities/rtmpget.cpp
+++ b/utilities/rtmpget.cpp
@@ -27,7 +27,7 @@
#include "GnashSleep.h"
#include "URL.h"
-#include <boost/cstdint.hpp>
+#include <cstdint>
#include <iomanip>
#include <map>
#include <algorithm>
@@ -182,8 +182,8 @@ writeFLVHeader(std::ostream& o)
}
-bool handleInvoke(rtmp::RTMP& r, FakeNC& nc, const boost::uint8_t* payload,
- const boost::uint8_t* end);
+bool handleInvoke(rtmp::RTMP& r, FakeNC& nc, const std::uint8_t* payload,
+ const std::uint8_t* end);
/// These functions create an RTMP call buffer and send it. They mimic
/// NetConnection.call() methods and replies to server calls.
@@ -538,8 +538,8 @@ main(int argc, char** argv)
}
bool
-handleInvoke(rtmp::RTMP& r, FakeNC& nc, const boost::uint8_t* payload,
- const boost::uint8_t* end)
+handleInvoke(rtmp::RTMP& r, FakeNC& nc, const std::uint8_t* payload,
+ const std::uint8_t* end)
{
assert(payload != end);
-----------------------------------------------------------------------
Summary of changes:
cygnal/cgi-bin/echo/echo.cpp | 6 +-
cygnal/cgi-bin/echo/echo.h | 6 +-
cygnal/cgi-bin/echo/gateway.cpp | 22 ++--
cygnal/cgi-bin/echo/gateway.h | 4 +-
cygnal/cgi-bin/fitcDemo/fitcDemo.cpp | 8 +-
cygnal/cgi-bin/fitcDemo/fitcDemo.h | 8 +-
cygnal/cgi-bin/oflaDemo/oflaDemo.cpp | 6 +-
cygnal/cgi-bin/oflaDemo/oflaDemo.h | 6 +-
cygnal/crc.cpp | 2 +-
cygnal/cygnal.h | 2 +-
cygnal/handler.cpp | 2 +-
cygnal/handler.h | 6 +-
cygnal/http_server.cpp | 46 ++++----
cygnal/http_server.h | 8 +-
cygnal/libamf/amf.cpp | 116 ++++++++++----------
cygnal/libamf/amf.h | 32 +++---
cygnal/libamf/amf_msg.cpp | 60 +++++-----
cygnal/libamf/amf_msg.h | 20 ++--
cygnal/libamf/buffer.cpp | 82 +++++++-------
cygnal/libamf/buffer.h | 46 ++++----
cygnal/libamf/element.cpp | 66 ++++++------
cygnal/libamf/element.h | 42 ++++----
cygnal/libamf/flv.cpp | 44 ++++----
cygnal/libamf/flv.h | 40 ++++----
cygnal/libamf/lcshm.cpp | 56 +++++-----
cygnal/libamf/lcshm.h | 30 +++---
cygnal/libamf/sol.cpp | 40 ++++----
cygnal/libamf/sol.h | 12 +-
cygnal/libnet/cque.cpp | 2 +-
cygnal/libnet/cque.h | 4 +-
cygnal/libnet/cqueue.cpp | 4 +-
cygnal/libnet/cqueue.h | 16 ++--
cygnal/libnet/diskstream.cpp | 30 +++---
cygnal/libnet/diskstream.h | 20 ++--
cygnal/libnet/http.cpp | 46 ++++----
cygnal/libnet/http.h | 20 ++--
cygnal/libnet/network.h | 4 +-
cygnal/libnet/rtmp.cpp | 106 +++++++++---------
cygnal/libnet/rtmp.h | 50 ++++----
cygnal/libnet/rtmp_client.cpp | 18 ++--
cygnal/libnet/rtmp_client.h | 2 +-
cygnal/libnet/rtmp_msg.h | 8 +-
cygnal/libnet/sshclient.cpp | 6 +-
cygnal/libnet/sshclient.h | 6 +-
cygnal/libnet/sshserver.cpp | 2 +-
cygnal/libnet/sshserver.h | 2 +-
cygnal/libnet/sslclient.cpp | 6 +-
cygnal/libnet/sslclient.h | 6 +-
cygnal/libnet/sslserver.cpp | 2 +-
cygnal/libnet/sslserver.h | 2 +-
cygnal/libnet/statistics.h | 2 +-
cygnal/proc.cpp | 6 +-
cygnal/proc.h | 6 +-
cygnal/rtmp_server.cpp | 86 +++++++-------
cygnal/rtmp_server.h | 24 ++--
cygnal/serverSO.cpp | 2 +-
cygnal/testsuite/libamf.all/test_amf.cpp | 12 +-
cygnal/testsuite/libamf.all/test_amfmsg.cpp | 2 +-
cygnal/testsuite/libamf.all/test_buffer.cpp | 28 +++---
cygnal/testsuite/libamf.all/test_flv.cpp | 4 +-
cygnal/testsuite/libamf.all/test_lc.cpp | 4 +-
cygnal/testsuite/libamf.all/test_number.cpp | 4 +-
cygnal/testsuite/libnet.all/test_cque.cpp | 6 +-
cygnal/testsuite/libnet.all/test_diskstream.cpp | 4 +-
cygnal/testsuite/libnet.all/test_handler.cpp | 6 +-
cygnal/testsuite/libnet.all/test_http.cpp | 16 ++--
cygnal/testsuite/libnet.all/test_rtmp.cpp | 2 +-
gui/Player.h | 2 +-
gui/aos4/aos4_agg_glue.h | 2 +-
gui/aos4/aos4_cairo_glue.h | 2 +-
gui/aos4/aos4_glue.h | 2 +-
gui/dump/dump.cpp | 4 +-
gui/fb/fb_glue_agg.cpp | 4 +-
gui/fb/fb_glue_agg.h | 2 +-
gui/fb/fb_glue_ovg.h | 2 +-
gui/fb/fbsup.h | 2 +-
gui/gui.cpp | 8 +-
gui/gui.h | 6 +-
gui/haiku/haiku_agg_glue.cpp | 4 +-
gui/haiku/haiku_agg_glue.h | 6 +-
gui/pythonmod/gnash-view.cpp | 4 +-
gui/sdl/sdl.cpp | 2 +-
gui/sdl/sdl_agg_glue.cpp | 4 +-
gui/sdl/sdl_agg_glue.h | 6 +-
gui/sdl/sdl_cairo_glue.cpp | 4 +-
gui/sdl/sdl_cairo_glue.h | 4 +-
gui/sdl/sdl_glue.h | 4 +-
gui/sdl/sdl_ogl_glue.cpp | 2 +-
gui/sdl/sdl_ogl_glue.h | 2 +-
libbase/AMF.cpp | 22 ++--
libbase/AMF.h | 30 +++---
libbase/BitsReader.cpp | 6 +-
libbase/BitsReader.h | 30 +++---
libbase/ClockTime.cpp | 12 +-
libbase/ClockTime.h | 6 +-
libbase/GnashImage.cpp | 2 +-
libbase/GnashImage.h | 6 +-
libbase/GnashNumeric.h | 16 ++--
libbase/GnashVaapiImage.cpp | 14 +-
libbase/GnashVaapiImage.h | 4 +-
libbase/IOChannel.cpp | 22 ++--
libbase/IOChannel.h | 8 +-
libbase/ImageIterators.h | 6 +-
libbase/Point2d.h | 30 +++---
libbase/RTMP.cpp | 84 +++++++-------
libbase/RTMP.h | 28 +++---
libbase/Range2d.h | 6 +-
libbase/SWFCtype.cpp | 4 +-
libbase/SharedMem.h | 4 +-
libbase/SimpleBuffer.h | 28 +++---
libbase/Socket.cpp | 6 +-
libbase/Socket.h | 4 +-
libbase/WallClockTimer.cpp | 4 +-
libbase/WallClockTimer.h | 6 +-
libbase/log.cpp | 4 +-
libbase/rc.cpp | 2 +-
libbase/rc.h | 12 +-
libbase/snappingrange.h | 4 +-
libbase/tu_file.cpp | 22 ++--
libbase/utf8.cpp | 18 ++--
libbase/utf8.h | 8 +-
libcore/AMFConverter.cpp | 14 +-
libcore/AMFConverter.h | 8 +-
libcore/Bitmap.cpp | 2 +-
libcore/Bitmap.h | 2 +-
libcore/Button.cpp | 4 +-
libcore/Button.h | 6 +-
libcore/DisplayList.cpp | 2 +-
libcore/DisplayList.h | 2 +-
libcore/DisplayObject.cpp | 12 +-
libcore/DisplayObject.h | 24 ++--
libcore/DragState.h | 10 +-
libcore/DynamicShape.cpp | 10 +-
libcore/DynamicShape.h | 16 ++--
libcore/FillStyle.cpp | 2 +-
libcore/FillStyle.h | 8 +-
libcore/Filters.h | 92 ++++++++--------
libcore/Font.cpp | 10 +-
libcore/Font.h | 16 ++--
libcore/FreetypeGlyphsProvider.cpp | 32 +++---
libcore/FreetypeGlyphsProvider.h | 4 +-
libcore/Function.h | 8 +-
libcore/Function2.h | 10 +-
libcore/Geometry.cpp | 6 +-
libcore/Geometry.h | 26 ++--
libcore/InteractiveObject.h | 6 +-
libcore/LineStyle.cpp | 6 +-
libcore/LineStyle.h | 6 +-
libcore/MorphShape.cpp | 2 +-
libcore/MorphShape.h | 2 +-
libcore/Movie.h | 4 +-
libcore/MovieClip.cpp | 42 ++++----
libcore/MovieClip.h | 14 +-
libcore/PropFlags.h | 10 +-
libcore/PropertyList.h | 2 +-
libcore/RGBA.cpp | 2 +-
libcore/RGBA.h | 20 ++--
libcore/SWFCxForm.cpp | 20 ++--
libcore/SWFCxForm.h | 22 ++--
libcore/SWFMatrix.cpp | 54 +++++-----
libcore/SWFMatrix.h | 32 +++---
libcore/SWFMovie.cpp | 6 +-
libcore/SWFMovie.h | 6 +-
libcore/SWFRect.cpp | 24 ++--
libcore/SWFRect.h | 50 ++++----
libcore/SWFStream.cpp | 38 +++---
libcore/SWFStream.h | 22 ++--
libcore/Shape.cpp | 2 +-
libcore/Shape.h | 2 +-
libcore/StaticText.cpp | 4 +-
libcore/StaticText.h | 4 +-
libcore/SystemClock.cpp | 4 +-
libcore/SystemClock.h | 4 +-
libcore/TextField.cpp | 72 ++++++------
libcore/TextField.h | 54 +++++-----
libcore/UserFunction.h | 2 +-
libcore/Video.cpp | 4 +-
libcore/Video.h | 4 +-
libcore/abc/AbcBlock.cpp | 114 ++++++++++----------
libcore/abc/AbcBlock.h | 24 ++--
libcore/abc/Class.cpp | 16 ++--
libcore/abc/Class.h | 8 +-
libcore/abc/CodeStream.cpp | 16 ++--
libcore/abc/CodeStream.h | 10 +-
libcore/abc/Method.cpp | 12 +-
libcore/abc/Method.h | 44 ++++----
libcore/abc/MultiName.h | 4 +-
libcore/abc/abc_function.h | 2 +-
libcore/abc/asException.h | 12 +-
libcore/as_value.cpp | 4 +-
libcore/as_value.h | 2 +-
libcore/asobj/ASConversions.cpp | 26 ++--
libcore/asobj/Array_as.cpp | 38 +++---
libcore/asobj/Color_as.cpp | 18 ++--
libcore/asobj/Date_as.cpp | 44 ++++----
libcore/asobj/Global_as.cpp | 6 +-
libcore/asobj/LocalConnection_as.cpp | 28 +++---
libcore/asobj/Microphone_as.cpp | 4 +-
libcore/asobj/MovieClip_as.cpp | 68 ++++++------
libcore/asobj/NetConnection_as.cpp | 38 +++---
libcore/asobj/NetStream_as.cpp | 58 +++++-----
libcore/asobj/NetStream_as.h | 26 ++--
libcore/asobj/Object.cpp | 2 +-
libcore/asobj/PlayHead.cpp | 8 +-
libcore/asobj/PlayHead.h | 10 +-
libcore/asobj/SharedObject_as.cpp | 22 ++--
libcore/asobj/Sound_as.cpp | 30 +++---
libcore/asobj/String_as.cpp | 10 +-
libcore/asobj/TextField_as.cpp | 8 +-
libcore/asobj/TextFormat_as.cpp | 28 +++---
libcore/asobj/TextFormat_as.h | 38 +++---
libcore/asobj/TextSnapshot_as.cpp | 32 +++---
libcore/asobj/XMLSocket_as.cpp | 6 +-
libcore/asobj/XML_as.cpp | 6 +-
libcore/asobj/flash/display/BitmapData_as.cpp | 116 ++++++++++----------
libcore/asobj/flash/display/BitmapData_as.h | 2 +-
libcore/asobj/flash/filters/BevelFilter_as.cpp | 10 +-
libcore/asobj/flash/filters/BlurFilter_as.cpp | 2 +-
.../asobj/flash/filters/DropShadowFilter_as.cpp | 2 +-
libcore/asobj/flash/filters/GlowFilter_as.cpp | 4 +-
.../asobj/flash/filters/GradientBevelFilter_as.cpp | 2 +-
.../asobj/flash/filters/GradientGlowFilter_as.cpp | 2 +-
libcore/asobj/flash/geom/ColorTransform_as.cpp | 10 +-
libcore/builtin_function.h | 2 +-
libcore/event_id.h | 2 +-
libcore/movie_root.cpp | 34 +++---
libcore/movie_root.h | 30 +++---
libcore/parser/SWFMovieDefinition.cpp | 16 ++--
libcore/parser/SWFMovieDefinition.h | 12 +-
libcore/parser/TypesParser.cpp | 48 ++++----
libcore/parser/action_buffer.cpp | 62 +++++-----
libcore/parser/action_buffer.h | 18 ++--
libcore/parser/filter_factory.cpp | 10 +-
libcore/parser/movie_definition.h | 12 +-
libcore/parser/sprite_definition.cpp | 2 +-
libcore/parser/sprite_definition.h | 12 +-
libcore/swf/CSMTextSettingsTag.cpp | 8 +-
libcore/swf/DefineBitsTag.cpp | 38 +++---
libcore/swf/DefineButtonCxformTag.cpp | 2 +-
libcore/swf/DefineButtonSoundTag.h | 2 +-
libcore/swf/DefineButtonTag.cpp | 12 +-
libcore/swf/DefineButtonTag.h | 8 +-
libcore/swf/DefineEditTextTag.cpp | 4 +-
libcore/swf/DefineEditTextTag.h | 24 ++--
libcore/swf/DefineFontAlignZonesTag.cpp | 14 +-
libcore/swf/DefineFontNameTag.h | 2 +-
libcore/swf/DefineFontTag.cpp | 26 ++--
libcore/swf/DefineFontTag.h | 16 ++--
libcore/swf/DefineMorphShapeTag.cpp | 10 +-
libcore/swf/DefineMorphShapeTag.h | 2 +-
libcore/swf/DefineScalingGridTag.cpp | 2 +-
libcore/swf/DefineSceneAndFrameLabelDataTag.h | 12 +-
libcore/swf/DefineShapeTag.cpp | 6 +-
libcore/swf/DefineShapeTag.h | 4 +-
libcore/swf/DefineTextTag.cpp | 4 +-
libcore/swf/DefineTextTag.h | 2 +-
libcore/swf/DefineVideoStreamTag.cpp | 4 +-
libcore/swf/DefineVideoStreamTag.h | 16 ++--
libcore/swf/DefinitionTag.h | 8 +-
libcore/swf/DoInitActionTag.h | 2 +-
libcore/swf/ExportAssetsTag.h | 6 +-
libcore/swf/ImportAssetsTag.h | 6 +-
libcore/swf/PlaceObject2Tag.cpp | 10 +-
libcore/swf/PlaceObject2Tag.h | 16 ++--
libcore/swf/ScriptLimitsTag.h | 4 +-
libcore/swf/SetTabIndexTag.cpp | 4 +-
libcore/swf/ShapeRecord.cpp | 6 +-
libcore/swf/ShapeRecord.h | 2 +-
libcore/swf/SoundStreamHeadTag.cpp | 16 ++--
libcore/swf/SoundStreamHeadTag.h | 2 +-
libcore/swf/StartSoundTag.h | 4 +-
libcore/swf/StreamSoundBlockTag.cpp | 6 +-
libcore/swf/StreamSoundBlockTag.h | 6 +-
libcore/swf/SymbolClassTag.h | 4 +-
libcore/swf/TextRecord.cpp | 12 +-
libcore/swf/TextRecord.h | 6 +-
libcore/swf/VideoFrameTag.cpp | 4 +-
libcore/swf/tag_loaders.cpp | 44 ++++----
libcore/vm/ASHandlers.cpp | 88 +++++++-------
libcore/vm/ActionExec.cpp | 12 +-
libcore/vm/ActionExec.h | 2 +-
libcore/vm/Machine.cpp | 118 ++++++++++----------
libcore/vm/Machine.h | 6 +-
libcore/vm/VM.cpp | 10 +-
libcore/vm/VM.h | 4 +-
libdevice/GnashDevice.h | 6 +-
libdevice/events/EventDevice.cpp | 2 +-
libdevice/events/InputDevice.cpp | 6 +-
libdevice/events/InputDevice.h | 6 +-
libdevice/events/MouseDevice.cpp | 2 +-
libdevice/rawfb/RawFBDevice.cpp | 4 +-
libdevice/rawfb/RawFBDevice.h | 8 +-
libdevice/vaapi/VaapiImage.cpp | 2 +-
libdevice/vaapi/VaapiImage.h | 4 +-
libdevice/vaapi/VaapiSurface.cpp | 6 +-
libdevice/vaapi/vaapi_common.h | 2 +-
libdevice/vaapi/vaapi_utils.cpp | 2 +-
libdevice/vaapi/vaapi_utils.h | 2 +-
libmedia/AudioDecoder.h | 22 ++--
libmedia/AudioDecoderSimple.cpp | 70 ++++++------
libmedia/AudioDecoderSimple.h | 6 +-
libmedia/AudioDecoderSpeex.cpp | 30 +++---
libmedia/AudioDecoderSpeex.h | 6 +-
libmedia/AudioInput.h | 2 +-
libmedia/AudioResampler.cpp | 12 +-
libmedia/AudioResampler.h | 4 +-
libmedia/FLVParser.cpp | 54 +++++-----
libmedia/FLVParser.h | 58 +++++-----
libmedia/MediaParser.cpp | 20 ++--
libmedia/MediaParser.h | 78 +++++++-------
libmedia/SoundInfo.h | 14 +-
libmedia/VideoConverter.h | 10 +-
libmedia/VideoInput.h | 2 +-
libmedia/ffmpeg/AudioDecoderFfmpeg.cpp | 52 +++++-----
libmedia/ffmpeg/AudioDecoderFfmpeg.h | 18 ++--
libmedia/ffmpeg/AudioInputFfmpeg.h | 2 +-
libmedia/ffmpeg/AudioResamplerFfmpeg.cpp | 4 +-
libmedia/ffmpeg/AudioResamplerFfmpeg.h | 6 +-
libmedia/ffmpeg/MediaHandlerFfmpeg.cpp | 2 +-
libmedia/ffmpeg/MediaParserFfmpeg.cpp | 56 +++++-----
libmedia/ffmpeg/MediaParserFfmpeg.h | 24 ++--
libmedia/ffmpeg/VideoConverterFfmpeg.cpp | 2 +-
libmedia/ffmpeg/VideoDecoderFfmpeg.cpp | 8 +-
libmedia/ffmpeg/VideoDecoderFfmpeg.h | 6 +-
libmedia/ffmpeg/VideoInputFfmpeg.h | 2 +-
libmedia/gst/AudioDecoderGst.cpp | 22 ++--
libmedia/gst/AudioDecoderGst.h | 8 +-
libmedia/gst/AudioInputGst.h | 2 +-
libmedia/gst/MediaHandlerGst.cpp | 2 +-
libmedia/gst/MediaParserGst.cpp | 4 +-
libmedia/gst/MediaParserGst.h | 6 +-
libmedia/gst/VideoConverterGst.cpp | 2 +-
libmedia/gst/VideoDecoderGst.cpp | 4 +-
libmedia/gst/VideoDecoderGst.h | 2 +-
libmedia/gst/VideoInputGst.h | 2 +-
libmedia/haiku/AudioDecoderHaiku.cpp | 18 ++--
libmedia/haiku/AudioDecoderHaiku.h | 10 +-
libmedia/haiku/AudioInputHaiku.h | 2 +-
libmedia/haiku/MediaParserHaiku.cpp | 4 +-
libmedia/haiku/MediaParserHaiku.h | 4 +-
libmedia/haiku/VideoDecoderHaiku.cpp | 8 +-
libmedia/haiku/VideoDecoderHaiku.h | 2 +-
libmedia/haiku/VideoInputHaiku.h | 2 +-
librender/GnashTexture.cpp | 2 +-
librender/GnashTexture.h | 2 +-
librender/agg/Renderer_agg.cpp | 10 +-
librender/agg/Renderer_agg_bitmap.h | 4 +-
librender/agg/Renderer_agg_style.h | 2 +-
librender/cairo/Renderer_cairo.cpp | 30 +++---
librender/cairo/Renderer_cairo.h | 2 +-
librender/opengl/Renderer_ogl.cpp | 24 ++--
librender/opengles1/Renderer_gles1.h | 2 +-
librender/openvg/OpenVGBitmap.h | 2 +-
librender/testr.cpp | 6 +-
libsound/AuxStream.h | 6 +-
libsound/EmbedSound.cpp | 2 +-
libsound/EmbedSound.h | 4 +-
libsound/EmbedSoundInst.cpp | 18 ++--
libsound/EmbedSoundInst.h | 6 +-
libsound/InputStream.h | 4 +-
libsound/LiveSound.cpp | 4 +-
libsound/LiveSound.h | 10 +-
libsound/NullSoundHandler.h | 2 +-
libsound/SoundEnvelope.h | 8 +-
libsound/SoundUtils.h | 2 +-
libsound/StreamingSound.cpp | 14 +-
libsound/StreamingSound.h | 2 +-
libsound/StreamingSoundData.cpp | 2 +-
libsound/WAVWriter.cpp | 24 ++--
libsound/WAVWriter.h | 4 +-
libsound/aos4/sound_handler_ahi.cpp | 18 ++--
libsound/aos4/sound_handler_ahi.h | 6 +-
libsound/mkit/sound_handler_mkit.cpp | 18 ++--
libsound/mkit/sound_handler_mkit.h | 6 +-
libsound/sdl/sound_handler_sdl.cpp | 6 +-
libsound/sdl/sound_handler_sdl.h | 4 +-
libsound/sound_handler.cpp | 12 +-
libsound/sound_handler.h | 4 +-
plugin/aos4/plugin.cpp | 4 +-
plugin/win32/plugin.cpp | 4 +-
testsuite/DummyCharacter.h | 2 +-
testsuite/FuzzyPixel.h | 2 +-
testsuite/MovieTester.cpp | 4 +-
testsuite/libbase.all/IntTypesTest.cpp | 18 ++--
testsuite/libbase.all/Point2dTest.cpp | 4 +-
testsuite/libcore.all/BitsReaderTest.cpp | 8 +-
testsuite/libcore.all/CodeStreamTest.cpp | 6 +-
testsuite/libcore.all/CxFormTest.cpp | 8 +-
testsuite/libcore.all/MatrixTest.cpp | 16 ++--
testsuite/libcore.all/StreamTest.cpp | 8 +-
testsuite/libdevice.all/test_rawfb.cpp | 2 +-
utilities/flvdumper.cpp | 2 +-
utilities/processor.cpp | 2 +-
utilities/rtmpget.cpp | 10 +-
394 files changed, 2879 insertions(+), 2879 deletions(-)
hooks/post-receive
--
Gnash
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Gnash-commit] [SCM] Gnash branch, master, updated. release_0_8_9_final-2035-g759defb,
Bastiaan Jacques <=