3d View -- How to display camera data in the camera frame?
AFAIK that's not possible by default and I guess there is no existing add-on which is able to display any kind of information in the camera frame.
However, you can draw the text using python's bgl module and create your own add-on. Following example code is based on our famous Operator Modal Draw template that comes with blender, extended by the answers from Coordinates of corners of camera view border and Multi-line Text in blf (with multi colour option) to get the ball rolling:

hud.py
import bpy
import blf
import bgl


# -&gt; BASED ON: https://blender.stackexchange.com/a/14746/31447
def view3d_find(context):
    # returns first 3d view, normally we get from context
    for area in context.window.screen.areas:
        if area.type == 'VIEW_3D':
            v3d = area.spaces[0]
            rv3d = v3d.region_3d
            for region in area.regions:
                if region.type == 'WINDOW':
                    return region, rv3d
    return None, None

def view3d_camera_border(context):
    obj = context.scene.camera
    cam = obj.data

    frame = cam.view_frame(scene=context.scene)
    # move from object-space into world-space 
    frame = [obj.matrix_world @ v for v in frame]

    # move into pixelspace
    from bpy_extras.view3d_utils import location_3d_to_region_2d
    region, rv3d = view3d_find(context)
    frame_px = [location_3d_to_region_2d(region, rv3d, v) for v in frame]
    return frame_px

# -&gt; BASED ON: https://blender.stackexchange.com/a/31799/31447
def draw_string(x, y, packed_strings):
    font_id = 0
    blf.size(font_id, 18, 72) 
    x_offset = 0
    y_offset = 0
    line_height = (blf.dimensions(font_id, &quot;M&quot;)[1] * 1.45)
    for command in packed_strings:
        if len(command) == 2:
            pstr, pcol = command
            blf.color(font_id, pcol[0], pcol[1], pcol[2], pcol[3]) # #bgl.glColor4f(pcol)
            text_width, text_height = blf.dimensions(font_id, pstr)
            blf.position(font_id, (x + x_offset), (y + y_offset), 0)
            blf.draw(font_id, pstr)
            x_offset += text_width
        else:
            x_offset = 0
            y_offset -= line_height

def draw_callback_px(self, context):
    
    WHITE = (1, 1, 1, .7)
    CR = &quot;Carriage Return&quot;
    
    x, y = view3d_camera_border(context)[3]
    cam_ob = context.scene.camera
    
    if cam_ob is not None:
        ps = [
            (&quot;{} {}mm&quot;.format(cam_ob.name, cam_ob.data.lens), WHITE), 
            CR,
            CR, 
            (&quot;T: {:.2f}, {:.2f}, {:.2f}&quot;.format(
                cam_ob.location.x, 
                cam_ob.location.y, 
                cam_ob.location.z), WHITE),
            CR,
            (&quot;R: {:.2f}, {:.2f}, {:.2f}&quot;.format(
                cam_ob.rotation_euler.x, 
                cam_ob.rotation_euler.y, 
                cam_ob.rotation_euler.z), WHITE),        
        ]
    
    draw_string(x+10, y-20, ps)
    # restore opengl defaults
    bgl.glLineWidth(1)
    bgl.glDisable(bgl.GL_BLEND)

# -&gt; MODAL OPERATOR TEMPLATE
class ModalDrawOperator(bpy.types.Operator):
    &quot;&quot;&quot;Draw a line with the mouse&quot;&quot;&quot;
    bl_idname = &quot;view3d.modal_operator&quot;
    bl_label = &quot;Simple Modal View3D Operator&quot;

    @classmethod
    def poll(cls, context):
        return context.area.type == 'VIEW_3D'
    
    def modal(self, context, event):
        context.area.tag_redraw()
        
        if event.type in {'RIGHTMOUSE', 'ESC'}:
            bpy.types.SpaceView3D.draw_handler_remove(self._handle, 'WINDOW')
            return {'CANCELLED'}
        
        return {'PASS_THROUGH'}

    def invoke(self, context, event):
        if context.space_data.region_3d.view_perspective == 'CAMERA':
            # the arguments we pass the the callback
            args = (self, context)
            # Add the region OpenGL drawing callback
            # draw in view space with 'POST_VIEW' and 'PRE_VIEW'
            self._handle = bpy.types.SpaceView3D.draw_handler_add(draw_callback_px, args, 'WINDOW', 'POST_PIXEL')

            context.window_manager.modal_handler_add(self)
            return {'RUNNING_MODAL'}
        else:
            self.report({'WARNING'}, &quot;Switch into Camera View&quot;)
            return {'CANCELLED'}



def register():
    bpy.utils.register_class(ModalDrawOperator)


def unregister():
    bpy.utils.unregister_class(ModalDrawOperator)


if __name__ == &quot;__main__&quot;:
    register()

Copy and paste the script into the text editor, run it, move over to the in 3d View, press F3 and type &quot;Simple Operator...&quot; to execute. If you'd like to convert it into an Add-on, just add a python dictionary named &quot;bl_info&quot; at the top of your addon: https://wiki.blender.org/wiki/Process/Addons/Guidelines/metainfo

In order to make it work for 2.7x versions you would have to replace 2 lines due to changes in Matrix Multiplication and on how to set the text color using blf.color in newer versions:
# draw_string()
- blf.color(font_id, pcol[0], pcol[1], pcol[2], pcol[3]) # Blender 2.8x
+ bgl.glColor4f(*pcol) # Blender 2.7x

# view3d_camera_border()
- frame = [obj.matrix_world @ v for v in frame] # Blender 2.8x
+ frame = [obj.matrix_world * v for v in frame] # Blender 2.7x