Added IsEndOfStream and IsDiscontiguous flags to buffers.

media/base/mock_media_filters.h

 // Copyright (c) 2009 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.
 
 #ifndef MEDIA_BASE_MOCK_MEDIA_FILTERS_H_
 #define MEDIA_BASE_MOCK_MEDIA_FILTERS_H_
 
 #include <string>
 
 #include "base/waitable_event.h"
@@ skipping 27 matching lines @@
   MockFilterConfig()
       : data_source_behavior(MOCK_DATA_SOURCE_NORMAL_INIT),
         has_video(true),
         video_width(1280u),
         video_height(720u),
         video_surface_format(VideoSurface::YV12),
         compressed_audio_mime_type(mime_type::kAACAudio),
         uncompressed_audio_mime_type(mime_type::kUncompressedAudio),
         compressed_video_mime_type(mime_type::kH264AnnexB),
         uncompressed_video_mime_type(mime_type::kUncompressedVideo),
-        frame_duration(base::TimeDelta::FromMicroseconds(33333)) {
+        frame_duration(base::TimeDelta::FromMicroseconds(33333)),
+        media_duration(base::TimeDelta::FromSeconds(5)) {
   }
 
   MockDataSourceBehavior data_source_behavior;
   bool has_video;
   size_t video_width;
   size_t video_height;
   VideoSurface::Format video_surface_format;
   std::string compressed_audio_mime_type;
   std::string uncompressed_audio_mime_type;
   std::string compressed_video_mime_type;
   std::string uncompressed_video_mime_type;
   base::TimeDelta frame_duration;
+  base::TimeDelta media_duration;
 };
 
 
-class MockDataSource : public media::DataSource {
+class MockDataSource : public DataSource {
  public:
   static FilterFactory* CreateFactory(const MockFilterConfig* config) {
      return new FilterFactoryImpl1<MockDataSource,
                                    const MockFilterConfig*>(config);
   }
 
   // Implementation of MediaFilter.
   virtual void Stop() {}
 
   // Implementation of DataSource.
@@ skipping 41 matching lines @@
   virtual bool SetPosition(int64 position) {
     return true;
   }
 
   virtual bool GetSize(int64* size_out) {
     *size_out = 0;
     return false;
   }
 
  private:
-  friend class media::FilterFactoryImpl1<MockDataSource,
-                                         const MockFilterConfig*>;
+  friend class FilterFactoryImpl1<MockDataSource,
+                                  const MockFilterConfig*>;
 
   explicit MockDataSource(const MockFilterConfig* config)
       : behavior_(config->data_source_behavior) {
   }
 
   virtual ~MockDataSource() {}
 
   void TaskBehavior() {
     switch (behavior_) {
       case MOCK_DATA_SOURCE_TASK_ERROR_POST_INIT:
@@ skipping 20 matching lines @@
  public:
   static FilterFactory* CreateFactory(const MockFilterConfig* config) {
      return new FilterFactoryImpl1<MockDemuxer,
                                    const MockFilterConfig*>(config);
   }
 
   // Implementation of MediaFilter.
   virtual void Stop() {}
 
   // Implementation of Demuxer.
-  virtual bool Initialize(media::DataSource* data_source) {
+  virtual bool Initialize(DataSource* data_source) {
     host_->InitializationComplete();
     return true;
   }
 
   virtual size_t GetNumberOfStreams() {
     if (config_->has_video) {
       return 2;
     }
     return 1;
   }
 
-  virtual media::DemuxerStream* GetStream(int stream_id) {
+  virtual DemuxerStream* GetStream(int stream_id) {
     switch (stream_id) {
       case 0:
         return &mock_audio_stream_;
       case 1:
         if (config_->has_video) {
           return &mock_video_stream_;
         }
         // Fall-through is correct if no video.
       default:
         ADD_FAILURE();
         return NULL;
     }
   }
 
  private:
-  friend class media::FilterFactoryImpl1<MockDemuxer, const MockFilterConfig*>;
+  friend class FilterFactoryImpl1<MockDemuxer, const MockFilterConfig*>;
 
   explicit MockDemuxer(const MockFilterConfig* config)
       : config_(config),
         mock_audio_stream_(config->compressed_audio_mime_type),
         mock_video_stream_(config->compressed_video_mime_type) {
   }
 
   virtual ~MockDemuxer() {}
 
   // Internal class implements DemuxerStream interface.
   class MockDemuxerStream : public DemuxerStream {
    public:
     explicit MockDemuxerStream(const std::string& mime_type) {
       media_format_.SetAsString(MediaFormat::kMimeType, mime_type);
     }
 
     virtual ~MockDemuxerStream() {}
 
     // Implementation of DemuxerStream.
     virtual const MediaFormat* GetMediaFormat() {
-      return &media_format_;  // TODO(ralphl): implement
+      return &media_format_;
     }
 
     virtual void Read(Assignable<Buffer>* buffer) {
       NOTREACHED();  // TODO(ralphl): fix me!!
     }
 
    private:
     MediaFormat media_format_;
 
     DISALLOW_COPY_AND_ASSIGN(MockDemuxerStream);
@@ skipping 31 matching lines @@
   virtual const MediaFormat* GetMediaFormat() {
     return &media_format_;
   }
 
   virtual void Read(Assignable<Buffer>* buffer) {
     // TODO(ralphl): implement mock read.
     NOTREACHED();
   }
 
  private:
-  friend class media::FilterFactoryImpl1<MockAudioDecoder,
-                                         const MockFilterConfig*>;
+  friend class FilterFactoryImpl1<MockAudioDecoder, const MockFilterConfig*>;
 
   explicit MockAudioDecoder(const MockFilterConfig* config) {
     media_format_.SetAsString(MediaFormat::kMimeType,
                               config->uncompressed_audio_mime_type);
   }
 
   virtual ~MockAudioDecoder() {}
 
   MediaFormat media_format_;
 
@@ skipping 18 matching lines @@
 
   // Implementation of AudioRenderer.
   virtual bool Initialize(AudioDecoder* decoder) {
     host_->InitializationComplete();
     return true;
   }
 
   virtual void SetVolume(float volume) {}
 
  private:
-  friend class media::FilterFactoryImpl1<MockAudioRenderer,
-                                         const MockFilterConfig*>;
+  friend class FilterFactoryImpl1<MockAudioRenderer, const MockFilterConfig*>;
 
   explicit MockAudioRenderer(const MockFilterConfig* config) {}
 
   virtual ~MockAudioRenderer() {}
 
   DISALLOW_COPY_AND_ASSIGN(MockAudioRenderer);
 };
 
 //------------------------------------------------------------------------------
 
 class MockVideoFrame : public VideoFrame {
  public:
   explicit MockVideoFrame(const MockFilterConfig* config,
                           base::TimeDelta timestamp)
       : config_(config),
-        surface_locked_(false),
-        timestamp_(timestamp),
-        duration_(config->frame_duration) {
+        surface_locked_(false) {
+    SetTimestamp(timestamp);
+    SetDuration(config->frame_duration);
+    size_t y_byte_count = config_->video_width * config_->video_height;
+    size_t uv_byte_count = y_byte_count / 4;
+    surface_.format = config_->video_surface_format;
+    surface_.width = config_->video_width;
+    surface_.height = config_->video_height;
+    surface_.planes = 3;
+    surface_.data[0] = new char[y_byte_count];
+    surface_.data[1] = new char[uv_byte_count];
+    surface_.data[2] = new char[uv_byte_count];
+    surface_.strides[0] = config_->video_width;
+    surface_.strides[1] = config_->video_width / 2;
+    surface_.strides[2] = config_->video_width / 2;
+    memset(surface_.data[0], 0, y_byte_count);
+    memset(surface_.data[1], 0x80, uv_byte_count);
+    memset(surface_.data[2], 0x80, uv_byte_count);
+    int64 num_white_pixels = y_byte_count *
+                             timestamp.InMicroseconds() /
+                             config_->media_duration.InMicroseconds();
+    if (num_white_pixels > y_byte_count) {
+      ADD_FAILURE();
+      num_white_pixels = y_byte_count;
+    }
+    if (num_white_pixels < 0) {
+      ADD_FAILURE();
+      num_white_pixels = 0;
+    }
+    memset(surface_.data[0], 0xFF, static_cast<size_t>(num_white_pixels));
   }
 
-  virtual ~MockVideoFrame() {}
-
-  virtual base::TimeDelta GetTimestamp() const {
-    return timestamp_;
-  }
-
-  virtual base::TimeDelta GetDuration() const {
-    return duration_;
-  }
-
-  virtual void SetTimestamp(const base::TimeDelta& timestamp) {
-    timestamp_ = timestamp;
-  }
-
-  virtual void SetDuration(const base::TimeDelta& duration) {
-    duration_ = duration;
+  virtual ~MockVideoFrame() {
+    delete[] surface_.data[0];
+    delete[] surface_.data[1];
+    delete[] surface_.data[2];
   }
 
   virtual bool Lock(VideoSurface* surface) {
     EXPECT_FALSE(surface_locked_);
+    if (surface_locked_) {
+      memset(surface, 0, sizeof(*surface));
+      return false;
+    }
     surface_locked_ = true;
-    surface->format = config_->video_surface_format;
-    surface->width = config_->video_width;
-    surface->height = config_->video_height;
-    // TODO(ralphl): mock the data for video surfaces too.
-    surface->planes = 3;
-    surface->data[0] = NULL;
-    surface->data[1] = NULL;
-    surface->data[2] = NULL;
-    surface->strides[0] = 0;
-    surface->strides[1] = 0;
-    surface->strides[2] = 0;
-    return false;
+    DCHECK(sizeof(*surface) == sizeof(surface_));
+    memcpy(surface, &surface_, sizeof(*surface));
+    return true;
   }
 
   virtual void Unlock() {
     EXPECT_TRUE(surface_locked_);
     surface_locked_ = false;
   }
 
  private:
   const MockFilterConfig* config_;
   bool surface_locked_;
-  base::TimeDelta timestamp_;
-  base::TimeDelta duration_;
+  VideoSurface surface_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoFrame);
 };
 
 class MockVideoDecoder : public VideoDecoder {
  public:
   static FilterFactory* CreateFactory(const MockFilterConfig* config) {
     return new FilterFactoryImpl1<MockVideoDecoder,
                                   const MockFilterConfig*>(config);
   }
@@ skipping 14 matching lines @@
   virtual const MediaFormat* GetMediaFormat() {
     return &media_format_;
   }
 
   virtual void Read(Assignable<VideoFrame>* buffer) {
     buffer->AddRef();
     host_->PostTask(NewRunnableMethod(this, &MockVideoDecoder::DoRead, buffer));
   }
 
  private:
-  friend class media::FilterFactoryImpl1<MockVideoDecoder,
-                                        const MockFilterConfig*>;
+  friend class FilterFactoryImpl1<MockVideoDecoder, const MockFilterConfig*>;
 
   explicit MockVideoDecoder(const MockFilterConfig* config)
       : config_(config) {
     media_format_.SetAsString(MediaFormat::kMimeType,
                               config->uncompressed_video_mime_type);
     media_format_.SetAsInteger(MediaFormat::kWidth, config->video_width);
     media_format_.SetAsInteger(MediaFormat::kHeight, config->video_height);
   }
 
   void DoRead(Assignable<VideoFrame>* buffer) {
-    VideoFrame* frame = new MockVideoFrame(config_, mock_frame_time_);
-    mock_frame_time_ += config_->frame_duration;
-    buffer->SetBuffer(frame);
-    buffer->OnAssignment();
+    if (mock_frame_time_ < config_->media_duration) {
+      VideoFrame* frame = new MockVideoFrame(config_, mock_frame_time_);
+      mock_frame_time_ += config_->frame_duration;
+      if (mock_frame_time_ >= config_->media_duration) {
+        frame->SetEndOfStream(true);
+      }
+      buffer->SetBuffer(frame);
+      buffer->OnAssignment();
+    }
     buffer->Release();
   }
 
   virtual ~MockVideoDecoder() {}
 
   MediaFormat media_format_;
   base::TimeDelta mock_frame_time_;
   const MockFilterConfig* config_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoDecoder);
@@ skipping 16 matching lines @@
   virtual void Stop() {}
 
   // Implementation of VideoRenderer.
   virtual bool Initialize(VideoDecoder* decoder) {
     host_->SetVideoSize(config_->video_width, config_->video_height);
     host_->InitializationComplete();
     return true;
   }
 
  private:
-  friend class media::FilterFactoryImpl1<MockVideoRenderer,
-                                         const MockFilterConfig*>;
+  friend class FilterFactoryImpl1<MockVideoRenderer, const MockFilterConfig*>;
 
   explicit MockVideoRenderer(const MockFilterConfig* config)
       : config_(config) {
   }
 
   virtual ~MockVideoRenderer() {}
 
   const MockFilterConfig* config_;
 
   DISALLOW_COPY_AND_ASSIGN(MockVideoRenderer);
 };
 
 
-
 //------------------------------------------------------------------------------
 // Simple class that derives from the WaitableEvent class.  The event remains
 // in the reset state until the initialization complete callback is called from
 // a media pipeline.  The normal use of this object looks like:
 //   Pipeline p;
 //   FilterFactoryCollection f;
 //   f->AddFactory(a);
 //   f->AddFactory(b);
 //   ...
 //   InitializationHelper h;
@@ skipping 47 matching lines @@
 
   bool callback_success_status_;
   bool waiting_for_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(InitializationHelper);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_BASE_MOCK_MEDIA_FILTERS_H_