Cleaning up src/media to be consistent with static versus anonymous namespaces.

media/tools/mfdecoder/main.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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.
 
 #ifdef UNICODE
 #undef UNICODE
 #endif
 
 #include <algorithm>
 
 #include <d3d9.h>
 #include <dxva2api.h>
 #include <evr.h>
 #include <mfapi.h>
 #include <mfreadwrite.h>
 #include <windows.h>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_comptr_win.h"
 #include "base/scoped_ptr.h"
 #include "base/time.h"
 #include "media/base/yuv_convert.h"
 #include "media/tools/mfdecoder/mfdecoder.h"
 #include "ui/gfx/gdi_util.h"
 
-namespace {
+static const char* const kWindowClass = "Chrome_MF_Decoder";
+static const char* const kWindowTitle = "MF Decoder";
+static const int kWindowStyleFlags =
+    (WS_OVERLAPPEDWINDOW | WS_VISIBLE) & ~(WS_MAXIMIZEBOX | WS_THICKFRAME);
+static bool g_render_to_window = false;
+static bool g_render_asap = false;
 
-const char* const kWindowClass = "Chrome_MF_Decoder";
-const char* const kWindowTitle = "MF Decoder";
-const int kWindowStyleFlags = (WS_OVERLAPPEDWINDOW | WS_VISIBLE) &
-                              ~(WS_MAXIMIZEBOX | WS_THICKFRAME);
-bool g_render_to_window = false;
-bool g_render_asap = false;
+static base::TimeDelta* g_decode_time;
+static base::TimeDelta* g_render_time;
+static int64 g_num_frames = 0;
 
-base::TimeDelta* g_decode_time;
-base::TimeDelta* g_render_time;
-int64 g_num_frames = 0;
-
-void usage() {
+static void usage() {
   static char* usage_msg = "Usage: mfdecoder (-s|-h) (-d|-r|-f) input-file\n"
                            "-s: Use software decoding\n"
                            "-h: Use hardware decoding\n"
                            "\n"
                            "-d: Decode to YV12 as fast as possible, no " \
                            "rendering or color-space conversion\n"
                            "-r: Render to window at 30ms per frame\n"
                            "-f: Decode and render as fast as possible\n"
                            "\n"
                            "To see this message: mfdecoder --help\n";
   fprintf(stderr, "%s", usage_msg);
 }
 
 // Converts an ASCII string to an Unicode string. This function allocates
 // space for the returned Unicode string from the heap and it is caller's
 // responsibility to free it.
 // Returns: An equivalent Unicode string if successful, NULL otherwise.
-wchar_t* ConvertASCIIStringToUnicode(const char* source) {
+static wchar_t* ConvertASCIIStringToUnicode(const char* source) {
   if (source == NULL) {
     LOG(ERROR) << "ConvertASCIIStringToUnicode: source cannot be NULL";
     return NULL;
   }
   DWORD string_length = MultiByteToWideChar(CP_ACP, 0, source, -1, NULL, 0);
   if (string_length == 0) {
     LOG(ERROR) << "Error getting size of ansi string";
     return NULL;
   }
   scoped_array<wchar_t> ret(new wchar_t[string_length]);
   if (ret.get() == NULL) {
     LOG(ERROR) << "Error allocating unicode string buffer";
     return NULL;
   }
   if (MultiByteToWideChar(CP_ACP, 0, source, string_length, ret.get(),
                           string_length) == 0) {
     LOG(ERROR) << "Error converting ansi string to unicode";
     return NULL;
   }
   return ret.release();
 }
 
 // Converts the given raw data buffer into RGB32 format, and drawing the result
 // into the given window. This is only used when DXVA2 is not enabled.
 // Returns: true on success.
-bool ConvertToRGBAndDrawToWindow(HWND video_window, uint8* data, int width,
-                                 int height, int stride) {
+static bool ConvertToRGBAndDrawToWindow(HWND video_window, uint8* data,
+                                        int width, int height, int stride) {
   CHECK(video_window != NULL);
   CHECK(data != NULL);
   CHECK_GT(width, 0);
   CHECK_GT(height, 0);
   CHECK_GE(stride, width);
   height = (height + 15) & ~15;
   bool success = true;
   uint8* y_start = reinterpret_cast<uint8*>(data);
   uint8* u_start = y_start + height * stride * 5 / 4;
   uint8* v_start = y_start + height * stride;
@@ skipping 27 matching lines @@
     success = false;
   }
   EndPaint(video_window, &ps);
 
   return success;
 }
 
 // Obtains the underlying raw data buffer for the given IMFMediaBuffer, and
 // calls ConvertToRGBAndDrawToWindow() with it.
 // Returns: true on success.
-bool PaintMediaBufferOntoWindow(HWND video_window, IMFMediaBuffer* video_buffer,
-                                int width, int height, int stride) {
+static bool PaintMediaBufferOntoWindow(HWND video_window,
+                                       IMFMediaBuffer* video_buffer,
+                                       int width, int height, int stride) {
   CHECK(video_buffer != NULL);
   HRESULT hr;
   BYTE* data;
   DWORD buffer_length;
   DWORD data_length;
   hr = video_buffer->Lock(&data, &buffer_length, &data_length);
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to lock IMFMediaBuffer";
     return false;
   }
@@ skipping 10 matching lines @@
     }
     *g_render_time += base::Time::Now() - render_start;
   }
   video_buffer->Unlock();
   return true;
 }
 
 // Obtains the D3D9 surface from the given IMFMediaBuffer, then calls methods
 // in the D3D device to draw to the window associated with it.
 // Returns: true on success.
-bool PaintD3D9BufferOntoWindow(IDirect3DDevice9* device,
-                               IMFMediaBuffer* video_buffer) {
+static bool PaintD3D9BufferOntoWindow(IDirect3DDevice9* device,
+                                      IMFMediaBuffer* video_buffer) {
   CHECK(device != NULL);
   ScopedComPtr<IDirect3DSurface9> surface;
   HRESULT hr = MFGetService(video_buffer, MR_BUFFER_SERVICE,
                             IID_PPV_ARGS(surface.Receive()));
   if (FAILED(hr)) {
     LOG(ERROR) << "Failed to get D3D9 surface from buffer";
     return false;
   }
   if (g_render_to_window) {
     base::Time render_start(base::Time::Now());
@@ skipping 33 matching lines @@
 }
 
 // Reads a sample from the given decoder, and draws the sample to the given
 // window. Obtains the IMFMediaBuffer objects from the given IMFSample, and
 // calls either PaintMediaBufferOntoWindow() or PaintD3D9BufferOntoWindow() with
 // each of them, depending on whether the decoder supports DXVA2.
 // The decoder should be initialized before calling this method.
 // For H.264 format, there should only be 1 buffer per sample, so each buffer
 // represents 1 frame.
 // Returns: true if successful.
-bool DrawVideoSample(HWND video_window, media::MFDecoder* decoder,
-                     IDirect3DDevice9* device) {
+static bool DrawVideoSample(HWND video_window, media::MFDecoder* decoder,
+                            IDirect3DDevice9* device) {
   CHECK(video_window != NULL);
   CHECK(decoder != NULL);
   CHECK(decoder->initialized());
 
   if (decoder->end_of_stream()) {
     LOG(ERROR) << "Failed to obtain more samples from decoder because end of "
                << "stream has been reached";
     return false;
   }
   ScopedComPtr<IMFSample> video_sample;
@@ skipping 27 matching lines @@
     return PaintD3D9BufferOntoWindow(device, video_buffer);
   } else {
     return PaintMediaBufferOntoWindow(video_window, video_buffer,
                                       decoder->width(), decoder->height(),
                                       decoder->mfbuffer_stride());
   }
 }
 
 // Creates a window with the given width and height.
 // Returns: A handle to the window on success, NULL otherwise.
-HWND CreateDrawWindow(int width, int height) {
+static HWND CreateDrawWindow(int width, int height) {
   WNDCLASS window_class = {0};
   window_class.lpszClassName = kWindowClass;
   window_class.hInstance = NULL;
   window_class.hbrBackground = 0;
   window_class.lpfnWndProc = DefWindowProc;
   window_class.hCursor = LoadCursor(0, IDC_ARROW);
 
   if (RegisterClass(&window_class) == 0) {
     LOG(ERROR) << "Failed to register window class";
     return false;
@@ skipping 14 matching lines @@
     return NULL;
   }
   return window;
 }
 
 // This function creates a D3D Device and a D3D Device Manager, sets the manager
 // to use the device, and returns the manager. It also initializes the D3D
 // device. This function is used by mfdecoder.cc during the call to
 // MFDecoder::GetDXVA2AttributesForSourceReader().
 // Returns: The D3D manager object if successful. Otherwise, NULL is returned.
-IDirect3DDeviceManager9* CreateD3DDevManager(HWND video_window,
-                                             IDirect3DDevice9** device) {
+static IDirect3DDeviceManager9* CreateD3DDevManager(HWND video_window,
+                                                    IDirect3DDevice9** device) {
   CHECK(video_window != NULL);
   CHECK(device != NULL);
   int ret = -1;
 
   ScopedComPtr<IDirect3DDeviceManager9> dev_manager;
   ScopedComPtr<IDirect3D9> d3d;
   d3d.Attach(Direct3DCreate9(D3D_SDK_VERSION));
   if (d3d == NULL) {
     LOG(ERROR) << "Failed to create D3D9";
     return NULL;
@@ skipping 41 matching lines @@
   }
   *device = temp_device.Detach();
   return dev_manager.Detach();
 }
 
 // Resets the D3D device to prevent scaling from happening because it was
 // created with window before resizing occurred. We need to change the back
 // buffer dimensions to the actual video frame dimensions.
 // Both the decoder and device should be initialized before calling this method.
 // Returns: true if successful.
-bool AdjustD3DDeviceBackBufferDimensions(media::MFDecoder* decoder,
-                                         IDirect3DDevice9* device,
-                                         HWND video_window) {
+static bool AdjustD3DDeviceBackBufferDimensions(media::MFDecoder* decoder,
+                                                IDirect3DDevice9* device,
+                                                HWND video_window) {
   CHECK(decoder != NULL);
   CHECK(decoder->initialized());
   CHECK(decoder->use_dxva2());
   CHECK(device != NULL);
   D3DPRESENT_PARAMETERS present_params = {0};
   present_params.BackBufferWidth = decoder->width();
   present_params.BackBufferHeight = decoder->height();
   present_params.BackBufferFormat = D3DFMT_UNKNOWN;
   present_params.BackBufferCount = 1;
   present_params.SwapEffect = D3DSWAPEFFECT_DISCARD;
   present_params.hDeviceWindow = video_window;
   present_params.Windowed = TRUE;
   present_params.Flags = D3DPRESENTFLAG_VIDEO;
   present_params.FullScreen_RefreshRateInHz = 0;
   present_params.PresentationInterval = 0;
 
   return SUCCEEDED(device->Reset(&present_params)) ? true : false;
 }
 
 // Post this task in the MessageLoop. This function keeps posting itself
 // until DrawVideoSample fails.
-void RepaintTask(media::MFDecoder* decoder, HWND video_window,
-                 IDirect3DDevice9* device) {
+static void RepaintTask(media::MFDecoder* decoder, HWND video_window,
+                        IDirect3DDevice9* device) {
   // This sends a WM_PAINT message so we can paint on the window later.
   // If we are using D3D9, then we do not send a WM_PAINT message since the two
   // do not work well together.
   if (!decoder->use_dxva2())
     InvalidateRect(video_window, NULL, TRUE);
   base::Time start(base::Time::Now());
   if (!DrawVideoSample(video_window, decoder, device)) {
     LOG(ERROR) << "DrawVideoSample failed, quitting MessageLoop";
     MessageLoopForUI::current()->Quit();
   } else {
     ++g_num_frames;
     if (!g_render_asap && g_render_to_window) {
       base::Time end(base::Time::Now());
       int64 delta = (end-start).InMilliseconds();
       MessageLoopForUI::current()->PostDelayedTask(
           FROM_HERE,
           NewRunnableFunction(&RepaintTask, decoder, video_window, device),
                               std::max<int64>(0L, 30-delta));
     } else {
       MessageLoopForUI::current()->PostTask(
           FROM_HERE,
           NewRunnableFunction(&RepaintTask, decoder, video_window, device));
     }
   }
 }
 
-}  // namespace
-
 int main(int argc, char** argv) {
   if (argc < 2) {
     fprintf(stderr, "missing arguments\n");
     usage();
     return -1;
   }
   if (strcmp(argv[1], "--help") == 0) {
     usage();
     return 0;
   }
@@ skipping 118 matching lines @@
           << "\nAverage decode time: " << ((g_num_frames == 0) ?
               0 : (g_decode_time->InMillisecondsF() / g_num_frames))
           << "\nRender time: " << g_render_time->InMilliseconds() << "ms"
           << "\nAverage render time: " << ((g_num_frames == 0) ?
               0 : (g_render_time->InMillisecondsF() / g_num_frames));
   printf("Normal termination\n");
   delete g_decode_time;
   delete g_render_time;
   return 0;
 }