starboard/shared/starboard/media/mime_type.cc - cobalt - Git at Google

 // Copyright 2016 The Cobalt Authors. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "starboard/shared/starboard/media/mime_type.h"

 #include <algorithm>
 #include <iosfwd>
 #include <locale>
 #include <numeric>
 #include <sstream>
 #include <string>
 #include <vector>

 #include "starboard/common/log.h"
 #include "starboard/common/string.h"

 namespace starboard {
 namespace shared {
 namespace starboard {
 namespace media {

 namespace {

 typedef std::vector<std::string> Strings;

 void ParseParamTypeAndValue(const std::string& name,
                             const std::string& value,
                             MimeType::Param* param) {
   SB_DCHECK(param);

   param->name = name;
   if (value.size() >= 2 && value[0] == '\"' && value.back() == '\"') {
     param->type = MimeType::kParamTypeString;
     param->string_value = value.substr(1, value.size() - 2);
     return;
   }

   param->string_value = value;

   int count;
   int i;
   if (SbStringScanF(value.c_str(), "%d%n", &i, &count) == 1 &&
       count == value.size()) {
     param->type = MimeType::kParamTypeInteger;
     param->int_value = i;
     return;
   }
   float f;
   std::stringstream buffer(value);
   buffer.imbue(std::locale::classic());
   buffer >> f;
   if (!buffer.fail() && buffer.rdbuf()->in_avail() == 0) {
     param->type = MimeType::kParamTypeFloat;
     param->float_value = f;
     return;
   }
   if (value == "true" || value == "false") {
     param->type = MimeType::kParamTypeBoolean;
     param->bool_value = value == "true";
     return;
   }

   param->type = MimeType::kParamTypeString;
 }

 bool ContainsSpace(const std::string& str) {
   for (size_t i = 0; i < str.size(); ++i) {
     if (isspace(str[i])) {
       return true;
     }
   }
   return false;
 }

 void Trim(std::string* str) {
   while (!str->empty() && isspace(*str->begin())) {
     str->erase(str->begin());
   }
   while (!str->empty() && isspace(*str->rbegin())) {
     str->resize(str->size() - 1);
   }
 }

 Strings SplitAndTrim(const std::string& str, char ch) {
   Strings result;
   size_t pos = 0;

   for (;;) {
     size_t next = str.find(ch, pos);
     std::string sub_str = str.substr(pos, next - pos);
     Trim(&sub_str);
     if (!sub_str.empty()) {
       result.push_back(sub_str);
     }
     if (next == str.npos) {
       break;
     }
     pos = next + 1;
   }

   return result;
 }

 }  // namespace

 const int MimeType::kInvalidParamIndex = -1;

 // static
 bool MimeType::ParseParamString(const std::string& param_string, Param* param) {
   std::vector<std::string> name_and_value = SplitAndTrim(param_string, '=');
   // The parameter must be on the format 'name=value' and neither |name| nor
   // |value| can be empty. |value| must also not contain '|' and ';'.
   if (name_and_value.size() != 2 || name_and_value[0].empty() ||
       name_and_value[1].empty() ||
       name_and_value[1].find('|') != std::string::npos ||
       name_and_value[1].find(';') != std::string::npos) {
     return false;
   }

   if (param) {
     ParseParamTypeAndValue(name_and_value[0], name_and_value[1], param);
   }
   return true;
 }

 MimeType::MimeType(const std::string& content_type) {
   Strings components = SplitAndTrim(content_type, ';');

   if (components.empty()) {
     return;
   }

   // 1. Verify if there is a valid type/subtype in the very beginning.
   if (ContainsSpace(components.front())) {
     return;
   }

   std::vector<std::string> type_and_container =
       SplitAndTrim(components.front(), '/');
   if (type_and_container.size() != 2 || type_and_container[0].empty() ||
       type_and_container[1].empty()) {
     return;
   }
   type_ = type_and_container[0];
   subtype_ = type_and_container[1];

   components.erase(components.begin());

   // 2. Verify the parameters have valid formats, we want to be strict here.
   for (Strings::iterator iter = components.begin(); iter != components.end();
        ++iter) {
     Param param;
     if (!ParseParamString(*iter, &param)) {
       return;
     }
     // There can only be no more than one codecs parameter and it has to be
     // the first parameter if it is present.
     if (param.name == "codecs") {
       if (!params_.empty()) {
         return;
       }
       codecs_ = SplitAndTrim(param.string_value, ',');
     }
     params_.push_back(param);
   }

   is_valid_ = true;
 }

 int MimeType::GetParamCount() const {
   return static_cast<int>(params_.size());
 }

 MimeType::ParamType MimeType::GetParamType(int index) const {
   SB_DCHECK(index < GetParamCount());

   return params_[index].type;
 }

 const std::string& MimeType::GetParamName(int index) const {
   SB_DCHECK(index < GetParamCount());

   return params_[index].name;
 }

 int MimeType::GetParamIndexByName(const char* name) const {
   for (size_t i = 0; i < params_.size(); ++i) {
     if (SbStringCompareNoCase(params_[i].name.c_str(), name) == 0) {
       return static_cast<int>(i);
     }
   }
   return kInvalidParamIndex;
 }

 int MimeType::GetParamIntValue(int index) const {
   SB_DCHECK(index < GetParamCount());

   if (params_[index].type == kParamTypeInteger) {
     return params_[index].int_value;
   }
   return 0;
 }

 float MimeType::GetParamFloatValue(int index) const {
   SB_DCHECK(index < GetParamCount());

   if (params_[index].type == kParamTypeInteger) {
     return params_[index].int_value;
   }
   if (params_[index].type == kParamTypeFloat) {
     return params_[index].float_value;
   }
   return 0.0f;
 }

 const std::string& MimeType::GetParamStringValue(int index) const {
   SB_DCHECK(index < GetParamCount());

   return params_[index].string_value;
 }

 bool MimeType::GetParamBoolValue(int index) const {
   SB_DCHECK(index < GetParamCount());

   if (params_[index].type == kParamTypeBoolean) {
     return params_[index].bool_value;
   }
   return false;
 }

 int MimeType::GetParamIntValue(const char* name, int default_value) const {
   int index = GetParamIndexByName(name);
   if (index != kInvalidParamIndex) {
     return GetParamIntValue(index);
   }
   return default_value;
 }

 float MimeType::GetParamFloatValue(const char* name,
                                    float default_value) const {
   int index = GetParamIndexByName(name);
   if (index != kInvalidParamIndex) {
     return GetParamFloatValue(index);
   }
   return default_value;
 }

 const std::string& MimeType::GetParamStringValue(
     const char* name,
     const std::string& default_value) const {
   int index = GetParamIndexByName(name);
   if (index != kInvalidParamIndex) {
     return GetParamStringValue(index);
   }
   return default_value;
 }

 bool MimeType::GetParamBoolValue(const char* name, bool default_value) const {
   int index = GetParamIndexByName(name);
   if (index != kInvalidParamIndex) {
     return GetParamBoolValue(index);
   }
   return default_value;
 }

 bool MimeType::ValidateIntParameter(const char* name) const {
   if (!is_valid()) {
     return false;
   }

   int index = GetParamIndexByName(name);
   if (index == kInvalidParamIndex) {
     return true;
   }
   return GetParamType(index) == kParamTypeInteger;
 }

 bool MimeType::ValidateFloatParameter(const char* name) const {
   if (!is_valid()) {
     return false;
   }

   int index = GetParamIndexByName(name);
   if (index == kInvalidParamIndex) {
     return true;
   }
   ParamType type = GetParamType(index);
   return type == kParamTypeInteger || type == kParamTypeFloat;
 }

 bool MimeType::ValidateStringParameter(const char* name,
                                        const std::string& pattern) const {
   if (!is_valid()) {
     return false;
   }

   int index = GetParamIndexByName(name);
   if (pattern.empty() || index == kInvalidParamIndex) {
     return true;
   }

   const std::string& param_value = params_[index].string_value;

   bool matches = false;
   size_t match_start = 0;
   while (!matches) {
     match_start = pattern.find(param_value, match_start);
     if (match_start == std::string::npos) {
       break;
     }

     size_t match_end = match_start + param_value.length();
     matches =
         // Matches if the match is at the start of the string or
         // if the preceding character is the divider _and_
         (match_start <= 0 || pattern[match_start - 1] == '|') &&
         // if the end of the match is the end of the pattern or
         // if the succeeding character is the divider.
         (match_end >= pattern.length() || pattern[match_end] == '|');
     match_start = match_end + 1;
   }
   return matches;
 }

 bool MimeType::ValidateBoolParameter(const char* name) const {
   if (!is_valid()) {
     return false;
   }

   int index = GetParamIndexByName(name);
   if (index == kInvalidParamIndex) {
     return true;
   }
   ParamType type = GetParamType(index);
   return type == kParamTypeBoolean;
 }

 std::string MimeType::ToString() const {
   if (!is_valid()) {
     return "{ InvalidMimeType }; ";
   }
   std::stringstream ss;
   ss << "{ type: " << type();
   ss << ", subtype: " << subtype();
   ss << ", codecs: ";
   if (codecs_.empty()) {
     ss << "null";
   } else {
     ss << codecs_[0];
     for (size_t i = 1; i < codecs_.size(); i++) {
       ss << "|" << codecs_[i];
     }
   }
   ss << ", params: ";
   if (params_.empty()) {
     ss << "null";
   } else {
     ss << "{ ";
     for (size_t i = 0; i < params_.size(); i++) {
       const Param& param = params_[i];
       if (i != 0) {
         ss << ",";
       }
       ss << param.name << "=";
       switch (param.type) {
         case kParamTypeInteger:
           ss << "(int)" << param.int_value;
           break;
         case kParamTypeFloat:
           ss << "(float)" << param.float_value;
           break;
         case kParamTypeString:
           ss << "(string)" << param.string_value;
           break;
         case kParamTypeBoolean:
           ss << "(bool)" << (param.bool_value ? "true" : "false");
           break;
       }
     }
     ss << " }";
   }
   ss << " }";
   return ss.str();
 }

 }  // namespace media
 }  // namespace starboard
 }  // namespace shared
 }  // namespace starboard
	// Copyright 2016 The Cobalt Authors. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "starboard/shared/starboard/media/mime_type.h"

	#include <algorithm>
	#include <iosfwd>
	#include <locale>
	#include <numeric>
	#include <sstream>
	#include <string>
	#include <vector>

	#include "starboard/common/log.h"
	#include "starboard/common/string.h"

	namespace starboard {
	namespace shared {
	namespace starboard {
	namespace media {

	namespace {

	typedef std::vector<std::string> Strings;

	void ParseParamTypeAndValue(const std::string& name,
	const std::string& value,
	MimeType::Param* param) {
	SB_DCHECK(param);

	param->name = name;
	if (value.size() >= 2 && value[0] == '\"' && value.back() == '\"') {
	param->type = MimeType::kParamTypeString;
	param->string_value = value.substr(1, value.size() - 2);
	return;
	}

	param->string_value = value;

	int count;
	int i;
	if (SbStringScanF(value.c_str(), "%d%n", &i, &count) == 1 &&
	count == value.size()) {
	param->type = MimeType::kParamTypeInteger;
	param->int_value = i;
	return;
	}
	float f;
	std::stringstream buffer(value);
	buffer.imbue(std::locale::classic());
	buffer >> f;
	if (!buffer.fail() && buffer.rdbuf()->in_avail() == 0) {
	param->type = MimeType::kParamTypeFloat;
	param->float_value = f;
	return;
	}
	if (value == "true" \|\| value == "false") {
	param->type = MimeType::kParamTypeBoolean;
	param->bool_value = value == "true";
	return;
	}

	param->type = MimeType::kParamTypeString;
	}

	bool ContainsSpace(const std::string& str) {
	for (size_t i = 0; i < str.size(); ++i) {
	if (isspace(str[i])) {
	return true;
	}
	}
	return false;
	}

	void Trim(std::string* str) {
	while (!str->empty() && isspace(*str->begin())) {
	str->erase(str->begin());
	}
	while (!str->empty() && isspace(*str->rbegin())) {
	str->resize(str->size() - 1);
	}
	}

	Strings SplitAndTrim(const std::string& str, char ch) {
	Strings result;
	size_t pos = 0;

	for (;;) {
	size_t next = str.find(ch, pos);
	std::string sub_str = str.substr(pos, next - pos);
	Trim(&sub_str);
	if (!sub_str.empty()) {
	result.push_back(sub_str);
	}
	if (next == str.npos) {
	break;
	}
	pos = next + 1;
	}

	return result;
	}

	} // namespace

	const int MimeType::kInvalidParamIndex = -1;

	// static
	bool MimeType::ParseParamString(const std::string& param_string, Param* param) {
	std::vector<std::string> name_and_value = SplitAndTrim(param_string, '=');
	// The parameter must be on the format 'name=value' and neither \|name\| nor
	// \|value\| can be empty. \|value\| must also not contain '\|' and ';'.
	if (name_and_value.size() != 2 \|\| name_and_value[0].empty() \|\|
	name_and_value[1].empty() \|\|
	name_and_value[1].find('\|') != std::string::npos \|\|
	name_and_value[1].find(';') != std::string::npos) {
	return false;
	}

	if (param) {
	ParseParamTypeAndValue(name_and_value[0], name_and_value[1], param);
	}
	return true;
	}

	MimeType::MimeType(const std::string& content_type) {
	Strings components = SplitAndTrim(content_type, ';');

	if (components.empty()) {
	return;
	}

	// 1. Verify if there is a valid type/subtype in the very beginning.
	if (ContainsSpace(components.front())) {
	return;
	}

	std::vector<std::string> type_and_container =
	SplitAndTrim(components.front(), '/');
	if (type_and_container.size() != 2 \|\| type_and_container[0].empty() \|\|
	type_and_container[1].empty()) {
	return;
	}
	type_ = type_and_container[0];
	subtype_ = type_and_container[1];

	components.erase(components.begin());

	// 2. Verify the parameters have valid formats, we want to be strict here.
	for (Strings::iterator iter = components.begin(); iter != components.end();
	++iter) {
	Param param;
	if (!ParseParamString(*iter, &param)) {
	return;
	}
	// There can only be no more than one codecs parameter and it has to be
	// the first parameter if it is present.
	if (param.name == "codecs") {
	if (!params_.empty()) {
	return;
	}
	codecs_ = SplitAndTrim(param.string_value, ',');
	}
	params_.push_back(param);
	}

	is_valid_ = true;
	}

	int MimeType::GetParamCount() const {
	return static_cast<int>(params_.size());
	}

	MimeType::ParamType MimeType::GetParamType(int index) const {
	SB_DCHECK(index < GetParamCount());

	return params_[index].type;
	}

	const std::string& MimeType::GetParamName(int index) const {
	SB_DCHECK(index < GetParamCount());

	return params_[index].name;
	}

	int MimeType::GetParamIndexByName(const char* name) const {
	for (size_t i = 0; i < params_.size(); ++i) {
	if (SbStringCompareNoCase(params_[i].name.c_str(), name) == 0) {
	return static_cast<int>(i);
	}
	}
	return kInvalidParamIndex;
	}

	int MimeType::GetParamIntValue(int index) const {
	SB_DCHECK(index < GetParamCount());

	if (params_[index].type == kParamTypeInteger) {
	return params_[index].int_value;
	}
	return 0;
	}

	float MimeType::GetParamFloatValue(int index) const {
	SB_DCHECK(index < GetParamCount());

	if (params_[index].type == kParamTypeInteger) {
	return params_[index].int_value;
	}
	if (params_[index].type == kParamTypeFloat) {
	return params_[index].float_value;
	}
	return 0.0f;
	}

	const std::string& MimeType::GetParamStringValue(int index) const {
	SB_DCHECK(index < GetParamCount());

	return params_[index].string_value;
	}

	bool MimeType::GetParamBoolValue(int index) const {
	SB_DCHECK(index < GetParamCount());

	if (params_[index].type == kParamTypeBoolean) {
	return params_[index].bool_value;
	}
	return false;
	}

	int MimeType::GetParamIntValue(const char* name, int default_value) const {
	int index = GetParamIndexByName(name);
	if (index != kInvalidParamIndex) {
	return GetParamIntValue(index);
	}
	return default_value;
	}

	float MimeType::GetParamFloatValue(const char* name,
	float default_value) const {
	int index = GetParamIndexByName(name);
	if (index != kInvalidParamIndex) {
	return GetParamFloatValue(index);
	}
	return default_value;
	}

	const std::string& MimeType::GetParamStringValue(
	const char* name,
	const std::string& default_value) const {
	int index = GetParamIndexByName(name);
	if (index != kInvalidParamIndex) {
	return GetParamStringValue(index);
	}
	return default_value;
	}

	bool MimeType::GetParamBoolValue(const char* name, bool default_value) const {
	int index = GetParamIndexByName(name);
	if (index != kInvalidParamIndex) {
	return GetParamBoolValue(index);
	}
	return default_value;
	}

	bool MimeType::ValidateIntParameter(const char* name) const {
	if (!is_valid()) {
	return false;
	}

	int index = GetParamIndexByName(name);
	if (index == kInvalidParamIndex) {
	return true;
	}
	return GetParamType(index) == kParamTypeInteger;
	}

	bool MimeType::ValidateFloatParameter(const char* name) const {
	if (!is_valid()) {
	return false;
	}

	int index = GetParamIndexByName(name);
	if (index == kInvalidParamIndex) {
	return true;
	}
	ParamType type = GetParamType(index);
	return type == kParamTypeInteger \|\| type == kParamTypeFloat;
	}

	bool MimeType::ValidateStringParameter(const char* name,
	const std::string& pattern) const {
	if (!is_valid()) {
	return false;
	}

	int index = GetParamIndexByName(name);
	if (pattern.empty() \|\| index == kInvalidParamIndex) {
	return true;
	}

	const std::string& param_value = params_[index].string_value;

	bool matches = false;
	size_t match_start = 0;
	while (!matches) {
	match_start = pattern.find(param_value, match_start);
	if (match_start == std::string::npos) {
	break;
	}

	size_t match_end = match_start + param_value.length();
	matches =
	// Matches if the match is at the start of the string or
	// if the preceding character is the divider _and_
	(match_start <= 0 \|\| pattern[match_start - 1] == '\|') &&
	// if the end of the match is the end of the pattern or
	// if the succeeding character is the divider.
	(match_end >= pattern.length() \|\| pattern[match_end] == '\|');
	match_start = match_end + 1;
	}
	return matches;
	}

	bool MimeType::ValidateBoolParameter(const char* name) const {
	if (!is_valid()) {
	return false;
	}

	int index = GetParamIndexByName(name);
	if (index == kInvalidParamIndex) {
	return true;
	}
	ParamType type = GetParamType(index);
	return type == kParamTypeBoolean;
	}

	std::string MimeType::ToString() const {
	if (!is_valid()) {
	return "{ InvalidMimeType }; ";
	}
	std::stringstream ss;
	ss << "{ type: " << type();
	ss << ", subtype: " << subtype();
	ss << ", codecs: ";
	if (codecs_.empty()) {
	ss << "null";
	} else {
	ss << codecs_[0];
	for (size_t i = 1; i < codecs_.size(); i++) {
	ss << "\|" << codecs_[i];
	}
	}
	ss << ", params: ";
	if (params_.empty()) {
	ss << "null";
	} else {
	ss << "{ ";
	for (size_t i = 0; i < params_.size(); i++) {
	const Param& param = params_[i];
	if (i != 0) {
	ss << ",";
	}
	ss << param.name << "=";
	switch (param.type) {
	case kParamTypeInteger:
	ss << "(int)" << param.int_value;
	break;
	case kParamTypeFloat:
	ss << "(float)" << param.float_value;
	break;
	case kParamTypeString:
	ss << "(string)" << param.string_value;
	break;
	case kParamTypeBoolean:
	ss << "(bool)" << (param.bool_value ? "true" : "false");
	break;
	}
	}
	ss << " }";
	}
	ss << " }";
	return ss.str();
	}

	} // namespace media
	} // namespace starboard
	} // namespace shared
	} // namespace starboard