ffmpeg chromium glue

media/filters/ffmpeg_demuxer.cc

 // Copyright (c) 2011 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 "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
@@ skipping 47 matching lines @@
                                          AVStream* stream)
     : demuxer_(demuxer),
       stream_(stream),
       type_(UNKNOWN),
       discontinuous_(false),
       stopped_(false) {
   DCHECK(demuxer_);
 
   // Determine our media format.
   switch (stream->codec->codec_type) {
-    case CODEC_TYPE_AUDIO:
+    case AVMEDIA_TYPE_AUDIO:
       type_ = AUDIO;
       break;
-    case CODEC_TYPE_VIDEO:
+    case AVMEDIA_TYPE_VIDEO:
       type_ = VIDEO;
       break;
     default:
       NOTREACHED();
       break;
   }
 
   // Calculate the duration.
   duration_ = ConvertStreamTimestamp(stream->time_base, stream->duration);
 }
@@ skipping 290 matching lines @@
 base::TimeDelta FFmpegDemuxer::GetStartTime() const {
   return start_time_;
 }
 
 int FFmpegDemuxer::Read(int size, uint8* data) {
   DCHECK(data_source_);
 
   // If read has ever failed, return with an error.
   // TODO(hclam): use a more meaningful constant as error.
   if (read_has_failed_)
-    return AVERROR_IO;
+    return AVERROR(EIO);
 
   // Even though FFmpeg defines AVERROR_EOF, it's not to be used with I/O
   // routines.  Instead return 0 for any read at or past EOF.
   int64 file_size;
   if (data_source_->GetSize(&file_size) && read_position_ >= file_size)
     return 0;
 
   // Asynchronous read from data source.
   data_source_->Read(read_position_, size, data,
                      NewCallback(this, &FFmpegDemuxer::OnReadCompleted));
 
   // TODO(hclam): The method is called on the demuxer thread and this method
   // call will block the thread. We need to implemented an additional thread to
   // let FFmpeg demuxer methods to run on.
   size_t last_read_bytes = WaitForRead();
   if (last_read_bytes == DataSource::kReadError) {
     if (host())
       host()->SetError(PIPELINE_ERROR_READ);
     else
       deferred_status_ = PIPELINE_ERROR_READ;
 
     // Returns with a negative number to signal an error to FFmpeg.
     read_has_failed_ = true;
-    return AVERROR_IO;
+    return AVERROR(EIO);
   }
   read_position_ += last_read_bytes;
 
   if (host())
     host()->SetCurrentReadPosition(read_position_);
 
   return last_read_bytes;
 }
 
 bool FFmpegDemuxer::GetPosition(int64* position_out) {
@@ skipping 39 matching lines @@
   if (host())
     data_source_->set_host(host());
 
   // Add ourself to Protocol list and get our unique key.
   std::string key = FFmpegGlue::GetInstance()->AddProtocol(this);
 
   // Open FFmpeg AVFormatContext.
   DCHECK(!format_context_);
   AVFormatContext* context = NULL;
   int result = av_open_input_file(&context, key.c_str(), NULL, 0, NULL);
-
   // Remove ourself from protocol list.

[scherkus (not reviewing), 2011/06/29 17:00:36]

could you add back this blank line?

[ilja, 2011/06/29 21:40:05]

Done.

   FFmpegGlue::GetInstance()->RemoveProtocol(this);
 
   if (result < 0) {
     callback->Run(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
   DCHECK(context);
   format_context_ = context;
 
   // Fully initialize AVFormatContext by parsing the stream a little.
   result = av_find_stream_info(format_context_);
   if (result < 0) {
     callback->Run(DEMUXER_ERROR_COULD_NOT_PARSE);
     return;
   }
 
   // Create demuxer streams for all supported streams.
   streams_.resize(DemuxerStream::NUM_TYPES);
   base::TimeDelta max_duration;
   const bool kDemuxerIsWebm = !strcmp("webm", format_context_->iformat->name);
   bool no_supported_streams = true;
   for (size_t i = 0; i < format_context_->nb_streams; ++i) {
     AVCodecContext* codec_context = format_context_->streams[i]->codec;
-    CodecType codec_type = codec_context->codec_type;
-    if (codec_type == CODEC_TYPE_AUDIO || codec_type == CODEC_TYPE_VIDEO) {
+    AVMediaType codec_type = codec_context->codec_type;
+    if (codec_type == AVMEDIA_TYPE_AUDIO || codec_type == AVMEDIA_TYPE_VIDEO) {
       AVStream* stream = format_context_->streams[i];
       // WebM is currently strictly VP8 and Vorbis.
       if (kDemuxerIsWebm && (stream->codec->codec_id != CODEC_ID_VP8 &&
         stream->codec->codec_id != CODEC_ID_VORBIS)) {
         packet_streams_.push_back(NULL);
         continue;
       }
 
       scoped_refptr<FFmpegDemuxerStream> demuxer_stream(
           new FFmpegDemuxerStream(this, stream));
@@ skipping 154 matching lines @@
 
   StreamVector::iterator iter;
   for (size_t i = 0; i < packet_streams_.size(); ++i) {
     if (!packet_streams_[i])
       continue;
 
     // If the codec type is audio, remove the reference. DemuxTask() will
     // look for such reference, and this will result in deleting the
     // audio packets after they are demuxed.
     if (packet_streams_[i]->GetAVStream()->codec->codec_type ==
-        CODEC_TYPE_AUDIO) {
+        AVMEDIA_TYPE_AUDIO) {
       packet_streams_[i] = NULL;
     }
   }
 }
 
 bool FFmpegDemuxer::StreamsHavePendingReads() {
   DCHECK_EQ(MessageLoop::current(), message_loop_);
   StreamVector::iterator iter;
   for (iter = streams_.begin(); iter != streams_.end(); ++iter) {
     if (*iter && (*iter)->HasPendingReads()) {
@@ skipping 23 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(size_t size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media