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 NeedKey(const std::string& type,
  90                     const std::vector<uint8>& init_data) {
  91   std::cout << "File is encrypted." << std::endl;
  92 }
  93
  94 static void SaveStatusAndSignal(base::WaitableEvent* event,
  95                                 media::PipelineStatus* status_out,
  96                                 media::PipelineStatus status) {
  97   *status_out = status;
  98   event->Signal();
  99 }
 100
 101 // TODO(vrk): Re-enabled audio. (crbug.com/112159)
 102 void InitPipeline(
 103     media::Pipeline* pipeline,
 104     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
 105     media::Demuxer* demuxer,
 106     const media::VideoRendererImpl::PaintCB& paint_cb,
 107     bool /* enable_audio */) {
 108   // Create our filter factories.
 109   scoped_ptr<media::FilterCollection> collection(
 110       new media::FilterCollection());
 111   collection->SetDemuxer(demuxer);
 112
 113   ScopedVector<media::VideoDecoder> video_decoders;
 114   video_decoders.push_back(new media::FFmpegVideoDecoder(task_runner));
 115   scoped_ptr<media::VideoRenderer> video_renderer(new media::VideoRendererImpl(
 116       task_runner,
 117       video_decoders.Pass(),
 118       media::SetDecryptorReadyCB(),
 119       paint_cb,
 120       true));
 121   collection->SetVideoRenderer(video_renderer.Pass());
 122
 123   ScopedVector<media::AudioDecoder> audio_decoders;
 124   audio_decoders.push_back(new media::FFmpegAudioDecoder(task_runner,
 125                                                          media::LogCB()));
 126   media::AudioParameters out_params(
 127       media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
 128       media::CHANNEL_LAYOUT_STEREO,
 129       44100,
 130       16,
 131       512);
 132   media::AudioHardwareConfig hardware_config(out_params, out_params);
 133
 134   scoped_ptr<media::AudioRenderer> audio_renderer(
 135       new media::AudioRendererImpl(task_runner,
 136                                    new media::NullAudioSink(task_runner),
 137                                    audio_decoders.Pass(),
 138                                    media::SetDecryptorReadyCB(),
 139                                    &hardware_config));
 140
 141   collection->SetAudioRenderer(audio_renderer.Pass());
 142
 143   base::WaitableEvent event(true, false);
 144   media::PipelineStatus status;
 145
 146   pipeline->Start(
 147       collection.Pass(), base::Bind(&DoNothing), base::Bind(&OnStatus),
 148       base::Bind(&SaveStatusAndSignal, &event, &status),
 149       base::Bind(&OnMetadata), base::Bind(&DoNothing),
 150       base::Bind(&DoNothing));
 151
 152   // Wait until the pipeline is fully initialized.
 153   event.Wait();
 154   CHECK_EQ(status, media::PIPELINE_OK) << "Pipeline initialization failed";
 155
 156   // And start the playback.
 157   pipeline->SetPlaybackRate(1.0f);
 158 }
 159
 160 void TerminateHandler(int signal) {
 161   g_running = false;
 162 }
 163
 164 void PeriodicalUpdate(
 165     media::Pipeline* pipeline,
 166     base::MessageLoop* message_loop) {
 167   if (!g_running) {
 168     // interrupt signal was received during last time period.
 169     // Quit message_loop only when pipeline is fully stopped.
 170     pipeline->Stop(base::MessageLoop::QuitClosure());
 171     return;
 172   }
 173
 174   // Consume all the X events
 175   while (XPending(g_display)) {
 176     XEvent e;
 177     XNextEvent(g_display, &e);
 178     switch (e.type) {
 179       case ButtonPress:
 180         {
 181           Window window;
 182           int x, y;
 183           unsigned int width, height, border_width, depth;
 184           XGetGeometry(g_display,
 185                        g_window,
 186                        &window,
 187                        &x,
 188                        &y,
 189                        &width,
 190                        &height,
 191                        &border_width,
 192                        &depth);
 193           base::TimeDelta time = pipeline->GetMediaDuration();
 194           pipeline->Seek(time*e.xbutton.x/width, base::Bind(&OnStatus));
 195         }
 196         break;
 197       case KeyPress:
 198         {
 199           KeySym key = XkbKeycodeToKeysym(g_display, e.xkey.keycode, 0, 0);
 200           if (key == XK_Escape) {
 201             g_running = false;
 202             // Quit message_loop only when pipeline is fully stopped.
 203             pipeline->Stop(base::MessageLoop::QuitClosure());
 204             return;
 205           } else if (key == XK_space) {
 206             if (pipeline->GetPlaybackRate() < 0.01f)  // paused
 207               pipeline->SetPlaybackRate(1.0f);
 208             else
 209               pipeline->SetPlaybackRate(0.0f);
 210           }
 211         }
 212         break;
 213       default:
 214         break;
 215     }
 216   }
 217
 218   message_loop->PostDelayedTask(
 219       FROM_HERE,
 220       base::Bind(&PeriodicalUpdate,
 221                  base::Unretained(pipeline),
 222                  message_loop),
 223       base::TimeDelta::FromMilliseconds(10));
 224 }
 225
 226 int main(int argc, char** argv) {
 227   base::AtExitManager at_exit;
 228   media::InitializeMediaLibraryForTesting();
 229
 230   CommandLine::Init(argc, argv);
 231   CommandLine* command_line = CommandLine::ForCurrentProcess();
 232   std::string filename = command_line->GetSwitchValueASCII("file");
 233
 234   if (filename.empty()) {
 235     std::cout << "Usage: " << argv[0] << " --file=FILE" << std::endl
 236               << std::endl
 237               << "Optional arguments:" << std::endl
 238               << "  [--audio]"
 239               << "  [--alsa-device=DEVICE]"
 240               << "  [--use-gl]"
 241               << "  [--streaming]" << std::endl
 242               << " Press [ESC] to stop" << std::endl
 243               << " Press [SPACE] to toggle pause/play" << std::endl
 244               << " Press mouse left button to seek" << std::endl;
 245     return 1;
 246   }
 247
 248   scoped_ptr<media::AudioManager> audio_manager(
 249       media::AudioManager::CreateForTesting());
 250   g_audio_manager = audio_manager.get();
 251
 252   logging::LoggingSettings settings;
 253   settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
 254   logging::InitLogging(settings);
 255
 256   // Install the signal handler.
 257   signal(SIGTERM, &TerminateHandler);
 258   signal(SIGINT, &TerminateHandler);
 259
 260   // Initialize X11.
 261   if (!InitX11())
 262     return 1;
 263
 264   // Initialize the pipeline thread and the pipeline.
 265   base::MessageLoop message_loop;
 266   base::Thread media_thread("MediaThread");
 267   media_thread.Start();
 268
 269   media::VideoRendererImpl::PaintCB paint_cb;
 270   if (command_line->HasSwitch("use-gl")) {
 271     paint_cb = media::BindToCurrentLoop(base::Bind(
 272         &GlVideoRenderer::Paint, new GlVideoRenderer(g_display, g_window)));
 273   } else {
 274     paint_cb = media::BindToCurrentLoop(base::Bind(
 275         &X11VideoRenderer::Paint, new X11VideoRenderer(g_display, g_window)));
 276   }
 277
 278   scoped_ptr<media::DataSource> data_source(new DataSourceLogger(
 279       CreateDataSource(filename), command_line->HasSwitch("streaming")));
 280   scoped_ptr<media::Demuxer> demuxer(new media::FFmpegDemuxer(
 281       media_thread.message_loop_proxy(), data_source.get(),
 282       base::Bind(&NeedKey), new media::MediaLog()));
 283
 284   media::Pipeline pipeline(media_thread.message_loop_proxy(),
 285                            new media::MediaLog());
 286   InitPipeline(&pipeline, media_thread.message_loop_proxy(), demuxer.get(),
 287                paint_cb, command_line->HasSwitch("audio"));
 288
 289   // Main loop of the application.
 290   g_running = true;
 291
 292   message_loop.PostTask(FROM_HERE, base::Bind(
 293       &PeriodicalUpdate, base::Unretained(&pipeline), &message_loop));
 294   message_loop.Run();
 295
 296   // Cleanup tasks.
 297   media_thread.Stop();
 298
 299   // Release callback which releases video renderer. Do this before cleaning up
 300   // X below since the video renderer has some X cleanup duties as well.
 301   paint_cb.Reset();
 302
 303   XDestroyWindow(g_display, g_window);
 304   XCloseDisplay(g_display);
 305   g_audio_manager = NULL;
 306
 307   return 0;
 308 }