media_param_traits.cc 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165
  1. // Copyright 2016 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "media/base/ipc/media_param_traits.h"
  5. #include "base/strings/stringprintf.h"
  6. #include "ipc/ipc_message_utils.h"
  7. #include "media/base/audio_parameters.h"
  8. #include "media/base/audio_point.h"
  9. #include "media/base/encryption_pattern.h"
  10. #include "media/base/encryption_scheme.h"
  11. #include "media/base/limits.h"
  12. #include "ui/gfx/ipc/geometry/gfx_param_traits.h"
  13. #include "ui/gfx/ipc/gfx_param_traits.h"
  14. using media::AudioParameters;
  15. using media::AudioLatency;
  16. using media::ChannelLayout;
  17. namespace IPC {
  18. void ParamTraits<AudioParameters>::Write(base::Pickle* m,
  19. const AudioParameters& p) {
  20. WriteParam(m, p.format());
  21. WriteParam(m, p.channel_layout());
  22. WriteParam(m, p.sample_rate());
  23. WriteParam(m, p.frames_per_buffer());
  24. WriteParam(m, p.channels());
  25. WriteParam(m, p.effects());
  26. WriteParam(m, p.mic_positions());
  27. WriteParam(m, p.latency_tag());
  28. WriteParam(m, p.hardware_capabilities());
  29. }
  30. bool ParamTraits<AudioParameters>::Read(const base::Pickle* m,
  31. base::PickleIterator* iter,
  32. AudioParameters* r) {
  33. AudioParameters::Format format;
  34. ChannelLayout channel_layout;
  35. int sample_rate, frames_per_buffer, channels, effects;
  36. std::vector<media::Point> mic_positions;
  37. AudioLatency::LatencyType latency_tag;
  38. absl::optional<media::AudioParameters::HardwareCapabilities>
  39. hardware_capabilities;
  40. if (!ReadParam(m, iter, &format) || !ReadParam(m, iter, &channel_layout) ||
  41. !ReadParam(m, iter, &sample_rate) ||
  42. !ReadParam(m, iter, &frames_per_buffer) ||
  43. !ReadParam(m, iter, &channels) || !ReadParam(m, iter, &effects) ||
  44. !ReadParam(m, iter, &mic_positions) ||
  45. !ReadParam(m, iter, &latency_tag) ||
  46. !ReadParam(m, iter, &hardware_capabilities)) {
  47. return false;
  48. }
  49. if (hardware_capabilities) {
  50. *r = AudioParameters(format, channel_layout, sample_rate, frames_per_buffer,
  51. *hardware_capabilities);
  52. } else {
  53. *r =
  54. AudioParameters(format, channel_layout, sample_rate, frames_per_buffer);
  55. }
  56. r->set_channels_for_discrete(channels);
  57. r->set_effects(effects);
  58. r->set_mic_positions(mic_positions);
  59. r->set_latency_tag(latency_tag);
  60. return r->IsValid();
  61. }
  62. void ParamTraits<AudioParameters>::Log(const AudioParameters& p,
  63. std::string* l) {
  64. l->append(base::StringPrintf("<AudioParameters>"));
  65. }
  66. void ParamTraits<AudioParameters::HardwareCapabilities>::Write(
  67. base::Pickle* m,
  68. const param_type& p) {
  69. WriteParam(m, p.min_frames_per_buffer);
  70. WriteParam(m, p.max_frames_per_buffer);
  71. WriteParam(m, p.bitstream_formats);
  72. }
  73. bool ParamTraits<AudioParameters::HardwareCapabilities>::Read(
  74. const base::Pickle* m,
  75. base::PickleIterator* iter,
  76. param_type* r) {
  77. int bitstream_formats;
  78. int max_frames_per_buffer;
  79. int min_frames_per_buffer;
  80. if (!ReadParam(m, iter, &min_frames_per_buffer) ||
  81. !ReadParam(m, iter, &max_frames_per_buffer) ||
  82. !ReadParam(m, iter, &bitstream_formats)) {
  83. return false;
  84. }
  85. r->min_frames_per_buffer = min_frames_per_buffer;
  86. r->max_frames_per_buffer = max_frames_per_buffer;
  87. r->bitstream_formats = bitstream_formats;
  88. return true;
  89. }
  90. void ParamTraits<AudioParameters::HardwareCapabilities>::Log(
  91. const param_type& p,
  92. std::string* l) {
  93. l->append(base::StringPrintf("<AudioParameters::HardwareCapabilities>"));
  94. }
  95. template <>
  96. struct ParamTraits<media::EncryptionPattern> {
  97. typedef media::EncryptionPattern param_type;
  98. static void Write(base::Pickle* m, const param_type& p);
  99. static bool Read(const base::Pickle* m,
  100. base::PickleIterator* iter,
  101. param_type* r);
  102. static void Log(const param_type& p, std::string* l);
  103. };
  104. void ParamTraits<media::EncryptionPattern>::Write(base::Pickle* m,
  105. const param_type& p) {
  106. WriteParam(m, p.crypt_byte_block());
  107. WriteParam(m, p.skip_byte_block());
  108. }
  109. bool ParamTraits<media::EncryptionPattern>::Read(const base::Pickle* m,
  110. base::PickleIterator* iter,
  111. param_type* r) {
  112. uint32_t crypt_byte_block, skip_byte_block;
  113. if (!ReadParam(m, iter, &crypt_byte_block) ||
  114. !ReadParam(m, iter, &skip_byte_block)) {
  115. return false;
  116. }
  117. *r = media::EncryptionPattern(crypt_byte_block, skip_byte_block);
  118. return true;
  119. }
  120. void ParamTraits<media::EncryptionPattern>::Log(const param_type& p,
  121. std::string* l) {
  122. l->append(base::StringPrintf("<EncryptionPattern>"));
  123. }
  124. } // namespace IPC
  125. // Generate param traits write methods.
  126. #include "ipc/param_traits_write_macros.h"
  127. namespace IPC {
  128. #undef MEDIA_BASE_IPC_MEDIA_PARAM_TRAITS_MACROS_H_
  129. #include "media/base/ipc/media_param_traits_macros.h"
  130. } // namespace IPC
  131. // Generate param traits read methods.
  132. #include "ipc/param_traits_read_macros.h"
  133. namespace IPC {
  134. #undef MEDIA_BASE_IPC_MEDIA_PARAM_TRAITS_MACROS_H_
  135. #include "media/base/ipc/media_param_traits_macros.h"
  136. } // namespace IPC
  137. // Generate param traits log methods.
  138. #include "ipc/param_traits_log_macros.h"
  139. namespace IPC {
  140. #undef MEDIA_BASE_IPC_MEDIA_PARAM_TRAITS_MACROS_H_
  141. #include "media/base/ipc/media_param_traits_macros.h"
  142. } // namespace IPC