File video capture device supports MJPEG format

media/filters/jpeg_parser.cc

 // Copyright 2015 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.
 
 #include "media/filters/jpeg_parser.h"
 
 #include "base/big_endian.h"
 #include "base/logging.h"
 
 using base::BigEndianReader;
@@ skipping 251 matching lines @@
     return false;
   }
   if (point_transform != 0) {
     DLOG(ERROR) << "Point transform should be 0 for baseline mode";
     return false;
   }
 
   return true;
 }
 
+// |eoi_ptr| will point to the end of image (after EOI marker) after search
+// succeeds. Returns true on EOI marker found, or false.
+static bool SearchEOI(const char* buffer, size_t length, const char** eoi_ptr) {
+  DCHECK(buffer);
+  DCHECK(eoi_ptr);
+  BigEndianReader reader(buffer, length);
+  uint8_t marker1;
+  uint8_t marker2;
+
+  while (reader.remaining() > 0) {
+    READ_U8_OR_RETURN_FALSE(&marker1);
+    if (marker1 != JPEG_MARKER_PREFIX)

[kcwu, 2015/08/20 09:01:38]

Does it help performance if using memcmp here?

[kcwu, 2015/08/20 09:18:36]

I mean memchr.

[henryhsu, 2015/08/20 09:50:59]

Yes, it help performance. Thanks.

+      continue;
+
+    do {
+      READ_U8_OR_RETURN_FALSE(&marker2);
+    } while (marker2 == JPEG_MARKER_PREFIX);  // skip fill bytes
+
+    switch (marker2) {
+      // Compressed data escape.
+      case 0x00:
+        break;
+      // Restart
+      case JPEG_RST0:
+      case JPEG_RST1:
+      case JPEG_RST2:
+      case JPEG_RST3:
+      case JPEG_RST4:
+      case JPEG_RST5:
+      case JPEG_RST6:
+      case JPEG_RST7:
+        break;
+      case JPEG_EOI:
+        *eoi_ptr = reader.ptr();
+        return true;
+      default:
+        // Skip for other markers.
+        uint16_t size;
+        READ_U16_OR_RETURN_FALSE(&size);
+        if (size < sizeof(size)) {
+          DLOG(ERROR) << "Ill-formed JPEG. Segment size (" << size
+                      << ") is smaller than size field (" << sizeof(size)
+                      << ")";
+          return false;
+        }
+        size -= sizeof(size);
+
+        if (!reader.Skip(size)) {
+          DLOG(ERROR) << "Ill-formed JPEG. Remaining size ("
+                      << reader.remaining()
+                      << ") is smaller than header specified (" << size << ")";
+          return false;
+        }
+        break;
+    }
+  }
+  return false;
+}
+
 // |result| is already initialized to 0 in ParseJpegPicture.
 static bool ParseSOI(const char* buffer,
                      size_t length,
                      JpegParseResult* result) {
   // Spec B.2.1 High-level syntax
   DCHECK(buffer);
   DCHECK(result);
   BigEndianReader reader(buffer, length);
   uint8_t marker1;
   uint8_t marker2;
@@ skipping 83 matching lines @@
   }
 
   if (!has_marker_dqt) {
     DLOG(ERROR) << "No DQT marker found";
     return false;
   }
 
   // Scan data follows scan header immediately.
   result->data = reader.ptr();
   result->data_size = reader.remaining();
+  const size_t kSoiSize = 2;
+  result->image_size = length + kSoiSize;
 
   return true;
 }
 
 bool ParseJpegPicture(const uint8_t* buffer,
                       size_t length,
                       JpegParseResult* result) {
   DCHECK(buffer);
   DCHECK(result);
   BigEndianReader reader(reinterpret_cast<const char*>(buffer), length);
   memset(result, 0, sizeof(JpegParseResult));
 
   uint8_t marker1, marker2;
   READ_U8_OR_RETURN_FALSE(&marker1);
   READ_U8_OR_RETURN_FALSE(&marker2);
   if (marker1 != JPEG_MARKER_PREFIX || marker2 != JPEG_SOI) {
     DLOG(ERROR) << "Not a JPEG";
     return false;
   }
 
   return ParseSOI(reader.ptr(), reader.remaining(), result);
 }
 
+bool ParseJpegStream(const uint8_t* buffer,
+                     size_t length,
+                     JpegParseResult* result) {
+  DCHECK(buffer);
+  DCHECK(result);
+  if (!ParseJpegPicture(buffer, length, result))
+    return false;
+
+  BigEndianReader reader(
+      reinterpret_cast<const char*>(result->data), result->data_size);
+  const char* eoi_ptr = nullptr;
+  if (!SearchEOI(reader.ptr(), reader.remaining(), &eoi_ptr)) {
+    DLOG(ERROR) << "SearchEOI failed";
+    return false;
+  }
+  DCHECK(eoi_ptr);
+  result->data_size = eoi_ptr - result->data;
+  result->image_size = eoi_ptr - reinterpret_cast<const char*>(buffer);
+  return true;
+}
+
 }  // namespace media