Home | History | Annotate | Download | only in capture 
      1 // Copyright 2013 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 
      5 #include "media/video/capture/file_video_capture_device.h"
      6 
      7 #include <string>
      8 
      9 #include "base/bind.h"
     10 #include "base/memory/scoped_ptr.h"
     11 #include "base/strings/string_number_conversions.h"
     12 #include "base/strings/string_piece.h"
     13 
     14 namespace media {
     15 static const int kY4MHeaderMaxSize = 200;
     16 static const char kY4MSimpleFrameDelimiter[] = "FRAME";
     17 static const int kY4MSimpleFrameDelimiterSize = 6;
     18 
     19 int ParseY4MInt(const base::StringPiece& token) {
     20   int temp_int;
     21   CHECK(base::StringToInt(token, &temp_int)) << token;
     22   return temp_int;
     23 }
     24 
     25 // Extract numerator and denominator out of a token that must have the aspect
     26 // numerator:denominator, both integer numbers.
     27 void ParseY4MRational(const base::StringPiece& token,
     28                       int* numerator,
     29                       int* denominator) {
     30   size_t index_divider = token.find(':');
     31   CHECK_NE(index_divider, token.npos);
     32   *numerator = ParseY4MInt(token.substr(0, index_divider));
     33   *denominator = ParseY4MInt(token.substr(index_divider + 1, token.length()));
     34   CHECK(*denominator);
     35 }
     36 
     37 // This function parses the ASCII string in |header| as belonging to a Y4M file,
     38 // returning the collected format in |video_format|. For a non authoritative
     39 // explanation of the header format, check
     40 // http://wiki.multimedia.cx/index.php?title=YUV4MPEG2
     41 // Restrictions: Only interlaced I420 pixel format is supported, and pixel
     42 // aspect ratio is ignored.
     43 // Implementation notes: Y4M header should end with an ASCII 0x20 (whitespace)
     44 // character, however all examples mentioned in the Y4M header description end
     45 // with a newline character instead. Also, some headers do _not_ specify pixel
     46 // format, in this case it means I420.
     47 // This code was inspired by third_party/libvpx/.../y4minput.* .
     48 void ParseY4MTags(const std::string& file_header,
     49                   media::VideoCaptureFormat* video_format) {
     50   video_format->pixel_format = media::PIXEL_FORMAT_I420;
     51   video_format->frame_size.set_width(0);
     52   video_format->frame_size.set_height(0);
     53   size_t index = 0;
     54   size_t blank_position = 0;
     55   base::StringPiece token;
     56   while ((blank_position = file_header.find_first_of("\n ", index)) !=
     57          std::string::npos) {
     58     // Every token is supposed to have an identifier letter and a bunch of
     59     // information immediately after, which we extract into a |token| here.
     60     token =
     61         base::StringPiece(&file_header[index + 1], blank_position - index - 1);
     62     CHECK(!token.empty());
     63     switch (file_header[index]) {
     64       case 'W':
     65         video_format->frame_size.set_width(ParseY4MInt(token));
     66         break;
     67       case 'H':
     68         video_format->frame_size.set_height(ParseY4MInt(token));
     69         break;
     70       case 'F': {
     71         // If the token is "FRAME", it means we have finished with the header.
     72         if (token[0] == 'R')
     73           break;
     74         int fps_numerator, fps_denominator;
     75         ParseY4MRational(token, &fps_numerator, &fps_denominator);
     76         video_format->frame_rate = fps_numerator / fps_denominator;
     77         break;
     78       }
     79       case 'I':
     80         // Interlacing is ignored, but we don't like mixed modes.
     81         CHECK_NE(token[0], 'm');
     82         break;
     83       case 'A':
     84         // Pixel aspect ratio ignored.
     85         break;
     86       case 'C':
     87         CHECK(token == "420" || token == "420jpeg" || token == "420paldv")
     88             << token;  // Only I420 is supported, and we fudge the variants.
     89         break;
     90       default:
     91         break;
     92     }
     93     // We're done if we have found a newline character right after the token.
     94     if (file_header[blank_position] == '\n')
     95       break;
     96     index = blank_position + 1;
     97   }
     98   // Last video format semantic correctness check before sending it back.
     99   CHECK(video_format->IsValid());
    100 }
    101 
    102 // Reads and parses the header of a Y4M |file|, returning the collected pixel
    103 // format in |video_format|. Returns the index of the first byte of the first
    104 // video frame.
    105 // Restrictions: Only trivial per-frame headers are supported.
    106 // static
    107 int64 FileVideoCaptureDevice::ParseFileAndExtractVideoFormat(
    108     base::File* file,
    109     media::VideoCaptureFormat* video_format) {
    110   std::string header(kY4MHeaderMaxSize, 0);
    111   file->Read(0, &header[0], kY4MHeaderMaxSize - 1);
    112 
    113   size_t header_end = header.find(kY4MSimpleFrameDelimiter);
    114   CHECK_NE(header_end, header.npos);
    115 
    116   ParseY4MTags(header, video_format);
    117   return header_end + kY4MSimpleFrameDelimiterSize;
    118 }
    119 
    120 // Opens a given file for reading, and returns the file to the caller, who is
    121 // responsible for closing it.
    122 // static
    123 base::File FileVideoCaptureDevice::OpenFileForRead(
    124     const base::FilePath& file_path) {
    125   base::File file(file_path, base::File::FLAG_OPEN | base::File::FLAG_READ);
    126   CHECK(file.IsValid()) << file_path.value();
    127   return file.Pass();
    128 }
    129 
    130 FileVideoCaptureDevice::FileVideoCaptureDevice(const base::FilePath& file_path)
    131     : capture_thread_("CaptureThread"),
    132       file_path_(file_path),
    133       frame_size_(0),
    134       current_byte_index_(0),
    135       first_frame_byte_index_(0) {}
    136 
    137 FileVideoCaptureDevice::~FileVideoCaptureDevice() {
    138   DCHECK(thread_checker_.CalledOnValidThread());
    139   // Check if the thread is running.
    140   // This means that the device have not been DeAllocated properly.
    141   CHECK(!capture_thread_.IsRunning());
    142 }
    143 
    144 void FileVideoCaptureDevice::AllocateAndStart(
    145     const VideoCaptureParams& params,
    146     scoped_ptr<VideoCaptureDevice::Client> client) {
    147   DCHECK(thread_checker_.CalledOnValidThread());
    148   CHECK(!capture_thread_.IsRunning());
    149 
    150   capture_thread_.Start();
    151   capture_thread_.message_loop()->PostTask(
    152       FROM_HERE,
    153       base::Bind(&FileVideoCaptureDevice::OnAllocateAndStart,
    154                  base::Unretained(this),
    155                  params,
    156                  base::Passed(&client)));
    157 }
    158 
    159 void FileVideoCaptureDevice::StopAndDeAllocate() {
    160   DCHECK(thread_checker_.CalledOnValidThread());
    161   CHECK(capture_thread_.IsRunning());
    162 
    163   capture_thread_.message_loop()->PostTask(
    164       FROM_HERE,
    165       base::Bind(&FileVideoCaptureDevice::OnStopAndDeAllocate,
    166                  base::Unretained(this)));
    167   capture_thread_.Stop();
    168 }
    169 
    170 int FileVideoCaptureDevice::CalculateFrameSize() {
    171   DCHECK_EQ(capture_format_.pixel_format, PIXEL_FORMAT_I420);
    172   DCHECK_EQ(capture_thread_.message_loop(), base::MessageLoop::current());
    173   return capture_format_.frame_size.GetArea() * 12 / 8;
    174 }
    175 
    176 void FileVideoCaptureDevice::OnAllocateAndStart(
    177     const VideoCaptureParams& params,
    178     scoped_ptr<VideoCaptureDevice::Client> client) {
    179   DCHECK_EQ(capture_thread_.message_loop(), base::MessageLoop::current());
    180 
    181   client_ = client.Pass();
    182 
    183   // Open the file and parse the header. Get frame size and format.
    184   DCHECK(!file_.IsValid());
    185   file_ = OpenFileForRead(file_path_);
    186   first_frame_byte_index_ =
    187       ParseFileAndExtractVideoFormat(&file_, &capture_format_);
    188   current_byte_index_ = first_frame_byte_index_;
    189   DVLOG(1) << "Opened video file " << capture_format_.frame_size.ToString()
    190            << ", fps: " << capture_format_.frame_rate;
    191 
    192   frame_size_ = CalculateFrameSize();
    193   video_frame_.reset(new uint8[frame_size_]);
    194 
    195   capture_thread_.message_loop()->PostTask(
    196       FROM_HERE,
    197       base::Bind(&FileVideoCaptureDevice::OnCaptureTask,
    198                  base::Unretained(this)));
    199 }
    200 
    201 void FileVideoCaptureDevice::OnStopAndDeAllocate() {
    202   DCHECK_EQ(capture_thread_.message_loop(), base::MessageLoop::current());
    203   file_.Close();
    204   client_.reset();
    205   current_byte_index_ = 0;
    206   first_frame_byte_index_ = 0;
    207   frame_size_ = 0;
    208   video_frame_.reset();
    209 }
    210 
    211 void FileVideoCaptureDevice::OnCaptureTask() {
    212   DCHECK_EQ(capture_thread_.message_loop(), base::MessageLoop::current());
    213   if (!client_)
    214     return;
    215   int result = file_.Read(current_byte_index_,
    216                           reinterpret_cast<char*>(video_frame_.get()),
    217                           frame_size_);
    218 
    219   // If we passed EOF to base::File, it will return 0 read characters. In that
    220   // case, reset the pointer and read again.
    221   if (result != frame_size_) {
    222     CHECK_EQ(result, 0);
    223     current_byte_index_ = first_frame_byte_index_;
    224     CHECK_EQ(file_.Read(current_byte_index_,
    225                         reinterpret_cast<char*>(video_frame_.get()),
    226                         frame_size_),
    227              frame_size_);
    228   } else {
    229     current_byte_index_ += frame_size_ + kY4MSimpleFrameDelimiterSize;
    230   }
    231 
    232   // Give the captured frame to the client.
    233   client_->OnIncomingCapturedData(video_frame_.get(),
    234                                   frame_size_,
    235                                   capture_format_,
    236                                   0,
    237                                   base::TimeTicks::Now());
    238   // Reschedule next CaptureTask.
    239   base::MessageLoop::current()->PostDelayedTask(
    240       FROM_HERE,
    241       base::Bind(&FileVideoCaptureDevice::OnCaptureTask,
    242                  base::Unretained(this)),
    243       base::TimeDelta::FromSeconds(1) / capture_format_.frame_rate);
    244 }
    245 
    246 }  // namespace media
    247