src/MediaTransporterCallback.cpp

   1 /**
   2  * Copyright (c) 2022 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gio/gio.h>
  18
  19 #include "MediaTransporterCallback.h"
  20 #include "MediaTransporterLog.h"
  21
  22 using namespace tizen_media_transporter;
  23
  24 InvokablePtr CallbackFactory::createTrackAddedCallback(void* handle, mtprTrackAddedCallback cb, void* userdata)
  25 {
  26         return InvokablePtr(new TrackAddedCallback(handle, cb, userdata));
  27 }
  28
  29 InvokablePtr CallbackFactory::createNoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback cb, void* userdata)
  30 {
  31         return InvokablePtr(new NoMoreTrackCallback(handle, cb, userdata));
  32 }
  33
  34 InvokablePtr CallbackFactory::createPacketCallback(void* handle, mtprMediaType type, mtprPacketCallback cb, void* userdata)
  35 {
  36         return InvokablePtr(new PacketCallback(handle, type, cb, userdata));
  37 }
  38
  39 InvokablePtr CallbackFactory::createErrorCallback(void* handle, mtprErrorCallback cb, void* userdata)
  40 {
  41         return InvokablePtr(new ErrorCallback(handle, cb, userdata));
  42 }
  43
  44 InvokablePtr CallbackFactory::createPacketSourceBufferStateCallback(void* handle, mtprPacketSourceBufferStateCallback cb, void* userdata)
  45 {
  46         return InvokablePtr(new PacketSourceBufferStateCallback(handle, cb, userdata));
  47 }
  48
  49 InvokablePtr CallbackFactory::createConnectionStatsCallback(void* handle, mtprConnectionStatsCallback cb, void* userdata)
  50 {
  51         return InvokablePtr(new ConnectionStatsCallback(handle, cb, userdata));
  52 }
  53
  54 TrackAddedCallback::TrackAddedCallback(void* handle, mtprTrackAddedCallback cb, void* userdata)
  55                                                         : AbstractCallback(handle, userdata), _callback(cb)
  56 {
  57         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
  58                         cb, handle, userdata);
  59 }
  60
  61 void TrackAddedCallback::invoke(VariantData data1, VariantData data2)
  62 {
  63         auto mediaType = std::get<mtprMediaType>(data1);
  64         auto trackId = std::get<unsigned int>(data2);
  65
  66         LOG_DEBUG(">>> callback[%p], mediaType[%d], trackId[%u], handle[%p], user_data[%p]",
  67                         _callback, mediaType, trackId, _handle, _userdata);
  68
  69         _callback(_handle, mediaType, trackId, _userdata);
  70 }
  71
  72 NoMoreTrackCallback::NoMoreTrackCallback(void* handle, mtprNoMoreTrackCallback cb, void* userdata)
  73                                                         : AbstractCallback(handle, userdata), _callback(cb)
  74 {
  75         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
  76                         cb, handle, userdata);
  77 }
  78
  79 void NoMoreTrackCallback::invoke()
  80 {
  81         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p]",
  82                         _callback, _handle, _userdata);
  83
  84         _callback(_handle, _userdata);
  85 }
  86
  87 PacketCallback::PacketCallback(void* handle, mtprMediaType type, mtprPacketCallback cb, void* userdata)
  88                                                         : AbstractCallback(handle, userdata), _type(type), _callback(cb)
  89 {
  90         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
  91                         cb, handle, userdata);
  92 }
  93
  94 void PacketCallback::invoke(VariantData data1, VariantData data2)
  95 {
  96         auto trackId = std::get<unsigned int>(data1);
  97         auto packet = std::get<media_packet_h>(data2);
  98
  99         LOG_VERBOSE(">>> callback[%p], handle[%p], type[%d], id[%d], packet[%p], user_data[%p]",
 100                         _callback, _handle, _type, trackId, packet, _userdata);
 101
 102         _callback(_handle, _type, trackId, packet, _userdata);
 103 }
 104
 105 ErrorCallback::ErrorCallback(void* handle, mtprErrorCallback cb,  void* userdata)
 106                                                         : AbstractCallback(handle, userdata), _callback(cb)
 107 {
 108         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
 109                         cb, handle, userdata);
 110 }
 111
 112 void ErrorCallback::invoke(VariantData data)
 113 {
 114         auto error = std::get<mtprError>(data);
 115
 116         LOG_DEBUG(">>> callback[%p], handle[%p], error[%d], user_data[%p]",
 117                         _callback, _handle, error, _userdata);
 118
 119         _callback(_handle, error, _userdata);
 120 }
 121
 122 PacketSourceBufferStateCallback::PacketSourceBufferStateCallback(void* handle, mtprPacketSourceBufferStateCallback cb, void* userdata)
 123                                 : AbstractCallback(handle, userdata), _callback(cb)
 124 {
 125         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
 126                         cb, handle, userdata);
 127 }
 128
 129 void PacketSourceBufferStateCallback::invoke(VariantData data1, VariantData data2)
 130 {
 131         auto sourceId = std::get<unsigned int>(data1);
 132         auto state = std::get<mtprPacketSourceBufferState>(data2);
 133
 134         LOG_DEBUG(">>> callback[%p], handle[%p], sourcdId[%d], state[%d], user_data[%p]",
 135                         _callback, _handle, sourceId, state, _userdata);
 136
 137         _callback(sourceId, state, _userdata);
 138 }
 139
 140 ConnectionStatsCallback::ConnectionStatsCallback(void* handle, mtprConnectionStatsCallback cb,  void* userdata)
 141                                                         : AbstractCallback(handle, userdata), _callback(cb)
 142 {
 143         LOG_DEBUG(">>> callback[%p], handle[%p], user_data[%p] registered",
 144                         cb, handle, userdata);
 145 }
 146
 147 bool ConnectionStatsCallback::invokeReturn(VariantData data)
 148 {
 149         auto prop = std::get<mtprConnectionStatsPropInfo>(data);
 150
 151         LOG_DEBUG(">>> callback[%p], handle[%p], prop[%p], user_data[%p]",
 152                         _callback, _handle, &prop, _userdata);
 153
 154         return _callback(_handle, &prop, _userdata);
 155 }