src/media/tools/player_x11/player_x11.cc

   1 // Copyright (c) 2012 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 <signal.h>
   6
   7 #include <iostream>  // NOLINT
   8
   9 #include "base/at_exit.h"
  10 #include "base/bind.h"
  11 #include "base/command_line.h"
  12 #include "base/files/file_path.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/scoped_vector.h"
  15 #include "base/threading/platform_thread.h"
  16 #include "base/threading/thread.h"
  17 #include "media/audio/audio_manager.h"
  18 #include "media/audio/null_audio_sink.h"
  19 #include "media/base/audio_hardware_config.h"
  20 #include "media/base/bind_to_current_loop.h"
  21 #include "media/base/decryptor.h"
  22 #include "media/base/filter_collection.h"
  23 #include "media/base/media.h"
  24 #include "media/base/media_log.h"
  25 #include "media/base/media_switches.h"
  26 #include "media/base/pipeline.h"
  27 #include "media/base/video_frame.h"
  28 #include "media/filters/audio_renderer_impl.h"
  29 #include "media/filters/ffmpeg_audio_decoder.h"
  30 #include "media/filters/ffmpeg_demuxer.h"
  31 #include "media/filters/ffmpeg_video_decoder.h"
  32 #include "media/filters/file_data_source.h"
  33 #include "media/filters/video_renderer_impl.h"
  34 #include "media/tools/player_x11/data_source_logger.h"
  35
  36 // Include X11 headers here because X11/Xlib.h #define's Status
  37 // which causes compiler errors with Status enum declarations
  38 // in media::DemuxerStream & media::AudioDecoder.
  39 #include <X11/XKBlib.h>
  40 #include <X11/Xlib.h>
  41 #include "media/tools/player_x11/gl_video_renderer.h"
  42 #include "media/tools/player_x11/x11_video_renderer.h"
  43
  44 static Display* g_display = NULL;
  45 static Window g_window = 0;
  46 static bool g_running = false;
  47
  48 media::AudioManager* g_audio_manager = NULL;
  49
  50 scoped_ptr<media::DataSource> CreateDataSource(const std::string& file_path) {
  51   media::FileDataSource* file_data_source = new media::FileDataSource();
  52   CHECK(file_data_source->Initialize(base::FilePath(file_path)));
  53
  54   scoped_ptr<media::DataSource> data_source(file_data_source);
  55   return data_source.Pass();
  56 }
  57
  58 // Initialize X11. Returns true if successful. This method creates the X11
  59 // window. Further initialization is done in X11VideoRenderer.
  60 bool InitX11() {
  61   g_display = XOpenDisplay(NULL);
  62   if (!g_display) {
  63     std::cout << "Error - cannot open display" << std::endl;
  64     return false;
  65   }
  66
  67   // Get properties of the screen.
  68   int screen = DefaultScreen(g_display);
  69   int root_window = RootWindow(g_display, screen);
  70
  71   // Creates the window.
  72   g_window = XCreateSimpleWindow(g_display, root_window, 1, 1, 100, 50, 0,
  73                                  BlackPixel(g_display, screen),
  74                                  BlackPixel(g_display, screen));
  75   XStoreName(g_display, g_window, "X11 Media Player");
  76
  77   XSelectInput(g_display, g_window,
  78                ExposureMask | ButtonPressMask | KeyPressMask);
  79   XMapWindow(g_display, g_window);
  80   return true;
  81 }
  82
  83 static void DoNothing() {}
  84
  85 static void OnStatus(media::PipelineStatus status) {}
  86
  87 static void OnMetadata(media::PipelineMetadata metadata) {}
  88
  89 static void OnBufferingStateChanged(media::BufferingState buffering_state) {}
  90
  91 static void NeedKey(const std::string& type,
  92                     const std::vector<uint8>& init_data) {
  93   std::cout << "File is encrypted." << std::endl;
  94 }
  95
  96 static void SaveStatusAndSignal(base::WaitableEvent* event,
  97                                 media::PipelineStatus* status_out,
  98                                 media::PipelineStatus status) {
  99   *status_out = status;
 100   event->Signal();
 101 }
 102
 103 // TODO(vrk): Re-enabled audio. (crbug.com/112159)
 104 void InitPipeline(
 105     media::Pipeline* pipeline,
 106     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
 107     media::Demuxer* demuxer,
 108     const media::VideoRendererImpl::PaintCB& paint_cb,
 109     bool /* enable_audio */) {
 110   // Create our filter factories.
 111   scoped_ptr<media::FilterCollection> collection(
 112       new media::FilterCollection());
 113   collection->SetDemuxer(demuxer);
 114
 115   ScopedVector<media::VideoDecoder> video_decoders;
 116   video_decoders.push_back(new media::FFmpegVideoDecoder(task_runner));
 117   scoped_ptr<media::VideoRenderer> video_renderer(new media::VideoRendererImpl(
 118       task_runner,
 119       video_decoders.Pass(),
 120       media::SetDecryptorReadyCB(),
 121       paint_cb,
 122       true));
 123   collection->SetVideoRenderer(video_renderer.Pass());
 124
 125   ScopedVector<media::AudioDecoder> audio_decoders;
 126   audio_decoders.push_back(new media::FFmpegAudioDecoder(task_runner,
 127                                                          media::LogCB()));
 128   media::AudioParameters out_params(
 129       media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
 130       media::CHANNEL_LAYOUT_STEREO,
 131       44100,
 132       16,
 133       512);
 134   media::AudioHardwareConfig hardware_config(out_params, out_params);
 135
 136   scoped_ptr<media::AudioRenderer> audio_renderer(
 137       new media::AudioRendererImpl(task_runner,
 138                                    new media::NullAudioSink(task_runner),
 139                                    audio_decoders.Pass(),
 140                                    media::SetDecryptorReadyCB(),
 141                                    &hardware_config));
 142
 143   collection->SetAudioRenderer(audio_renderer.Pass());
 144
 145   base::WaitableEvent event(true, false);
 146   media::PipelineStatus status;
 147
 148   pipeline->Start(
 149       collection.Pass(), base::Bind(&DoNothing), base::Bind(&OnStatus),
 150       base::Bind(&SaveStatusAndSignal, &event, &status),
 151       base::Bind(&OnMetadata), base::Bind(&OnBufferingStateChanged),
 152       base::Bind(&DoNothing));
 153
 154   // Wait until the pipeline is fully initialized.
 155   event.Wait();
 156   CHECK_EQ(status, media::PIPELINE_OK) << "Pipeline initialization failed";
 157
 158   // And start the playback.
 159   pipeline->SetPlaybackRate(1.0f);
 160 }
 161
 162 void TerminateHandler(int signal) {
 163   g_running = false;
 164 }
 165
 166 void PeriodicalUpdate(
 167     media::Pipeline* pipeline,
 168     base::MessageLoop* message_loop) {
 169   if (!g_running) {
 170     // interrupt signal was received during last time period.
 171     // Quit message_loop only when pipeline is fully stopped.
 172     pipeline->Stop(base::MessageLoop::QuitClosure());
 173     return;
 174   }
 175
 176   // Consume all the X events
 177   while (XPending(g_display)) {
 178     XEvent e;
 179     XNextEvent(g_display, &e);
 180     switch (e.type) {
 181       case ButtonPress:
 182         {
 183           Window window;
 184           int x, y;
 185           unsigned int width, height, border_width, depth;
 186           XGetGeometry(g_display,
 187                        g_window,
 188                        &window,
 189                        &x,
 190                        &y,
 191                        &width,
 192                        &height,
 193                        &border_width,
 194                        &depth);
 195           base::TimeDelta time = pipeline->GetMediaDuration();
 196           pipeline->Seek(time*e.xbutton.x/width, base::Bind(&OnStatus));
 197         }
 198         break;
 199       case KeyPress:
 200         {
 201           KeySym key = XkbKeycodeToKeysym(g_display, e.xkey.keycode, 0, 0);
 202           if (key == XK_Escape) {
 203             g_running = false;
 204             // Quit message_loop only when pipeline is fully stopped.
 205             pipeline->Stop(base::MessageLoop::QuitClosure());
 206             return;
 207           } else if (key == XK_space) {
 208             if (pipeline->GetPlaybackRate() < 0.01f)  // paused
 209               pipeline->SetPlaybackRate(1.0f);
 210             else
 211               pipeline->SetPlaybackRate(0.0f);
 212           }
 213         }
 214         break;
 215       default:
 216         break;
 217     }
 218   }
 219
 220   message_loop->PostDelayedTask(
 221       FROM_HERE,
 222       base::Bind(&PeriodicalUpdate,
 223                  base::Unretained(pipeline),
 224                  message_loop),
 225       base::TimeDelta::FromMilliseconds(10));
 226 }
 227
 228 int main(int argc, char** argv) {
 229   base::AtExitManager at_exit;
 230   media::InitializeMediaLibraryForTesting();
 231
 232   CommandLine::Init(argc, argv);
 233   CommandLine* command_line = CommandLine::ForCurrentProcess();
 234   std::string filename = command_line->GetSwitchValueASCII("file");
 235
 236   if (filename.empty()) {
 237     std::cout << "Usage: " << argv[0] << " --file=FILE" << std::endl
 238               << std::endl
 239               << "Optional arguments:" << std::endl
 240               << "  [--audio]"
 241               << "  [--alsa-device=DEVICE]"
 242               << "  [--use-gl]"
 243               << "  [--streaming]" << std::endl
 244               << " Press [ESC] to stop" << std::endl
 245               << " Press [SPACE] to toggle pause/play" << std::endl
 246               << " Press mouse left button to seek" << std::endl;
 247     return 1;
 248   }
 249
 250   scoped_ptr<media::AudioManager> audio_manager(
 251       media::AudioManager::CreateForTesting());
 252   g_audio_manager = audio_manager.get();
 253
 254   logging::LoggingSettings settings;
 255   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 256   logging::InitLogging(settings);
 257
 258   // Install the signal handler.
 259   signal(SIGTERM, &TerminateHandler);
 260   signal(SIGINT, &TerminateHandler);
 261
 262   // Initialize X11.
 263   if (!InitX11())
 264     return 1;
 265
 266   // Initialize the pipeline thread and the pipeline.
 267   base::MessageLoop message_loop;
 268   base::Thread media_thread("MediaThread");
 269   media_thread.Start();
 270
 271   media::VideoRendererImpl::PaintCB paint_cb;
 272   if (command_line->HasSwitch("use-gl")) {
 273     paint_cb = media::BindToCurrentLoop(base::Bind(
 274         &GlVideoRenderer::Paint, new GlVideoRenderer(g_display, g_window)));
 275   } else {
 276     paint_cb = media::BindToCurrentLoop(base::Bind(
 277         &X11VideoRenderer::Paint, new X11VideoRenderer(g_display, g_window)));
 278   }
 279
 280   scoped_ptr<media::DataSource> data_source(new DataSourceLogger(
 281       CreateDataSource(filename), command_line->HasSwitch("streaming")));
 282   scoped_ptr<media::Demuxer> demuxer(new media::FFmpegDemuxer(
 283       media_thread.message_loop_proxy(), data_source.get(),
 284       base::Bind(&NeedKey), new media::MediaLog()));
 285
 286   media::Pipeline pipeline(media_thread.message_loop_proxy(),
 287                            new media::MediaLog());
 288   InitPipeline(&pipeline, media_thread.message_loop_proxy(), demuxer.get(),
 289                paint_cb, command_line->HasSwitch("audio"));
 290
 291   // Main loop of the application.
 292   g_running = true;
 293
 294   message_loop.PostTask(FROM_HERE, base::Bind(
 295       &PeriodicalUpdate, base::Unretained(&pipeline), &message_loop));
 296   message_loop.Run();
 297
 298   // Cleanup tasks.
 299   media_thread.Stop();
 300
 301   // Release callback which releases video renderer. Do this before cleaning up
 302   // X below since the video renderer has some X cleanup duties as well.
 303   paint_cb.Reset();
 304
 305   XDestroyWindow(g_display, g_window);
 306   XCloseDisplay(g_display);
 307   g_audio_manager = NULL;
 308
 309   return 0;
 310 }