Mac Video Capture AVFoundation: Calculate compressed frame size for MJPEG.

media/video/capture/mac/video_capture_device_avfoundation_mac.mm

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #import "media/video/capture/mac/video_capture_device_avfoundation_mac.h"
 
 #import <CoreVideo/CoreVideo.h>
 
+#include <cstring>  // For memchr.
+
 #include "base/logging.h"
 #include "base/mac/foundation_util.h"
 #include "media/video/capture/mac/video_capture_device_mac.h"
 #include "ui/gfx/geometry/size.h"
 
 // Prefer MJPEG if frame width or height is larger than this.
 static const int kMjpegWidthThreshold = 640;
 static const int kMjpegHeightThreshold = 480;
 
 // This function translates Mac Core Video pixel formats to Chromium pixel
 // formats. Chromium pixel formats are sorted in order of preference.
 media::VideoPixelFormat FourCCToChromiumPixelFormat(FourCharCode code) {
   switch (code) {
     case kCVPixelFormatType_422YpCbCr8:
       return media::PIXEL_FORMAT_UYVY;
     case CoreMediaGlue::kCMPixelFormat_422YpCbCr8_yuvs:
       return media::PIXEL_FORMAT_YUY2;
     case CoreMediaGlue::kCMVideoCodecType_JPEG_OpenDML:
       return media::PIXEL_FORMAT_MJPEG;
     default:
       return media::PIXEL_FORMAT_UNKNOWN;
   }
 }
 
+// Returns frame size by finding the End Of Image marker, or 0 if not found.
+size_t JpegFrameSize(const char* sample, size_t sampleSize) {
+  // Jump to next marker (0xff), check for End Of Image (0xd9), repeat.
+  const char* end = sample + sampleSize - 1;
+  for (const char* it = sample;
+       (it = static_cast<const char*>(memchr(it, 0xff, end - it)));

[torbjorng, 2015/02/12 14:32:57]

I'm not too fond of side-effects in loop termination criteria, consider putting
memchr code in loop body for readability.
Also, while pointer-interpreted-as-boolean is OK in the language, is it really
accepted by all compilers?

+       ++it) {
+    if (it[1] == static_cast<char>(0xd9))
+      return 2 + (it - sample);
+  }
+  DLOG(WARNING) << "JPEG End Of Image (EOI) marker not found.";
+  return 0;
+}
+
 @implementation VideoCaptureDeviceAVFoundation
 
 #pragma mark Class methods
 
 + (void)getDeviceNames:(NSMutableDictionary*)deviceNames {
   // At this stage we already know that AVFoundation is supported and the whole
   // library is loaded and initialised, by the device monitoring.
   NSArray* devices = [AVCaptureDeviceGlue devices];
   for (CrAVCaptureDevice* device in devices) {
     if (([device hasMediaType:AVFoundationGlue::AVMediaTypeVideo()] ||
@@ skipping 256 matching lines @@
     // If MJPEG, use block buffer instead of pixel buffer.
     CoreMediaGlue::CMBlockBufferRef blockBuffer =
         CoreMediaGlue::CMSampleBufferGetDataBuffer(sampleBuffer);
     if (blockBuffer) {
       size_t lengthAtOffset;
       CoreMediaGlue::CMBlockBufferGetDataPointer(
           blockBuffer, 0, &lengthAtOffset, &frameSize, &baseAddress);
       // Expect the MJPEG data to be available as a contiguous reference, i.e.
       // not covered by multiple memory blocks.
       CHECK_EQ(lengthAtOffset, frameSize);
+
+      // If |frameSize| is suspiciously high (>= 8 bpp), calculate the actual
+      // size by finding the end of image marker. The purpose is to speed up the
+      // jpeg decoding in the browser.

[tommi (sloooow) - chröme, 2015/02/11 15:57:44]

what about adding a note about the validation step in libvpx?  Since that's
where we're spending cycles right now, it will help a future reader understand
the context.

+      if (static_cast<int>(frameSize) >= dimensions.width * dimensions.height)
+        frameSize = JpegFrameSize(baseAddress, frameSize);

[tommi (sloooow) - chröme, 2015/02/11 15:57:44]

If JpegFrameSize fails and returns 0, should we keep the previous value?

+
+      if (frameSize == 0)
+        return;
     }
   } else {
     videoFrame = CoreMediaGlue::CMSampleBufferGetImageBuffer(sampleBuffer);
     // Lock the frame and calculate frame size.
     if (CVPixelBufferLockBaseAddress(videoFrame, kCVPixelBufferLock_ReadOnly) ==
         kCVReturnSuccess) {
       baseAddress = static_cast<char*>(CVPixelBufferGetBaseAddress(videoFrame));
       frameSize = CVPixelBufferGetHeight(videoFrame) *
                   CVPixelBufferGetBytesPerRow(videoFrame);
     } else {
@@ skipping 23 matching lines @@
 }
 
 - (void)sendErrorString:(NSString*)error {
   DLOG(ERROR) << [error UTF8String];
   base::AutoLock lock(lock_);
   if (frameReceiver_)
     frameReceiver_->ReceiveError([error UTF8String]);
 }
 
 @end