src/third_party/libjingle/source/talk/media/base/videoframe.cc

   1 /*
   2  * libjingle
   3  * Copyright 2011 Google Inc.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are met:
   7  *
   8  *  1. Redistributions of source code must retain the above copyright notice,
   9  *     this list of conditions and the following disclaimer.
  10  *  2. Redistributions in binary form must reproduce the above copyright notice,
  11  *     this list of conditions and the following disclaimer in the documentation
  12  *     and/or other materials provided with the distribution.
  13  *  3. The name of the author may not be used to endorse or promote products
  14  *     derived from this software without specific prior written permission.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  17  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  18  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  19  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  20  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  22  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  23  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  24  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  25  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26  */
  27
  28 #include "talk/media/base/videoframe.h"
  29
  30 #include <string.h>
  31
  32 #if !defined(DISABLE_YUV)
  33 #include "libyuv/compare.h"
  34 #include "libyuv/planar_functions.h"
  35 #include "libyuv/scale.h"
  36 #endif
  37
  38 #include "talk/media/base/videocommon.h"
  39 #include "webrtc/base/logging.h"
  40
  41 namespace cricket {
  42
  43 // Round to 2 pixels because Chroma channels are half size.
  44 #define ROUNDTO2(v) (v & ~1)
  45
  46 rtc::StreamResult VideoFrame::Write(rtc::StreamInterface* stream,
  47                                           int* error) {
  48   rtc::StreamResult result = rtc::SR_SUCCESS;
  49   const uint8* src_y = GetYPlane();
  50   const uint8* src_u = GetUPlane();
  51   const uint8* src_v = GetVPlane();
  52   if (!src_y || !src_u || !src_v) {
  53     return result;  // Nothing to write.
  54   }
  55   const int32 y_pitch = GetYPitch();
  56   const int32 u_pitch = GetUPitch();
  57   const int32 v_pitch = GetVPitch();
  58   const size_t width = GetWidth();
  59   const size_t height = GetHeight();
  60   const size_t half_width = (width + 1) >> 1;
  61   const size_t half_height = (height + 1) >> 1;
  62   // Write Y.
  63   for (size_t row = 0; row < height; ++row) {
  64     result = stream->Write(src_y + row * y_pitch, width, NULL, error);
  65     if (result != rtc::SR_SUCCESS) {
  66       return result;
  67     }
  68   }
  69   // Write U.
  70   for (size_t row = 0; row < half_height; ++row) {
  71     result = stream->Write(src_u + row * u_pitch, half_width, NULL, error);
  72     if (result != rtc::SR_SUCCESS) {
  73       return result;
  74     }
  75   }
  76   // Write V.
  77   for (size_t row = 0; row < half_height; ++row) {
  78     result = stream->Write(src_v + row * v_pitch, half_width, NULL, error);
  79     if (result != rtc::SR_SUCCESS) {
  80       return result;
  81     }
  82   }
  83   return result;
  84 }
  85
  86 bool VideoFrame::CopyToPlanes(
  87     uint8* dst_y, uint8* dst_u, uint8* dst_v,
  88     int32 dst_pitch_y, int32 dst_pitch_u, int32 dst_pitch_v) const {
  89 #if !defined(DISABLE_YUV)
  90   int32 src_width = static_cast<int>(GetWidth());
  91   int32 src_height = static_cast<int>(GetHeight());
  92   return libyuv::I420Copy(GetYPlane(), GetYPitch(),
  93                           GetUPlane(), GetUPitch(),
  94                           GetVPlane(), GetVPitch(),
  95                           dst_y, dst_pitch_y,
  96                           dst_u, dst_pitch_u,
  97                           dst_v, dst_pitch_v,
  98                           src_width, src_height) == 0;
  99 #else
 100   int uv_size = GetUPitch() * GetChromaHeight();
 101   memcpy(dst_y, GetYPlane(), GetWidth() * GetHeight());
 102   memcpy(dst_u, GetUPlane(), uv_size);
 103   memcpy(dst_v, GetVPlane(), uv_size);
 104   return true;
 105 #endif
 106 }
 107
 108 void VideoFrame::CopyToFrame(VideoFrame* dst) const {
 109   if (!dst) {
 110     LOG(LS_ERROR) << "NULL dst pointer.";
 111     return;
 112   }
 113
 114   CopyToPlanes(dst->GetYPlane(), dst->GetUPlane(), dst->GetVPlane(),
 115                dst->GetYPitch(), dst->GetUPitch(), dst->GetVPitch());
 116 }
 117
 118 // TODO(fbarchard): Handle odd width/height with rounding.
 119 void VideoFrame::StretchToPlanes(
 120     uint8* dst_y, uint8* dst_u, uint8* dst_v,
 121     int32 dst_pitch_y, int32 dst_pitch_u, int32 dst_pitch_v,
 122     size_t width, size_t height, bool interpolate, bool vert_crop) const {
 123   if (!GetYPlane() || !GetUPlane() || !GetVPlane()) {
 124     LOG(LS_ERROR) << "NULL plane pointer.";
 125     return;
 126   }
 127
 128   size_t src_width = GetWidth();
 129   size_t src_height = GetHeight();
 130   if (width == src_width && height == src_height) {
 131     CopyToPlanes(dst_y, dst_u, dst_v, dst_pitch_y, dst_pitch_u, dst_pitch_v);
 132     return;
 133   }
 134   const uint8* src_y = GetYPlane();
 135   const uint8* src_u = GetUPlane();
 136   const uint8* src_v = GetVPlane();
 137
 138   if (vert_crop) {
 139     // Adjust the input width:height ratio to be the same as the output ratio.
 140     if (src_width * height > src_height * width) {
 141       // Reduce the input width, but keep size/position aligned for YuvScaler
 142       src_width = ROUNDTO2(src_height * width / height);
 143       int32 iwidth_offset = ROUNDTO2((GetWidth() - src_width) / 2);
 144       src_y += iwidth_offset;
 145       src_u += iwidth_offset / 2;
 146       src_v += iwidth_offset / 2;
 147     } else if (src_width * height < src_height * width) {
 148       // Reduce the input height.
 149       src_height = src_width * height / width;
 150       int32 iheight_offset = static_cast<int32>(
 151           (GetHeight() - src_height) >> 2);
 152       iheight_offset <<= 1;  // Ensure that iheight_offset is even.
 153       src_y += iheight_offset * GetYPitch();
 154       src_u += iheight_offset / 2 * GetUPitch();
 155       src_v += iheight_offset / 2 * GetVPitch();
 156     }
 157   }
 158
 159   // TODO(fbarchard): Implement a simple scale for non-libyuv.
 160 #if !defined(DISABLE_YUV)
 161   // Scale to the output I420 frame.
 162   libyuv::Scale(src_y, src_u, src_v,
 163                 GetYPitch(), GetUPitch(), GetVPitch(),
 164                 static_cast<int>(src_width), static_cast<int>(src_height),
 165                 dst_y, dst_u, dst_v, dst_pitch_y, dst_pitch_u, dst_pitch_v,
 166                 static_cast<int>(width), static_cast<int>(height), interpolate);
 167 #endif
 168 }
 169
 170 size_t VideoFrame::StretchToBuffer(size_t dst_width, size_t dst_height,
 171                                    uint8* dst_buffer, size_t size,
 172                                    bool interpolate, bool vert_crop) const {
 173   if (!dst_buffer) {
 174     LOG(LS_ERROR) << "NULL dst_buffer pointer.";
 175     return 0;
 176   }
 177
 178   size_t needed = SizeOf(dst_width, dst_height);
 179   if (needed <= size) {
 180     uint8* dst_y = dst_buffer;
 181     uint8* dst_u = dst_y + dst_width * dst_height;
 182     uint8* dst_v = dst_u + ((dst_width + 1) >> 1) * ((dst_height + 1) >> 1);
 183     StretchToPlanes(dst_y, dst_u, dst_v,
 184                     static_cast<int32>(dst_width),
 185                     static_cast<int32>((dst_width + 1) >> 1),
 186                     static_cast<int32>((dst_width + 1) >> 1),
 187                     dst_width, dst_height, interpolate, vert_crop);
 188   }
 189   return needed;
 190 }
 191
 192 void VideoFrame::StretchToFrame(VideoFrame* dst,
 193                                 bool interpolate, bool vert_crop) const {
 194   if (!dst) {
 195     LOG(LS_ERROR) << "NULL dst pointer.";
 196     return;
 197   }
 198
 199   StretchToPlanes(dst->GetYPlane(), dst->GetUPlane(), dst->GetVPlane(),
 200                   dst->GetYPitch(), dst->GetUPitch(), dst->GetVPitch(),
 201                   dst->GetWidth(), dst->GetHeight(),
 202                   interpolate, vert_crop);
 203   dst->SetElapsedTime(GetElapsedTime());
 204   dst->SetTimeStamp(GetTimeStamp());
 205 }
 206
 207 VideoFrame* VideoFrame::Stretch(size_t dst_width, size_t dst_height,
 208                                 bool interpolate, bool vert_crop) const {
 209   VideoFrame* dest = CreateEmptyFrame(static_cast<int>(dst_width),
 210                                       static_cast<int>(dst_height),
 211                                       GetPixelWidth(), GetPixelHeight(),
 212                                       GetElapsedTime(), GetTimeStamp());
 213   if (dest) {
 214     StretchToFrame(dest, interpolate, vert_crop);
 215   }
 216   return dest;
 217 }
 218
 219 bool VideoFrame::SetToBlack() {
 220 #if !defined(DISABLE_YUV)
 221   return libyuv::I420Rect(GetYPlane(), GetYPitch(),
 222                           GetUPlane(), GetUPitch(),
 223                           GetVPlane(), GetVPitch(),
 224                           0, 0,
 225                           static_cast<int>(GetWidth()),
 226                           static_cast<int>(GetHeight()),
 227                           16, 128, 128) == 0;
 228 #else
 229   int uv_size = GetUPitch() * GetChromaHeight();
 230   memset(GetYPlane(), 16, GetWidth() * GetHeight());
 231   memset(GetUPlane(), 128, uv_size);
 232   memset(GetVPlane(), 128, uv_size);
 233   return true;
 234 #endif
 235 }
 236
 237 static const size_t kMaxSampleSize = 1000000000u;
 238 // Returns whether a sample is valid.
 239 bool VideoFrame::Validate(uint32 fourcc, int w, int h,
 240                           const uint8 *sample, size_t sample_size) {
 241   if (h < 0) {
 242     h = -h;
 243   }
 244   // 16384 is maximum resolution for VP8 codec.
 245   if (w < 1 || w > 16384 || h < 1 || h > 16384) {
 246     LOG(LS_ERROR) << "Invalid dimensions: " << w << "x" << h;
 247     return false;
 248   }
 249   uint32 format = CanonicalFourCC(fourcc);
 250   int expected_bpp = 8;
 251   switch (format) {
 252     case FOURCC_I400:
 253     case FOURCC_RGGB:
 254     case FOURCC_BGGR:
 255     case FOURCC_GRBG:
 256     case FOURCC_GBRG:
 257       expected_bpp = 8;
 258       break;
 259     case FOURCC_I420:
 260     case FOURCC_I411:
 261     case FOURCC_YU12:
 262     case FOURCC_YV12:
 263     case FOURCC_M420:
 264     case FOURCC_Q420:
 265     case FOURCC_NV21:
 266     case FOURCC_NV12:
 267       expected_bpp = 12;
 268       break;
 269     case FOURCC_I422:
 270     case FOURCC_YV16:
 271     case FOURCC_YUY2:
 272     case FOURCC_UYVY:
 273     case FOURCC_RGBP:
 274     case FOURCC_RGBO:
 275     case FOURCC_R444:
 276       expected_bpp = 16;
 277       break;
 278     case FOURCC_I444:
 279     case FOURCC_YV24:
 280     case FOURCC_24BG:
 281     case FOURCC_RAW:
 282       expected_bpp = 24;
 283       break;
 284
 285     case FOURCC_ABGR:
 286     case FOURCC_BGRA:
 287     case FOURCC_ARGB:
 288       expected_bpp = 32;
 289       break;
 290
 291     case FOURCC_MJPG:
 292     case FOURCC_H264:
 293       expected_bpp = 0;
 294       break;
 295     default:
 296       expected_bpp = 8;  // Expect format is at least 8 bits per pixel.
 297       break;
 298   }
 299   size_t expected_size = (w * expected_bpp + 7) / 8 * h;
 300   // For compressed formats, expect 4 bits per 16 x 16 macro.  I420 would be
 301   // 6 bits, but grey can be 4 bits.
 302   if (expected_bpp == 0) {
 303     expected_size = ((w + 15) / 16) * ((h + 15) / 16) * 4 / 8;
 304   }
 305   if (sample == NULL) {
 306     LOG(LS_ERROR) << "NULL sample pointer."
 307                   << " format: " << GetFourccName(format)
 308                   << " bpp: " << expected_bpp
 309                   << " size: " << w << "x" << h
 310                   << " expected: " << expected_size
 311                   << " " << sample_size;
 312     return false;
 313   }
 314   // TODO(fbarchard): Make function to dump information about frames.
 315   uint8 four_samples[4] = { 0, 0, 0, 0 };
 316   for (size_t i = 0; i < ARRAY_SIZE(four_samples) && i < sample_size; ++i) {
 317     four_samples[i] = sample[i];
 318   }
 319   if (sample_size < expected_size) {
 320     LOG(LS_ERROR) << "Size field is too small."
 321                   << " format: " << GetFourccName(format)
 322                   << " bpp: " << expected_bpp
 323                   << " size: " << w << "x" << h
 324                   << " " << sample_size
 325                   << " expected: " << expected_size
 326                   << " sample[0..3]: " << static_cast<int>(four_samples[0])
 327                   << ", " << static_cast<int>(four_samples[1])
 328                   << ", " << static_cast<int>(four_samples[2])
 329                   << ", " << static_cast<int>(four_samples[3]);
 330     return false;
 331   }
 332   if (sample_size > kMaxSampleSize) {
 333     LOG(LS_WARNING) << "Size field is invalid."
 334                     << " format: " << GetFourccName(format)
 335                     << " bpp: " << expected_bpp
 336                     << " size: " << w << "x" << h
 337                     << " " << sample_size
 338                     << " expected: " << 2 * expected_size
 339                     << " sample[0..3]: " << static_cast<int>(four_samples[0])
 340                     << ", " << static_cast<int>(four_samples[1])
 341                     << ", " << static_cast<int>(four_samples[2])
 342                     << ", " << static_cast<int>(four_samples[3]);
 343     return false;
 344   }
 345   // Show large size warning once every 100 frames.
 346   // TODO(fbarchard): Make frame counter atomic for thread safety.
 347   static int large_warn100 = 0;
 348   size_t large_expected_size = expected_size * 2;
 349   if (expected_bpp >= 8 &&
 350       (sample_size > large_expected_size || sample_size > kMaxSampleSize) &&
 351       large_warn100 % 100 == 0) {
 352     ++large_warn100;
 353     LOG(LS_WARNING) << "Size field is too large."
 354                     << " format: " << GetFourccName(format)
 355                     << " bpp: " << expected_bpp
 356                     << " size: " << w << "x" << h
 357                     << " bytes: " << sample_size
 358                     << " expected: " << large_expected_size
 359                     << " sample[0..3]: " << static_cast<int>(four_samples[0])
 360                     << ", " << static_cast<int>(four_samples[1])
 361                     << ", " << static_cast<int>(four_samples[2])
 362                     << ", " << static_cast<int>(four_samples[3]);
 363   }
 364
 365   // TODO(fbarchard): Add duplicate pixel check.
 366   // TODO(fbarchard): Use frame counter atomic for thread safety.
 367   static bool valid_once = true;
 368   if (valid_once) {
 369     valid_once = false;
 370     LOG(LS_INFO) << "Validate frame passed."
 371                  << " format: " << GetFourccName(format)
 372                  << " bpp: " << expected_bpp
 373                  << " size: " << w << "x" << h
 374                  << " bytes: " << sample_size
 375                  << " expected: " << expected_size
 376                  << " sample[0..3]: " << static_cast<int>(four_samples[0])
 377                  << ", " << static_cast<int>(four_samples[1])
 378                  << ", " << static_cast<int>(four_samples[2])
 379                  << ", " << static_cast<int>(four_samples[3]);
 380   }
 381   return true;
 382 }
 383
 384 }  // namespace cricket