Motown: Various fixes related to video playback support

services/media/framework_ffmpeg/ffmpeg_audio_decoder.cc

 // Copyright 2016 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/logging.h"
 #include "services/media/framework_ffmpeg/ffmpeg_audio_decoder.h"
 
 namespace mojo {
 namespace media {
 
@@ skipping 59 matching lines @@
   DCHECK(allocator);
 
   int64_t pts = av_frame.pts;
   if (pts == AV_NOPTS_VALUE) {
     pts = next_pts_;
     next_pts_ += av_frame.nb_samples;
   } else {
     next_pts_ = pts;
   }
 
-  uint64_t payload_size;
-  void* payload_buffer;
-
-  AvBufferContext* av_buffer_context =
-      reinterpret_cast<AvBufferContext*>(av_buffer_get_opaque(av_frame.buf[0]));
-
   if (lpcm_util_) {
     // We need to interleave. The non-interleaved frames are in a buffer that
     // was allocated from the default allocator. That buffer will get released
     // later in ReleaseBufferForAvFrame. We need a new buffer for the
     // interleaved frames, which we get from the provided allocator.
     DCHECK(stream_type_);
     DCHECK(stream_type_->audio());
-    payload_size = stream_type_->audio()->min_buffer_size(av_frame.nb_samples);
-    payload_buffer = allocator->AllocatePayloadBuffer(payload_size);
+    uint64_t payload_size =
+        stream_type_->audio()->min_buffer_size(av_frame.nb_samples);
+    void* payload_buffer = allocator->AllocatePayloadBuffer(payload_size);
 
-    lpcm_util_->Interleave(av_buffer_context->buffer(),
-                           av_buffer_context->size(), payload_buffer,
-                           av_frame.nb_samples);
+    lpcm_util_->Interleave(av_frame.buf[0]->data, av_frame.buf[0]->size,
+                           payload_buffer, av_frame.nb_samples);
+
+    return Packet::Create(
+        pts,
+        false,  // The base class is responsible for end-of-stream.
+        payload_size, payload_buffer, allocator);
   } else {
     // We don't need to interleave. The interleaved frames are in a buffer that
-    // was allocated from the correct allocator. We take ownership of the buffer
-    // by calling Release here so that ReleaseBufferForAvFrame won't release it.
-    payload_size = av_buffer_context->size();
-    payload_buffer = av_buffer_context->Release();
+    // was allocated from the correct allocator.
+    return DecoderPacket::Create(pts, av_buffer_ref(av_frame.buf[0]));
   }
-
-  return Packet::Create(
-      pts,
-      false,  // The base class is responsible for end-of-stream.
-      payload_size, payload_buffer, allocator);
 }
 
 PacketPtr FfmpegAudioDecoder::CreateOutputEndOfStreamPacket() {
   return Packet::CreateEndOfStream(next_pts_);
 }
 
 int FfmpegAudioDecoder::AllocateBufferForAvFrame(
     AVCodecContext* av_codec_context,
     AVFrame* av_frame,
     int flags) {
   // CODEC_CAP_DR1 is required in order to do allocation this way.
   DCHECK(av_codec_context->codec->capabilities & CODEC_CAP_DR1);
 
   FfmpegAudioDecoder* self =
       reinterpret_cast<FfmpegAudioDecoder*>(av_codec_context->opaque);
   DCHECK(self);
   DCHECK(self->allocator_);
 
   AVSampleFormat av_sample_format =
       static_cast<AVSampleFormat>(av_frame->format);
 
   int buffer_size = av_samples_get_buffer_size(
       &av_frame->linesize[0], av_codec_context->channels, av_frame->nb_samples,
       av_sample_format, FfmpegAudioDecoder::kChannelAlign);
   if (buffer_size < 0) {
     LOG(WARNING) << "av_samples_get_buffer_size failed";
     return buffer_size;
   }
 
-  AvBufferContext* av_buffer_context =
-      new AvBufferContext(buffer_size, self->allocator_);
-  uint8_t* buffer = av_buffer_context->buffer();
+  uint8_t* buffer = static_cast<uint8_t*>(
+      self->allocator_->AllocatePayloadBuffer(buffer_size));
 
   if (!av_sample_fmt_is_planar(av_sample_format)) {
     // Samples are interleaved. There's just one buffer.
     av_frame->data[0] = buffer;
   } else {
     // Samples are not interleaved. There's one buffer per channel.
     int channels = av_codec_context->channels;
     int bytes_per_channel = buffer_size / channels;
     uint8_t* channel_buffer = buffer;
 
@@ skipping 21 matching lines @@
       }
 
       // The rest go only in extended_data.
       for (; channel < channels; ++channel) {
         av_frame->extended_data[channel] = channel_buffer;
         channel_buffer += bytes_per_channel;
       }
     }
   }
 
-  av_frame->buf[0] = av_buffer_create(
-      buffer, buffer_size, ReleaseBufferForAvFrame, av_buffer_context,
-      0);  // flags
+  av_frame->buf[0] = av_buffer_create(buffer, buffer_size,
+                                      ReleaseBufferForAvFrame, self->allocator_,
+                                      0);  // flags
 
   return 0;
 }
 
 void FfmpegAudioDecoder::ReleaseBufferForAvFrame(void* opaque,
                                                  uint8_t* buffer) {
-  AvBufferContext* av_buffer_context =
-      reinterpret_cast<AvBufferContext*>(opaque);
-  DCHECK(av_buffer_context);
-  // Either this buffer has already been released to someone else's ownership,
-  // or it's the same as the buffer parameter.
-  DCHECK(av_buffer_context->buffer() == nullptr ||
-         av_buffer_context->buffer() == buffer);
-  delete av_buffer_context;
+  DCHECK(opaque);
+  DCHECK(buffer);
+  PayloadAllocator* allocator = reinterpret_cast<PayloadAllocator*>(opaque);
+  allocator->ReleasePayloadBuffer(buffer);
 }
 
 }  // namespace media
 }  // namespace mojo