Roll FFmpeg for M37.

media/cast/test/sender.cc

 // Copyright 2013 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.
 
 // Test application that simulates a cast sender - Data can be either generated
 // or read from a file.
 
 #include <queue>
 
 #include "base/at_exit.h"
@@ skipping 122 matching lines @@
   video_config.max_qp = 40;
 
   // SSRCs and payload type. Don't change them.
   video_config.rtp_config.ssrc = 11;
   video_config.incoming_feedback_ssrc = 12;
   video_config.rtp_config.payload_type = 96;
   video_config.rtp_config.max_delay_ms = 300;
   return video_config;
 }
 
-void AVFreeFrame(AVFrame* frame) { avcodec_free_frame(&frame); }
+void AVFreeFrame(AVFrame* frame) { av_frame_free(&frame); }
 
 class SendProcess {
  public:
   SendProcess(scoped_refptr<base::SingleThreadTaskRunner> thread_proxy,
               base::TickClock* clock,
               const VideoSenderConfig& video_config)
       : test_app_thread_proxy_(thread_proxy),
         video_config_(video_config),
         synthetic_count_(0),
         clock_(clock),
@@ skipping 372 matching lines @@
       LOG(INFO) << "Unknown packet.";
       packet.reset();
     }
     return packet.Pass();
   }
 
   void DecodeAudio(ScopedAVPacket packet) {
     // Audio.
     AVFrame* avframe = av_frame_alloc();
 
-    // Shallow copy of the packet.
+    // Make a shallow copy of packet so we can slide packet.data as frames are
+    // decoded from the packet; otherwise av_free_packet() will corrupt memory.
     AVPacket packet_temp = *packet.get();
 
     do {
-      avcodec_get_frame_defaults(avframe);
       int frame_decoded = 0;
       int result = avcodec_decode_audio4(
           av_audio_context(), avframe, &frame_decoded, &packet_temp);
       CHECK(result >= 0) << "Failed to decode audio.";
       packet_temp.size -= result;
       packet_temp.data += result;
       if (!frame_decoded)
         continue;
 
       int frames_read = avframe->nb_samples;
@@ skipping 19 matching lines @@
               ChannelLayoutToChromeChannelLayout(
                   av_audio_context()->channel_layout,
                   av_audio_context()->channels),
               av_audio_context()->channels,
               av_audio_context()->sample_rate,
               frames_read,
               &avframe->data[0],
               // Note: Not all files have correct values for pkt_pts.
               base::TimeDelta::FromMilliseconds(avframe->pkt_pts));
       audio_algo_.EnqueueBuffer(buffer);
+      av_frame_unref(avframe);
     } while (packet_temp.size > 0);
-    avcodec_free_frame(&avframe);
+    av_frame_free(&avframe);
 
     const int frames_needed_to_scale =
         playback_rate_ * av_audio_context()->sample_rate /
         kAudioPacketsPerSecond;
     while (frames_needed_to_scale <= audio_algo_.frames_buffered()) {
       if (!audio_algo_.FillBuffer(audio_fifo_input_bus_.get(),
                                   audio_fifo_input_bus_->frames())) {
         // Nothing can be scaled. Decode some more.
         return;
       }
@@ skipping 19 matching lines @@
       audio_resampler_->Resample(resampled_bus->frames(),
                                  resampled_bus.get());
       audio_bus_queue_.push(resampled_bus.release());
     }
   }
 
   void DecodeVideo(ScopedAVPacket packet) {
     // Video.
     int got_picture;
     AVFrame* avframe = av_frame_alloc();
-    avcodec_get_frame_defaults(avframe);
     // Tell the decoder to reorder for us.
     avframe->reordered_opaque =
         av_video_context()->reordered_opaque = packet->pts;
     CHECK(avcodec_decode_video2(
         av_video_context(), avframe, &got_picture, packet.get()) >= 0)
         << "Video decode error.";
     if (!got_picture)

[wolenetz, 2014/05/20 22:37:10]

Need to free avframe before returning early here?

[DaleCurtis, 2014/05/20 23:00:45]

Done.

       return;
     gfx::Size size(av_video_context()->width, av_video_context()->height);
     if (!video_first_pts_set_ ||
         avframe->reordered_opaque < video_first_pts_) {
       video_first_pts_set_ = true;
       video_first_pts_ = avframe->reordered_opaque;
     }
     int64 pts = avframe->reordered_opaque - video_first_pts_;
     video_frame_queue_.push(
         VideoFrame::WrapExternalYuvData(
             media::VideoFrame::YV12,
             size,
             gfx::Rect(size),
             size,
             avframe->linesize[0],
             avframe->linesize[1],
             avframe->linesize[2],
             avframe->data[0],
             avframe->data[1],
             avframe->data[2],
             base::TimeDelta::FromMilliseconds(pts),
             base::Bind(&AVFreeFrame, avframe)));

[wolenetz, 2014/05/20 22:37:10]

Need to av_frame_unref(avframe) prior to AVFreeFrame(avframe)?

[DaleCurtis, 2014/05/20 23:00:45]

No, that's done by av_frame_free().

   }
 
   void Decode(bool decode_audio) {
     // Read the stream until one video frame can be decoded.
     while (true) {
       if (decode_audio && !audio_bus_queue_.empty())
         return;
       if (!decode_audio && !video_frame_queue_.empty())
         return;
 
@@ skipping 350 matching lines @@
                  base::Passed(&audio_stats_subscriber),
                  base::Passed(&offset_estimator)),
       base::TimeDelta::FromSeconds(logging_duration_seconds));
 
   send_process->Start(cast_sender->audio_frame_input(),
                       cast_sender->video_frame_input());
 
   io_message_loop.Run();
   return 0;
 }